home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / unix / armlinux / kernel_src / linux-2.0.,fff / linuxarm-2.0.18
Encoding:
Text File  |  1996-09-07  |  1.8 MB  |  69,168 lines
Text Truncated. Only the first 1MB is shown below. Download the file for the complete contents.
  1. diff -u -X rej --recursive --new-file linux.orig/CREDITS linux/CREDITS
  2. --- linux.orig/CREDITS    Sat Sep  7 19:07:16 1996
  3. +++ linux/CREDITS    Fri Sep  6 21:14:50 1996
  4. @@ -692,6 +692,12 @@
  5.  S: D-64283 Darmstadt
  6.  S: Germany
  7.  
  8. +N: Russell King
  9. +E: rmk92@ecs.soton.ac.uk
  10. +D: Linux/arm port & hacker
  11. +S: 28 Waterer Gardens, Burgh Heath, Tadworth, Surrey. KT20 5PB
  12. +S: England
  13. +
  14.  N: Olaf Kirch
  15.  E: okir@monad.swb.de
  16.  D: Author of the Linux Network Administrators' Guide
  17. diff -u -X rej --recursive --new-file linux.orig/Documentation/Configure.help linux/Documentation/Configure.help
  18. --- linux.orig/Documentation/Configure.help    Sat Sep  7 18:59:20 1996
  19. +++ linux/Documentation/Configure.help    Sat Aug 10 10:29:48 1996
  20. @@ -322,6 +322,11 @@
  21.    in and removed from the running kernel whenever you want), say M
  22.    here and read Documentation/modules.txt. If unsure, say Y.
  23.  
  24. +Adfs Image File System (IMG)
  25. +CONFIG_BLK_DEV_IMG
  26. +  This is a device driver that allows access to partitions held in
  27. +  files on a RiscOS formatted hard disk drive.
  28. +
  29.  Support for Deskstation RPC44 
  30.  CONFIG_DESKSTATION_RPC44
  31.    This is a machine with a R4400 100 MHz CPU. To compile a Linux
  32. diff -u -X rej --recursive --new-file linux.orig/MAINTAINERS linux/MAINTAINERS
  33. --- linux.orig/MAINTAINERS    Sat Sep  7 19:00:01 1996
  34. +++ linux/MAINTAINERS    Sat Aug 17 23:13:11 1996
  35. @@ -341,6 +341,18 @@
  36.  M:    jam@acm.org
  37.  S:    Maintained
  38.  
  39. +ARM:
  40. +P:    Russell King
  41. +M:    rmk92@ecs.soton.ac.uk
  42. +L:    linux-arm@vger.rutgers.edu
  43. +W:    http://whirligig.ecs.soton.ac.uk/~rmk92/armlinux.html
  44. +S:    Maintained
  45. +
  46. +ARM MFM AND FLOPPY DRIVERS
  47. +P:    Dave Gilbert
  48. +M:    dag@cs.man.ac.uk
  49. +S:    Maintained
  50. +
  51.  REST:
  52.  P:    Linus Torvalds
  53.  S:    Buried alive in email
  54. diff -u -X rej --recursive --new-file linux.orig/Makefile linux/Makefile
  55. --- linux.orig/Makefile    Sat Sep  7 19:07:17 1996
  56. +++ linux/Makefile    Fri Sep  6 21:14:50 1996
  57. @@ -2,7 +2,7 @@
  58.  PATCHLEVEL = 0
  59.  SUBLEVEL = 18
  60.  
  61. -ARCH = i386
  62. +ARCH = arm
  63.  
  64.  #
  65.  # For SMP kernels, set this. We don't want to have this in the config file
  66. @@ -113,12 +113,16 @@
  67.  # Include the make variables (CC, etc...)
  68.  #
  69.  
  70. +# Modified 11/02/96 by Russell King
  71. +#    - Doesn't include the drivers subdirectory as standard.
  72. +#    - Modified the 'nm' line in vmlinux so that we remove local and absolute symbols.
  73. +
  74.  ARCHIVES    =kernel/kernel.o mm/mm.o fs/fs.o ipc/ipc.o net/network.a
  75.  FILESYSTEMS    =fs/filesystems.a
  76. -DRIVERS        =drivers/block/block.a \
  77. +DRIVERS     =drivers/block/block.a \
  78.           drivers/char/char.a
  79.  LIBS        =$(TOPDIR)/lib/lib.a
  80. -SUBDIRS        =kernel drivers mm fs net ipc lib
  81. +SUBDIRS        =kernel mm fs net ipc lib
  82.  
  83.  ifeq ($(CONFIG_ISDN),y)
  84.  DRIVERS := $(DRIVERS) drivers/isdn/isdn.a
  85. @@ -148,10 +152,14 @@
  86.  
  87.  include arch/$(ARCH)/Makefile
  88.  
  89. +ifndef CONFIG_ARM
  90. +SUBDIRS := drivers $(SUBDIRS)
  91. +endif
  92. +
  93.  ifdef SMP
  94.  
  95.  .S.s:
  96. -    $(CC) -D__ASSEMBLY__ $(AFLAGS) -traditional -E -o $*.s $<
  97. +    $(CC) -D__ASSEMBLY__ $(AFLAGS) -traditional -E -o $*.o $<
  98.  .S.o:
  99.      $(CC) -D__ASSEMBLY__ $(AFLAGS) -traditional -c -o $*.o $<
  100.  
  101. @@ -176,9 +184,9 @@
  102.          $(FILESYSTEMS) \
  103.          $(DRIVERS) \
  104.          $(LIBS) -o vmlinux
  105. -    $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort > System.map
  106. +    $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)\|\( A \)\|\( t L\)' | sort > System.map
  107.  
  108. -symlinks:
  109. +symlinks::
  110.      rm -f include/asm
  111.      ( cd include ; ln -sf asm-$(ARCH) asm)
  112.  
  113. @@ -316,7 +324,7 @@
  114.      rm -fr modules/*
  115.      rm -f submenu*
  116.  
  117. -mrproper: clean
  118. +mrproper:: clean
  119.      rm -f include/linux/autoconf.h include/linux/version.h
  120.      rm -f drivers/sound/local.h drivers/sound/.defines
  121.      rm -f drivers/scsi/aic7xxx_asm drivers/scsi/aic7xxx_seq.h
  122. @@ -331,11 +339,11 @@
  123.      rm -f $(TOPDIR)/include/linux/modversions.h
  124.      rm -f $(TOPDIR)/include/linux/modules/*
  125.  
  126. -
  127.  distclean: mrproper
  128.      rm -f core `find . \( -name '*.orig' -o -name '*.rej' -o -name '*~' \
  129. -                -o -name '*.bak' -o -name '#*#' -o -name '.*.orig' \
  130. -                -o -name '.*.rej' -o -name '.SUMS' -o -size 0 \) -print` TAGS
  131. +        -o -name '*.bak' -o -name '#*#' -o -name '.*.orig' \
  132. +        -o -name '.*.rej' -o -name '.SUMS' -o -size 0 \) -print` TAGS
  133. +
  134.  
  135.  backup: mrproper
  136.      cd .. && tar cf - linux/ | gzip -9 > backup.gz
  137. diff -u -X rej --recursive --new-file linux.orig/README.arm linux/README.arm
  138. --- linux.orig/README.arm    Thu Jan  1 01:00:00 1970
  139. +++ linux/README.arm    Sat Aug 17 23:32:37 1996
  140. @@ -0,0 +1,121 @@
  141. +ARM Linux 2.0.13
  142. +================
  143. +
  144. +*** Warning ***
  145. +---------------
  146. +
  147. +  Currently, 1.3.45 onwards contains new Image file drivers (IMG)
  148. +  that are in alpha testing.  I make no claims to their stability
  149. +  at the moment, so use it at your peril - it may destroy your
  150. +  hard disk!
  151. +
  152. +Contributors
  153. +------------
  154. +
  155. +  Here is a list of people actively working on the project (If you
  156. +  wish to be added to the list, please email me):
  157. +
  158. +  Name: Russell King
  159. +  Mail: rmk92@ecs.soton.ac.uk
  160. +  Desc: Original developer of ARM Linux, A5000 code and project
  161. +        co-ordinator.
  162. +
  163. +  Name: Dave Gilbert
  164. +  Mail: gilbertd@cs.man.ac.uk
  165. +  Desc: A3/4/5xx floppy and hard disk code maintainer.
  166. +
  167. +  Name: Ian Jeffray
  168. +  Mail: ian_jeffray@MENTORG.COM
  169. +  Desc: A3/4/5xx serial and parallel port code maintainer.
  170. +
  171. +
  172. +Notes
  173. +=====
  174. +
  175. +Cross compilation
  176. +-----------------
  177. +
  178. +  In order to compile ARM Linux, you will need the cross-utilities on
  179. +  ftp.ecs.soton.ac.uk in the /pub/armlinux/cross-compilers subdirectory,
  180. +  or a working version of ARM Linux with the compiler distribution.
  181. +
  182. +  To configure the kernel, edit the top-level makefile, replacing:
  183. +
  184. +    ARCH = i386 with ARCH = arm
  185. +
  186. +  Also, alter CC= and HOSTCC= to point to your compiler.
  187. +
  188. +  Then examine arch/arm/Makefile for sub-architecture options (including
  189. +  processor and machine type), setting them as required.
  190. +
  191. +  Do a 'make config', followed by 'make dep', and finally 'make all' to
  192. +  build the kernel (vmlinux).  A compressed image can be built by doing
  193. +  a 'make zImage' instead of 'make all'.
  194. +
  195. +  Please send all patches, bug reports and code for the ARM Linux project
  196. +  to rmk92@ecs.soton.ac.uk.  Patches will not be included into future
  197. +  kernels unless they come to me (or the relevant person concerned).
  198. +
  199. +Kernel initialisation abort codes
  200. +---------------------------------
  201. +
  202. +  When the kernel is unable to boot, it will if possible display a colour
  203. +  at the top of the screen.  The colours have the following significance
  204. +  when run in a 16 colour mode with the default palette:
  205. +
  206. +    Stripes of White,Red,Yellow,Green:
  207. +       Wrong/incorrect processor architecture detected.
  208. +    Red:
  209. +       Undefined instruction handler was entered.
  210. +    Green:
  211. +       Prefetch abort handler entered.
  212. +    Yellow:
  213. +       Data abort handler entered.
  214. +    Magenta:
  215. +       Address exception handler entered.
  216. +
  217. +Request to developers
  218. +---------------------
  219. +
  220. +  When writing device drivers which include a separate assember file, please
  221. +  include it in with the C file, and not the arch/arm/lib directory.  This
  222. +  helps to allow the driver to be compiled as a loadable module without
  223. +  requiring half the code to be needlessly compiled into the main kernel
  224. +  image.
  225. +
  226. +IMG drivers
  227. +-----------
  228. +
  229. +  The new image drivers (introduced in v1.3.45) have changed again.  They
  230. +  now hook into the ll_rw code, and appears to give 770k/s now (used to be
  231. +  660k/s).  However, they're not fully tested yet!
  232. +
  233. +ST506 hard drives
  234. +-----------------
  235. +
  236. +  The ST506 hard drive controllers seem to be working fine (if
  237. +  a little slowly).  At the moment they will only work off the
  238. +  controllers on an A4x0's motherboard, but for it to work
  239. +  off a Podule just requires someone with a podule to add the
  240. +  addresses for the IRQ mask and the HDC base to the source.
  241. +
  242. +  As of 31/3/96 it works with two drives (you should get the
  243. +  ADFS *configure harddrive set to 2). I've got an internal
  244. +  20MB and a great big external 5.25" FH 64MB drive (who could
  245. +  ever want more :-) ).
  246. +
  247. +  I've just got 240K/s off it (a dd with bs=128k); thats about half of what
  248. +  RiscOS gets; but its a heck of a lot better than the 50K/s I was getting
  249. +  last week :-)
  250. +
  251. +  Known bug: Drive data errors can cause a hang; including cases where
  252. +  the controller has fixed the error using ECC. (Possibly ONLY
  253. +  in that case...hmm).
  254. +
  255. +
  256. +1772 Floppy
  257. +-----------
  258. +  This also seems to work OK, but hasn't been stressed much lately.
  259. +  It hasn't got any code for disc change detection in there at the
  260. +  moment which could be a bit of a problem!  Suggestions on the
  261. +  correct way to do this are welcome.
  262. diff -u -X rej --recursive --new-file linux.orig/arch/arm/Makefile linux/arch/arm/Makefile
  263. --- linux.orig/arch/arm/Makefile    Thu Jan  1 01:00:00 1970
  264. +++ linux/arch/arm/Makefile    Sun Aug 25 10:33:23 1996
  265. @@ -0,0 +1,135 @@
  266. +#
  267. +# arch/arm/Makefile
  268. +#
  269. +# THIS IS THE VERSION/[PATCHLEVELS]:  2.0.10/[2,1,0]
  270. +#  [RMK,DAG,IC]
  271. +#
  272. +# This file is included by the global makefile so that you can add your own
  273. +# architecture-specific flags and dependencies. Remember to do have actions
  274. +# for "archclean" and "archdep" for cleaning up and making dependencies for
  275. +# this architecture
  276. +#
  277. +# This file is subject to the terms and conditions of the GNU General Public
  278. +# License.  See the file "COPYING" in the main directory of this archive
  279. +# for more details.
  280. +#
  281. +# Copyright (C) 1995, 1996 by Russell King
  282. +
  283. +
  284. +# MACHINE can be: arc a5k rpc
  285. +# PROCESSOR can be: arm2 arm3 arm6
  286. +# Computer:    MACHINE:  PROCESSOR:
  287. +#  A3xx        arc      arm2
  288. +#  A4xx        arc      arm2
  289. +#  A5xx        arc      arm2
  290. +#  A5000    a5k      arm3
  291. +#  A4000    a5k      arm3
  292. +#  A3020    a5k      arm3 (arm250 really)
  293. +#
  294. +CONFIG_ARCH_A5K      = 1
  295. +#CONFIG_ARCH_ARM      = 1
  296. +#CONFIG_ARCH_SA110EVAL     = 1
  297. +#
  298. +#CONFIG_PROC_ARM2     = 1
  299. +CONFIG_PROC_ARM3     = 1
  300. +#CONFIG_PROC_ARM6     = 1
  301. +#CONFIG_PROC_SA110     = 1
  302. +
  303. +# Machine Architecture
  304. +ifdef CONFIG_ARCH_A5K
  305. +CFLAGS        += -DCONFIG_ARCH_A5K
  306. +MACHINE         = a5k
  307. +endif
  308. +
  309. +ifdef CONFIG_ARCH_ARM
  310. +CFLAGS        += -DCONFIG_ARCH_ARM
  311. +MACHINE         = a5k
  312. +endif
  313. +
  314. +ifdef CONFIG_ARCH_SA110EVAL
  315. +CFLAGS        += -DCONFIG_ARCH_SA110EVAL
  316. +MACHINE         = sa110eval
  317. +endif
  318. +
  319. +# Processor Architecture
  320. +ifdef CONFIG_PROC_ARM2
  321. +CFLAGS_ARCH    += -m2
  322. +PROCESSOR     = arm2
  323. +TEXTADDR     = 0x01800000
  324. +endif
  325. +
  326. +ifdef CONFIG_PROC_ARM3
  327. +CFLAGS_ARCH    += -m3
  328. +PROCESSOR     = arm3
  329. +TEXTADDR     = 0x01800000
  330. +endif
  331. +
  332. +ifdef CONFIG_PROC_ARM6
  333. +CFLAGS_ARCH    += -m6
  334. +PROCESSOR     = arm6
  335. +TEXTADDR     = 0xC0000000
  336. +endif
  337. +
  338. +ifdef CONFIG_PROC_SA110
  339. +CFLAGS_ARCH    += -m6
  340. +PROCESSOR     = sa110
  341. +TEXTADDR     = 0xC0000000
  342. +endif
  343. +
  344. +OBJDUMP         = objdump
  345. +CPP         = $(CC) -E
  346. +ARCHCC        := $(word 1,$(CC))
  347. +GCCLIB        := `$(ARCHCC) $(CFLAGS_ARCH) --print-libgcc-file-name`
  348. +HOSTCFLAGS    := $(CFLAGS:-fomit-frame-pointer=)
  349. +CFLAGS        := $(CFLAGS:-fomit-frame-pointer=) $(CFLAGS_ARCH)
  350. +LINKFLAGS     = -Ttext $(TEXTADDR)
  351. +ZLINKFLAGS     = -N -Ttext $(TEXTADDR)
  352. +
  353. +HEAD        := arch/arm/kernel/head.o
  354. +SUBDIRS        := $(SUBDIRS) arch/arm/kernel arch/arm/mm arch/arm/lib arch/arm/drivers
  355. +ARCHIVES    := arch/arm/kernel/kernel.o arch/arm/mm/mm.o $(ARCHIVES)
  356. +LIBS        := arch/arm/lib/lib.a $(LIBS) $(GCCLIB)
  357. +DRIVERS        := arch/arm/drivers/block/block.a arch/arm/drivers/char/char.a \
  358. +           arch/arm/drivers/net/net.a
  359. +
  360. +ifdef CONFIG_SOUND
  361. +DRIVERS        := $(DRIVERS) arch/arm/drivers/sound/sound.a
  362. +endif
  363. +
  364. +ifdef CONFIG_SCSI
  365. +DRIVERS        := $(DRIVERS) arch/arm/drivers/scsi/scsi.a
  366. +endif
  367. +
  368. +symlinks::
  369. +    rm -f include/asm-arm/arch include/asm-arm/proc
  370. +    (cd include/asm-arm; ln -sf arch-$(MACHINE) arch; ln -sf proc-$(PROCESSOR) proc)
  371. +
  372. +mrproper::
  373. +    rm -f include/asm-arm/arch include/asm-arm/proc
  374. +    @$(MAKE) -C arch/$(ARCH)/drivers mrproper
  375. +
  376. +arch/arm/kernel: dummy
  377. +    $(MAKE) linuxsubdirs SUBDIRS=arch/arm/kernel
  378. +
  379. +arch/arm/mm: dummy
  380. +    $(MAKE) linuxsubdirs SUBDIRS=arch/arm/mm
  381. +
  382. +MAKEBOOT = $(MAKE) -C arch/$(ARCH)/boot
  383. +
  384. +zImage:
  385. +    @$(MAKEBOOT) zImage
  386. +
  387. +zinstall:
  388. +    @$(MAKEBOOT) zinstall
  389. +
  390. +Image: vmlinux
  391. +    @$(MAKEBOOT) Image
  392. +
  393. +install: vmlinux
  394. +    @$(MAKEBOOT) install
  395. +
  396. +archclean:
  397. +    @$(MAKEBOOT) clean
  398. +
  399. +archdep:
  400. +    @$(MAKEBOOT) dep
  401. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/Makefile linux/arch/arm/boot/Makefile
  402. --- linux.orig/arch/arm/boot/Makefile    Thu Jan  1 01:00:00 1970
  403. +++ linux/arch/arm/boot/Makefile    Mon Mar 11 20:46:17 1996
  404. @@ -0,0 +1,34 @@
  405. +#
  406. +# arch/arm/boot/Makefile
  407. +#
  408. +# This file is subject to the terms and conditions of the GNU General Public
  409. +# License.  See the file "COPYING" in the main directory of this archive
  410. +# for more details.
  411. +#
  412. +# Copyright (C) 1995, 1996 Russell King
  413. +#
  414. +
  415. +Image:    $(CONFIGURE) tools/build $(TOPDIR)/vmlinux
  416. +    tools/build $(TOPDIR)/vmlinux > Image
  417. +    sync
  418. +
  419. +zImage:    $(CONFIGURE) tools/build compressed/vmlinux
  420. +    tools/build compressed/vmlinux > zImage
  421. +
  422. +compressed/vmlinux: $(TOPDIR)/vmlinux dep
  423. +    @$(MAKE) -C compressed vmlinux
  424. +
  425. +install: $(CONFIGURE) Image
  426. +    sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) Image $(TOPDIR)/System.map "$(INSTALL_PATH)"
  427. +
  428. +zinstall: $(CONFIGURE) zImage
  429. +    sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) zImage $(TOPDIR)/System.map "$(INSTALL_PATH)"
  430. +
  431. +tools/build: tools/build.c
  432. +    $(HOSTCC) $(HOSTCFLAGS) -o $@ $< -I$(TOPDIR)/include
  433. +
  434. +clean:
  435. +    rm -f Image zImage tools/build
  436. +    @$(MAKE) -C compressed clean
  437. +
  438. +dep:
  439. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/compressed/Makefile linux/arch/arm/boot/compressed/Makefile
  440. --- linux.orig/arch/arm/boot/compressed/Makefile    Thu Jan  1 01:00:00 1970
  441. +++ linux/arch/arm/boot/compressed/Makefile    Thu Jul 11 09:44:26 1996
  442. @@ -0,0 +1,59 @@
  443. +#
  444. +# linux/arch/arm/boot/compressed/Makefile
  445. +#
  446. +# create a compressed vmlinux image from the original vmlinux
  447. +#
  448. +# With this config, max compressed image size = 640k
  449. +# Uncompressed image size = 1.3M (text+data)
  450. +
  451. +CFLAGS = -O2 -DSTDC_HEADERS
  452. +LOADADDR = 0x01800000
  453. +RELADDR = 0x01960000
  454. +ARFLAGS = rcv
  455. +
  456. +SYSTEM = $(TOPDIR)/vmlinux
  457. +DECOMP_OBJS = misc.o ../../lib/ll_char_wr.o
  458. +
  459. +
  460. +all:        vmlinux
  461. +
  462. +vmlinux:    head.o piggy.o
  463. +        $(LD) -Ttext=$(LOADADDR) -o vmlinux head.o piggy.o
  464. +
  465. +head.o:     head.S
  466. +        $(CC) -traditional -DRELADDR=$(RELADDR) -c head.S
  467. +
  468. +piggy.o:    decomphead.o decompress.a compressed.o
  469. +        $(LD) -s -Ttext=$(RELADDR) -o a.out decomphead.o compressed.o decompress.a
  470. +        strip a.out
  471. +        ./piggyback a.out > piggy.o
  472. +        rm -f a.out
  473. +
  474. +compressed.o:    $(SYSTEM) xtract piggyback
  475. +        ./xtract $(SYSTEM) | gzip -9 | ./piggyback > compressed.o
  476. +
  477. +
  478. +# rules for decompression part of kernel
  479. +
  480. +decompress.a:    $(DECOMP_OBJS)
  481. +        $(AR) $(ARFLAGS) decompress.a $(DECOMP_OBJS)
  482. +
  483. +decomphead.o:    decomphead.S
  484. +        $(CC) -traditional -DLOADADDR=$(LOADADDR) -c decomphead.S
  485. +
  486. +../../lib/ll_char_wr.o:
  487. +        make -C ../../lib ll_char_wr.o
  488. +
  489. +
  490. +# rules for extracting & piggybacking the kernel
  491. +
  492. +xtract:     xtract.c
  493. +        $(HOSTCC) $(HOSTCFLAGS) -o xtract xtract.c
  494. +
  495. +piggyback:    piggyback.c
  496. +        $(HOSTCC) $(HOSTCFLAGS) -o piggyback piggyback.c
  497. +
  498. +
  499. +clean:
  500. +        rm -f xtract piggyback vmlinux decompress.a a.out
  501. +
  502. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/compressed/decomphead.S linux/arch/arm/boot/compressed/decomphead.S
  503. --- linux.orig/arch/arm/boot/compressed/decomphead.S    Thu Jan  1 01:00:00 1970
  504. +++ linux/arch/arm/boot/compressed/decomphead.S    Thu Jul 11 09:59:45 1996
  505. @@ -0,0 +1,25 @@
  506. +/*
  507. + *  linux/arch/arm/boot/decomphead.S
  508. + */
  509. +
  510. +.text
  511. +    .global    __stext
  512. +__stext:
  513. +    b    start
  514. +LC0:
  515. +    .word    __edata
  516. +    .word    __end
  517. +    .word    LOADADDR + 0x23
  518. +    .word    _user_stack+4096
  519. +start:
  520. +    adr    r1, LC0
  521. +    ldmia    r1, {r2, r3, r4, sp}
  522. +    mov    r1, #0
  523. +clrzlp:    str    r1, [r2], #4
  524. +    cmp    r2, r3
  525. +    blt    clrzlp
  526. +    bic    r0, r4, #3
  527. +    bl    _decompress_kernel
  528. +    mov    r0, #0
  529. +    mov    pc, r4
  530. +
  531. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/compressed/head.S linux/arch/arm/boot/compressed/head.S
  532. --- linux.orig/arch/arm/boot/compressed/head.S    Thu Jan  1 01:00:00 1970
  533. +++ linux/arch/arm/boot/compressed/head.S    Sun Feb 11 09:32:10 1996
  534. @@ -0,0 +1,36 @@
  535. +        .text
  536. +        .align
  537. +
  538. +@ Entry point
  539. +@ r0 = kernel info page
  540. +@ r1 = kernel length (length of this code+data)
  541. +
  542. +        .global __stext
  543. +__stext:
  544. +        b    start
  545. +LC0:
  546. +        .word    _input_data
  547. +        .word    _input_end
  548. +        .word    RELADDR
  549. +start:
  550. +        teq    r0, #0
  551. +        beq    newparams
  552. +        mov    r4,     #0x02000000
  553. +        add    r4, r4, #0x0007C000    @ = 0x0207C000 [new param location]
  554. +        mov    r3,     #0x4000
  555. +        sub    r3, r3, #4
  556. +lp2:        ldmia    r0!, {r5, r6, r7, r8, r9, r10, r11, r12}
  557. +        stmia    r4!, {r5, r6, r7, r8, r9, r10, r11, r12}
  558. +        subs    r3, r3, #32
  559. +        bpl    lp2
  560. +newparams:    adr    r3, LC0
  561. +        ldmia    r3, {r2, r3, r4}
  562. +        sub    r3, r3, r2
  563. +        mov    r1, r4
  564. +lp:        ldmia    r2!, {r5, r6, r7, r8, r9, r10, r11, r12}
  565. +        stmia    r4!, {r5, r6, r7, r8, r9, r10, r11, r12}
  566. +        subs    r3, r3, #32
  567. +        bpl    lp
  568. +        ldr    r1, [r1, #0x14]
  569. +        mov    pc, r1
  570. +
  571. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/compressed/misc.c linux/arch/arm/boot/compressed/misc.c
  572. --- linux.orig/arch/arm/boot/compressed/misc.c    Thu Jan  1 01:00:00 1970
  573. +++ linux/arch/arm/boot/compressed/misc.c    Thu Jul 11 09:57:17 1996
  574. @@ -0,0 +1,402 @@
  575. +/*
  576. + * misc.c
  577. + * 
  578. + * This is a collection of several routines from gzip-1.0.3 
  579. + * adapted for Linux.
  580. + *
  581. + * malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
  582. + * puts by Nick Holloway 1993
  583. + */
  584. +
  585. +#include <string.h>
  586. +
  587. +#include <asm/segment.h>
  588. +#include <asm/io.h>
  589. +
  590. +/*
  591. + * gzip delarations
  592. + */
  593. +
  594. +#define OF(args)  args
  595. +#define STATIC static
  596. +
  597. +/*
  598. + * Optimised C version of memzero for the ARM.
  599. + */
  600. +extern __inline__ __ptr_t memzero (__ptr_t s, size_t n)
  601. +{
  602. +    int i = n;
  603. +    union { int i; char *cp; unsigned long *lp; } ss;
  604. +    ss.cp = (char *)s;
  605. +
  606. +    if (i > 3) {
  607. +        while (ss.i & 3) {
  608. +            *ss.cp++ = 0;
  609. +            i --;
  610. +        }
  611. +    }
  612. +
  613. +    while (i > 32) {
  614. +        *(unsigned long *)ss.lp++ = 0;
  615. +        *(unsigned long *)ss.lp++ = 0;
  616. +        *(unsigned long *)ss.lp++ = 0;
  617. +        *(unsigned long *)ss.lp++ = 0;
  618. +        *(unsigned long *)ss.lp++ = 0;
  619. +        *(unsigned long *)ss.lp++ = 0;
  620. +        *(unsigned long *)ss.lp++ = 0;
  621. +        *(unsigned long *)ss.lp++ = 0;
  622. +        i -= 32;
  623. +    }
  624. +
  625. +    for (; i > 0; i--)
  626. +        *ss.cp++ = 0;
  627. +    return s;
  628. +}
  629. +
  630. +typedef unsigned char  uch;
  631. +typedef unsigned short ush;
  632. +typedef unsigned long  ulg;
  633. +
  634. +#define WSIZE 0x8000        /* Window size must be at least 32k, */
  635. +                /* and a power of two */
  636. +
  637. +static uch *inbuf;        /* input buffer */
  638. +static uch window[WSIZE];    /* Sliding window buffer */
  639. +
  640. +static unsigned insize = 0;    /* valid bytes in inbuf */
  641. +static unsigned inptr = 0;    /* index of next byte to be processed in inbuf */
  642. +static unsigned outcnt = 0;    /* bytes in output buffer */
  643. +
  644. +/* gzip flag byte */
  645. +#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
  646. +#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
  647. +#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
  648. +#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
  649. +#define COMMENT      0x10 /* bit 4 set: file comment present */
  650. +#define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
  651. +#define RESERVED     0xC0 /* bit 6,7:   reserved */
  652. +
  653. +#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
  654. +
  655. +/* Diagnostic functions */
  656. +#ifdef DEBUG
  657. +#  define Assert(cond,msg) {if(!(cond)) error(msg);}
  658. +#  define Trace(x) fprintf x
  659. +#  define Tracev(x) {if (verbose) fprintf x ;}
  660. +#  define Tracevv(x) {if (verbose>1) fprintf x ;}
  661. +#  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
  662. +#  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
  663. +#else
  664. +#  define Assert(cond,msg)
  665. +#  define Trace(x)
  666. +#  define Tracev(x)
  667. +#  define Tracevv(x)
  668. +#  define Tracec(c,x)
  669. +#  define Tracecv(c,x)
  670. +#endif
  671. +
  672. +static int  fill_inbuf(void);
  673. +static void flush_window(void);
  674. +static void error(char *m);
  675. +static void gzip_mark(void **);
  676. +static void gzip_release(void **);
  677. +
  678. +/*
  679. + * These are set up by the setup-routine at boot-time:
  680. + */
  681. +
  682. +struct param_struct
  683. +{
  684. +    unsigned long page_size;
  685. +    unsigned long nr_pages;
  686. +    unsigned long ramdisk_size;
  687. +    unsigned long mountrootrdonly;
  688. +    unsigned long rootdev;
  689. +    unsigned long video_num_cols;
  690. +    unsigned long video_num_rows;
  691. +    unsigned long video_x;
  692. +    unsigned long video_y;
  693. +    unsigned long memc_control_reg;
  694. +    unsigned char sounddefault;
  695. +    unsigned char adfsdrives;
  696. +    unsigned char bytes_per_char_h;
  697. +    unsigned char bytes_per_char_v;
  698. +    unsigned long unused[256/4-11];
  699. +    char paths[8][128];
  700. +    char commandline[256];
  701. +};
  702. +
  703. +static struct param_struct *params=(struct param_struct *)0x0207C000; 
  704. +
  705. +extern char input_data[], input_end[];
  706. +
  707. +static long bytes_out = 0;
  708. +static uch *output_data;
  709. +static unsigned long output_ptr = 0;
  710. +
  711. +static void *malloc(int size);
  712. +static void free(void *where);
  713. +static void error(char *m);
  714. +static void gzip_mark(void **);
  715. +static void gzip_release(void **);
  716. +
  717. +static void puts(const char *);
  718. +
  719. +unsigned int bytes_per_char_h;
  720. +unsigned int video_num_lines;
  721. +unsigned int video_num_columns;
  722. +static unsigned int white;
  723. +static unsigned char *vidmem = (unsigned char *)0x02000000;
  724. +
  725. +extern int end;
  726. +static long free_mem_ptr = (long)&end;
  727. +
  728. +#define HEAP_SIZE 0x2000
  729. +
  730. +#include "../../../../lib/inflate.c"
  731. +
  732. +static void *malloc(int size)
  733. +{
  734. +    void *p;
  735. +
  736. +    if (size <0) error("Malloc error\n");
  737. +    if (free_mem_ptr <= 0) error("Memory error\n");
  738. +
  739. +    free_mem_ptr = (free_mem_ptr + 3) & ~3;    /* Align */
  740. +
  741. +    p = (void *)free_mem_ptr;
  742. +    free_mem_ptr += size;
  743. +
  744. +    /*
  745. +     * The part of the compressed kernel which has already been expanded
  746. +     * is no longer needed. Therefore we can reuse it for malloc.
  747. +     * With bigger kernels, this is necessary.
  748. +     */
  749. + 
  750. +    if (free_mem_ptr >= 0x01a00000)
  751. +        error("\nOut of memory\n");
  752. +    return p;
  753. +}
  754. +
  755. +static void free(void *where)
  756. +{    /* Don't care */
  757. +}
  758. +
  759. +static void gzip_mark(void **ptr)
  760. +{
  761. +    *ptr = (void *) free_mem_ptr;
  762. +}
  763. +
  764. +static void gzip_release(void **ptr)
  765. +{
  766. +    free_mem_ptr = (long) *ptr;
  767. +}
  768. +
  769. +const char cmap_80[][8]=
  770. +{
  771. + {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, /*   */
  772. + {0x18,0x18,0x18,0x18,0x18,0x00,0x18,0x00}, /* ! */
  773. + {0x6C,0x6C,0x6C,0x00,0x00,0x00,0x00,0x00}, /* " */
  774. + {0x36,0x36,0x7F,0x36,0x7F,0x36,0x36,0x00}, /* # */
  775. + {0x0C,0x3F,0x68,0x3E,0x0B,0x7E,0x18,0x00}, /* $ */
  776. + {0x60,0x66,0x0C,0x18,0x30,0x66,0x06,0x00}, /* % */
  777. + {0x38,0x6C,0x6C,0x38,0x6D,0x66,0x3B,0x00}, /* & */
  778. + {0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00}, /* ' */
  779. + {0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x00}, /* ( */
  780. + {0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0x00}, /* ) */
  781. + {0x00,0x18,0x7E,0x3C,0x7E,0x18,0x00,0x00}, /* * */
  782. + {0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00}, /* + */
  783. + {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x30}, /* , */
  784. + {0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00}, /* - */
  785. + {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00}, /* . */
  786. + {0x00,0x06,0x0C,0x18,0x30,0x60,0x00,0x00}, /* / */
  787. + {0x3C,0x66,0x6E,0x7E,0x76,0x66,0x3C,0x00}, /* 0 */
  788. + {0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00}, /* 1 */
  789. + {0x3C,0x66,0x06,0x0C,0x18,0x30,0x7E,0x00}, /* 2 */
  790. + {0x3C,0x66,0x06,0x1C,0x06,0x66,0x3C,0x00}, /* 3 */
  791. + {0x0C,0x1C,0x3C,0x6C,0x7E,0x0C,0x0C,0x00}, /* 4 */
  792. + {0x7E,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00}, /* 5 */
  793. + {0x1C,0x30,0x60,0x7C,0x66,0x66,0x3C,0x00}, /* 6 */
  794. + {0x7E,0x06,0x0C,0x18,0x30,0x30,0x30,0x00}, /* 7 */
  795. + {0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00}, /* 8 */
  796. + {0x3C,0x66,0x66,0x3E,0x06,0x0C,0x38,0x00}, /* 9 */
  797. + {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00}, /* : */
  798. + {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x30}, /* ; */
  799. + {0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00}, /* < */
  800. + {0x00,0x00,0x7E,0x00,0x7E,0x00,0x00,0x00}, /* = */
  801. + {0x30,0x18,0x0C,0x06,0x0C,0x18,0x30,0x00}, /* > */
  802. + {0x3C,0x66,0x0C,0x18,0x18,0x00,0x18,0x00}, /* ? */
  803. + {0x3C,0x66,0x6E,0x6A,0x6E,0x60,0x3C,0x00}, /* @ */
  804. + {0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00}, /* A */
  805. + {0x7C,0x66,0x66,0x7C,0x66,0x66,0x7C,0x00}, /* B */
  806. + {0x3C,0x66,0x60,0x60,0x60,0x66,0x3C,0x00}, /* C */
  807. + {0x78,0x6C,0x66,0x66,0x66,0x6C,0x78,0x00}, /* D */
  808. + {0x7E,0x60,0x60,0x7C,0x60,0x60,0x7E,0x00}, /* E */
  809. + {0x7E,0x60,0x60,0x7C,0x60,0x60,0x60,0x00}, /* F */
  810. + {0x3C,0x66,0x60,0x6E,0x66,0x66,0x3C,0x00}, /* G */
  811. + {0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00}, /* H */
  812. + {0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00}, /* I */
  813. + {0x3E,0x0C,0x0C,0x0C,0x0C,0x6C,0x38,0x00}, /* J */
  814. + {0x66,0x6C,0x78,0x70,0x78,0x6C,0x66,0x00}, /* K */
  815. + {0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00}, /* L */
  816. + {0x63,0x77,0x7F,0x6B,0x6B,0x63,0x63,0x00}, /* M */
  817. + {0x66,0x66,0x76,0x7E,0x6E,0x66,0x66,0x00}, /* N */
  818. + {0x3C,0x66,0x66,0x66,0x66,0x66,0x3C,0x00}, /* O */
  819. + {0x7C,0x66,0x66,0x7C,0x60,0x60,0x60,0x00}, /* P */
  820. + {0x3C,0x66,0x66,0x66,0x6A,0x6C,0x36,0x00}, /* Q */
  821. + {0x7C,0x66,0x66,0x7C,0x6C,0x66,0x66,0x00}, /* R */
  822. + {0x3C,0x66,0x60,0x3C,0x06,0x66,0x3C,0x00}, /* S */
  823. + {0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00}, /* T */
  824. + {0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00}, /* U */
  825. + {0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00}, /* V */
  826. + {0x63,0x63,0x6B,0x6B,0x7F,0x77,0x63,0x00}, /* W */
  827. + {0x66,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00}, /* X */
  828. + {0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00}, /* Y */
  829. + {0x7E,0x06,0x0C,0x18,0x30,0x60,0x7E,0x00}, /* Z */
  830. + {0x7C,0x60,0x60,0x60,0x60,0x60,0x7C,0x00}, /* [ */
  831. + {0x00,0x60,0x30,0x18,0x0C,0x06,0x00,0x00}, /* \ */
  832. + {0x3E,0x06,0x06,0x06,0x06,0x06,0x3E,0x00}, /* ] */
  833. + {0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00}, /* ^ */
  834. + {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF}, /* _ */
  835. + {0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00}, /* ` */
  836. + {0x00,0x00,0x3C,0x06,0x3E,0x66,0x3E,0x00}, /* a */
  837. + {0x60,0x60,0x7C,0x66,0x66,0x66,0x7C,0x00}, /* b */
  838. + {0x00,0x00,0x3C,0x66,0x60,0x66,0x3C,0x00}, /* c */
  839. + {0x06,0x06,0x3E,0x66,0x66,0x66,0x3E,0x00}, /* d */
  840. + {0x00,0x00,0x3C,0x66,0x7E,0x60,0x3C,0x00}, /* e */
  841. + {0x1C,0x30,0x30,0x7C,0x30,0x30,0x30,0x00}, /* f */
  842. + {0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x3C}, /* g */
  843. + {0x60,0x60,0x7C,0x66,0x66,0x66,0x66,0x00}, /* h */
  844. + {0x18,0x00,0x38,0x18,0x18,0x18,0x3C,0x00}, /* i */
  845. + {0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x70}, /* j */
  846. + {0x60,0x60,0x66,0x6C,0x78,0x6C,0x66,0x00}, /* k */
  847. + {0x38,0x18,0x18,0x18,0x18,0x18,0x3C,0x00}, /* l */
  848. + {0x00,0x00,0x36,0x7F,0x6B,0x6B,0x63,0x00}, /* m */
  849. + {0x00,0x00,0x7C,0x66,0x66,0x66,0x66,0x00}, /* n */
  850. + {0x00,0x00,0x3C,0x66,0x66,0x66,0x3C,0x00}, /* o */
  851. + {0x00,0x00,0x7C,0x66,0x66,0x7C,0x60,0x60}, /* p */
  852. + {0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x07}, /* q */
  853. + {0x00,0x00,0x6C,0x76,0x60,0x60,0x60,0x00}, /* r */
  854. + {0x00,0x00,0x3E,0x60,0x3C,0x06,0x7C,0x00}, /* s */
  855. + {0x30,0x30,0x7C,0x30,0x30,0x30,0x1C,0x00}, /* t */
  856. + {0x00,0x00,0x66,0x66,0x66,0x66,0x3E,0x00}, /* u */
  857. + {0x00,0x00,0x66,0x66,0x66,0x3C,0x18,0x00}, /* v */
  858. + {0x00,0x00,0x63,0x6B,0x6B,0x7F,0x36,0x00}, /* w */
  859. + {0x00,0x00,0x66,0x3C,0x18,0x3C,0x66,0x00}, /* x */
  860. + {0x00,0x00,0x66,0x66,0x66,0x3E,0x06,0x3C}, /* y */
  861. + {0x00,0x00,0x7E,0x0C,0x18,0x30,0x7E,0x00}, /* z */
  862. + {0x0C,0x18,0x18,0x70,0x18,0x18,0x0C,0x00}, /* { */
  863. + {0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00}, /* | */
  864. + {0x30,0x18,0x18,0x0E,0x18,0x18,0x30,0x00}, /* } */
  865. + {0x31,0x6B,0x46,0x00,0x00,0x00,0x00,0x00}, /* ~ */
  866. + {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}  /*  */
  867. +};
  868. +
  869. +static void puts(const char *s)
  870. +{
  871. +    extern void ll_write_char(char *, unsigned long);
  872. +    int x,y;
  873. +    unsigned char c;
  874. +    char *ptr;
  875. +
  876. +    x = params->video_x;
  877. +    y = params->video_y;
  878. +
  879. +    while ( ( c = *(unsigned char *)s++ ) != '\0' ) {
  880. +        if ( c == '\n' ) {
  881. +            x = 0;
  882. +            if ( ++y >= video_num_lines ) {
  883. +                y--;
  884. +            }
  885. +        } else {
  886. +            ptr = vidmem + (y*video_num_columns*params->bytes_per_char_v+x)*bytes_per_char_h;
  887. +            ll_write_char (ptr, c|(white<<8));
  888. +            if ( ++x >= video_num_columns ) {
  889. +                x = 0;
  890. +                if ( ++y >= video_num_lines ) {
  891. +                    y--;
  892. +                }
  893. +            }
  894. +        }
  895. +    }
  896. +
  897. +    params->video_x = x;
  898. +    params->video_y = y;
  899. +}
  900. +        
  901. +__ptr_t memcpy(__ptr_t __dest, __const __ptr_t __src,
  902. +                size_t __n)
  903. +{
  904. +    int i;
  905. +    char *d = (char *)__dest, *s = (char *)__src;
  906. +
  907. +    for (i=0;i<__n;i++) d[i] = s[i];
  908. +}
  909. +
  910. +/* ===========================================================================
  911. + * Fill the input buffer. This is called only when the buffer is empty
  912. + * and at least one byte is really needed.
  913. + */
  914. +int fill_inbuf()
  915. +{
  916. +    if (insize != 0) {
  917. +    error("ran out of input data\n");
  918. +    }
  919. +
  920. +    inbuf = input_data;
  921. +    insize = input_end - input_data;
  922. +    inptr = 1;
  923. +    return inbuf[0];
  924. +}
  925. +
  926. +/* ===========================================================================
  927. + * Write the output window window[0..outcnt-1] and update crc and bytes_out.
  928. + * (Used for the decompressed data only.)
  929. + */
  930. +void flush_window()
  931. +{
  932. +    ulg c = crc;
  933. +    unsigned n;
  934. +    uch *in, *out, ch;
  935. +
  936. +    in = window;
  937. +    out = &output_data[output_ptr];
  938. +    for (n = 0; n < outcnt; n++) {
  939. +    ch = *out++ = *in++;
  940. +    c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
  941. +    }
  942. +    crc = c;
  943. +    bytes_out += (ulg)outcnt;
  944. +    output_ptr += (ulg)outcnt;
  945. +    outcnt = 0;
  946. +}
  947. +
  948. +static void error(char *x)
  949. +{
  950. +    puts("\n\n");
  951. +    puts(x);
  952. +    puts("\n\n -- System halted");
  953. +
  954. +    while(1);    /* Halt */
  955. +}
  956. +
  957. +#define STACK_SIZE (4096)
  958. +
  959. +long user_stack [STACK_SIZE];
  960. +
  961. +void decompress_kernel(int output_start)
  962. +{
  963. +    video_num_lines = params->video_num_rows;
  964. +    video_num_columns  = params->video_num_cols;
  965. +    bytes_per_char_h = params->bytes_per_char_h;
  966. +    white = bytes_per_char_h == 8 ? 0xfc : 7;
  967. +    
  968. +    if (params->nr_pages * params->page_size < 2048*1024) error("<2M of mem\n");
  969. +
  970. +    output_data = (char *)output_start;    /* Points to kernel start */
  971. +
  972. +    makecrc();
  973. +    puts("Uncompressing Linux...");
  974. +    gunzip();
  975. +    puts("done.\nNow booting the kernel\n");
  976. +}
  977. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/compressed/piggyback.c linux/arch/arm/boot/compressed/piggyback.c
  978. --- linux.orig/arch/arm/boot/compressed/piggyback.c    Thu Jan  1 01:00:00 1970
  979. +++ linux/arch/arm/boot/compressed/piggyback.c    Sun Jul  7 12:34:25 1996
  980. @@ -0,0 +1,91 @@
  981. +/*
  982. + *    linux/zBoot/piggyback.c
  983. + *
  984. + *    (C) 1993 Hannu Savolainen
  985. + */
  986. +
  987. +/*
  988. + *    This program reads the compressed system image from stdin and
  989. + *    encapsulates it into an object file written to the stdout.
  990. + */
  991. +
  992. +#include <stdio.h>
  993. +#include <unistd.h>
  994. +#include <a.out.h>
  995. +#include <sys/fcntl.h>
  996. +
  997. +int main(int argc, char *argv[])
  998. +{
  999. +    int n=0, len=0, fd = 0;
  1000. +    char tmp_buf[640*1024];
  1001. +    
  1002. +    struct exec obj = {0x00670107};    /* object header */
  1003. +    char string_names[] = {"_input_data\0_input_end\0"};
  1004. +
  1005. +    struct nlist var_names[2] = /* Symbol table */
  1006. +        {
  1007. +            {    /* _input_data    */
  1008. +                {(char *)4}, 7, 0, 0, 0
  1009. +            },
  1010. +            {    /* _input_len */
  1011. +                {(char *)16}, 7, 0, 0, 0
  1012. +            }
  1013. +        };
  1014. +
  1015. +
  1016. +    if (argc > 1) {
  1017. +        fd = open (argv[1], O_RDONLY);
  1018. +        if (fd < 0) {
  1019. +            fprintf (stderr, "%s: ", argv[0]);
  1020. +            perror (argv[1]);
  1021. +            exit (1);
  1022. +        }
  1023. +    }
  1024. +
  1025. +    len = 0;
  1026. +    while ((n = read(fd, &tmp_buf[len], sizeof(tmp_buf)-len+1)) > 0)
  1027. +          len += n;
  1028. +
  1029. +    len = (len + 3) & ~3;
  1030. +
  1031. +    if (n==-1) {
  1032. +        perror("stdin");
  1033. +        exit(-1);
  1034. +    }
  1035. +
  1036. +    if (len >= sizeof(tmp_buf)) {
  1037. +        fprintf(stderr, "%s: Input too large\n", argv[0]);
  1038. +        exit(-1);
  1039. +    }
  1040. +
  1041. +    if (argc < 2)
  1042. +        fprintf(stderr, "Compressed size %d.\n", len);
  1043. +
  1044. +/*
  1045. + *    Output object header
  1046. + */
  1047. +    obj.a_data = len /* + sizeof(long) */;
  1048. +    obj.a_syms = sizeof(var_names);
  1049. +    write(1, (char *)&obj, sizeof(obj));
  1050. +
  1051. +/*
  1052. + *    Output data segment (compressed system & len)
  1053. + */
  1054. +    write(1, tmp_buf, len);
  1055. +
  1056. +/*
  1057. + *    Output symbol table
  1058. + */
  1059. +    var_names[1].n_value = len;
  1060. +    write(1, (char *)&var_names, sizeof(var_names));
  1061. +
  1062. +/*
  1063. + *    Output string table
  1064. + */
  1065. +    len = sizeof(string_names) + sizeof(len);
  1066. +    write(1, (char *)&len, sizeof(len));
  1067. +    write(1, string_names, sizeof(string_names));
  1068. +
  1069. +    exit(0);
  1070. +
  1071. +}
  1072. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/compressed/xtract.c linux/arch/arm/boot/compressed/xtract.c
  1073. --- linux.orig/arch/arm/boot/compressed/xtract.c    Thu Jan  1 01:00:00 1970
  1074. +++ linux/arch/arm/boot/compressed/xtract.c    Sat Jul 13 19:20:28 1996
  1075. @@ -0,0 +1,86 @@
  1076. +/*
  1077. + *  linux/zBoot/xtract.c
  1078. + *
  1079. + *  Copyright (C) 1993  Hannu Savolainen
  1080. + *
  1081. + *    Extracts the system image and writes it to the stdout.
  1082. + *    based on tools/build.c by Linus Torvalds
  1083. + */
  1084. +
  1085. +#include <stdio.h>    /* fprintf */
  1086. +#include <string.h>
  1087. +#include <stdlib.h>    /* contains exit */
  1088. +#include <sys/types.h>    /* unistd.h needs this */
  1089. +#include <sys/stat.h>
  1090. +#include <sys/sysmacros.h>
  1091. +#include <unistd.h>    /* contains read/write */
  1092. +#include <fcntl.h>
  1093. +#include <a.out.h>
  1094. +
  1095. +#define N_MAGIC_OFFSET 1024
  1096. +
  1097. +static int GCC_HEADER = sizeof(struct exec);
  1098. +
  1099. +#define STRINGIFY(x) #x
  1100. +
  1101. +void die(char * str)
  1102. +{
  1103. +    fprintf(stderr,"%s\n",str);
  1104. +    exit(1);
  1105. +}
  1106. +
  1107. +void usage(void)
  1108. +{
  1109. +    die("Usage: xtract system [ | gzip | piggyback > piggy.s]");
  1110. +}
  1111. +
  1112. +int main(int argc, char ** argv)
  1113. +{
  1114. +    int /*i,c,*/id, sz;
  1115. +    char buf[1024];
  1116. +/*    char major_root, minor_root;*/
  1117. +/*    struct stat sb;*/
  1118. +
  1119. +    struct exec *ex = (struct exec *)buf;
  1120. +
  1121. +    if (argc  != 2)
  1122. +        usage();
  1123. +    
  1124. +    if ((id=open(argv[1],O_RDONLY,0))<0)
  1125. +        die("Unable to open 'system'");
  1126. +    if (read(id,buf,GCC_HEADER) != GCC_HEADER)
  1127. +        die("Unable to read header of 'system'");
  1128. +    if (N_MAGIC(*ex) == ZMAGIC) {
  1129. +        GCC_HEADER = N_MAGIC_OFFSET;
  1130. +        lseek(id, GCC_HEADER, SEEK_SET);
  1131. +    } else if (N_MAGIC(*ex) != QMAGIC)
  1132. +        die("Non-GCC header of 'system'");
  1133. +
  1134. +    sz = N_SYMOFF(*ex) - GCC_HEADER + 4;    /* +4 to get the same result than tools/build */
  1135. +
  1136. +    fprintf(stderr, "System size is %d\n", sz);
  1137. +
  1138. +    while (sz)
  1139. +    {
  1140. +        int l, n;
  1141. +
  1142. +        l = sz;
  1143. +        if (l > sizeof(buf)) l = sizeof(buf);
  1144. +
  1145. +        if ((n=read(id, buf, l)) !=l)
  1146. +        {
  1147. +            if (n == -1) 
  1148. +               perror(argv[1]);
  1149. +            else
  1150. +               fprintf(stderr, "Unexpected EOF\n");
  1151. +
  1152. +            die("Can't read system");
  1153. +        }
  1154. +
  1155. +        write(1, buf, l);
  1156. +        sz -= l;
  1157. +    }
  1158. +
  1159. +    close(id);
  1160. +    return(0);
  1161. +}
  1162. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/install.sh linux/arch/arm/boot/install.sh
  1163. --- linux.orig/arch/arm/boot/install.sh    Thu Jan  1 01:00:00 1970
  1164. +++ linux/arch/arm/boot/install.sh    Wed May  8 22:00:32 1996
  1165. @@ -0,0 +1,60 @@
  1166. +#!/bin/sh
  1167. +#
  1168. +# arch/i386/boot/install.sh
  1169. +#
  1170. +# This file is subject to the terms and conditions of the GNU General Public
  1171. +# License.  See the file "COPYING" in the main directory of this archive
  1172. +# for more details.
  1173. +#
  1174. +# Copyright (C) 1995 by Linus Torvalds
  1175. +#
  1176. +# Adapted from code in arch/i386/boot/Makefile by H. Peter Anvin
  1177. +#
  1178. +# "make install" script for i386 architecture
  1179. +#
  1180. +# Arguments:
  1181. +#   $1 - kernel version
  1182. +#   $2 - kernel image file
  1183. +#   $3 - kernel map file
  1184. +#   $4 - default install path (blank if root directory)
  1185. +#
  1186. +
  1187. +# User may have a custom install script
  1188. +
  1189. +if [ -x /sbin/installkernel ]; then
  1190. +  exec /sbin/installkernel "$@"
  1191. +fi
  1192. +
  1193. +if [ "$2" = "zImage" ]; then
  1194. +# Compressed install
  1195. +  echo "Installing compressed kernel"
  1196. +  if [ -f $4/vmlinuz-$1 ]; then
  1197. +    mv $4/vmlinuz-$1 $4/vmlinuz.old
  1198. +  fi
  1199. +
  1200. +  if [ -f $4/System.map-$1 ]; then
  1201. +    mv $4/System.map-$1 $4/System.old
  1202. +  fi
  1203. +
  1204. +  cat $2 > $4/vmlinuz-$1
  1205. +  cp $3 $4/System.map-$1
  1206. +else
  1207. +# Normal install
  1208. +  echo "Installing normal kernel"
  1209. +  if [ -f $4/vmlinux-$1 ]; then
  1210. +    mv $4/vmlinux-$1 $4/vmlinux.old
  1211. +  fi
  1212. +
  1213. +  if [ -f $4/System.map ]; then
  1214. +    mv $4/System.map $4/System.old
  1215. +  fi
  1216. +
  1217. +  cat $2 > $4/vmlinux-$1
  1218. +  cp $3 $4/System.map
  1219. +fi
  1220. +
  1221. +if [ -x /sbin/loadmap ]; then
  1222. +  /sbin/loadmap --rdev /dev/ima
  1223. +else
  1224. +  echo "You have to install it yourself"
  1225. +fi
  1226. diff -u -X rej --recursive --new-file linux.orig/arch/arm/boot/tools/build.c linux/arch/arm/boot/tools/build.c
  1227. --- linux.orig/arch/arm/boot/tools/build.c    Thu Jan  1 01:00:00 1970
  1228. +++ linux/arch/arm/boot/tools/build.c    Sun Feb 11 22:01:19 1996
  1229. @@ -0,0 +1,56 @@
  1230. +#include <stdio.h>
  1231. +#include <stdlib.h>
  1232. +#include <a.out.h>
  1233. +#include <string.h>
  1234. +
  1235. +int main(int argc, char **argv)
  1236. +{
  1237. +    void *data;
  1238. +    struct exec ex;
  1239. +    FILE *f;
  1240. +    int totlen;
  1241. +
  1242. +    if (argc < 2) {
  1243. +        fprintf(stderr, "Usage: build kernel-name\n");
  1244. +        exit(1);
  1245. +    }
  1246. +
  1247. +    f = fopen(argv[1], "rb");
  1248. +
  1249. +    fread(&ex, 1, sizeof(ex), f);
  1250. +
  1251. +    if(N_MAGIC(ex) == ZMAGIC) {
  1252. +        fseek(f, 4096, SEEK_SET);
  1253. +        totlen = ex.a_text + ex.a_data + ex.a_bss;
  1254. +    } else
  1255. +    if(N_MAGIC(ex) == QMAGIC) {
  1256. +        unsigned long my_header[8];
  1257. +        
  1258. +        fseek(f, 0x20, SEEK_SET);
  1259. +
  1260. +        memset(my_header, 0, 0x20);
  1261. +
  1262. +        my_header[0] = 0xea000006;
  1263. +        
  1264. +        fwrite(my_header, 4, 8, stdout);
  1265. +        
  1266. +        totlen = ex.a_text + ex.a_data + ex.a_bss - 0x20;
  1267. +    } else {
  1268. +        fprintf(stderr, "Unacceptable a.out header on kernel\n");
  1269. +        fclose(f);
  1270. +        exit(1);
  1271. +    }
  1272. +
  1273. +    fprintf(stderr, "Kernel is %dk (%dk text, %dk data, %dk bss)\n",
  1274. +        (ex.a_text + ex.a_data + ex.a_bss)/1024,
  1275. +         ex.a_text/1024, ex.a_data/1024, ex.a_bss/1024);
  1276. +
  1277. +    data = malloc(totlen);
  1278. +    fread(data, 1, totlen, f);
  1279. +    fwrite(data, 1, totlen, stdout);
  1280. +
  1281. +    free(data);
  1282. +    fclose(f);
  1283. +    fflush(stdout);
  1284. +    return 0;
  1285. +}
  1286. diff -u -X rej --recursive --new-file linux.orig/arch/arm/config.in linux/arch/arm/config.in
  1287. --- linux.orig/arch/arm/config.in    Thu Jan  1 01:00:00 1970
  1288. +++ linux/arch/arm/config.in    Wed Jul 31 13:35:08 1996
  1289. @@ -0,0 +1,89 @@
  1290. +#
  1291. +# For a description of the syntax of this configuration file,
  1292. +# see the Configure script.
  1293. +#
  1294. +# architecture in arch/arm/Makefile'
  1295. +
  1296. +mainmenu_name "Linux kernel configuration"
  1297. +
  1298. +define_bool CONFIG_ARM y
  1299. +
  1300. +mainmenu_option next_comment
  1301. +comment 'Code maturity level options'
  1302. +bool 'Prompt for development and/or incomplete code/drivers' CONFIG_EXPERIMENTAL
  1303. +endmenu
  1304. +
  1305. +mainmenu_option next_comment
  1306. +comment 'Loadable module support'
  1307. +bool 'Enable loadable module support' CONFIG_MODULES
  1308. +if [ "$CONFIG_MODULES" = "y" ]; then
  1309. +  bool 'Set version information on all symbols for modules' CONFIG_MODVERSIONS
  1310. +  bool 'Kernel daemon support (e.g. autoload of modules)' CONFIG_KERNELD
  1311. +fi
  1312. +endmenu
  1313. +
  1314. +mainmenu_option next_comment
  1315. +comment 'General setup'
  1316. +bool 'Networking support' CONFIG_NET
  1317. +bool 'System V IPC' CONFIG_SYSVIPC
  1318. +define_bool CONFIG_BINFMT_AOUT y
  1319. +define_bool CONFIG_BINFMT_ELF n
  1320. +define_bool CONFIG_BINFMT_JAVA n
  1321. +endmenu
  1322. +
  1323. +source arch/arm/drivers/block/Config.in
  1324. +
  1325. +if [ "$CONFIG_NET" = "y" ]; then
  1326. +  source net/Config.in
  1327. +fi
  1328. +
  1329. +mainmenu_option next_comment
  1330. +comment 'SCSI support'
  1331. +
  1332. +tristate 'SCSI support?' CONFIG_SCSI
  1333. +
  1334. +if [ "$CONFIG_SCSI" != "n" ]; then
  1335. +  source arch/arm/drivers/scsi/Config.in
  1336. +fi
  1337. +endmenu
  1338. +
  1339. +if [ "$CONFIG_NET" = "y" ]; then
  1340. +  mainmenu_option next_comment
  1341. +  comment 'Network device support'
  1342. +
  1343. +  bool 'Network device support?' CONFIG_NETDEVICES
  1344. +  if [ "$CONFIG_NETDEVICES" = "y" ]; then
  1345. +    source arch/arm/drivers/net/Config.in
  1346. +  fi
  1347. +  endmenu
  1348. +fi
  1349. +
  1350. +# mainmenu_option next_comment
  1351. +# comment 'ISDN subsystem'
  1352. +#
  1353. +# tristate 'ISDN support' CONFIG_ISDN
  1354. +# if [ "$CONFIG_ISDN" != "n" ]; then
  1355. +#   source drivers/isdn/Config.in
  1356. +# fi
  1357. +# endmenu
  1358. +
  1359. +source fs/Config.in
  1360. +
  1361. +source arch/arm/drivers/char/Config.in
  1362. +
  1363. +mainmenu_option next_comment
  1364. +comment 'Sound'
  1365. +
  1366. +bool 'Sound support' CONFIG_SOUND
  1367. +endmenu
  1368. +
  1369. +mainmenu_option next_comment
  1370. +comment 'Kernel hacking'
  1371. +
  1372. +#bool 'Debug kmalloc/kfree' CONFIG_DEBUG_MALLOC
  1373. +bool 'Kernel profiling support' CONFIG_PROFILE
  1374. +if [ "$CONFIG_PROFILE" = "y" ]; then
  1375. +  int ' Profile shift count' CONFIG_PROFILE_SHIFT 2
  1376. +fi
  1377. +endmenu
  1378. +
  1379. diff -u -X rej --recursive --new-file linux.orig/arch/arm/defconfig linux/arch/arm/defconfig
  1380. --- linux.orig/arch/arm/defconfig    Thu Jan  1 01:00:00 1970
  1381. +++ linux/arch/arm/defconfig    Tue Jul 30 17:17:14 1996
  1382. @@ -0,0 +1,164 @@
  1383. +#
  1384. +# Automatically generated make config: don't edit
  1385. +#
  1386. +CONFIG_ARM=y
  1387. +
  1388. +#
  1389. +# Code maturity level options
  1390. +#
  1391. +# CONFIG_EXPERIMENTAL is not set
  1392. +
  1393. +#
  1394. +# Loadable module support
  1395. +#
  1396. +CONFIG_MODULES=y
  1397. +CONFIG_MODVERSIONS=y
  1398. +# CONFIG_KERNELD is not set
  1399. +
  1400. +#
  1401. +# General setup
  1402. +#
  1403. +CONFIG_NET=y
  1404. +CONFIG_SYSVIPC=y
  1405. +CONFIG_BINFMT_AOUT=y
  1406. +# CONFIG_BINFMT_ELF is not set
  1407. +# CONFIG_BINFMT_JAVA is not set
  1408. +
  1409. +#
  1410. +# Floppy, IDE, and other block devices
  1411. +#
  1412. +CONFIG_BLK_DEV_FD=y
  1413. +CONFIG_BLK_DEV_IDE=y
  1414. +
  1415. +#
  1416. +# Please see Documentation/ide.txt for help/info on IDE drives
  1417. +#
  1418. +# CONFIG_BLK_DEV_IDECD is not set
  1419. +# CONFIG_BLK_DEV_IDETAPE is not set
  1420. +# CONFIG_BLK_DEV_IDE_CARDS is not set
  1421. +# CONFIG_BLK_DEV_XD is not set
  1422. +
  1423. +#
  1424. +# Additional Block Devices
  1425. +#
  1426. +# CONFIG_BLK_DEV_LOOP is not set
  1427. +# CONFIG_BLK_DEV_MD is not set
  1428. +# CONFIG_BLK_DEV_RAM is not set
  1429. +CONFIG_BLK_DEV_IMG=y
  1430. +
  1431. +#
  1432. +# Networking options
  1433. +#
  1434. +# CONFIG_FIREWALL is not set
  1435. +# CONFIG_NET_ALIAS is not set
  1436. +CONFIG_INET=y
  1437. +# CONFIG_IP_FORWARD is not set
  1438. +# CONFIG_IP_MULTICAST is not set
  1439. +# CONFIG_IP_ACCT is not set
  1440. +# CONFIG_IP_ROUTER is not set
  1441. +# CONFIG_NET_IPIP is not set
  1442. +
  1443. +#
  1444. +# (it is safe to leave these untouched)
  1445. +#
  1446. +# CONFIG_INET_PCTCP is not set
  1447. +# CONFIG_INET_RARP is not set
  1448. +# CONFIG_NO_PATH_MTU_DISCOVERY is not set
  1449. +# CONFIG_IP_NOSR is not set
  1450. +# CONFIG_SKB_LARGE is not set
  1451. +
  1452. +#
  1453. +#  
  1454. +#
  1455. +# CONFIG_IPX is not set
  1456. +# CONFIG_ATALK is not set
  1457. +# CONFIG_AX25 is not set
  1458. +# CONFIG_BRIDGE is not set
  1459. +# CONFIG_NETLINK is not set
  1460. +
  1461. +#
  1462. +# SCSI support
  1463. +#
  1464. +# CONFIG_SCSI is not set
  1465. +
  1466. +#
  1467. +# SCSI support type (disk, tape, CDrom)
  1468. +#
  1469. +# CONFIG_BLK_DEV_SD is not set
  1470. +# CONFIG_CHR_DEV_ST is not set
  1471. +# CONFIG_BLK_DEV_SR is not set
  1472. +# CONFIG_CHR_DEV_SG is not set
  1473. +
  1474. +#
  1475. +# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
  1476. +#
  1477. +# CONFIG_SCSI_MULTI_LUN is not set
  1478. +# CONFIG_SCSI_CONSTANTS is not set
  1479. +
  1480. +#
  1481. +# SCSI low-level drivers
  1482. +#
  1483. +# CONFIG_SCSI_ACORNSCSI_3 is not set
  1484. +# CONFIG_SCSI_CUMANA_1 is not set
  1485. +# CONFIG_SCSI_ECOSCSI is not set
  1486. +# CONFIG_SCSI_OAK is not set
  1487. +
  1488. +#
  1489. +# Network device support
  1490. +#
  1491. +CONFIG_NETDEVICES=y
  1492. +CONFIG_DUMMY=y
  1493. +# CONFIG_EQUALIZER is not set
  1494. +CONFIG_PPP=y
  1495. +
  1496. +#
  1497. +# CCP compressors for PPP are only built as modules.
  1498. +#
  1499. +# CONFIG_SLIP is not set
  1500. +# CONFIG_ETHER1 is not set
  1501. +# CONFIG_ETHER3 is not set
  1502. +
  1503. +#
  1504. +# Filesystems
  1505. +#
  1506. +# CONFIG_QUOTA is not set
  1507. +# CONFIG_LOCK_MANDATORY is not set
  1508. +CONFIG_MINIX_FS=y
  1509. +# CONFIG_EXT_FS is not set
  1510. +CONFIG_EXT2_FS=y
  1511. +# CONFIG_XIA_FS is not set
  1512. +CONFIG_FAT_FS=y
  1513. +CONFIG_MSDOS_FS=y
  1514. +# CONFIG_VFAT_FS is not set
  1515. +# CONFIG_UMSDOS_FS is not set
  1516. +CONFIG_PROC_FS=y
  1517. +CONFIG_NFS_FS=y
  1518. +# CONFIG_ROOT_NFS is not set
  1519. +CONFIG_SMB_FS=m
  1520. +CONFIG_SMB_LONG=y
  1521. +# CONFIG_ISO9660_FS is not set
  1522. +# CONFIG_HPFS_FS is not set
  1523. +# CONFIG_SYSV_FS is not set
  1524. +# CONFIG_AFFS_FS is not set
  1525. +# CONFIG_UFS_FS is not set
  1526. +
  1527. +#
  1528. +# Character devices
  1529. +#
  1530. +# CONFIG_SERIAL_ECHO is not set
  1531. +CONFIG_SERIAL=y
  1532. +CONFIG_ATOMWIDE_SERIAL=y
  1533. +# CONFIG_DUALSP_SERIAL is not set
  1534. +CONFIG_MOUSE=y
  1535. +CONFIG_KBDMOUSE=y
  1536. +CONFIG_PRINTER=y
  1537. +
  1538. +#
  1539. +# Sound
  1540. +#
  1541. +CONFIG_SOUND=y
  1542. +
  1543. +#
  1544. +# Kernel hacking
  1545. +#
  1546. +# CONFIG_PROFILE is not set
  1547. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/Makefile linux/arch/arm/drivers/Makefile
  1548. --- linux.orig/arch/arm/drivers/Makefile    Thu Jan  1 01:00:00 1970
  1549. +++ linux/arch/arm/drivers/Makefile    Thu Mar 28 11:51:08 1996
  1550. @@ -0,0 +1,37 @@
  1551. +#
  1552. +# Makefile for the linux kernel device drivers.
  1553. +#
  1554. +# Note! Dependencies are done automagically by 'make dep', which also
  1555. +# removes any old dependencies. DON'T put your own dependencies here
  1556. +# unless it's something special (ie not a .c file).
  1557. +#
  1558. +# Note 2! The CFLAGS definitions are now in the main makefile...
  1559. +
  1560. +SUB_DIRS     := block char net #streams
  1561. +MOD_SUB_DIRS := $(SUB_DIRS)
  1562. +ALL_SUB_DIRS := $(SUB_DIRS) scsi sound
  1563. +
  1564. +# If CONFIG_SCSI is set, the core of scsi support will be added to the kernel,
  1565. +# but some of the low-level things may also be modules.
  1566. +ifeq ($(CONFIG_SCSI),y)
  1567. +SUB_DIRS += scsi
  1568. +MOD_SUB_DIRS += scsi
  1569. +else
  1570. +  ifeq ($(CONFIG_SCSI),m)
  1571. +  MOD_SUB_DIRS += scsi
  1572. +  endif
  1573. +endif
  1574. +
  1575. +ifeq ($(CONFIG_SOUND),y)
  1576. +SUB_DIRS += sound
  1577. +else
  1578. +  ifeq ($(CONFIG_SOUND),m)
  1579. +  MOD_SUB_DIRS += sound
  1580. +  endif
  1581. +endif
  1582. +
  1583. +include $(TOPDIR)/Rules.make
  1584. +
  1585. +mrproper:
  1586. +    set -e; for i in $(ALL_SUB_DIRS); do $(MAKE) -C $$i mrproper; done
  1587. +
  1588. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/Config.in linux/arch/arm/drivers/block/Config.in
  1589. --- linux.orig/arch/arm/drivers/block/Config.in    Thu Jan  1 01:00:00 1970
  1590. +++ linux/arch/arm/drivers/block/Config.in    Fri Aug  9 22:51:44 1996
  1591. @@ -0,0 +1,43 @@
  1592. +#
  1593. +# Block device driver configuration
  1594. +#
  1595. +mainmenu_option next_comment
  1596. +comment 'Floppy, IDE, and other block devices'
  1597. +
  1598. +tristate 'Normal floppy disk support' CONFIG_BLK_DEV_FD
  1599. +bool 'Enhanced IDE disk/cdrom/tape support' CONFIG_BLK_DEV_IDE
  1600. +comment 'Please see Documentation/ide.txt for help/info on IDE drives'
  1601. +if [ "$CONFIG_BLK_DEV_IDE" = "n" ]; then
  1602. +  bool 'Use Old IDE harddisk driver' CONFIG_BLK_DEV_HD_ONLY
  1603. +else
  1604. +  bool '  Include IDE/ATAPI CDROM support' CONFIG_BLK_DEV_IDECD
  1605. +  bool '  Include IDE/ATAPI TAPE support' CONFIG_BLK_DEV_IDETAPE
  1606. +  bool '  Support expansion card IDE interfaces' CONFIG_BLK_DEV_IDE_CARDS
  1607. +  if [ "$CONFIG_BLK_DEV_IDE_CARDS" = "y" ]; then
  1608. +    bool '    ICS IDE interface support' CONFIG_BLK_DEV_IDE_ICS
  1609. +  fi
  1610. +fi
  1611. +
  1612. +tristate 'MFM harddisk support' CONFIG_BLK_DEV_XD
  1613. +
  1614. +comment 'Additional Block Devices'
  1615. +
  1616. +tristate 'Loopback device support' CONFIG_BLK_DEV_LOOP
  1617. +bool 'Multiple device driver support' CONFIG_BLK_DEV_MD
  1618. +if [ "$CONFIG_BLK_DEV_MD" = "y" ]; then
  1619. +  tristate '  Linear (append) mode' CONFIG_MD_LINEAR
  1620. +  tristate '  RAID-0 (striping) mode' CONFIG_MD_STRIPED
  1621. +fi
  1622. +tristate 'RAM disk support' CONFIG_BLK_DEV_RAM
  1623. +if [ "$CONFIG_BLK_DEV_RAM" = "y" ]; then
  1624. +  bool '   Initial RAM disk (initrd) support' CONFIG_BLK_DEV_INITRD
  1625. +fi
  1626. +bool 'ADFS image file support' CONFIG_BLK_DEV_IMG
  1627. +
  1628. +if [ "$CONFIG_BLK_DEV_HD_IDE" = "y" -o "$CONFIG_BLK_DEV_HD_ONLY" = "y" ]; then
  1629. +  define_bool CONFIG_BLK_DEV_HD y
  1630. +else
  1631. +  define_bool CONFIG_BLK_DEV_HD n
  1632. +fi
  1633. +
  1634. +endmenu
  1635. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/Makefile linux/arch/arm/drivers/block/Makefile
  1636. --- linux.orig/arch/arm/drivers/block/Makefile    Thu Jan  1 01:00:00 1970
  1637. +++ linux/arch/arm/drivers/block/Makefile    Sun Aug 25 15:35:26 1996
  1638. @@ -0,0 +1,148 @@
  1639. +#
  1640. +# Makefile for the kernel block device drivers.
  1641. +#
  1642. +# Note! Dependencies are done automagically by 'make dep', which also
  1643. +# removes any old dependencies. DON'T put your own dependencies here
  1644. +# unless it's something special (ie not a .c file).
  1645. +#
  1646. +# Note 2! The CFLAGS definition is now inherited from the
  1647. +# parent makefile.
  1648. +#
  1649. +
  1650. +all: links first_rule
  1651. +
  1652. +L_TARGET := block.a
  1653. +L_OBJS   := ll_rw_blk.o genhd.o
  1654. +M_OBJS   :=
  1655. +MOD_LIST_NAME := BLOCK_MODULES
  1656. +
  1657. +LK      = README.fd README.hd README.ide README.md \
  1658. +        ide_modes.h ide-cd.c ide-tape.c ide-tape.h \
  1659. +        linear.c loop.c md.c raid0.c rd.c
  1660. +
  1661. +# Architecture dependencies
  1662. +
  1663. +ifeq ($(MACHINE),a5k)
  1664. +  FLOPPY = floppy.o floppydma.o
  1665. +  FLOPPYMOD = floppy-mod.o
  1666. +endif
  1667. +
  1668. +ifeq ($(MACHINE),arc)
  1669. +  FLOPPY = fd1772.o fd1772dma.o
  1670. +  FLOPPYMOD = fd1772-mod.o
  1671. +endif
  1672. +
  1673. +# Common dependencies
  1674. +
  1675. +ifdef FLOPPY
  1676. +  ifeq ($(CONFIG_BLK_DEV_FD),y)
  1677. +    L_OBJS += $(FLOPPY)
  1678. +  else
  1679. +    ifeq ($(CONFIG_BLK_DEV_FD),m)
  1680. +      M_OBJS += $(FLOPPYMOD)
  1681. +    endif
  1682. +  endif
  1683. +endif
  1684. +
  1685. +ifeq ($(CONFIG_BLK_DEV_IMG),y)
  1686. +  L_OBJS += adfsimg.o adfspart.o
  1687. +endif
  1688. +
  1689. +ifeq ($(CONFIG_BLK_DEV_RAM),y)
  1690. +  L_OBJS += rd.o
  1691. +else
  1692. +  ifeq ($(CONFIG_BLK_DEV_RAM),m)
  1693. +    M_OBJS += rd.o
  1694. +  endif
  1695. +endif
  1696. +
  1697. +ifeq ($(CONFIG_BLK_DEV_LOOP),y)
  1698. +  L_OBJS += loop.o
  1699. +else
  1700. +  ifeq ($(CONFIG_BLK_DEV_LOOP),m)
  1701. +    M_OBJS += loop.o
  1702. +  endif
  1703. +endif
  1704. +
  1705. +ifeq ($(CONFIG_BLK_DEV_HD),y)
  1706. +  L_OBJS += hd.o
  1707. +endif
  1708. +
  1709. +ifeq ($(CONFIG_BLK_DEV_IDE),y)
  1710. +  L_OBJS += ide.o
  1711. +endif
  1712. +
  1713. +ifeq (*(CONFIG_BLK_DEV_IDE_ICS),y)
  1714. +  L_OBJS += ide-ics.o
  1715. +else
  1716. +  ifeq ($(CONFIG_BLK_DEV_IDE_ICS),m)
  1717. +    M_OBJS += ide-ics.o
  1718. +  endif
  1719. +endif
  1720. +
  1721. +ifeq ($(CONFIG_BLK_DEV_IDECD),y)
  1722. +  L_OBJS += ide-cd.o
  1723. +endif
  1724. +
  1725. +ifeq ($(CONFIG_BLK_DEV_IDETAPE),y)
  1726. +  L_OBJS += ide-tape.o
  1727. +endif
  1728. +
  1729. +ifeq ($(CONFIG_BLK_DEV_XD),y)
  1730. +  L_OBJS += mfmhd.o mfm.o
  1731. +else
  1732. +  ifeq ($(CONFIG_BLK_DEV_XD),m)
  1733. +    M_OBJS += mfmhd_mod.o
  1734. +  endif
  1735. +endif
  1736. +
  1737. +ifeq ($(CONFIG_BLK_DEV_MD),y)
  1738. +  LX_OBJS += md.o
  1739. +  ifeq ($(CONFIG_MD_LINEAR),y)
  1740. +    L_OBJS += linear.o
  1741. +  else
  1742. +    ifeq ($(CONFIG_MD_LINEAR),m)
  1743. +      M_OBJS += linear.o
  1744. +    endif
  1745. +  endif
  1746. +  ifeq ($(CONFIG_MD_STRIPED),y)
  1747. +    L_OBJS += raid0.o
  1748. +  else
  1749. +    ifeq ($(CONFIG_MD_STRIPED),m)
  1750. +      M_OBJS += raid0.o
  1751. +    endif
  1752. +  endif
  1753. +endif
  1754. +
  1755. +include $(TOPDIR)/Rules.make
  1756. +
  1757. +fastdep: links
  1758. +
  1759. +# Most modules require to be linked against GCCLIB.
  1760. +
  1761. +floppy_mod.o: $(FLOPPY)
  1762. +    ld -r -o $@ $(FLOPPY) $(GCCLIB)
  1763. +
  1764. +fd1772_mod.o: $(FLOPPY)
  1765. +    ld -r -o $@ $(FLOPPY) $(GCCLIB)
  1766. +
  1767. +mfmhd_mod.o: mfmhd.o mfm.o
  1768. +    ld -r -o $@ mfmhd.o mfm.o $(GCCLIB)
  1769. +
  1770. +.PHONY: links
  1771. +links:
  1772. +    -@for f in $(LK); do \
  1773. +        if [ ! -e $$f ]; then \
  1774. +            echo "ln -s ../../../../drivers/block/$$f ."; \
  1775. +            ln -s ../../../../drivers/block/$$f .; \
  1776. +        fi; \
  1777. +    done
  1778. +
  1779. +mrproper:
  1780. +    -@for f in $(LK); do \
  1781. +        if [ -L $$f ]; then \
  1782. +            echo $(RM) $$f; \
  1783. +            $(RM) $$f; \
  1784. +        fi; \
  1785. +    done
  1786. +
  1787. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/adfs.h linux/arch/arm/drivers/block/adfs.h
  1788. --- linux.orig/arch/arm/drivers/block/adfs.h    Thu Jan  1 01:00:00 1970
  1789. +++ linux/arch/arm/drivers/block/adfs.h    Tue Apr  2 19:36:15 1996
  1790. @@ -0,0 +1,75 @@
  1791. +/*
  1792. + * linux/arch/arm/drivers/block/adfs.h
  1793. + *
  1794. + * Copyright (c) 1996 Russell King.
  1795. + */
  1796. +
  1797. +/*
  1798. + * Disc record size
  1799. + */
  1800. +#define RECSIZE 60
  1801. +
  1802. +/*
  1803. + * Disc record
  1804. + */
  1805. +struct disc_record {
  1806. +    unsigned char  log2secsize;
  1807. +    unsigned char  secspertrack;
  1808. +    unsigned char  heads;
  1809. +    unsigned char  density;
  1810. +    unsigned char  idlen;
  1811. +    unsigned char  log2bpmb;
  1812. +    unsigned char  skew;
  1813. +    unsigned char  bootoption;
  1814. +    unsigned char  lowsector;
  1815. +    unsigned char  nzones;
  1816. +    unsigned short zone_spare;
  1817. +    unsigned long  root;
  1818. +    unsigned long  disc_size;
  1819. +    unsigned short disc_id;
  1820. +    unsigned char  disc_name[10];
  1821. +    unsigned long  disc_type;
  1822. +};
  1823. +
  1824. +/*
  1825. + * Partition types.
  1826. + */
  1827. +#define PARTITION_RISCIX 1
  1828. +
  1829. +/*
  1830. + * New-directory disks have a separate attributes byte - this is the bit mask.
  1831. + */
  1832. +#define OBJ_OWNREAD    1
  1833. +#define OBJ_OWNWRITE    2
  1834. +#define OBJ_LOCKED    4
  1835. +#define OBJ_DIRECTORY    8
  1836. +#define OBJ_EXECUTE    16
  1837. +#define OBJ_PUBREAD    32
  1838. +#define OBJ_PUBWRITE    64
  1839. +
  1840. +/*
  1841. + * Offset in bytes of the boot block on the disk.
  1842. + */
  1843. +#define BOOT_SECTOR_ADDRESS 0xc00
  1844. +
  1845. +/*
  1846. + * Calculate the boot block checksum on an ADFS drive.  Note that this will
  1847. + * appear to be correct if the sector contains all zeros, so also check that
  1848. + * the disk size is non-zero!!!
  1849. + */
  1850. +extern inline int adfs_checkbblk (unsigned char *ptr)
  1851. +{
  1852. +    unsigned int result;
  1853. +    
  1854. +    __asm__ ("
  1855. +    adds    %3, %2, %3
  1856. +    sub    %3, %3, #1
  1857. +1:    ldrb    %4, [%3, #-1]!
  1858. +    adc    %0, %0, %4
  1859. +    movs    %0, %0, lsl #24
  1860. +    mov    %0, %0, lsr #24
  1861. +    teqs    %2, %3
  1862. +    bne    1b
  1863. +    " : "=r" (result) : "0" (0), "r" (ptr), "r" (512), "r" (0));
  1864. +    return result != ptr[511];
  1865. +}
  1866. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/adfsimg.c linux/arch/arm/drivers/block/adfsimg.c
  1867. --- linux.orig/arch/arm/drivers/block/adfsimg.c    Thu Jan  1 01:00:00 1970
  1868. +++ linux/arch/arm/drivers/block/adfsimg.c    Sat Aug  3 23:03:05 1996
  1869. @@ -0,0 +1,1119 @@
  1870. +/*
  1871. + * linux/arch/arm/drivers/block/adfsimg.c
  1872. + *
  1873. + * Copyright (c) 1996 Russell King.
  1874. + *
  1875. + * Implement image files under Linux (allows Linux to access partition files
  1876. + *  on ADFS disks).
  1877. + *
  1878. + * This file is split into two halves: the first half is the actual image
  1879. + * mapper creation code, and the second half is the device driver.
  1880. + *
  1881. + * Changelog:
  1882. + *  28-03-1996    RMK    Created
  1883. + *  02-04-1996    RMK    Cleaned up per-device data into structure [should
  1884. + *              improve code].
  1885. + *  24-06-1996    RMK    Marked 4GB problem areas.
  1886. + *            Altered blocksize checking code - now uses the larger
  1887. + *              of the sector size and map bit size.
  1888. + *  04-06-1996    RMK    Re-wrote mapping function.  Now applies mapping as
  1889. + *              blocks come to be put on the queues.
  1890. + *  06-06-1996    RMK    Pass through blocks that need to be split up.
  1891. + */
  1892. +
  1893. +#include <linux/kernel.h>
  1894. +#include <linux/major.h>
  1895. +#include <linux/string.h>
  1896. +#include <linux/ctype.h>
  1897. +#include <linux/malloc.h>
  1898. +#include <linux/blkdev.h>
  1899. +#include <linux/errno.h>
  1900. +#include <linux/genhd.h>
  1901. +#include <linux/hdreg.h>
  1902. +
  1903. +#include <asm/segment.h>
  1904. +#include <asm/bitops.h>
  1905. +
  1906. +#define MAJOR_NR ADFSIMG_MAJOR
  1907. +#include "blk.h"
  1908. +#include "adfs.h"
  1909. +
  1910. +/*----------------------------------------------------------------------------------------
  1911. + * User configuration
  1912. + *
  1913. + * Number of minors per device, and number of devices.  Note that we have
  1914. + * a limit of 256 on the number of minors at the moment.
  1915. + */
  1916. +#define ADFSIMG_SHIFT    5
  1917. +#define ADFSIMG_NRDEV    (256 / (1 << ADFSIMG_SHIFT))
  1918. +#define ADFSIMG_PARMASK    ((1 << ADFSIMG_SHIFT) - 1)
  1919. +/*
  1920. + * This maps a device onto an index into the adfsimage structure
  1921. + */
  1922. +#define TARGETMAP(kdev) DEVICE_NR(kdev)
  1923. +/*
  1924. + * Debugging contants...
  1925. + */
  1926. +#define DEBUG_SWAP        32
  1927. +#define DEBUG_CHANGED        16
  1928. +#define DEBUG_MAPPING        8
  1929. +#define DEBUG_BUFFERS        4
  1930. +#define DEBUG_REQUESTS        2
  1931. +#define DEBUG_ADDMAPPING    1
  1932. +#define DEBUG            (DEBUG_CHANGED)
  1933. +
  1934. +/*
  1935. + * This is left over from the old code - the old !Config filenames for the files
  1936. + * get copied into this array.
  1937. + */
  1938. +static char arc_hd_files[8][128];
  1939. +
  1940. +struct adfsimage {
  1941. +    kdev_t        dev;        /* device on which to look for filename        */
  1942. +    char        *filename;    /* adfs filename without the 'fsname::drive.$.'    */
  1943. +    /*
  1944. +     * Private data
  1945. +     */
  1946. +    kdev_t        mapdev;        /* Current device map array is associated with    */
  1947. +    struct map        *mapstrt;    /* Map array                    */
  1948. +    unsigned int    mapsize;    /* number of map entries - 1            */
  1949. +    unsigned int    mapalloced;    /* Size of map array                */
  1950. +    unsigned int    blocksize;    /* blocksize this device supports        */
  1951. +    unsigned int    accesscount;    /* number of times this has been opened        */
  1952. +    unsigned int    capacity;    /* number of sectors in this image file        */
  1953. +    struct request    *req;        /* Currently executing request            */
  1954. +    struct file        filp;        /* fake filp for open device            */
  1955. +    struct inode    inode;        /* fake inode for open device            */
  1956. +    unsigned char    busy:1,        /* Device is currently busy            */
  1957. +            changed:1;    /* Mapped device has been changed        */
  1958. +} adfsimg_images[ADFSIMG_NRDEV] = {
  1959. +  { 0, arc_hd_files[0], 0x000, NULL, 0, 0, 0, 0, 0, NULL, {0, }, {0, }, 0, 0 },
  1960. +  { 0, arc_hd_files[1], 0x000, NULL, 0, 0, 0, 0, 0, NULL, {0, }, {0, }, 0, 0 },
  1961. +  { 0, arc_hd_files[2], 0x000, NULL, 0, 0, 0, 0, 0, NULL, {0, }, {0, }, 0, 0 },
  1962. +  { 0, arc_hd_files[3], 0x000, NULL, 0, 0, 0, 0, 0, NULL, {0, }, {0, }, 0, 0 },
  1963. +  { 0, arc_hd_files[4], 0x000, NULL, 0, 0, 0, 0, 0, NULL, {0, }, {0, }, 0, 0 },
  1964. +  { 0, arc_hd_files[5], 0x000, NULL, 0, 0, 0, 0, 0, NULL, {0, }, {0, }, 0, 0 },
  1965. +  { 0, arc_hd_files[6], 0x000, NULL, 0, 0, 0, 0, 0, NULL, {0, }, {0, }, 0, 0 },
  1966. +  { 0, arc_hd_files[7], 0x000, NULL, 0, 0, 0, 0, 0, NULL, {0, }, {0, }, 0, 0 }
  1967. +};
  1968. +
  1969. +void adfsimg_add_image (int slot, kdev_t dev, char *path)
  1970. +{
  1971. +    adfsimg_images[slot].dev = dev;
  1972. +    strcpy (adfsimg_images[slot].filename, path);
  1973. +}
  1974. +
  1975. +struct map {
  1976. +    unsigned long strt_sblk;
  1977. +    unsigned long strt_dblk;
  1978. +    unsigned long length;
  1979. +};
  1980. +
  1981. +static struct wait_queue *busy_wait;
  1982. +
  1983. +/*
  1984. + * These are private to the map generation code
  1985. + */
  1986. +static void *_adfsimg_map;
  1987. +static struct disc_record adfsimg_dr;
  1988. +static int adfsimg_zonesize;
  1989. +static int adfsimg_idsperzone;
  1990. +static int adfsimg_maplen;
  1991. +
  1992. +/*
  1993. + * Lock a device - prevents opens/closes/revalidates all happening at the same time.
  1994. + */
  1995. +static inline void
  1996. +adfsimg_lockdev (struct adfsimage *img)
  1997. +{
  1998. +    while (img->busy) {
  1999. +        barrier ();
  2000. +    sleep_on (&busy_wait);
  2001. +    }
  2002. +    img->busy = 1;
  2003. +}    
  2004. +
  2005. +static inline void
  2006. +adfsimg_unlockdev (struct adfsimage *img)
  2007. +{
  2008. +    img->busy = 0;
  2009. +    wake_up (&busy_wait);
  2010. +}
  2011. +
  2012. +/*
  2013. + * read blocks to an area of memory.  [eg map, boot block etc].
  2014. + */
  2015. +static void *
  2016. +adfsimg_read (void *data, struct adfsimage *img, unsigned long blkaddr, int length)
  2017. +{
  2018. +    struct buffer_head *bh;
  2019. +    unsigned char *p;
  2020. +
  2021. +    for (p = (unsigned char *)data; length > 0; blkaddr ++, length -= img->blocksize) {
  2022. +    bh = breada (img->dev, blkaddr, img->blocksize, 0, PAGE_SIZE);
  2023. +
  2024. +    if (!bh)
  2025. +        return NULL;
  2026. +    memcpy (p, bh->b_data, img->blocksize);
  2027. +    p += img->blocksize;
  2028. +    brelse (bh);
  2029. +    }
  2030. +
  2031. +    return data;
  2032. +}
  2033. +
  2034. +/*
  2035. + * Calculate block number for zone, zone index.
  2036. + */
  2037. +static inline unsigned long
  2038. +adfsimg_calcblockno (struct adfsimage *img, unsigned int zone, unsigned int start)
  2039. +{
  2040. +    /* *** 4GB LIMITATION ALERT! *** */
  2041. +    return (((zone ? zone * adfsimg_zonesize - RECSIZE * 8 : 0) + start) << adfsimg_dr.log2bpmb) /
  2042. +           img->blocksize;
  2043. +}
  2044. +
  2045. +static inline void
  2046. +adfsimg_addmapping (struct adfsimage *img, unsigned int zone, unsigned int start, unsigned int len)
  2047. +{
  2048. +    struct map newmap;
  2049. +
  2050. +    /*
  2051. +     * totaladdr  - starting block number for this segment
  2052. +     * startaddr  - sector on media for start
  2053. +     * lengthaddr - length in sectors of this block
  2054. +     */
  2055. +#if DEBUG & DEBUG_ADDMAPPING
  2056. +    printk ("Z: %8d S: %8d E: %8d ", zone, start, start + len);
  2057. +#endif
  2058. +    newmap.strt_sblk = 0;
  2059. +    newmap.strt_dblk = adfsimg_calcblockno (img, zone, start);
  2060. +    /* *** 4GB LIMITATION ALERT! *** */
  2061. +    newmap.length    = (len << adfsimg_dr.log2bpmb) / img->blocksize;
  2062. +
  2063. +    if (!img->mapstrt) {
  2064. +    img->mapstrt = kmalloc (5 * sizeof (newmap), GFP_KERNEL);
  2065. +    img->mapsize = 0; /* Size - 1 */
  2066. +    img->mapalloced = 5; /* allocated size */
  2067. +    memcpy (img->mapstrt, &newmap, sizeof (newmap));
  2068. +    } else {
  2069. +    struct map *mp;
  2070. +    mp = img->mapstrt + img->mapsize;
  2071. +    if (mp->strt_dblk + mp->length == newmap.strt_dblk)
  2072. +        mp->length += newmap.length;
  2073. +    else
  2074. +    if (img->mapsize < img->mapalloced - 1) {
  2075. +        newmap.strt_sblk = mp->strt_sblk + mp->length;
  2076. +        img->mapsize ++;
  2077. +        memcpy (&img->mapstrt[img->mapsize], &newmap, sizeof (newmap));
  2078. +    } else {
  2079. +        newmap.strt_sblk = mp->strt_sblk + mp->length;
  2080. +        mp = kmalloc ((img->mapalloced + 5) * sizeof (newmap), GFP_KERNEL);
  2081. +        img->mapalloced += 5;
  2082. +        img->mapsize ++;
  2083. +        memcpy (mp, img->mapstrt, img->mapsize * sizeof (newmap));
  2084. +        kfree (img->mapstrt);
  2085. +        img->mapstrt = mp;
  2086. +        memcpy (&img->mapstrt[img->mapsize], &newmap, sizeof (newmap));
  2087. +    }
  2088. +    }
  2089. +#if DEBUG & DEBUG_ADDMAPPING
  2090. +    printk ("SSB: %08lX STB: %08lX LEN: %08lX\n", img->mapstrt[img->mapsize].strt_sblk,
  2091. +        img->mapstrt[img->mapsize].strt_dblk, img->mapstrt[img->mapsize].length);
  2092. +#endif
  2093. +}
  2094. +
  2095. +static unsigned long
  2096. +adfsimg_scanmap (struct adfsimage *img, unsigned long internaladdr, int objlength, int simple)
  2097. +{
  2098. +    unsigned int fragment, zone, startzone, sectoroff, mapoff, found;
  2099. +
  2100. +    fragment  = (int)internaladdr >> 8;
  2101. +    startzone = zone = fragment / adfsimg_idsperzone;
  2102. +    sectoroff = (internaladdr & 0xff) ? (internaladdr & 0xff) - 1 : 0;
  2103. +/*
  2104. + * Problem area: if log2secsize < log2bpmb, then the map offset calculation
  2105. + *    breaks horribly.  However, can an internal address refer to a non-allocation
  2106. + *    unit sector offset?
  2107. + *
  2108. + * Ideas:
  2109. + *  if (adfsimg_dr.log2secsize > adfsimg_dr.log2bpmb)
  2110. + *    mapoff = sectoroff << (adfsimg_dr.log2secsize - adfsimg_dr.log2bpmb);
  2111. + *  else
  2112. + *    mapoff = sectoroff >> (adfsimg_dr.log2bpmb - adfsimg_dr.log2secsize);
  2113. + *
  2114. + *  shift = adfsimg_dr.log2secsize - adfsimg_dr.log2bpmb;
  2115. + *  if (shift < 0)
  2116. + *    mapoff = sectoroff >> (- shift);
  2117. + *  else
  2118. + *    mapoff = sectoroff << shift;
  2119. + */
  2120. +    mapoff = sectoroff << (adfsimg_dr.log2secsize - adfsimg_dr.log2bpmb);
  2121. +    objlength >>= adfsimg_dr.log2bpmb;
  2122. +    found = 0;
  2123. +
  2124. +    do {
  2125. +        unsigned char const *map;
  2126. +        unsigned int bmoff, bmoff_max;
  2127. +
  2128. +    map = ((unsigned char *)_adfsimg_map) + (zone << adfsimg_dr.log2secsize) + 4 +
  2129. +            (zone == 0 ? RECSIZE : 0);
  2130. +    bmoff_max = adfsimg_zonesize - ((zone == 0) ? RECSIZE << 3 : 0);
  2131. +    bmoff = 0;
  2132. +
  2133. +    while (bmoff < bmoff_max) {
  2134. +        unsigned long t;
  2135. +        unsigned int n, start;
  2136. +        int z;
  2137. +
  2138. +        start = bmoff;
  2139. +        z = bmoff >> 3;
  2140. +
  2141. +        t = ((map[z] | (map[z + 1] << 8) | (map[z + 2] << 16)) >> (bmoff & 7))
  2142. +        & ((1 << adfsimg_dr.idlen) - 1);
  2143. +        bmoff += adfsimg_dr.idlen;
  2144. +
  2145. +        /*
  2146. +         * I think that this would be better coded in assembler...
  2147. +         */
  2148. +        if (bmoff & 7) {
  2149. +            n = map[bmoff >> 3] >> (bmoff & 7);
  2150. +            if (!n)
  2151. +            bmoff = (bmoff + 8) & ~7;
  2152. +        else
  2153. +            for (; (n & 1) == 0; n >>= 1, bmoff += 1);
  2154. +        }
  2155. +        if (!(bmoff & 7)) {
  2156. +        while ((n = map[bmoff >> 3]) == 0)
  2157. +            bmoff += 8;
  2158. +
  2159. +        for (; (n & 1) == 0; n >>= 1, bmoff += 1);
  2160. +            }
  2161. +        bmoff += 1;
  2162. +        if (t == fragment) {
  2163. +        int length = bmoff - start;
  2164. +        if (mapoff) {
  2165. +            if (length < mapoff) {
  2166. +            mapoff -= length;
  2167. +            length = 0;
  2168. +            } else {
  2169. +            start += mapoff;
  2170. +            length -= mapoff;
  2171. +                mapoff = 0;
  2172. +            }
  2173. +        }
  2174. +        if (length) {
  2175. +            if (objlength < length)
  2176. +            length = objlength;
  2177. +            objlength -= length;
  2178. +            if (simple)
  2179. +            return adfsimg_calcblockno (img, zone, start);
  2180. +            else
  2181. +            adfsimg_addmapping(img, zone, start, length);
  2182. +            found += 1;
  2183. +            if (!objlength)
  2184. +            return found;
  2185. +        }
  2186. +        }
  2187. +    }
  2188. +    zone += 1;
  2189. +    if (zone == adfsimg_dr.nzones)
  2190. +        zone = 0;
  2191. +    bmoff = 0;
  2192. +    } while (zone != startzone);
  2193. +    return found;
  2194. +}
  2195. +
  2196. +static int
  2197. +adfsimg_decenddirs (struct adfsimage *img, int showinfo, unsigned long diraddr, char **ptr)
  2198. +{
  2199. +    char *leftptr, *p;
  2200. +    char dirname[16];
  2201. +    unsigned char *dir;
  2202. +    int i, length;
  2203. +
  2204. +    dir = kmalloc (2048, GFP_KERNEL);
  2205. +    if (!dir)
  2206. +    return 0;
  2207. +
  2208. +    leftptr = *ptr;
  2209. +
  2210. +    while (1) {
  2211. +        unsigned char *dirptr;
  2212. +    if (!adfsimg_read (dir, img, diraddr, 2048)) {
  2213. +        if (showinfo)
  2214. +        printk (" dir unreadable");
  2215. +        kfree (dir);
  2216. +        return 0;
  2217. +    }
  2218. +    /*
  2219. +     * Check that the directory looks feasable
  2220. +     */
  2221. +    if ((strncmp ((char *)dir + 1, "Nick", 4) && strncmp ((char *)dir + 1, "Hugo", 4)) ||
  2222. +        strncmp ((char *)dir + 1, (char *)dir + 2043, 4)) {
  2223. +        if (showinfo)
  2224. +        printk (" broken dir");
  2225. +        kfree (dir);
  2226. +        return 0;
  2227. +    }
  2228. +
  2229. +    p = strchr (leftptr, '.');
  2230. +    if (!p)
  2231. +        strcpy (dirname, leftptr);
  2232. +    else {
  2233. +        strncpy (dirname, leftptr, p - leftptr);
  2234. +        dirname[p - leftptr] = '\0';
  2235. +        leftptr = ++p;
  2236. +    }
  2237. +
  2238. +    for (dirptr = dir + 5; *dirptr; dirptr += 26) {
  2239. +        for (i = 0; i < 10; i++) {
  2240. +            char c1, c2;
  2241. +            if (dirptr[i] == 0x0d || dirname[i] == '\0')
  2242. +            break;
  2243. +        c1 = tolower(dirptr[i]);
  2244. +        c2 = tolower(dirname[i]);
  2245. +        if (c1 != c2)
  2246. +            break;
  2247. +        }
  2248. +        if (dirname[i] == '\0' && (i == 10 || dirptr[i] == 0x0d))
  2249. +        break;
  2250. +    }
  2251. +
  2252. +    if (!*dirptr) {
  2253. +        if (showinfo)
  2254. +        printk (" %s '%s' not found\n", p ? "dir" : "file", dirname);
  2255. +        kfree (dir);
  2256. +        return 0;
  2257. +    }
  2258. +
  2259. +    /*
  2260. +     * Check that we're not referencing a file when we mean a directory or
  2261. +     * vice versa.
  2262. +     */
  2263. +    if ((dirptr[25] & OBJ_DIRECTORY && !p) || (!(dirptr[25] & OBJ_DIRECTORY) && p)) {
  2264. +        if (showinfo)
  2265. +        printk (" %s '%s' is not a %s\n", p ? "file" : "dir", dirname, p ? "dir" : "file");
  2266. +        kfree (dir);
  2267. +        return 0;
  2268. +    }
  2269. +
  2270. +    length = (unsigned long) dirptr[18] | (dirptr[19] << 8) |
  2271. +         (dirptr[20] << 16) | (dirptr[21] << 24);
  2272. +    diraddr = (unsigned long) dirptr[22] | (dirptr[23] << 8) | (dirptr[24] << 16);
  2273. +    diraddr = adfsimg_scanmap (img, diraddr, length, p ? 1 : 0);
  2274. +    if (!diraddr) {
  2275. +        if (showinfo)
  2276. +        printk (" internal error");
  2277. +        kfree (dir);
  2278. +        return 0;
  2279. +    }
  2280. +    if (!p) {
  2281. +        /*
  2282. +         * We must have come to the end of the string.  This entry is the
  2283. +         * filename.
  2284. +         */
  2285. +        kfree (dir);
  2286. +        return 1;
  2287. +    }
  2288. +    }
  2289. +}
  2290. +
  2291. +/*
  2292. + * Read in either map, and check the cross-check.  If the first map
  2293. + * has an invalid cross-check, try the other map.
  2294. + */
  2295. +static unsigned long
  2296. +adfsimg_readmap (struct adfsimage *img, int showinfo)
  2297. +{
  2298. +    unsigned int map_no, bad, maplen;
  2299. +    unsigned long mapaddr;
  2300. +
  2301. +    /* *** 4GB LIMITATION ALERT! *** */
  2302. +    mapaddr = (((adfsimg_dr.nzones >> 1) * adfsimg_zonesize -
  2303. +        ((adfsimg_dr.nzones > 1) ? RECSIZE * 8 : 0)) << adfsimg_dr.log2bpmb) /
  2304. +            img->blocksize;
  2305. +    adfsimg_maplen = adfsimg_dr.nzones << adfsimg_dr.log2secsize;
  2306. +    maplen = (adfsimg_maplen | (img->blocksize - 1)) / img->blocksize;
  2307. +
  2308. +    if (!(_adfsimg_map = vmalloc (maplen * img->blocksize))) {
  2309. +    if (showinfo)
  2310. +        printk (" no mem");
  2311. +    return 0;
  2312. +    }
  2313. +
  2314. +    /*
  2315. +     * We try to read the first map.
  2316. +     */
  2317. +    for (map_no = 0; map_no < 2; map_no ++) {
  2318. +    unsigned long blk_strt;
  2319. +    unsigned int off, chk;
  2320. +    unsigned char *map;
  2321. +
  2322. +    /*
  2323. +     * If img->blocksize > 1<<adfsimg_dr.log2secsize, then we could
  2324. +     * have problems here when trying the second map.
  2325. +     */
  2326. +    blk_strt = mapaddr + (map_no ? maplen : 0);
  2327. +    bad = 0;
  2328. +
  2329. +    if (!adfsimg_read (_adfsimg_map, img, blk_strt, maplen * img->blocksize)) {
  2330. +        bad = 1;
  2331. +        if (showinfo)
  2332. +        printk (" map %d unreadable", map_no);
  2333. +        break;
  2334. +    }
  2335. +
  2336. +    map = (unsigned char *)_adfsimg_map;
  2337. +    for (off = 3, chk = 0; off < (adfsimg_dr.nzones << adfsimg_dr.log2secsize);
  2338. +            off += 1 << adfsimg_dr.log2secsize)
  2339. +        chk ^= map[off];
  2340. +
  2341. +    if (chk != 0xff) {
  2342. +        bad = 1;
  2343. +        if (showinfo)
  2344. +        printk (" map %d corrupt", map_no + 1);
  2345. +    } else
  2346. +        break;
  2347. +    }
  2348. +    if (bad)
  2349. +        vfree (_adfsimg_map);
  2350. +
  2351. +    return bad ? 0 : mapaddr + 2 * maplen;
  2352. +}
  2353. +
  2354. +/*
  2355. + * Read in the boot sector, and validate it.  Also validate the
  2356. + * block size that we are using.
  2357. + */
  2358. +static struct disc_record *
  2359. +adfsimg_readbootsect (struct adfsimage *img, int showinfo)
  2360. +{
  2361. +    unsigned char *boot_sectors;
  2362. +    int allocation_unit_size;
  2363. +    struct buffer_head *bh;
  2364. +
  2365. +    if (!(bh = bread (img->dev, BOOT_SECTOR_ADDRESS / img->blocksize,
  2366. +        img->blocksize > 512 ? img->blocksize : 512))) {
  2367. +    if (showinfo)
  2368. +        printk (" bread failed");
  2369. +    return NULL;
  2370. +    }
  2371. +
  2372. +    boot_sectors = bh->b_data + BOOT_SECTOR_ADDRESS % img->blocksize;
  2373. +
  2374. +    if (adfs_checkbblk (boot_sectors)) {
  2375. +    if (showinfo)
  2376. +        printk (" non-adfs");
  2377. +    brelse (bh);
  2378. +    return NULL;
  2379. +    }
  2380. +
  2381. +    memcpy (&adfsimg_dr, boot_sectors + 0x1c0, sizeof (adfsimg_dr));
  2382. +    brelse (bh);
  2383. +
  2384. +    /*
  2385. +     * The blocksize must not be larger than the sector size specified
  2386. +     * in the boot sector, or else all this code breaks.
  2387. +     */
  2388. +    if (adfsimg_dr.log2secsize > adfsimg_dr.log2bpmb)
  2389. +    allocation_unit_size = 1 << adfsimg_dr.log2secsize;
  2390. +    else
  2391. +    allocation_unit_size = 1 << adfsimg_dr.log2bpmb;
  2392. +    if (img->blocksize > allocation_unit_size) {
  2393. +    if (showinfo)
  2394. +        printk (" allocation unit size too large - %d > %d", img->blocksize, allocation_unit_size);
  2395. +    return NULL;
  2396. +    }
  2397. +
  2398. +    return &adfsimg_dr;
  2399. +}
  2400. +
  2401. +static int adfsimg_init_onedisk (int target, int showinfo)
  2402. +{
  2403. +    struct adfsimage *img = adfsimg_images + target;
  2404. +    unsigned long root_dir_address;
  2405. +    unsigned int blocksize;
  2406. +    char *p;
  2407. +
  2408. +    img->mapdev = MKDEV(UNNAMED_MAJOR, 0);
  2409. +    if (MAJOR(img->dev) == ADFSIMG_MAJOR)
  2410. +    return 0;
  2411. +
  2412. +    if (img->filename == NULL || strlen (img->filename) == 0 || MAJOR(img->dev) == UNNAMED_MAJOR)
  2413. +    return 0;
  2414. +
  2415. +    if (showinfo)
  2416. +    printk (" im%c", target + 'a');
  2417. +
  2418. +    /*
  2419. +     * Sort out the sector size that we can support.  Most devices
  2420. +     * default to 1024 byte blocks, and 512 byte sectors.
  2421. +     *
  2422. +     * TODO:
  2423. +     * However, we do check this against the size wanted in the boot
  2424. +     * block.  If it says that the sector size is 1024, then we might
  2425. +     * as well stick with 1024 byte blocks, otherwise switch to 512...
  2426. +     *
  2427. +     * Change:
  2428. +     * We now check the blocksize against the larger of the sector size
  2429. +     * and the map bit size.
  2430. +     */
  2431. +    if (hardsect_size[MAJOR(img->dev)])
  2432. +    blocksize = hardsect_size[MAJOR(img->dev)][MINOR(img->dev)];
  2433. +    else
  2434. +    blocksize = 512;
  2435. +
  2436. +    set_blocksize (img->dev, blocksize);
  2437. +    img->blocksize = blocksize;
  2438. +
  2439. +    /*
  2440. +     * Now read in the boot sector.  This has to be blocksize
  2441. +     * independent.
  2442. +     */
  2443. +    if (!adfsimg_readbootsect (img, showinfo))
  2444. +    return 0;
  2445. +
  2446. +    adfsimg_zonesize   = (8 << adfsimg_dr.log2secsize) - adfsimg_dr.zone_spare;
  2447. +    adfsimg_idsperzone = adfsimg_zonesize / (adfsimg_dr.idlen + 1);
  2448. +
  2449. +    if (!(root_dir_address = adfsimg_readmap (img, showinfo)))
  2450. +    return 0;
  2451. +
  2452. +    p = img->filename;
  2453. +    adfsimg_decenddirs (img, showinfo, root_dir_address, &p);
  2454. +
  2455. +    if (_adfsimg_map != NULL) {
  2456. +    vfree (_adfsimg_map);
  2457. +    _adfsimg_map = NULL;
  2458. +    }
  2459. +
  2460. +    img->mapdev = img->dev;
  2461. +
  2462. +    return img->mapstrt[img->mapsize].strt_sblk + img->mapstrt[img->mapsize].length;
  2463. +}
  2464. +
  2465. +/*
  2466. + * Get an index into the mapping array for this 'block'.  Once we have found
  2467. + * it, then as we map following blocks, we can just increment the index.
  2468. + */
  2469. +static inline int adfsimg_getindex (struct adfsimage *img, unsigned long block)
  2470. +{
  2471. +    unsigned int i, low, high;
  2472. +    const struct map *mp;
  2473. +
  2474. +    mp = img->mapstrt;
  2475. +
  2476. +    if (block >= (mp[img->mapsize].strt_sblk + mp[img->mapsize].length)) {
  2477. +    printk ("%s: access requested to block outside device: blk %lX\n",
  2478. +        kdevname (img->dev), block);
  2479. +    return -1;
  2480. +    }
  2481. +    for (low = 0, i = (high = img->mapsize) / 2; low != high; i = (high + low) >> 1) {
  2482. +    if (block < mp[i].strt_sblk)
  2483. +        high = i;
  2484. +    else if (block >= mp[i].strt_sblk + mp[i].length)
  2485. +        low = i + 1;
  2486. +    else break;
  2487. +    }
  2488. +#if DEBUG & DEBUG_MAPPING
  2489. +    printk ("Map entry: %lX [%lX-%lX]->[%lX-%lX]\n", block,
  2490. +        mp[i].strt_sblk, mp[i].strt_sblk + mp[i].length,
  2491. +        mp[i].strt_dblk, mp[i].strt_dblk + mp[i].length);
  2492. +#endif
  2493. +    return i;
  2494. +}
  2495. +
  2496. +/*========================================================================================
  2497. + * This is the 'device' driver for the image files.
  2498. + */
  2499. +
  2500. +static struct hd_struct adfsimg_parts[256] = { {0, 0}, };
  2501. +
  2502. +/*
  2503. + * Every request that comes in here is a request that needs to be split up into
  2504. + * a maximum of 64 separate requests.
  2505. + */
  2506. +static void adfsimg_request (void)
  2507. +{
  2508. +    while (1) {
  2509. +    unsigned int target, minor;
  2510. +    unsigned long block, length, nsectors, offset;
  2511. +    struct adfsimage *img;
  2512. +    int index;
  2513. +
  2514. +    INIT_REQUEST;
  2515. +
  2516. +    target = TARGETMAP(CURRENT->rq_dev);
  2517. +    img = adfsimg_images + target;
  2518. +
  2519. +    if (MAJOR(img->mapdev) == UNNAMED_MAJOR) {
  2520. +        printk (KERN_ERR
  2521. +        "im%c: request for mapping to unnamed device\n",
  2522. +            target + 'a');
  2523. +        end_request (0);
  2524. +        continue;
  2525. +    }
  2526. +
  2527. +    if (img->changed) {
  2528. +        end_request (0);
  2529. +        continue;
  2530. +    }
  2531. +
  2532. +    minor = MINOR(CURRENT->rq_dev);
  2533. +    block = CURRENT->sector;
  2534. +    nsectors = CURRENT->current_nr_sectors;
  2535. +    if (block >= adfsimg_parts[minor].nr_sects ||
  2536. +        (block + nsectors) > adfsimg_parts[minor].nr_sects) {
  2537. +        printk (KERN_ERR
  2538. +        "im%c: invalid block/size: minor = %u, block = %lu count = %lu\n",
  2539. +            target + 'a', minor, block, nsectors);
  2540. +        end_request (0);
  2541. +        continue;
  2542. +    }
  2543. +
  2544. +    block += adfsimg_parts[minor].start_sect;
  2545. +    index = adfsimg_getindex (img, block);
  2546. +    if (index < 0) {
  2547. +        printk (KERN_ERR
  2548. +            "im%c: invalid index: block = %lX\n", target + 'a', block);
  2549. +        end_request (0);
  2550. +        continue;
  2551. +    }
  2552. +#if 0
  2553. +     printk (KERN_ERR "Received an adfsimg_request (blk %lu len %lu ", block, nsectors);
  2554. +#endif
  2555. +    offset = block - img->mapstrt[index].strt_sblk;
  2556. +    block = offset + img->mapstrt[index].strt_dblk;
  2557. +    length = img->mapstrt[index].length - offset;
  2558. +#if 0
  2559. +    printk ("-> blk %lu len %lu), blksz=%d ", block, length, img->blocksize);
  2560. +#endif
  2561. +
  2562. +    while (nsectors) {
  2563. +        struct buffer_head *bh;
  2564. +        bh = getblk (img->mapdev, block, img->blocksize);
  2565. +        if (!bh) {
  2566. +        printk (KERN_ERR
  2567. +            "im%c: getblk(-,%ld,%d) returned NULL",
  2568. +            target + 'a', block, img->blocksize);
  2569. +        end_request (0);
  2570. +        break;
  2571. +        }
  2572. +        if (!buffer_uptodate(bh) && CURRENT->cmd == READ) {
  2573. +        ll_rw_block(READ, 1, &bh);
  2574. +        wait_on_buffer(bh);
  2575. +        if (!buffer_uptodate(bh)) {
  2576. +            brelse(bh);
  2577. +#if 0
  2578. +            printk ("error\n");
  2579. +#endif
  2580. +            end_request (0);
  2581. +            break;
  2582. +        }
  2583. +        }
  2584. +        if (CURRENT->cmd == READ)
  2585. +        memcpy (CURRENT->buffer, bh->b_data, img->blocksize);
  2586. +        else {
  2587. +            memcpy (bh->b_data, CURRENT->buffer, img->blocksize);
  2588. +            mark_buffer_uptodate(bh, 1);
  2589. +            mark_buffer_dirty(bh, 1);
  2590. +        }
  2591. +        brelse(bh);
  2592. +        CURRENT->buffer += img->blocksize;
  2593. +        CURRENT->sector += img->blocksize >> 9;
  2594. +        nsectors -= 1;
  2595. +        block ++;
  2596. +        if (!--length) {
  2597. +            index ++;
  2598. +        block = img->mapstrt[index].strt_dblk;
  2599. +        length = img->mapstrt[index].length;
  2600. +        }
  2601. +        if (nsectors == 0) {
  2602. +#if 0
  2603. +        printk ("ok\n");
  2604. +#endif
  2605. +        end_request (1);
  2606. +        }        
  2607. +    }
  2608. +    }
  2609. +}
  2610. +
  2611. +static int adfsimg_revalidate_disk (kdev_t dev, int maxusage);
  2612. +/*
  2613. + * TODO:
  2614. + *   IOCTL to get mapping filenames
  2615. + *   IOCTL to set mapping filenames
  2616. + *    - lock device.
  2617. + *    - set changed flag on device.
  2618. + *    - create new map.
  2619. + *    - unlock device.
  2620. + */
  2621. +static int
  2622. +adfsimg_ioctl (struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
  2623. +{
  2624. +    struct hd_geometry *loc = (struct hd_geometry *) arg;
  2625. +    int err, target;
  2626. +
  2627. +    if (!inode || !(inode->i_rdev))
  2628. +    return -EINVAL;
  2629. +
  2630. +    target = TARGETMAP(inode->i_rdev);
  2631. +
  2632. +    if (target >= ADFSIMG_NRDEV)
  2633. +    return -ENODEV;
  2634. +
  2635. +    switch (cmd) {
  2636. +    case HDIO_GETGEO:
  2637. +    if (!loc) return -EINVAL;
  2638. +    err = verify_area (VERIFY_WRITE, loc, sizeof (*loc));
  2639. +    if (err)
  2640. +        return err;
  2641. +    put_user (4, (char *)&loc->heads);
  2642. +    put_user (17, (char *)&loc->sectors);
  2643. +    put_user (adfsimg_parts[MINOR(inode->i_rdev)].nr_sects / (17 * 4), (short *)&loc->cylinders);
  2644. +    put_user (adfsimg_parts[MINOR(inode->i_rdev)].start_sect, (long *)&loc->start);
  2645. +    return 0;
  2646. +    case BLKRASET:
  2647. +    if (!suser ()) return -EACCES;
  2648. +    if (arg > 0xff) return -EINVAL;
  2649. +    read_ahead[MAJOR(inode->i_rdev)] = arg;
  2650. +    return 0;
  2651. +    case BLKRAGET:
  2652. +    if (!arg)  return -EINVAL;
  2653. +    err = verify_area (VERIFY_WRITE, (long *)arg, sizeof (long));
  2654. +    if (err)
  2655. +        return err;
  2656. +    put_user (read_ahead[MAJOR(inode->i_rdev)], (long *)arg);
  2657. +    return 0;
  2658. +    case BLKGETSIZE: /* Return device size */
  2659. +    if (!arg)  return -EINVAL;
  2660. +    err = verify_area (VERIFY_WRITE, (long *)arg, sizeof (long));
  2661. +    if (err)
  2662. +        return err;
  2663. +    put_user (adfsimg_parts[MINOR(inode->i_rdev)].nr_sects, (long *)arg);
  2664. +    return 0;
  2665. +    case BLKFLSBUF:
  2666. +    if (!suser ()) return -EACCES;
  2667. +    fsync_dev (inode->i_rdev);
  2668. +    invalidate_buffers (inode->i_rdev);
  2669. +    return 0;
  2670. +
  2671. +    case BLKRRPART:
  2672. +    return adfsimg_revalidate_disk (inode->i_rdev, 1);
  2673. +#if 0
  2674. +    case IMGFNGET:
  2675. +    return -EINVAL;
  2676. +
  2677. +    case IMGFNSET:
  2678. +    if (!suser ()) return -EACCES;
  2679. +    return -EINVAL;
  2680. +#endif
  2681. +
  2682. +    RO_IOCTLS(inode->i_rdev, arg);
  2683. +    default:
  2684. +    return -EINVAL;
  2685. +    }
  2686. +}
  2687. +
  2688. +/*
  2689. + * Open an mapped device.  Check for disk changes etc, and open
  2690. + * the real device.  This means that if that device wants to, it
  2691. + * can do things like locking the drive door.  We force ourself
  2692. + * to be busy while opening the real device.
  2693. + */
  2694. +static int adfsimg_open (struct inode *inode, struct file *filp)
  2695. +{
  2696. +    struct adfsimage *img;
  2697. +    unsigned int target;
  2698. +    int retval = 0;
  2699. +
  2700. +    target = TARGETMAP(inode->i_rdev);
  2701. +
  2702. +    if (target >= ADFSIMG_NRDEV)
  2703. +    return -ENODEV;
  2704. +
  2705. +    img = adfsimg_images + target;
  2706. +
  2707. +    if (MAJOR(img->mapdev) == UNNAMED_MAJOR)
  2708. +    return -ENODEV;
  2709. +#if 1
  2710. +    if (filp->f_mode & 2)
  2711. +    return -EROFS;
  2712. +#endif
  2713. +    check_disk_change (inode->i_rdev);
  2714. +
  2715. +    /*
  2716. +     * If the device is still changed, then it means that we haven't
  2717. +     * been able to revalidate it yet.
  2718. +     */
  2719. +    if (img->changed)
  2720. +    return -ENXIO;
  2721. +
  2722. +    adfsimg_lockdev (img);
  2723. +
  2724. +    if (img->accesscount == 0) {
  2725. +    /* was this the first open? */
  2726. +    struct file *d_filp;
  2727. +    struct inode *d_inode;
  2728. +    int retval;
  2729. +
  2730. +    d_filp = &img->filp;
  2731. +    d_inode = &img->inode;
  2732. +
  2733. +    memset (d_filp, 0, sizeof (*d_filp));
  2734. +    memset (d_inode, 0, sizeof (*d_inode));
  2735. +
  2736. +    d_inode->i_rdev = img->mapdev;
  2737. +    d_filp->f_inode = d_inode;
  2738. +    d_filp->f_mode  = filp->f_mode;
  2739. +
  2740. +    retval = blkdev_open (d_inode, d_filp);
  2741. +    }
  2742. +
  2743. +    if (retval == 0)
  2744. +    img->accesscount ++;
  2745. +
  2746. +    adfsimg_unlockdev (img);
  2747. +
  2748. +    return retval;
  2749. +}
  2750. +
  2751. +/*
  2752. + * Releasing a block device means we sync() it, so that it can safely
  2753. + * be forgotten about...  Close the real device as well if this is the
  2754. + * last release.
  2755. + */
  2756. +static void adfsimg_release (struct inode *inode, struct file *filp)
  2757. +{
  2758. +    struct adfsimage *img;
  2759. +    unsigned int target;
  2760. +
  2761. +    /*
  2762. +     * Make this image file busy while we unmount the device (we may sleep).
  2763. +     */
  2764. +
  2765. +    sync_dev (inode->i_rdev);
  2766. +    target = TARGETMAP(inode->i_rdev);
  2767. +
  2768. +    if (target >= ADFSIMG_NRDEV) {
  2769. +    printk ("im: releasing invalid device %d\n", target);
  2770. +    return;
  2771. +    }
  2772. +
  2773. +    img = adfsimg_images + target;
  2774. +
  2775. +    adfsimg_lockdev (img);
  2776. +
  2777. +    img->accesscount --;
  2778. +    if (img->accesscount == 0 && img->filp.f_op && img->filp.f_op->release)
  2779. +    img->filp.f_op->release (&img->inode, NULL);
  2780. +
  2781. +    /*
  2782. +     * Don't forget to wake up anything on the busy queues.
  2783. +     */
  2784. +    adfsimg_unlockdev (img);
  2785. +}
  2786. +
  2787. +static void adfsimg_geninit (struct gendisk *dev);
  2788. +
  2789. +static int adfsimg_sizes[256]      = { 0, };
  2790. +static int adfsimg_blocksizes[256] = { 0, };
  2791. +static int adfsimg_hardsizes[256]  = { 0, };
  2792. +
  2793. +static struct gendisk adfsimg_gendisk = {
  2794. +    MAJOR_NR,        /* major number */
  2795. +    "im",        /* major name   */
  2796. +    ADFSIMG_SHIFT,    /* bits to shift to get real from partition */
  2797. +    1 << ADFSIMG_SHIFT,    /* number of partitions per real */
  2798. +    ADFSIMG_NRDEV,    /* maximum number of reals */
  2799. +    adfsimg_geninit,    /* init function */
  2800. +    adfsimg_parts,    /* adfsimg_struct */
  2801. +    adfsimg_sizes,    /* block sizes */
  2802. +    0,            /* number */
  2803. +    (void *)NULL,    /* internal */
  2804. +    NULL        /* next */
  2805. +};
  2806. +
  2807. +/*
  2808. + * This is the ADFS Image file init entry point
  2809. + */
  2810. +static void adfsimg_geninit (struct gendisk *dev)
  2811. +{
  2812. +    int i;
  2813. +
  2814. +    adfsimg_gendisk.nr_real = ADFSIMG_NRDEV;
  2815. +
  2816. +    for (i = 0; i < 256; i++) {
  2817. +    adfsimg_blocksizes[i] = 1024;
  2818. +    adfsimg_hardsizes[i] = 512;
  2819. +    }
  2820. +
  2821. +    blksize_size[MAJOR_NR] = adfsimg_blocksizes;
  2822. +    hardsect_size[MAJOR_NR] = adfsimg_hardsizes;
  2823. +
  2824. +    printk (" im :");
  2825. +    for (i = 0; i < ADFSIMG_NRDEV; i++) {
  2826. +        int retval;
  2827. +
  2828. +        retval = adfsimg_init_onedisk (i, 1);
  2829. +        if (retval > 0) {
  2830. +        adfsimg_gendisk.part[i << ADFSIMG_SHIFT].nr_sects = retval;
  2831. +        adfsimg_images[i].capacity = retval;
  2832. +        adfsimg_images[i].changed = 0;
  2833. +    } else {
  2834. +        adfsimg_gendisk.part[i << ADFSIMG_SHIFT].start_sect = -1;
  2835. +        adfsimg_gendisk.part[i << ADFSIMG_SHIFT].nr_sects = 0;
  2836. +        adfsimg_images[i].capacity = retval;
  2837. +        adfsimg_images[i].changed = 1;
  2838. +    }
  2839. +    }
  2840. +    printk ("\n");
  2841. +}
  2842. +
  2843. +/*
  2844. + * Check to see if our media that we are mapping has changed, or
  2845. + * the mapped file has been altered.  I do wish that there were
  2846. + * upcalls...
  2847. + *
  2848. + * This will always return 1 until:
  2849. + * a) ALL opens on the device have been closed.
  2850. + * b) The device is re-opened.
  2851. + */
  2852. +static int adfsimg_checkmediachange (kdev_t dev)
  2853. +{
  2854. +    struct adfsimage *img;
  2855. +    int target;
  2856. +
  2857. +    target = TARGETMAP(dev);
  2858. +
  2859. +    if (target >= ADFSIMG_NRDEV) {
  2860. +    printk ("im: adfsimg_checkmediachange: invalid device\n");
  2861. +    return 0;
  2862. +    }
  2863. +
  2864. +    img = adfsimg_images + target;
  2865. +
  2866. +    if (MAJOR(img->mapdev) == UNNAMED_MAJOR)
  2867. +     return 0;
  2868. +
  2869. +    /*
  2870. +     * Check our mapped device first.  This way, our mapped device
  2871. +     * gets invalidated, and we can tell our device that its changed.
  2872. +     */
  2873. +    if (check_disk_change(img->mapdev)) {
  2874. +    /* its changed */
  2875. +    int i;
  2876. +    for (i = 0; i < ADFSIMG_NRDEV; i++) {
  2877. +        if (img->mapdev == adfsimg_images[i].mapdev) {
  2878. +        adfsimg_images[i].changed = 1;
  2879. +#if DEBUG & DEBUG_CHANGED
  2880. +        printk ("im: checkdiskchange: host device changed [target = %d]\n", i);
  2881. +#endif
  2882. +        }
  2883. +    }
  2884. +    }
  2885. +    if (img->changed)
  2886. +    return 1;
  2887. +    return 0;
  2888. +}
  2889. +
  2890. +/*
  2891. + * Revalidate our partitions.  We do not revalidate the device that
  2892. + * we are mapping, since that should have already been done.  However,
  2893. + * we do call it the disk change just to make sure.
  2894. + *
  2895. + * This means that we don't re-read our mapping information, and
  2896. + * we keep our size info on the raw image file.
  2897. + */
  2898. +static int adfsimg_revalidate_disk (kdev_t dev, int maxusage)
  2899. +{
  2900. +    int target, max_p, start, i;
  2901. +    struct adfsimage *img;
  2902. +    unsigned long flags;
  2903. +
  2904. +    target = TARGETMAP(dev);
  2905. +
  2906. +    if (target >= ADFSIMG_NRDEV) {
  2907. +    printk ("im: adfsimg_revalidate: invalid device\n");
  2908. +    return 0;
  2909. +    }
  2910. +#if DEBUG & DEBUG_CHANGED
  2911. +printk ("im: adfsimg_revalidate: target %d\n", target);
  2912. +#endif
  2913. +    img = adfsimg_images + target;
  2914. +
  2915. +    if (MAJOR(img->mapdev) == UNNAMED_MAJOR)
  2916. +    return 0;
  2917. +
  2918. +    save_flags_cli (flags);
  2919. +    if (img->busy || img->accesscount > maxusage) {
  2920. +        restore_flags (flags);
  2921. +    return -EBUSY;
  2922. +    }
  2923. +    img->busy = 1;
  2924. +    restore_flags (flags);
  2925. +
  2926. +    start = target << ADFSIMG_SHIFT;
  2927. +    max_p = adfsimg_gendisk.max_p;
  2928. +
  2929. +    for (i = adfsimg_gendisk.max_p - 1; i >= 0; i--) {
  2930. +    int minor = start + i;
  2931. +    if (adfsimg_gendisk.part[minor].nr_sects > 0) {
  2932. +        kdev_t devi = MKDEV(MAJOR_NR, minor);
  2933. +        sync_dev (devi);
  2934. +        invalidate_inodes (devi);
  2935. +        invalidate_buffers (devi);
  2936. +    }
  2937. +    adfsimg_gendisk.part[minor].start_sect = 0;
  2938. +    adfsimg_gendisk.part[minor].nr_sects = 0;
  2939. +    blksize_size[MAJOR_NR][minor] = 1024;
  2940. +    }
  2941. +
  2942. +    if (!check_disk_change (img->mapdev)) {
  2943. +    img->changed = 0;
  2944. +
  2945. +    adfsimg_gendisk.part[start].nr_sects = img->capacity;
  2946. +    resetup_one_dev (&adfsimg_gendisk, target);
  2947. +    }
  2948. +
  2949. +    adfsimg_unlockdev (img);
  2950. +    return 0;
  2951. +}
  2952. +
  2953. +static int adfsimg_revalidate (kdev_t dev)
  2954. +{
  2955. +    return adfsimg_revalidate_disk (dev, 0);
  2956. +}
  2957. +
  2958. +static struct file_operations adfsimg_fops = {
  2959. +    NULL,        /* lseek - default */
  2960. +    block_read,        /* read - general block-dev read */
  2961. +    block_write,    /* write - general block-dev write */
  2962. +    NULL,        /* readdir - bad */
  2963. +    NULL,        /* select */
  2964. +    adfsimg_ioctl,    /* ioctl */
  2965. +    NULL,        /* mmap */
  2966. +    adfsimg_open,    /* open */
  2967. +    adfsimg_release,    /* release */
  2968. +    block_fsync,    /* fsync */
  2969. +    NULL,        /* fasync */
  2970. +    adfsimg_checkmediachange, /* disk change */
  2971. +    adfsimg_revalidate    /* revalidate */
  2972. +};
  2973. +
  2974. +int adfsimg_init (void)
  2975. +{
  2976. +    struct gendisk **gdp;
  2977. +
  2978. +    if (register_blkdev (MAJOR_NR, "im", &adfsimg_fops)) {
  2979. +    printk ("adfsimg: unable to get major %d for image file system\n", MAJOR_NR);
  2980. +    return -1;
  2981. +    }
  2982. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  2983. +    read_ahead[MAJOR_NR] = 0;    /* we rely on the hardware reading ahead */
  2984. +
  2985. +    for (gdp = &gendisk_head; *gdp; gdp = &((*gdp)->next));
  2986. +    *gdp = &adfsimg_gendisk;    /* link onto tail of list */
  2987. +    return 0;
  2988. +}
  2989. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/adfspart.c linux/arch/arm/drivers/block/adfspart.c
  2990. --- linux.orig/arch/arm/drivers/block/adfspart.c    Thu Jan  1 01:00:00 1970
  2991. +++ linux/arch/arm/drivers/block/adfspart.c    Mon Jul 15 21:32:56 1996
  2992. @@ -0,0 +1,364 @@
  2993. +/*
  2994. + * linux/arch/arm/drivers/block/adfspart.c
  2995. + *
  2996. + * Copyright (c) 1996 Russell King.
  2997. + *
  2998. + * Scan ADFS partitions on hard disk drives.
  2999. + */
  3000. +
  3001. +#include <linux/config.h>
  3002. +#include <linux/kernel.h>
  3003. +#include <linux/kdev_t.h>
  3004. +#include <linux/major.h>
  3005. +#include <linux/string.h>
  3006. +#include <linux/genhd.h>
  3007. +#include <linux/fs.h>
  3008. +
  3009. +#include "adfs.h"
  3010. +
  3011. +#undef  CONFIG_WRITE_PROTECT_ADFS
  3012. +#define CONFIG_ICS
  3013. +#define CONFIG_ADFS
  3014. +#undef  CONFIG_CUMANA
  3015. +
  3016. +/*
  3017. + * All partition types below here have been disabled.
  3018. + */
  3019. +#define PARTITION_LINUX        16
  3020. +extern void add_partition (struct gendisk *hd, int minor, int start, int size);
  3021. +
  3022. +static void adfspart_setgeometry (kdev_t dev, int secspertrack, int heads, unsigned long totalblocks)
  3023. +{
  3024. +    extern void hd_set_geometry (kdev_t dev, unsigned char, unsigned char, unsigned long, unsigned int);
  3025. +    extern void xd_set_geometry (kdev_t dev, unsigned char, unsigned char, unsigned long, unsigned int);
  3026. +
  3027. +    switch (MAJOR(dev)) {
  3028. +#ifdef CONFIG_BLK_DEV_HD
  3029. +    /*
  3030. +     * It would actually look like the HD driver doesn't actually need this,
  3031. +     * since it asks the drive about its the geometry...  However, the 'BIOS'
  3032. +     * information is not updated...
  3033. +     */
  3034. +    case HD_MAJOR:
  3035. +    hd_set_geometry (dev, secspertrack, heads, totalblocks, 1);
  3036. +    break;
  3037. +#endif
  3038. +#ifdef CONFIG_BLK_DEV_IDE
  3039. +#ifndef CONFIG_BLK_DEV_HD
  3040. +    case IDE0_MAJOR:
  3041. +#endif
  3042. +    case IDE1_MAJOR:
  3043. +    case IDE2_MAJOR:
  3044. +    case IDE3_MAJOR:
  3045. +    break;
  3046. +#endif
  3047. +#ifdef CONFIG_BLK_DEV_XD
  3048. +    case XT_DISK_MAJOR:
  3049. +    xd_set_geometry (dev, secspertrack, heads, totalblocks, 1);
  3050. +    break;
  3051. +#endif
  3052. +    default:
  3053. +    printk ("%s: don't know how to set geometry\n", kdevname (dev));
  3054. +    break;
  3055. +    }
  3056. +}
  3057. +
  3058. +#ifdef CONFIG_CUMANA
  3059. +static int adfspart_check_CUMANA (struct gendisk *hd, kdev_t dev,
  3060. +    unsigned long first_sector, int minor)
  3061. +{
  3062. +    struct buffer_head *bh;
  3063. +    struct disc_record *dr;
  3064. +    unsigned long start_sect = 0, nr_sects;
  3065. +    int first = 1, mask = (1 << hd->minor_shift) - 1;
  3066. +
  3067. +    /*
  3068. +     * Try Cumana style partitions - sector 3 contains ADFS boot block with pointer
  3069. +     * to next 'drive'.
  3070. +     *
  3071. +     * There are unknowns in this code - is the 'cylinder number' of the next
  3072. +     * partition relative to the start of this one - I'm assuming it is.
  3073. +     *
  3074. +     * Also, which ID did Cumana use?
  3075. +     *
  3076. +     * This is totally unfinished, and will require more work to get it going.
  3077. +     * Hence it is totally untested.
  3078. +     */
  3079. +
  3080. +    while (1) {
  3081. +    unsigned long end_sector;
  3082. +
  3083. +    if (!(bh = bread (dev, first_sector + 3, 1024)))
  3084. +        return -1;
  3085. +
  3086. +    if (adfspart_checkbblk (bh->b_data)) {
  3087. +        brelse (bh);
  3088. +        return first ? 0 : 1;
  3089. +    }
  3090. +
  3091. +    dr = (struct disc_record *)(bh->b_data + 0x1c0);
  3092. +
  3093. +    if (dr->disc_size == 0) {
  3094. +        brelse (bh);
  3095. +        return first ? 0 : 1;
  3096. +    }
  3097. +
  3098. +    end_sector = (bh->b_data[0x1fd] + (bh->b_data[0x1fe] << 8)) *
  3099. +         (dr->heads + (dr->lowsector & 0x40 ? 1 : 0)) * dr->secspertrack;
  3100. +
  3101. +    switch (bh->b_data[0x1fc] & 15) {
  3102. +        case 0: /* No partition / ADFS? */
  3103. +        if (end_cylinder == 0) {
  3104. +            /*
  3105. +             * No partition
  3106. +             */
  3107. +            nr_sects = dr->disc_size >> bb->log2secsize;
  3108. +            add_partition (hd, minor, first_sector, nr_sects);
  3109. +            return 1;
  3110. +        }
  3111. +        break;
  3112. +
  3113. +        case 1: /* RiscIX - we don't know how to find the next one. */
  3114. +        add_partition (hd, minor, first_sector, end_sector);
  3115. +        first_sector += end_sector;
  3116. +        break;
  3117. +    }
  3118. +    brelse (bh);
  3119. +    }
  3120. +}
  3121. +#endif
  3122. +
  3123. +#ifdef CONFIG_ADFS
  3124. +/*
  3125. + * Purpose: allocate ADFS partitions.
  3126. + *
  3127. + * Params : hd        - pointer to gendisk structure to store partition info.
  3128. + *        dev        - device number to access.
  3129. + *        first_sector- first readable sector on the device.
  3130. + *        minor    - first available minor on device.
  3131. + *
  3132. + * Returns: -1 on error, 0 for no ADFS boot sector, 1 for ok.
  3133. + *
  3134. + * Alloc  : hda  = whole drive
  3135. + *        hda1 = ADFS partition on first drive.
  3136. + *        hda2 = non-ADFS partition.
  3137. + */
  3138. +static int adfspart_check_ADFS (struct gendisk *hd, kdev_t dev,
  3139. +    unsigned long first_sector, int minor)
  3140. +{
  3141. +    struct buffer_head *bh;
  3142. +    unsigned long start_sect, nr_sects;
  3143. +    struct disc_record *dr;
  3144. +    int sectors_per_track, heads;
  3145. +
  3146. +    if (!(bh = bread (dev, first_sector + 3, 1024)))
  3147. +    return -1;
  3148. +
  3149. +    if (adfs_checkbblk (bh->b_data)) {
  3150. +        brelse (bh);
  3151. +        return 0;
  3152. +    }
  3153. +
  3154. +    dr = (struct disc_record *)(bh->b_data + 0x1c0);
  3155. +
  3156. +    if (dr->disc_size == 0) {
  3157. +    brelse (bh);
  3158. +    return 0;
  3159. +    }
  3160. +
  3161. +    printk (" [ADFS]");
  3162. +#ifdef CONFIG_WRITE_PROTECT_ADFS
  3163. +    write_protect (hd, MINOR(dev));
  3164. +#endif
  3165. +
  3166. +    sectors_per_track = dr->secspertrack;
  3167. +    heads = dr->heads + (dr->lowsector & 0x40 ? 1 : 0);
  3168. +
  3169. +    nr_sects = dr->disc_size >> dr->log2secsize;
  3170. +    /*
  3171. +     * insert ADFS drive partition details
  3172. +     */
  3173. +    add_partition (hd, minor, first_sector, nr_sects);
  3174. +#ifdef CONFIG_WRITE_PROTECT_ADFS
  3175. +    write_protect (hd, minor);
  3176. +#endif
  3177. +    adfspart_setgeometry (dev, sectors_per_track, heads, nr_sects);
  3178. +
  3179. +    /*
  3180. +     * Work out start of non-adfs partition.
  3181. +     */
  3182. +    start_sect = ((bh->b_data[0x1fe] << 8) + bh->b_data[0x1fd]) * sectors_per_track * heads;
  3183. +
  3184. +    if (start_sect) {
  3185. +    /*
  3186. +     * we now have a problem - how to set the origional disk size if the
  3187. +     * disk doesn't report it, since there is no standard way of getting
  3188. +     * that info.
  3189. +     */
  3190. +    switch (bh->b_data[0x1fc] & 15) {
  3191. +    case PARTITION_RISCIX:
  3192. +        printk (" [RiscIX]");
  3193. +        nr_sects = 1;        /* need to do something about that... */
  3194. +
  3195. +        adfspart_setgeometry (dev, sectors_per_track, heads, start_sect + nr_sects);
  3196. +        add_partition (hd, minor, first_sector + start_sect, nr_sects);
  3197. +        break;
  3198. +
  3199. +    case PARTITION_LINUX:
  3200. +        printk (" [Linux]");
  3201. +        nr_sects = 1;        /* need to do something about that... */
  3202. +
  3203. +        adfspart_setgeometry (dev, sectors_per_track, heads, start_sect + nr_sects);
  3204. +        break;
  3205. +    }
  3206. +    }
  3207. +    return 1;
  3208. +}
  3209. +#endif
  3210. +
  3211. +#ifdef CONFIG_ICS
  3212. +/*
  3213. + * Purpose: allocate ICS partitions.
  3214. + *
  3215. + * Params : hd        - pointer to gendisk structure to store partition info.
  3216. + *        dev        - device number to access.
  3217. + *        first_sector- first readable sector on the device.
  3218. + *        minor    - first available minor on device.
  3219. + *
  3220. + * Returns: -1 on error, 0 for no ICS table, 1 for partitions ok.
  3221. + *
  3222. + * Alloc  : hda  = whole drive
  3223. + *        hda1 = ADFS partition 0 on first drive.
  3224. + *        hda2 = optional 'adfs' style partition after ADFS partition 0.
  3225. + *        hda3 = ADFS partition 1 on first drive.
  3226. + *        hda4 = optional 'adfs' style partition after ADFS partition 1.
  3227. + *        ..etc..
  3228. + */
  3229. +static int adfspart_check_ICS (struct gendisk *hd, kdev_t dev,
  3230. +    unsigned long first_sector, int minor)
  3231. +{
  3232. +    unsigned long sum, start_sect, nr_sects, last_sect = 0, *p;
  3233. +    int i, mask = (1 << hd->minor_shift) - 1;
  3234. +    int sectors_per_track, heads;
  3235. +    struct buffer_head *bh, *bh2;
  3236. +    struct disc_record *dr;
  3237. +
  3238. +    /*
  3239. +     * Try ICS style partitions - sector 0 contains partition info.
  3240. +     */
  3241. +
  3242. +    if (!(bh = bread (dev, first_sector, 1024)))
  3243. +        return -1;
  3244. +
  3245. +    /*
  3246. +     * The fax is a bit unclear here - it says:
  3247. +     * 'The checksum is caluclated as the 32-bit sum of all the bytes in the sector
  3248. +     *  from (0 to 507) + &50617274, and is stored at 508 - 511.'  Does this mean
  3249. +     * a step of 4 bytes, or one byte?
  3250. +     */
  3251. +    for (i = 0, sum = 0x50617274; i < 507; i++)
  3252. +    sum += bh->b_data[i];
  3253. +
  3254. +    if (sum != *(unsigned long *)(&bh->b_data[507])) {
  3255. +        brelse (bh);
  3256. +    return 0; /* not ICS partition table */
  3257. +    }
  3258. +
  3259. +    /*
  3260. +     * Now get the disc record from the boot sectors (the first partition MUST be ADFS)
  3261. +     */
  3262. +    if (!(bh2 = bread (dev, first_sector + 3, 1024))) {
  3263. +        brelse (bh);
  3264. +    return -1;
  3265. +    }
  3266. +
  3267. +    if (adfs_checkbblk (bh2->b_data)) {
  3268. +        brelse (bh2);
  3269. +        brelse (bh);
  3270. +        return 0;
  3271. +    }
  3272. +    
  3273. +    dr = (struct disc_record *)(bh->b_data + 0x1c0);
  3274. +
  3275. +    if (dr->disc_size == 0) {
  3276. +        brelse (bh2);
  3277. +    brelse (bh);
  3278. +    return 0;
  3279. +    }
  3280. +
  3281. +    sectors_per_track = dr->secspertrack;
  3282. +    heads = dr->heads + (dr->lowsector & 0x40 ? 1 : 0);
  3283. +
  3284. +    brelse (bh2);
  3285. +
  3286. +    printk (" [ICS]");
  3287. +#ifdef CONFIG_WRITE_PROTECT_ADFS
  3288. +    write_protect (hd, MINOR(dev));
  3289. +#endif
  3290. +
  3291. +    p = (unsigned long *)bh->b_data;
  3292. +    while (1) {
  3293. +    if ((minor & mask) == 0)
  3294. +        break;
  3295. +
  3296. +    start_sect = *p++;
  3297. +    nr_sects = *p++;
  3298. +    if (!start_sect || !nr_sects)
  3299. +        break;
  3300. +
  3301. +    add_partition (hd, minor, first_sector + start_sect, nr_sects);
  3302. +    last_sect = first_sector + start_sect + nr_sects;
  3303. +#ifdef CONFIG_WRITE_PROTECT_ADFS
  3304. +    write_protect (hd, minor);
  3305. +#endif
  3306. +    /*
  3307. +     * We have detected a partition.  It could be followed by another non-ICS
  3308. +     * partition specified in the boot block. [currently not implemented].
  3309. +     */
  3310. +    minor += 2;
  3311. +    }
  3312. +
  3313. +    brelse (bh);
  3314. +
  3315. +    adfspart_setgeometry (dev, sectors_per_track, heads, last_sect);
  3316. +
  3317. +    return 1;
  3318. +}
  3319. +#endif
  3320. +
  3321. +/*
  3322. + * Purpose: initialise all the partitions on an ADFS drive.
  3323. + *          These may be other ADFS partitions or a Linux/RiscBSD/RiscIX
  3324. + *        partition.
  3325. + *
  3326. + * Params : hd         - pointer to gendisk structure to store devices partitions.
  3327. + *          dev         - device number to access
  3328. + *        first_sector - first available sector on the disk.
  3329. + *        minor     - first available minor on this device.
  3330. + *
  3331. + * Returns: -1 on error, 0 if not ADFS format, 1 if ok.
  3332. + */
  3333. +int adfspart_initdev (struct gendisk *hd, kdev_t dev,
  3334. +        unsigned long first_sector, int minor)
  3335. +{
  3336. +    int r = 0;
  3337. +
  3338. +#ifdef CONFIG_ICS
  3339. +    if (r == 0)
  3340. +    r = adfspart_check_ICS (hd, dev, first_sector, minor);
  3341. +#endif
  3342. +#ifdef CONFIG_CUMANA
  3343. +    if (r == 0)    
  3344. +    r = adfspart_check_CUMANA (hd, dev, first_sector, minor);
  3345. +#endif
  3346. +#ifdef CONFIG_ADFS
  3347. +    if (r == 0)
  3348. +    r = adfspart_check_ADFS (hd, dev, first_sector, minor);
  3349. +#endif
  3350. +    if (r < 0)
  3351. +    printk (" unable to read boot sectors / partition sectors");
  3352. +    else
  3353. +    if (r)
  3354. +    printk ("\n");
  3355. +    return r;
  3356. +}
  3357. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/blk.h linux/arch/arm/drivers/block/blk.h
  3358. --- linux.orig/arch/arm/drivers/block/blk.h    Thu Jan  1 01:00:00 1970
  3359. +++ linux/arch/arm/drivers/block/blk.h    Fri Sep  6 23:58:51 1996
  3360. @@ -0,0 +1,446 @@
  3361. +#ifndef _BLK_H
  3362. +#define _BLK_H
  3363. +
  3364. +#include <linux/blkdev.h>
  3365. +#include <linux/locks.h>
  3366. +#include <linux/config.h>
  3367. +
  3368. +/*
  3369. + * NR_REQUEST is the number of entries in the request-queue.
  3370. + * NOTE that writes may use only the low 2/3 of these: reads
  3371. + * take precedence.
  3372. + */
  3373. +#define NR_REQUEST    64
  3374. +
  3375. +/*
  3376. + * This is used in the elevator algorithm.  We don't prioritise reads
  3377. + * over writes any more --- although reads are more time-critical than
  3378. + * writes, by treating them equally we increase filesystem throughput.
  3379. + * This turns out to give better overall performance.  -- sct
  3380. + */
  3381. +#define IN_ORDER(s1,s2) \
  3382. +((s1)->rq_dev < (s2)->rq_dev || (((s1)->rq_dev == (s2)->rq_dev && \
  3383. +(s1)->sector < (s2)->sector)))
  3384. +
  3385. +/*
  3386. + * These will have to be changed to be aware of different buffer
  3387. + * sizes etc.. It actually needs a major cleanup.
  3388. + */
  3389. +#if defined(IDE_DRIVER) || defined(MD_DRIVER)
  3390. +#define SECTOR_MASK ((BLOCK_SIZE >> 9) - 1)
  3391. +#else
  3392. +#define SECTOR_MASK (blksize_size[MAJOR_NR] &&     \
  3393. +    blksize_size[MAJOR_NR][MINOR(CURRENT->rq_dev)] ? \
  3394. +    ((blksize_size[MAJOR_NR][MINOR(CURRENT->rq_dev)] >> 9) - 1) :  \
  3395. +    ((BLOCK_SIZE >> 9)  -  1))
  3396. +#endif /* IDE_DRIVER */
  3397. +
  3398. +#define SUBSECTOR(block) (CURRENT->current_nr_sectors > 0)
  3399. +
  3400. +#ifdef CONFIG_CDU31A
  3401. +extern int cdu31a_init(void);
  3402. +#endif CONFIG_CDU31A
  3403. +#ifdef CONFIG_MCD
  3404. +extern int mcd_init(void);
  3405. +#endif CONFIG_MCD
  3406. +#ifdef CONFIG_MCDX
  3407. +extern int mcdx_init(void);
  3408. +#endif CONFIG_MCDX
  3409. +#ifdef CONFIG_SBPCD
  3410. +extern int sbpcd_init(void);
  3411. +#endif CONFIG_SBPCD
  3412. +#ifdef CONFIG_AZTCD
  3413. +extern int aztcd_init(void);
  3414. +#endif CONFIG_AZTCD
  3415. +#ifdef CONFIG_CDU535
  3416. +extern int sony535_init(void);
  3417. +#endif CONFIG_CDU535
  3418. +#ifdef CONFIG_GSCD
  3419. +extern int gscd_init(void);
  3420. +#endif CONFIG_GSCD
  3421. +#ifdef CONFIG_CM206
  3422. +extern int cm206_init(void);
  3423. +#endif CONFIG_CM206
  3424. +#ifdef CONFIG_OPTCD
  3425. +extern int optcd_init(void);
  3426. +#endif CONFIG_OPTCD
  3427. +#ifdef CONFIG_SJCD
  3428. +extern int sjcd_init(void);
  3429. +#endif CONFIG_SJCD
  3430. +#ifdef CONFIG_BLK_DEV_HD
  3431. +extern int hd_init(void);
  3432. +#endif
  3433. +#ifdef CONFIG_BLK_DEV_IDE
  3434. +extern int ide_init(void);
  3435. +#endif
  3436. +#ifdef CONFIG_BLK_DEV_XD
  3437. +extern int xd_init(void);
  3438. +#endif
  3439. +#ifdef CONFIG_BLK_DEV_LOOP
  3440. +extern int loop_init(void);
  3441. +#endif
  3442. +#ifdef CONFIG_BLK_DEV_MD
  3443. +extern int md_init(void);
  3444. +#endif CONFIG_BLK_DEV_MD
  3445. +
  3446. +extern void set_device_ro(kdev_t dev,int flag);
  3447. +void add_blkdev_randomness(int major);
  3448. +
  3449. +extern int floppy_init(void);
  3450. +extern void rd_load(void);
  3451. +extern int rd_init(void);
  3452. +extern int rd_doload;        /* 1 = load ramdisk, 0 = don't load */
  3453. +extern int rd_prompt;        /* 1 = prompt for ramdisk, 0 = don't prompt */
  3454. +extern int rd_image_start;    /* starting block # of image */
  3455. +
  3456. +#ifdef CONFIG_BLK_DEV_INITRD
  3457. +
  3458. +#define INITRD_MINOR 250 /* shouldn't collide with /dev/ram* too soon ... */
  3459. +
  3460. +extern unsigned long initrd_start,initrd_end;
  3461. +extern int mount_initrd; /* zero if initrd should not be mounted */
  3462. +void initrd_init(void);
  3463. +
  3464. +#endif
  3465. +
  3466. +#define RO_IOCTLS(dev,where) \
  3467. +  case BLKROSET: { int __err;  if (!suser()) return -EACCES; \
  3468. +           __err = verify_area(VERIFY_READ, (void *) (where), sizeof(long)); \
  3469. +           if (!__err) set_device_ro((dev),get_fs_long((long *) (where))); return __err; } \
  3470. +  case BLKROGET: { int __err = verify_area(VERIFY_WRITE, (void *) (where), sizeof(long)); \
  3471. +           if (!__err) put_fs_long(0!=is_read_only(dev),(long *) (where)); return __err; }
  3472. +         
  3473. +#if defined(MAJOR_NR) || defined(IDE_DRIVER)
  3474. +
  3475. +/*
  3476. + * Add entries as needed.
  3477. + */
  3478. +
  3479. +#ifdef IDE_DRIVER
  3480. +
  3481. +#define DEVICE_NR(device)    (MINOR(device) >> PARTN_BITS)
  3482. +#define DEVICE_ON(device)    /* nothing */
  3483. +#define DEVICE_OFF(device)    /* nothing */
  3484. +
  3485. +#elif (MAJOR_NR == RAMDISK_MAJOR)
  3486. +
  3487. +/* ram disk */
  3488. +#define DEVICE_NAME "ramdisk"
  3489. +#define DEVICE_REQUEST rd_request
  3490. +#define DEVICE_NR(device) (MINOR(device))
  3491. +#define DEVICE_ON(device) 
  3492. +#define DEVICE_OFF(device)
  3493. +#define DEVICE_NO_RANDOM
  3494. +
  3495. +#elif (MAJOR_NR == FLOPPY_MAJOR)
  3496. +
  3497. +static void floppy_off(unsigned int nr);
  3498. +
  3499. +#define DEVICE_NAME "floppy"
  3500. +#define DEVICE_INTR do_floppy
  3501. +#define DEVICE_REQUEST do_fd_request
  3502. +#define DEVICE_NR(device) ( (MINOR(device) & 3) | ((MINOR(device) & 0x80 ) >> 5 ))
  3503. +#define DEVICE_ON(device)
  3504. +#define DEVICE_OFF(device) floppy_off(DEVICE_NR(device))
  3505. +
  3506. +#elif (MAJOR_NR == HD_MAJOR)
  3507. +
  3508. +/* harddisk: timeout is 6 seconds.. */
  3509. +#define DEVICE_NAME "harddisk"
  3510. +#define DEVICE_INTR do_hd
  3511. +#define DEVICE_TIMEOUT HD_TIMER
  3512. +#define TIMEOUT_VALUE (6*HZ)
  3513. +#define DEVICE_REQUEST do_hd_request
  3514. +#define DEVICE_NR(device) (MINOR(device)>>6)
  3515. +#define DEVICE_ON(device)
  3516. +#define DEVICE_OFF(device)
  3517. +
  3518. +#elif (MAJOR_NR == SCSI_DISK_MAJOR)
  3519. +
  3520. +#define DEVICE_NAME "scsidisk"
  3521. +#define DEVICE_INTR do_sd  
  3522. +#define TIMEOUT_VALUE (2*HZ)
  3523. +#define DEVICE_REQUEST do_sd_request
  3524. +#define DEVICE_NR(device) (MINOR(device) >> 4)
  3525. +#define DEVICE_ON(device)
  3526. +#define DEVICE_OFF(device)
  3527. +
  3528. +/* Kludge to use the same number for both char and block major numbers */
  3529. +#elif  (MAJOR_NR == MD_MAJOR) && defined(MD_DRIVER)
  3530. +
  3531. +#define DEVICE_NAME "Multiple devices driver"
  3532. +#define DEVICE_REQUEST do_md_request
  3533. +#define DEVICE_NR(device) (MINOR(device))
  3534. +#define DEVICE_ON(device)
  3535. +#define DEVICE_OFF(device)
  3536. +
  3537. +#elif (MAJOR_NR == SCSI_TAPE_MAJOR)
  3538. +
  3539. +#define DEVICE_NAME "scsitape"
  3540. +#define DEVICE_INTR do_st  
  3541. +#define DEVICE_NR(device) (MINOR(device) & 0x7f)
  3542. +#define DEVICE_ON(device)
  3543. +#define DEVICE_OFF(device)
  3544. +
  3545. +#elif (MAJOR_NR == SCSI_CDROM_MAJOR)
  3546. +
  3547. +#define DEVICE_NAME "CD-ROM"
  3548. +#define DEVICE_INTR do_sr
  3549. +#define DEVICE_REQUEST do_sr_request
  3550. +#define DEVICE_NR(device) (MINOR(device))
  3551. +#define DEVICE_ON(device)
  3552. +#define DEVICE_OFF(device)
  3553. +
  3554. +#elif (MAJOR_NR == XT_DISK_MAJOR)
  3555. +
  3556. +#define DEVICE_NAME "xt disk"
  3557. +#define DEVICE_REQUEST do_xd_request
  3558. +#define DEVICE_NR(device) (MINOR(device) >> 6)
  3559. +#define DEVICE_ON(device)
  3560. +#define DEVICE_OFF(device)
  3561. +
  3562. +#elif defined(MFM_DISK_MAJOR) && (MAJOR_NR == MFM_DISK_MAJOR)
  3563. +
  3564. +#define DEVICE_NAME "mfm disk"
  3565. +#define DEVICE_INTR do_mfm
  3566. +#define DEVICE_REQUEST do_mfm_request
  3567. +#define DEVICE_NR(device) (MINOR(device) >> 6)
  3568. +#define DEVICE_ON(device)
  3569. +#define DEVICE_OFF(device)
  3570. +
  3571. +#elif (MAJOR_NR == CDU31A_CDROM_MAJOR)
  3572. +
  3573. +#define DEVICE_NAME "CDU31A"
  3574. +#define DEVICE_REQUEST do_cdu31a_request
  3575. +#define DEVICE_NR(device) (MINOR(device))
  3576. +#define DEVICE_ON(device)
  3577. +#define DEVICE_OFF(device)
  3578. +
  3579. +#elif (MAJOR_NR == MITSUMI_CDROM_MAJOR)
  3580. +
  3581. +#define DEVICE_NAME "Mitsumi CD-ROM"
  3582. +/* #define DEVICE_INTR do_mcd */
  3583. +#define DEVICE_REQUEST do_mcd_request
  3584. +#define DEVICE_NR(device) (MINOR(device))
  3585. +#define DEVICE_ON(device)
  3586. +#define DEVICE_OFF(device)
  3587. +
  3588. +#elif (MAJOR_NR == MITSUMI_X_CDROM_MAJOR)
  3589. +
  3590. +#define DEVICE_NAME "Mitsumi CD-ROM"
  3591. +/* #define DEVICE_INTR do_mcdx */
  3592. +#define DEVICE_REQUEST do_mcdx_request
  3593. +#define DEVICE_NR(device) (MINOR(device))
  3594. +#define DEVICE_ON(device)
  3595. +#define DEVICE_OFF(device)
  3596. +
  3597. +#elif (MAJOR_NR == MATSUSHITA_CDROM_MAJOR)
  3598. +
  3599. +#define DEVICE_NAME "Matsushita CD-ROM controller #1"
  3600. +#define DEVICE_REQUEST do_sbpcd_request
  3601. +#define DEVICE_NR(device) (MINOR(device))
  3602. +#define DEVICE_ON(device)
  3603. +#define DEVICE_OFF(device)
  3604. +
  3605. +#elif (MAJOR_NR == MATSUSHITA_CDROM2_MAJOR)
  3606. +
  3607. +#define DEVICE_NAME "Matsushita CD-ROM controller #2"
  3608. +#define DEVICE_REQUEST do_sbpcd2_request
  3609. +#define DEVICE_NR(device) (MINOR(device))
  3610. +#define DEVICE_ON(device)
  3611. +#define DEVICE_OFF(device)
  3612. +
  3613. +#elif (MAJOR_NR == MATSUSHITA_CDROM3_MAJOR)
  3614. +
  3615. +#define DEVICE_NAME "Matsushita CD-ROM controller #3"
  3616. +#define DEVICE_REQUEST do_sbpcd3_request
  3617. +#define DEVICE_NR(device) (MINOR(device))
  3618. +#define DEVICE_ON(device)
  3619. +#define DEVICE_OFF(device)
  3620. +
  3621. +#elif (MAJOR_NR == MATSUSHITA_CDROM4_MAJOR)
  3622. +
  3623. +#define DEVICE_NAME "Matsushita CD-ROM controller #4"
  3624. +#define DEVICE_REQUEST do_sbpcd4_request
  3625. +#define DEVICE_NR(device) (MINOR(device))
  3626. +#define DEVICE_ON(device)
  3627. +#define DEVICE_OFF(device)
  3628. +
  3629. +#elif (MAJOR_NR == AZTECH_CDROM_MAJOR)
  3630. +
  3631. +#define DEVICE_NAME "Aztech CD-ROM"
  3632. +#define DEVICE_REQUEST do_aztcd_request
  3633. +#define DEVICE_NR(device) (MINOR(device))
  3634. +#define DEVICE_ON(device)
  3635. +#define DEVICE_OFF(device)
  3636. +
  3637. +#elif (MAJOR_NR == CDU535_CDROM_MAJOR)
  3638. +
  3639. +#define DEVICE_NAME "SONY-CDU535"
  3640. +#define DEVICE_INTR do_cdu535
  3641. +#define DEVICE_REQUEST do_cdu535_request
  3642. +#define DEVICE_NR(device) (MINOR(device))
  3643. +#define DEVICE_ON(device)
  3644. +#define DEVICE_OFF(device)
  3645. +
  3646. +#elif (MAJOR_NR == GOLDSTAR_CDROM_MAJOR)
  3647. +
  3648. +#define DEVICE_NAME "Goldstar R420"
  3649. +#define DEVICE_REQUEST do_gscd_request
  3650. +#define DEVICE_NR(device) (MINOR(device))
  3651. +#define DEVICE_ON(device)
  3652. +#define DEVICE_OFF(device)
  3653. +
  3654. +#elif (MAJOR_NR == CM206_CDROM_MAJOR)
  3655. +#define DEVICE_NAME "Philips/LMS cd-rom cm206"
  3656. +#define DEVICE_REQUEST do_cm206_request
  3657. +#define DEVICE_NR(device) (MINOR(device))
  3658. +#define DEVICE_ON(device)
  3659. +#define DEVICE_OFF(device)
  3660. +
  3661. +#elif (MAJOR_NR == OPTICS_CDROM_MAJOR)
  3662. +
  3663. +#define DEVICE_NAME "DOLPHIN 8000AT CD-ROM"
  3664. +#define DEVICE_REQUEST do_optcd_request
  3665. +#define DEVICE_NR(device) (MINOR(device))
  3666. +#define DEVICE_ON(device)
  3667. +#define DEVICE_OFF(device)
  3668. +
  3669. +#elif (MAJOR_NR == SANYO_CDROM_MAJOR)
  3670. +
  3671. +#define DEVICE_NAME "Sanyo H94A CD-ROM"
  3672. +#define DEVICE_REQUEST do_sjcd_request
  3673. +#define DEVICE_NR(device) (MINOR(device))
  3674. +#define DEVICE_ON(device)
  3675. +#define DEVICE_OFF(device)
  3676. +
  3677. +#elif (MAJOR_NR == ADFSIMG_MAJOR)
  3678. +
  3679. +#define DEVICE_NAME "im"
  3680. +#define DEVICE_REQUEST adfsimg_request
  3681. +#define DEVICE_NR(device) (MINOR(device) >> ADFSIMG_SHIFT)
  3682. +#define DEVICE_ON(device)
  3683. +#define DEVICE_OFF(device)
  3684. +
  3685. +#endif /* MAJOR_NR == whatever */
  3686. +
  3687. +#if (MAJOR_NR != SCSI_TAPE_MAJOR)
  3688. +#if !defined(IDE_DRIVER)
  3689. +
  3690. +#ifndef CURRENT
  3691. +#define CURRENT (blk_dev[MAJOR_NR].current_request)
  3692. +#endif
  3693. +
  3694. +#define CURRENT_DEV DEVICE_NR(CURRENT->rq_dev)
  3695. +
  3696. +#ifdef DEVICE_INTR
  3697. +static void (*DEVICE_INTR)(void) = NULL;
  3698. +#endif
  3699. +#ifdef DEVICE_TIMEOUT
  3700. +
  3701. +#define SET_TIMER \
  3702. +((timer_table[DEVICE_TIMEOUT].expires = jiffies + TIMEOUT_VALUE), \
  3703. +(timer_active |= 1<<DEVICE_TIMEOUT))
  3704. +
  3705. +#define CLEAR_TIMER \
  3706. +timer_active &= ~(1<<DEVICE_TIMEOUT)
  3707. +
  3708. +#define SET_INTR(x) \
  3709. +if ((DEVICE_INTR = (x)) != NULL) \
  3710. +    SET_TIMER; \
  3711. +else \
  3712. +    CLEAR_TIMER;
  3713. +
  3714. +#else
  3715. +
  3716. +#define SET_INTR(x) (DEVICE_INTR = (x))
  3717. +
  3718. +#endif /* DEVICE_TIMEOUT */
  3719. +
  3720. +static void (DEVICE_REQUEST)(void);
  3721. +
  3722. +#ifdef DEVICE_INTR
  3723. +#define CLEAR_INTR SET_INTR(NULL)
  3724. +#else
  3725. +#define CLEAR_INTR
  3726. +#endif
  3727. +
  3728. +#define INIT_REQUEST \
  3729. +    if (!CURRENT) {\
  3730. +        CLEAR_INTR; \
  3731. +        return; \
  3732. +    } \
  3733. +    if (MAJOR(CURRENT->rq_dev) != MAJOR_NR) \
  3734. +        panic(DEVICE_NAME ": request list destroyed"); \
  3735. +    if (CURRENT->bh) { \
  3736. +        if (!buffer_locked(CURRENT->bh)) \
  3737. +            panic(DEVICE_NAME ": block not locked"); \
  3738. +    }
  3739. +
  3740. +#endif /* !defined(IDE_DRIVER) */
  3741. +
  3742. +/* end_request() - SCSI devices have their own version */
  3743. +/*               - IDE drivers have their own copy too */
  3744. +
  3745. +#if ! SCSI_BLK_MAJOR(MAJOR_NR)
  3746. +
  3747. +#if defined(IDE_DRIVER) && !defined(_IDE_C) /* shared copy for IDE modules */
  3748. +void ide_end_request(byte uptodate, ide_hwgroup_t *hwgroup);
  3749. +#else
  3750. +
  3751. +#ifdef IDE_DRIVER
  3752. +void ide_end_request(byte uptodate, ide_hwgroup_t *hwgroup) {
  3753. +    struct request *req = hwgroup->rq;
  3754. +#else
  3755. +static void end_request(int uptodate) {
  3756. +    struct request *req = CURRENT;
  3757. +#endif /* IDE_DRIVER */
  3758. +    struct buffer_head * bh;
  3759. +
  3760. +    req->errors = 0;
  3761. +    if (!uptodate) {
  3762. +        printk("end_request: I/O error, dev %s, sector %lu\n",
  3763. +            kdevname(req->rq_dev), req->sector);
  3764. +        req->nr_sectors--;
  3765. +        req->nr_sectors &= ~SECTOR_MASK;
  3766. +        req->sector += (BLOCK_SIZE / 512);
  3767. +        req->sector &= ~SECTOR_MASK;        
  3768. +    }
  3769. +
  3770. +    if ((bh = req->bh) != NULL) {
  3771. +        req->bh = bh->b_reqnext;
  3772. +        bh->b_reqnext = NULL;
  3773. +        mark_buffer_uptodate(bh, uptodate);
  3774. +        unlock_buffer(bh);
  3775. +        if ((bh = req->bh) != NULL) {
  3776. +            req->current_nr_sectors = bh->b_size >> 9;
  3777. +            if (req->nr_sectors < req->current_nr_sectors) {
  3778. +                req->nr_sectors = req->current_nr_sectors;
  3779. +                printk("end_request: buffer-list destroyed\n");
  3780. +            }
  3781. +            req->buffer = bh->b_data;
  3782. +            return;
  3783. +        }
  3784. +    }
  3785. +#ifndef DEVICE_NO_RANDOM
  3786. +    add_blkdev_randomness(MAJOR(req->rq_dev));
  3787. +#endif
  3788. +#ifdef IDE_DRIVER
  3789. +    blk_dev[MAJOR(req->rq_dev)].current_request = req->next;
  3790. +    hwgroup->rq = NULL;
  3791. +#else
  3792. +    DEVICE_OFF(req->rq_dev);
  3793. +    CURRENT = req->next;
  3794. +#endif /* IDE_DRIVER */
  3795. +    if (req->sem != NULL)
  3796. +        up(req->sem);
  3797. +    req->rq_status = RQ_INACTIVE;
  3798. +    wake_up(&wait_for_request);
  3799. +}
  3800. +#endif /* defined(IDE_DRIVER) && !defined(_IDE_C) */
  3801. +#endif /* ! SCSI_BLK_MAJOR(MAJOR_NR) */
  3802. +#endif /* (MAJOR_NR != SCSI_TAPE_MAJOR) */
  3803. +
  3804. +#endif /* defined(MAJOR_NR) || defined(IDE_DRIVER) */
  3805. +
  3806. +#endif /* _BLK_H */
  3807. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/fd1772.c linux/arch/arm/drivers/block/fd1772.c
  3808. --- linux.orig/arch/arm/drivers/block/fd1772.c    Thu Jan  1 01:00:00 1970
  3809. +++ linux/arch/arm/drivers/block/fd1772.c    Sat Sep  7 21:09:40 1996
  3810. @@ -0,0 +1,1638 @@
  3811. +/*
  3812. + *  linux/kernel/arch/arm/drivers/block/fd1772.c
  3813. + *  Based on ataflop.c in the m68k Linux
  3814. + *  Copyright (C) 1993  Greg Harp
  3815. + *  Atari Support by Bjoern Brauel, Roman Hodek
  3816. + *  Archimedes Support by Dave Gilbert (gilbertd@cs.man.ac.uk)
  3817. + *
  3818. + *  Big cleanup Sep 11..14 1994 Roman Hodek:
  3819. + *   - Driver now works interrupt driven
  3820. + *   - Support for two drives; should work, but I cannot test that :-(
  3821. + *   - Reading is done in whole tracks and buffered to speed up things
  3822. + *   - Disk change detection and drive deselecting after motor-off
  3823. + *     similar to TOS
  3824. + *   - Autodetection of disk format (DD/HD); untested yet, because I
  3825. + *     don't have an HD drive :-(
  3826. + *
  3827. + *  Fixes Nov 13 1994 Martin Schaller:
  3828. + *   - Autodetection works now
  3829. + *   - Support for 5 1/4" disks
  3830. + *   - Removed drive type (unknown on atari)
  3831. + *   - Do seeks with 8 Mhz
  3832. + *
  3833. + *  Changes by Andreas Schwab:
  3834. + *   - After errors in multiple read mode try again reading single sectors
  3835. + *  (Feb 1995):
  3836. + *   - Clean up error handling
  3837. + *   - Set blk_size for proper size checking
  3838. + *   - Initialize track register when testing presence of floppy
  3839. + *   - Implement some ioctl's
  3840. + *
  3841. + *  Changes by Torsten Lang:
  3842. + *   - When probing the floppies we should add the FDC1772CMDADD_H flag since
  3843. + *     the FDC1772 will otherwise wait forever when no disk is inserted...
  3844. + *
  3845. + *  Things left to do:
  3846. + *   - Formatting
  3847. + *   - Maybe a better strategy for disk change detection (does anyone
  3848. + *     know one?)
  3849. + *   - There are some strange problems left: The strangest one is
  3850. + *     that, at least on my TT (4+4MB), the first 2 Bytes of the last
  3851. + *     page of the TT-Ram (!) change their contents (some bits get
  3852. + *     set) while a floppy DMA is going on. But there are no accesses
  3853. + *     to these memory locations from the kernel... (I tested that by
  3854. + *     making the page read-only). I cannot explain what's going on...
  3855. + *   - Sometimes the drive-change-detection stops to work. The
  3856. + *     function is still called, but the WP bit always reads as 0...
  3857. + *     Maybe a problem with the status reg mode or a timing problem.
  3858. + *     Note 10/12/94: The change detection now seems to work reliably.
  3859. + *     There is no proof, but I've seen no hang for a long time...
  3860. + *
  3861. + * ARCHIMEDES changes: (gilbertd@cs.man.ac.uk)
  3862. + *     26/12/95 - Changed all names starting with FDC to FDC1772
  3863. + *                Removed all references to clock speed of FDC - we're stuck with 8MHz
  3864. + *                Modified disk_type structure to remove HD formats
  3865. + *
  3866. + *      7/ 1/96 - Wrote FIQ code, removed most remaining atariisms
  3867. + *
  3868. + *     13/ 1/96 - Well I think its read a single sector; but there is a problem
  3869. + *                fd_rwsec_done which is called in FIQ mode starts another transfer
  3870. + *                off (in fd_rwsec) while still in FIQ mode.  Because its still in
  3871. + *                FIQ mode it can't service the DMA and loses data. So need to
  3872. + *                heavily restructure.
  3873. + *     14/ 1/96 - Found that the definitions of the register numbers of the
  3874. + *                FDC were multiplied by 2 in the header for the 16bit words
  3875. + *                of the atari so half the writes were going in the wrong place.
  3876. + *                Also realised that the FIQ entry didn't make any attempt to
  3877. + *                preserve registers or return correctly; now in assembler.
  3878. + *
  3879. + *     11/ 2/96 - Hmm - doesn't work on real machine.  Auto detect doesn't
  3880. + *                and hacking that past seems to wait forever - check motor
  3881. + *                being turned on.
  3882. + *
  3883. + *     17/ 2/96 - still having problems - forcing track to -1 when selecting
  3884. + *                new drives seems to allow it to read first few sectors
  3885. + *                but then we get solid hangs at apparently random places
  3886. + *                which change depending what is happening.
  3887. + *
  3888. + *      9/ 3/96 - Fiddled a lot of stuff around to move to kernel 1.3.35
  3889. + *                A lot of fiddling in DMA stuff. Having problems with it
  3890. + *                constnatly thinking its timeing out. Ah - its timeout
  3891. + *                was set to (6*HZ) rather than jiffies+(6*HZ).  Now giving
  3892. + *                duff data!
  3893. + *
  3894. + *      5/ 4/96 - Made it use the new IOC_ macros rather than *ioc
  3895. + *                Hmm - giving unexpected FIQ and then timeouts
  3896. + *     18/ 8/96 - Ran through indent -kr -i8
  3897. + *                Some changes to disc change detect; don't know how well it
  3898. + *                works.
  3899. + *     24/ 8/96 - Put all the track buffering code back in from the atari
  3900. + *                code - I wonder if it will still work... No :-)
  3901. + *                Still works if I turn off track buffering.
  3902. + *     25/ 8/96 - Changed the timer expires that I'd added back to be 
  3903. + *                jiffies + ....; and it all sprang to life! Got 2.8K/sec
  3904. + *                off a cp -r of a 679K disc (showed 94% cpu usage!)
  3905. + *                (PC gets 14.3K/sec - 0% CPU!) Hmm - hard drive corrupt!
  3906. + *                Also perhaps that compile was with cache off.
  3907. + *                changed cli in fd_readtrack_check to cliIF
  3908. + *                changed vmallocs to kmalloc (whats the difference!!)
  3909. + *                Removed the busy wait loop in do_fd_request and replaced
  3910. + *                by a routine on tq_immediate; only 11% cpu on a dd off the
  3911. + *                raw disc - but the speed is the same.
  3912. + */
  3913. +
  3914. +#include <linux/config.h>
  3915. +#include <linux/sched.h>
  3916. +#include <linux/fs.h>
  3917. +#include <linux/fcntl.h>
  3918. +#include <linux/kernel.h>
  3919. +#include <linux/interrupt.h>
  3920. +#include <linux/timer.h>
  3921. +#include <linux/tqueue.h>
  3922. +#include <linux/fd.h>
  3923. +#include <linux/fd1772.h>
  3924. +#include <linux/errno.h>
  3925. +#include <linux/types.h>
  3926. +#include <linux/delay.h>
  3927. +#include <linux/mm.h>
  3928. +
  3929. +#include <asm/arch/oldlatches.h>
  3930. +#include <asm/system.h>
  3931. +#include <asm/bitops.h>
  3932. +#include <asm/dma.h>
  3933. +#include <asm/hardware.h>
  3934. +#include <asm/io.h>
  3935. +#include <asm/irq.h>
  3936. +#include <asm/irq-no.h>
  3937. +#include <asm/pgtable.h>
  3938. +
  3939. +#define MAJOR_NR FLOPPY_MAJOR
  3940. +#define FLOPPY_DMA 0
  3941. +#include "blk.h"
  3942. +
  3943. +/* Note: FD_MAX_UNITS could be redefined to 2 for the Atari (with
  3944. + * little additional rework in this file). But I'm not yet sure if
  3945. + * some other code depends on the number of floppies... (It is defined
  3946. + * in a public header!)
  3947. + */
  3948. +#if 0
  3949. +#undef FD_MAX_UNITS
  3950. +#define    FD_MAX_UNITS    2
  3951. +#endif
  3952. +
  3953. +/* Ditto worries for Arc - DAG */
  3954. +#define FD_MAX_UNITS 4
  3955. +#define TRACKBUFFER 0
  3956. +/*#define DEBUG*/
  3957. +
  3958. +#ifdef DEBUG
  3959. +#define DPRINT(a)    printk a
  3960. +#else
  3961. +#define DPRINT(a)
  3962. +#endif
  3963. +
  3964. +/* Disk types: DD */
  3965. +static struct archy_disk_type {
  3966. +    const char *name;
  3967. +    unsigned spt;        /* sectors per track */
  3968. +    unsigned blocks;    /* total number of blocks */
  3969. +    unsigned stretch;    /* track doubling ? */
  3970. +} disk_type[] = {
  3971. +
  3972. +    { "d360", 9, 720, 0 },            /* 360kB diskette */
  3973. +    { "D360", 9, 720, 1 },            /* 360kb in 720kb drive */
  3974. +    { "D720", 9, 1440, 0 },            /* 720kb diskette (DD) */
  3975. +    /*{ "D820", 10,1640, 0}, *//* DD disk with 82 tracks/10 sectors 
  3976. +                                  - DAG - can't see how type detect can distinguish this
  3977. +                      from 720K until it reads block 4 by which time its too late! */
  3978. +};
  3979. +
  3980. +#define    NUM_DISK_TYPES (sizeof(disk_type)/sizeof(*disk_type))
  3981. +
  3982. +/*
  3983. + * Maximum disk size (in kilobytes). This default is used whenever the
  3984. + * current disk size is unknown.
  3985. + */
  3986. +#define MAX_DISK_SIZE 720
  3987. +
  3988. +static int floppy_sizes[256];
  3989. +static int floppy_blocksizes[256] = {0,};
  3990. +
  3991. +/* current info on each unit */
  3992. +static struct archy_floppy_struct {
  3993. +    int connected;        /* !=0 : drive is connected */
  3994. +    int autoprobe;        /* !=0 : do autoprobe       */
  3995. +
  3996. +    struct archy_disk_type *disktype;    /* current type of disk */
  3997. +
  3998. +    int track;        /* current head position or -1
  3999. +                   * if unknown */
  4000. +    unsigned int steprate;    /* steprate setting */
  4001. +    unsigned int wpstat;    /* current state of WP signal
  4002. +                   * (for disk change detection) */
  4003. +} unit[FD_MAX_UNITS];
  4004. +
  4005. +/* DAG: On Arc we spin on a flag being cleared by fdc1772_comendhandler which
  4006. +   is an assembler routine */
  4007. +extern void fdc1772_comendhandler(void);    /* Actually doens't have these parameters - see fd1772.S */
  4008. +extern volatile int fdc1772_comendstatus;
  4009. +extern volatile int fdc1772_fdc_int_done;
  4010. +
  4011. +#define FDC1772BASE (0x3210000>>2)
  4012. +
  4013. +#define FDC1772_READ(reg) inb(FDC1772BASE+(reg/2))
  4014. +
  4015. +/* DAG: You wouldn't be silly to ask why FDC1772_WRITE is a function rather
  4016. +   than the #def below - well simple - the #def won't compile - and I
  4017. +   don't understand why (__outwc not defined) */
  4018. +/* NOTE: Reg is 0,2,4,6 as opposed to 0,1,2,3 or 0,4,8,12 to keep compatibility
  4019. +   with the ST version of fd1772.h */
  4020. +/*#define FDC1772_WRITE(reg,val) outw(val,(reg+FDC1772BASE)); */
  4021. +void FDC1772_WRITE(int reg, unsigned char val)
  4022. +{
  4023. +    if (reg == FDC1772REG_CMD) {
  4024. +        DPRINT(("FDC1772_WRITE new command 0x%x\n", val));
  4025. +        if (fdc1772_fdc_int_done) {
  4026. +            DPRINT(("FDC1772_WRITE: Hmm fdc1772_fdc_int_done true - resetting\n"));
  4027. +            fdc1772_fdc_int_done = 0;
  4028. +        };
  4029. +    };
  4030. +    outb(val, (reg / 2) + FDC1772BASE);
  4031. +};
  4032. +
  4033. +#define    MAX_SECTORS    22
  4034. +
  4035. +unsigned char *DMABuffer;    /* buffer for writes */
  4036. +/*static unsigned long PhysDMABuffer; *//* physical address */
  4037. +/* DAG: On Arc we just go straight for the DMA buffer */
  4038. +#define PhysDMABuffer DMABuffer
  4039. +
  4040. +#ifdef TRACKBUFFER   
  4041. +unsigned char *TrackBuffer;       /* buffer for reads */
  4042. +#define PhysTrackBuffer TrackBuffer /* physical address */
  4043. +static int BufferDrive, BufferSide, BufferTrack;
  4044. +static int read_track;    /* non-zero if we are reading whole tracks */
  4045. +  
  4046. +#define SECTOR_BUFFER(sec)  (TrackBuffer + ((sec)-1)*512)
  4047. +#define IS_BUFFERED(drive,side,track) \
  4048. +    (BufferDrive == (drive) && BufferSide == (side) && BufferTrack == (track))
  4049. +#endif
  4050. +
  4051. +/*
  4052. + * These are global variables, as that's the easiest way to give
  4053. + * information to interrupts. They are the data used for the current
  4054. + * request.
  4055. + */
  4056. +static int SelectedDrive = 0;
  4057. +static int ReqCmd, ReqBlock;
  4058. +static int ReqSide, ReqTrack, ReqSector, ReqCnt;
  4059. +static int HeadSettleFlag = 0;
  4060. +static unsigned char *ReqData, *ReqBuffer;
  4061. +static int MotorOn = 0, MotorOffTrys;
  4062. +
  4063. +/* Synchronization of FDC1772 access. */
  4064. +static volatile int fdc_busy = 0;
  4065. +static struct wait_queue *fdc_wait = NULL;
  4066. +
  4067. +
  4068. +static unsigned int changed_floppies = 0xff, fake_change = 0;
  4069. +#define    CHECK_CHANGE_DELAY    HZ/2
  4070. +
  4071. +/* DAG - increased to 30*HZ - not sure if this is the correct thing to do */
  4072. +#define    FD_MOTOR_OFF_DELAY    (30*HZ)
  4073. +#define    FD_MOTOR_OFF_MAXTRY    (10*20)
  4074. +
  4075. +#define FLOPPY_TIMEOUT        (6*HZ)
  4076. +#define RECALIBRATE_ERRORS    4    /* After this many errors the drive
  4077. +                     * will be recalibrated. */
  4078. +#define MAX_ERRORS            8    /* After this many errors the driver
  4079. +                         * will give up. */
  4080. +
  4081. +
  4082. +#define    START_MOTOR_OFF_TIMER(delay)            \
  4083. +    do {                        \
  4084. +        motor_off_timer.expires = jiffies + (delay);        \
  4085. +        add_timer( &motor_off_timer );            \
  4086. +        MotorOffTrys = 0;                \
  4087. +    } while(0)
  4088. +
  4089. +#define    START_CHECK_CHANGE_TIMER(delay)                \
  4090. +    do {                            \
  4091. +        timer_table[FLOPPY_TIMER].expires = jiffies + (delay);    \
  4092. +        timer_active |= (1 << FLOPPY_TIMER);            \
  4093. +    } while(0)
  4094. +
  4095. +#define    START_TIMEOUT()                    \
  4096. +    do {                        \
  4097. +        del_timer( &timeout_timer );            \
  4098. +        timeout_timer.expires = jiffies + FLOPPY_TIMEOUT;    \
  4099. +        add_timer( &timeout_timer );            \
  4100. +    } while(0)
  4101. +
  4102. +#define    STOP_TIMEOUT()                    \
  4103. +    do {                        \
  4104. +        del_timer( &timeout_timer );            \
  4105. +    } while(0)
  4106. +
  4107. +#define ENABLE_IRQ() enable_irq(FIQ_FD1772+16);
  4108. +
  4109. +#define DISABLE_IRQ() disable_irq(FIQ_FD1772+16);
  4110. +
  4111. +static void fd1772_checkint(void);
  4112. +
  4113. +struct tq_struct fd1772_tq = 
  4114. +{ 0,0, (void *)fd1772_checkint, 0 };
  4115. +/*
  4116. + * The driver is trying to determine the correct media format
  4117. + * while Probing is set. fd_rwsec_done() clears it after a
  4118. + * successful access.
  4119. + */
  4120. +static int Probing = 0;
  4121. +
  4122. +/* This flag is set when a dummy seek is necesary to make the WP
  4123. + * status bit accessible.
  4124. + */
  4125. +static int NeedSeek = 0;
  4126. +
  4127. +
  4128. +/***************************** Prototypes *****************************/
  4129. +
  4130. +static void fd_select_side(int side);
  4131. +static void fd_select_drive(int drive);
  4132. +static void fd_deselect(void);
  4133. +static void fd_motor_off_timer(unsigned long dummy);
  4134. +static void check_change(void);
  4135. +static __inline__ void set_head_settle_flag(void);
  4136. +static __inline__ int get_head_settle_flag(void);
  4137. +static void floppy_irqconsequencehandler(void);
  4138. +static void fd_error(void);
  4139. +static void do_fd_action(int drive);
  4140. +static void fd_calibrate(void);
  4141. +static void fd_calibrate_done(int status);
  4142. +static void fd_seek(void);
  4143. +static void fd_seek_done(int status);
  4144. +static void fd_rwsec(void);
  4145. +#ifdef TRACKBUFFER   
  4146. +static void fd_readtrack_check( unsigned long dummy );  
  4147. +#endif
  4148. +static void fd_rwsec_done(int status);
  4149. +static void fd_times_out(unsigned long dummy);
  4150. +static void finish_fdc(void);
  4151. +static void finish_fdc_done(int dummy);
  4152. +static void floppy_off(unsigned int nr);
  4153. +static __inline__ void copy_buffer(void *from, void *to);
  4154. +static void setup_req_params(int drive);
  4155. +static void redo_fd_request(void);
  4156. +static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int
  4157. +            cmd, unsigned long param);
  4158. +static void fd_probe(int drive);
  4159. +static int fd_test_drive_present(int drive);
  4160. +static void config_types(void);
  4161. +static int floppy_open(struct inode *inode, struct file *filp);
  4162. +static void floppy_release(struct inode *inode, struct file *filp);
  4163. +
  4164. +/************************* End of Prototypes **************************/
  4165. +
  4166. +static struct timer_list motor_off_timer =
  4167. +{NULL, NULL, 0, 0, fd_motor_off_timer};
  4168. +#ifdef TRACKBUFFER
  4169. +static struct timer_list readtrack_timer =
  4170. +             { NULL, NULL, 0, 0, fd_readtrack_check };
  4171. +#endif
  4172. +static struct timer_list timeout_timer =
  4173. +{NULL, NULL, 0, 0, fd_times_out};
  4174. +
  4175. +/* DAG: Haven't got a clue what this is? */
  4176. +int stdma_islocked(void)
  4177. +{
  4178. +    return 0;
  4179. +};
  4180. +
  4181. +/* Select the side to use. */
  4182. +
  4183. +static void fd_select_side(int side)
  4184. +{
  4185. +    unsigned long flags;
  4186. +
  4187. +    save_flags(flags);
  4188. +    cli();
  4189. +
  4190. +    oldlatch_aupdate(LATCHA_SIDESEL, side ? 0 : LATCHA_SIDESEL);
  4191. +    restore_flags(flags);
  4192. +}
  4193. +
  4194. +
  4195. +/* Select a drive, update the FDC1772's track register
  4196. + */
  4197. +
  4198. +static void fd_select_drive(int drive)
  4199. +{
  4200. +    unsigned long flags;
  4201. +
  4202. +#ifdef DEBUG
  4203. +    printk("fd_select_drive:%d\n", drive);
  4204. +#endif
  4205. +    /* Hmm - nowhere do we seem to turn the motor on - I'm going to do it here! */
  4206. +    oldlatch_aupdate(LATCHA_MOTOR | LATCHA_INUSE, 0);
  4207. +
  4208. +    if (drive == SelectedDrive)
  4209. +        return;
  4210. +
  4211. +    save_flags(flags);
  4212. +    cli();
  4213. +    oldlatch_aupdate(LATCHA_FDSELALL, 0xf - (1 << drive));
  4214. +    restore_flags(flags);
  4215. +
  4216. +    /* restore track register to saved value */
  4217. +    FDC1772_WRITE(FDC1772REG_TRACK, unit[drive].track);
  4218. +    udelay(25);
  4219. +
  4220. +    SelectedDrive = drive;
  4221. +}
  4222. +
  4223. +
  4224. +/* Deselect both drives. */
  4225. +
  4226. +static void fd_deselect(void)
  4227. +{
  4228. +    unsigned long flags;
  4229. +
  4230. +    DPRINT(("fd_deselect\n"));
  4231. +
  4232. +    save_flags(flags);
  4233. +    cli();
  4234. +    oldlatch_aupdate(LATCHA_FDSELALL | LATCHA_MOTOR | LATCHA_INUSE, 0xf | LATCHA_MOTOR | LATCHA_INUSE);
  4235. +    restore_flags(flags);
  4236. +
  4237. +    SelectedDrive = -1;
  4238. +}
  4239. +
  4240. +
  4241. +/* This timer function deselects the drives when the FDC1772 switched the
  4242. + * motor off. The deselection cannot happen earlier because the FDC1772
  4243. + * counts the index signals, which arrive only if one drive is selected.
  4244. + */
  4245. +
  4246. +static void fd_motor_off_timer(unsigned long dummy)
  4247. +{
  4248. +    unsigned long flags;
  4249. +    unsigned char status;
  4250. +    int delay;
  4251. +
  4252. +    del_timer(&motor_off_timer);
  4253. +
  4254. +    if (SelectedDrive < 0)
  4255. +        /* no drive selected, needn't deselect anyone */
  4256. +        return;
  4257. +
  4258. +    save_flags(flags);
  4259. +    cli();
  4260. +
  4261. +    if (fdc_busy)        /* was stdma_islocked */
  4262. +        goto retry;
  4263. +
  4264. +    status = FDC1772_READ(FDC1772REG_STATUS);
  4265. +
  4266. +    if (!(status & 0x80)) {
  4267. +        /* motor already turned off by FDC1772 -> deselect drives */
  4268. +        DPRINT(("fdc1772: deselecting in fd_motor_off_timer\n"));
  4269. +        fd_deselect();
  4270. +        restore_flags(flags);
  4271. +        MotorOn = 0;
  4272. +        return;
  4273. +    }
  4274. +    /* not yet off, try again */
  4275. +
  4276. +      retry:
  4277. +    restore_flags(flags);
  4278. +    /* Test again later; if tested too often, it seems there is no disk
  4279. +     * in the drive and the FDC1772 will leave the motor on forever (or,
  4280. +     * at least until a disk is inserted). So we'll test only twice
  4281. +     * per second from then on...
  4282. +     */
  4283. +    delay = (MotorOffTrys < FD_MOTOR_OFF_MAXTRY) ?
  4284. +        (++MotorOffTrys, HZ / 20) : HZ / 2;
  4285. +    START_MOTOR_OFF_TIMER(delay);
  4286. +}
  4287. +
  4288. +
  4289. +/* This function is repeatedly called to detect disk changes (as good
  4290. + * as possible) and keep track of the current state of the write protection.
  4291. + */
  4292. +
  4293. +static void check_change(void)
  4294. +{
  4295. +    static int drive = 0;
  4296. +
  4297. +    unsigned long flags;
  4298. +    int stat;
  4299. +
  4300. +    if (fdc_busy)
  4301. +        return;        /* Don't start poking about if the fdc is busy */
  4302. +
  4303. +    return;            /* lets just forget it for the mo DAG */
  4304. +
  4305. +    if (++drive > 1 || !unit[drive].connected)
  4306. +        drive = 0;
  4307. +
  4308. +    save_flags(flags);
  4309. +    cli();
  4310. +
  4311. +    if (!stdma_islocked()) {
  4312. +        stat = !!(FDC1772_READ(FDC1772REG_STATUS) & FDC1772STAT_WPROT);
  4313. +
  4314. +        /* The idea here is that if the write protect line has changed then
  4315. +        the disc must have changed */
  4316. +        if (stat != unit[drive].wpstat) {
  4317. +            DPRINT(("wpstat[%d] = %d\n", drive, stat));
  4318. +            unit[drive].wpstat = stat;
  4319. +            set_bit(drive, &changed_floppies);
  4320. +        }
  4321. +    }
  4322. +    restore_flags(flags);
  4323. +
  4324. +    START_CHECK_CHANGE_TIMER(CHECK_CHANGE_DELAY);
  4325. +}
  4326. +
  4327. +
  4328. +/* Handling of the Head Settling Flag: This flag should be set after each
  4329. + * seek operation, because we dont't use seeks with verify.
  4330. + */
  4331. +
  4332. +static __inline__ void set_head_settle_flag(void)
  4333. +{
  4334. +    HeadSettleFlag = FDC1772CMDADD_E;
  4335. +}
  4336. +
  4337. +static __inline__ int get_head_settle_flag(void)
  4338. +{
  4339. +    int tmp = HeadSettleFlag;
  4340. +    HeadSettleFlag = 0;
  4341. +    return (tmp);
  4342. +}
  4343. +
  4344. +
  4345. +
  4346. +
  4347. +/* General Interrupt Handling */
  4348. +
  4349. +static void (*FloppyIRQHandler) (int status) = NULL;
  4350. +
  4351. +static void floppy_irqconsequencehandler(void)
  4352. +{
  4353. +    unsigned char status;
  4354. +    void (*handler) (int);
  4355. +
  4356. +    fdc1772_fdc_int_done = 0;
  4357. +
  4358. +    handler = FloppyIRQHandler;
  4359. +    FloppyIRQHandler = NULL;
  4360. +
  4361. +    if (handler) {
  4362. +        nop();
  4363. +        status = (unsigned char) fdc1772_comendstatus;
  4364. +        DPRINT(("FDC1772 irq, status = %02x handler = %08lx\n", (unsigned int) status, (unsigned long) handler));
  4365. +        handler(status);
  4366. +    } else {
  4367. +        DPRINT(("FDC1772 irq, no handler status=%02x\n", fdc1772_comendstatus));
  4368. +    }
  4369. +    DPRINT(("FDC1772 irq: end of floppy_irq\n"));
  4370. +}
  4371. +
  4372. +
  4373. +/* Error handling: If some error happened, retry some times, then
  4374. + * recalibrate, then try again, and fail after MAX_ERRORS.
  4375. + */
  4376. +
  4377. +static void fd_error(void)
  4378. +{
  4379. +    printk("FDC1772: fd_error\n");
  4380. +    /*panic("fd1772: fd_error"); *//* DAG tmp */
  4381. +    if (!CURRENT)
  4382. +        return;
  4383. +    CURRENT->errors++;
  4384. +    if (CURRENT->errors >= MAX_ERRORS) {
  4385. +        printk("fd%d: too many errors.\n", SelectedDrive);
  4386. +        end_request(0);
  4387. +    } else if (CURRENT->errors == RECALIBRATE_ERRORS) {
  4388. +        printk("fd%d: recalibrating\n", SelectedDrive);
  4389. +        if (SelectedDrive != -1)
  4390. +            unit[SelectedDrive].track = -1;
  4391. +    }
  4392. +    redo_fd_request();
  4393. +}
  4394. +
  4395. +
  4396. +
  4397. +#define    SET_IRQ_HANDLER(proc) do { FloppyIRQHandler = (proc); } while(0)
  4398. +
  4399. +
  4400. +/* do_fd_action() is the general procedure for a fd request: All
  4401. + * required parameter settings (drive select, side select, track
  4402. + * position) are checked and set if needed. For each of these
  4403. + * parameters and the actual reading or writing exist two functions:
  4404. + * one that starts the setting (or skips it if possible) and one
  4405. + * callback for the "done" interrupt. Each done func calls the next
  4406. + * set function to propagate the request down to fd_rwsec_done().
  4407. + */
  4408. +
  4409. +static void do_fd_action(int drive)
  4410. +{
  4411. +    DPRINT(("do_fd_action unit[drive].track=%d\n", unit[drive].track));
  4412. +
  4413. +#ifdef TRACKBUFFER
  4414. +  repeat:
  4415. +
  4416. +  if (IS_BUFFERED( drive, ReqSide, ReqTrack )) {
  4417. +    if (ReqCmd == READ) {
  4418. +      copy_buffer( SECTOR_BUFFER(ReqSector), ReqData );
  4419. +      if (++ReqCnt < CURRENT->current_nr_sectors) {
  4420. +        /* read next sector */
  4421. +        setup_req_params( drive );
  4422. +        goto repeat;
  4423. +      }
  4424. +      else {
  4425. +        /* all sectors finished */
  4426. +        CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
  4427. +        CURRENT->sector += CURRENT->current_nr_sectors;
  4428. +        end_request( 1 );
  4429. +        redo_fd_request();
  4430. +        return;
  4431. +      }
  4432. +    }
  4433. +    else {
  4434. +      /* cmd == WRITE, pay attention to track buffer
  4435. +       * consistency! */
  4436. +      copy_buffer( ReqData, SECTOR_BUFFER(ReqSector) );
  4437. +    }
  4438. +  }
  4439. +#endif
  4440. +
  4441. +    if (SelectedDrive != drive) {
  4442. +        /*unit[drive].track = -1; DAG */
  4443. +        fd_select_drive(drive);
  4444. +    };
  4445. +
  4446. +
  4447. +    if (unit[drive].track == -1)
  4448. +        fd_calibrate();
  4449. +    else if (unit[drive].track != ReqTrack << unit[drive].disktype->stretch)
  4450. +        fd_seek();
  4451. +    else
  4452. +        fd_rwsec();
  4453. +}
  4454. +
  4455. +
  4456. +/* Seek to track 0 if the current track is unknown */
  4457. +
  4458. +static void fd_calibrate(void)
  4459. +{
  4460. +    DPRINT(("fd_calibrate\n"));
  4461. +    if (unit[SelectedDrive].track >= 0) {
  4462. +        fd_calibrate_done(0);
  4463. +        return;
  4464. +    }
  4465. +    DPRINT(("fd_calibrate (after track compare)\n"));
  4466. +    SET_IRQ_HANDLER(fd_calibrate_done);
  4467. +    /* we can't verify, since the speed may be incorrect */
  4468. +    FDC1772_WRITE(FDC1772REG_CMD, FDC1772CMD_RESTORE | unit[SelectedDrive].steprate);
  4469. +
  4470. +    NeedSeek = 1;
  4471. +    MotorOn = 1;
  4472. +    START_TIMEOUT();
  4473. +    /* wait for IRQ */
  4474. +}
  4475. +
  4476. +
  4477. +static void fd_calibrate_done(int status)
  4478. +{
  4479. +    printk("fd_calibrate_done()\n");
  4480. +    STOP_TIMEOUT();
  4481. +
  4482. +    /* set the correct speed now */
  4483. +    if (status & FDC1772STAT_RECNF) {
  4484. +        printk("fd%d: restore failed\n", SelectedDrive);
  4485. +        fd_error();
  4486. +    } else {
  4487. +        unit[SelectedDrive].track = 0;
  4488. +        fd_seek();
  4489. +    }
  4490. +}
  4491. +
  4492. +
  4493. +/* Seek the drive to the requested track. The drive must have been
  4494. + * calibrated at some point before this.
  4495. + */
  4496. +
  4497. +static void fd_seek(void)
  4498. +{
  4499. +    DPRINT(("fd_seek() to track %d (unit[SelectedDrive].track=%d)\n", ReqTrack,
  4500. +        unit[SelectedDrive].track));
  4501. +    if (unit[SelectedDrive].track == ReqTrack <<
  4502. +        unit[SelectedDrive].disktype->stretch) {
  4503. +        fd_seek_done(0);
  4504. +        return;
  4505. +    }
  4506. +    FDC1772_WRITE(FDC1772REG_DATA, ReqTrack <<
  4507. +              unit[SelectedDrive].disktype->stretch);
  4508. +    udelay(25);
  4509. +    SET_IRQ_HANDLER(fd_seek_done);
  4510. +    FDC1772_WRITE(FDC1772REG_CMD, FDC1772CMD_SEEK | unit[SelectedDrive].steprate);
  4511. +
  4512. +    MotorOn = 1;
  4513. +    set_head_settle_flag();
  4514. +    START_TIMEOUT();
  4515. +    /* wait for IRQ */
  4516. +}
  4517. +
  4518. +
  4519. +static void fd_seek_done(int status)
  4520. +{
  4521. +    DPRINT(("fd_seek_done()\n"));
  4522. +    STOP_TIMEOUT();
  4523. +
  4524. +    /* set the correct speed */
  4525. +    if (status & FDC1772STAT_RECNF) {
  4526. +        printk("fd%d: seek error (to track %d)\n",
  4527. +               SelectedDrive, ReqTrack);
  4528. +        /* we don't know exactly which track we are on now! */
  4529. +        unit[SelectedDrive].track = -1;
  4530. +        fd_error();
  4531. +    } else {
  4532. +        unit[SelectedDrive].track = ReqTrack <<
  4533. +            unit[SelectedDrive].disktype->stretch;
  4534. +        NeedSeek = 0;
  4535. +        fd_rwsec();
  4536. +    }
  4537. +}
  4538. +
  4539. +
  4540. +/* This does the actual reading/writing after positioning the head
  4541. + * over the correct track.
  4542. + */
  4543. +
  4544. +#ifdef TRACKBUFFER
  4545. +static int MultReadInProgress = 0;
  4546. +#endif
  4547. +
  4548. +
  4549. +static void fd_rwsec(void)
  4550. +{
  4551. +    unsigned long paddr, flags;
  4552. +    unsigned int rwflag, old_motoron;
  4553. +    unsigned int track;
  4554. +
  4555. +    DPRINT(("fd_rwsec(), Sec=%d, Access=%c\n", ReqSector, ReqCmd == WRITE ? 'w' : 'r'));
  4556. +    if (ReqCmd == WRITE) {
  4557. +        /*cache_push( (unsigned long)ReqData, 512 ); */
  4558. +        paddr = (unsigned long) ReqData;
  4559. +        rwflag = 0x100;
  4560. +    } else {
  4561. +#ifdef TRACKBUFFER
  4562. +    if (read_track)
  4563. +      paddr = (unsigned long)PhysTrackBuffer;
  4564. +    else
  4565. +      paddr =(unsigned long)PhysDMABuffer;
  4566. +#else
  4567. +    paddr = (unsigned long)PhysDMABuffer;
  4568. +#endif
  4569. +        rwflag = 0;
  4570. +    }
  4571. +
  4572. +    DPRINT(("fd_rwsec() before sidesel rwflag=%d sec=%d trk=%d\n", rwflag,
  4573. +        ReqSector, FDC1772_READ(FDC1772REG_TRACK)));
  4574. +    fd_select_side(ReqSide);
  4575. +
  4576. +    /*DPRINT(("fd_rwsec() before start sector \n")); */
  4577. +    /* Start sector of this operation */
  4578. +#ifdef TRACKBUFFER
  4579. +  FDC1772_WRITE( FDC1772REG_SECTOR, !read_track ? ReqSector : 1 );
  4580. +#else
  4581. +  FDC1772_WRITE( FDC1772REG_SECTOR, ReqSector );
  4582. +#endif
  4583. +
  4584. +    /* Cheat for track if stretch != 0 */
  4585. +    if (unit[SelectedDrive].disktype->stretch) {
  4586. +        track = FDC1772_READ(FDC1772REG_TRACK);
  4587. +        FDC1772_WRITE(FDC1772REG_TRACK, track >>
  4588. +                  unit[SelectedDrive].disktype->stretch);
  4589. +    }
  4590. +    udelay(25);
  4591. +
  4592. +    DPRINT(("fd_rwsec() before setup DMA \n"));
  4593. +    /* Setup DMA - Heavily modified by DAG */
  4594. +    save_flags(flags);
  4595. +    cliIF();
  4596. +    disable_dma(FLOPPY_DMA);
  4597. +    set_dma_mode(FLOPPY_DMA, rwflag ? DMA_MODE_WRITE : DMA_MODE_READ);
  4598. +    set_dma_addr(FLOPPY_DMA, (long) paddr);        /* DAG - changed from Atari specific */
  4599. +#ifdef TRACKBUFFER
  4600. +  set_dma_count(FLOPPY_DMA,(!read_track ? 1 : unit[SelectedDrive].disktype->spt)*512);
  4601. +#else
  4602. +    set_dma_count(FLOPPY_DMA, 512);        /* Block/sector size - going to have to change */
  4603. +#endif
  4604. +    SET_IRQ_HANDLER(fd_rwsec_done);
  4605. +    /* Turn on dma int */
  4606. +    enable_dma(FLOPPY_DMA);
  4607. +    restore_flags(flags);
  4608. +    /* Now give it something to do */
  4609. +    FDC1772_WRITE(FDC1772REG_CMD, (rwflag ? (FDC1772CMD_WRSEC | FDC1772CMDADD_P) : 
  4610. +#ifdef TRACKBUFFER
  4611. +              (FDC1772CMD_RDSEC | (read_track ? FDC1772CMDADD_M : 0))
  4612. +#else
  4613. +              FDC1772CMD_RDSEC
  4614. +#endif
  4615. +    ));
  4616. +
  4617. +    DPRINT(("fd_rwsec() after DMA setup flags=0x%08x\n", flags));
  4618. +    /*sti(); *//* DAG - Hmm */
  4619. +    /* Hmm - should do something DAG */
  4620. +    old_motoron = MotorOn;
  4621. +    MotorOn = 1;
  4622. +    NeedSeek = 1;
  4623. +
  4624. +    /* wait for interrupt */
  4625. +
  4626. +#ifdef TRACKBUFFER
  4627. +  if (read_track) {
  4628. +    /* If reading a whole track, wait about one disk rotation and
  4629. +     * then check if all sectors are read. The FDC will even
  4630. +     * search for the first non-existant sector and need 1 sec to
  4631. +     * recognise that it isn't present :-(
  4632. +     */
  4633. +    readtrack_timer.expires = jiffies + HZ/5 + (old_motoron ? 0 : HZ);
  4634. +                              /* 1 rot. + 5 rot.s if motor was off  */
  4635. +    add_timer( &readtrack_timer );
  4636. +    MultReadInProgress = 1;
  4637. + }
  4638. +#endif
  4639. +
  4640. +    /*DPRINT(("fd_rwsec() before START_TIMEOUT \n")); */
  4641. +    START_TIMEOUT();
  4642. +    /*DPRINT(("fd_rwsec() after START_TIMEOUT \n")); */
  4643. +}
  4644. +
  4645. +
  4646. +#ifdef TRACKBUFFER
  4647. +
  4648. +static void fd_readtrack_check( unsigned long dummy )
  4649. +
  4650. +{ unsigned long flags, addr;
  4651. +  extern unsigned char *fdc1772_dataaddr;
  4652. +
  4653. +  save_flags(flags);
  4654. +  cliIF();
  4655. +
  4656. +  del_timer( &readtrack_timer );
  4657. +
  4658. +  if (!MultReadInProgress) {
  4659. +    /* This prevents a race condition that could arise if the
  4660. +     * interrupt is triggered while the calling of this timer
  4661. +     * callback function takes place. The IRQ function then has
  4662. +     * already cleared 'MultReadInProgress'  when control flow
  4663. +     * gets here.
  4664. +     */
  4665. +        restore_flags(flags);
  4666. +    return;
  4667. +  }
  4668. +
  4669. +  /* get the current DMA address */
  4670. +  addr=*fdc1772_dataaddr; /* DAG - ? */
  4671. +
  4672. +  if (addr >= PhysTrackBuffer + unit[SelectedDrive].disktype->spt*512) {
  4673. +    /* already read enough data, force an FDC interrupt to stop
  4674. +     * the read operation
  4675. +     */
  4676. +    SET_IRQ_HANDLER( NULL );
  4677. +    restore_flags(flags);
  4678. +    DPRINT(("fd_readtrack_check(): done\n"));
  4679. +    FDC1772_WRITE( FDC1772REG_CMD, FDC1772CMD_FORCI );
  4680. +    udelay(25);
  4681. +
  4682. +    /* No error until now -- the FDC would have interrupted
  4683. +     * otherwise!
  4684. +     */
  4685. +    fd_rwsec_done( 0 );
  4686. +  }
  4687. +  else {
  4688. +    /* not yet finished, wait another tenth rotation */
  4689. +    restore_flags(flags);
  4690. +    DPRINT(("fd_readtrack_check(): not yet finished\n"));
  4691. +    readtrack_timer.expires = jiffies + HZ/5/10;
  4692. +    add_timer( &readtrack_timer );
  4693. +  }
  4694. +}
  4695. +
  4696. +#endif
  4697. +
  4698. +static void fd_rwsec_done(int status)
  4699. +{
  4700. +    unsigned int track;
  4701. +
  4702. +    DPRINT(("fd_rwsec_done() status=%d\n", status));
  4703. +
  4704. +#ifdef TRACKBUFFER
  4705. +  if (read_track && !MultReadInProgress) return;
  4706. +  MultReadInProgress = 0;
  4707. +
  4708. +  STOP_TIMEOUT();
  4709. +
  4710. +  if (read_track)
  4711. +    del_timer( &readtrack_timer );
  4712. +#endif
  4713. +
  4714. +
  4715. +    /* Correct the track if stretch != 0 */
  4716. +    if (unit[SelectedDrive].disktype->stretch) {
  4717. +        track = FDC1772_READ(FDC1772REG_TRACK);
  4718. +        FDC1772_WRITE(FDC1772REG_TRACK, track <<
  4719. +                  unit[SelectedDrive].disktype->stretch);
  4720. +    }
  4721. +    if (ReqCmd == WRITE && (status & FDC1772STAT_WPROT)) {
  4722. +        printk("fd%d: is write protected\n", SelectedDrive);
  4723. +        goto err_end;
  4724. +    }
  4725. +    if ((status & FDC1772STAT_RECNF)
  4726. +#ifdef TRACKBUFFER
  4727. +    /* RECNF is no error after a multiple read when the FDC
  4728. +     * searched for a non-existant sector!
  4729. +     */
  4730. +    && !(read_track &&
  4731. +       FDC1772_READ(FDC1772REG_SECTOR) > unit[SelectedDrive].disktype->spt)
  4732. +#endif
  4733. +    ) {
  4734. +        if (Probing) {
  4735. +            if (unit[SelectedDrive].disktype > disk_type) {
  4736. +                /* try another disk type */
  4737. +                unit[SelectedDrive].disktype--;
  4738. +                floppy_sizes[SelectedDrive]
  4739. +                    = unit[SelectedDrive].disktype->blocks >> 1;
  4740. +            } else
  4741. +                Probing = 0;
  4742. +        } else {
  4743. +            /* record not found, but not probing. Maybe stretch wrong ? Restart probing */
  4744. +            if (unit[SelectedDrive].autoprobe) {
  4745. +                unit[SelectedDrive].disktype = disk_type + NUM_DISK_TYPES - 1;
  4746. +                floppy_sizes[SelectedDrive]
  4747. +                    = unit[SelectedDrive].disktype->blocks >> 1;
  4748. +                Probing = 1;
  4749. +            }
  4750. +        }
  4751. +        if (Probing) {
  4752. +            setup_req_params(SelectedDrive);
  4753. +#ifdef TRACKBUFFER
  4754. +      BufferDrive = -1;
  4755. +#endif
  4756. +            do_fd_action(SelectedDrive);
  4757. +            return;
  4758. +        }
  4759. +        printk("fd%d: sector %d not found (side %d, track %d)\n",
  4760. +               SelectedDrive, FDC1772_READ(FDC1772REG_SECTOR), ReqSide, ReqTrack);
  4761. +        goto err_end;
  4762. +    }
  4763. +    if (status & FDC1772STAT_CRC) {
  4764. +        printk("fd%d: CRC error (side %d, track %d, sector %d)\n",
  4765. +               SelectedDrive, ReqSide, ReqTrack, FDC1772_READ(FDC1772REG_SECTOR));
  4766. +        goto err_end;
  4767. +    }
  4768. +    if (status & FDC1772STAT_LOST) {
  4769. +        printk("fd%d: lost data (side %d, track %d, sector %d)\n",
  4770. +               SelectedDrive, ReqSide, ReqTrack, FDC1772_READ(FDC1772REG_SECTOR));
  4771. +        goto err_end;
  4772. +    }
  4773. +    Probing = 0;
  4774. +
  4775. +    if (ReqCmd == READ) {
  4776. +#ifdef TRACKBUFFER
  4777. +    if (!read_track)
  4778. +      {
  4779. +        /*cache_clear (PhysDMABuffer, 512);*/
  4780. +        copy_buffer (DMABuffer, ReqData);
  4781. +      }
  4782. +    else
  4783. +      {
  4784. +        /*cache_clear (PhysTrackBuffer, MAX_SECTORS * 512);*/
  4785. +        BufferDrive = SelectedDrive;
  4786. +        BufferSide  = ReqSide;
  4787. +        BufferTrack = ReqTrack;
  4788. +        copy_buffer (SECTOR_BUFFER (ReqSector), ReqData);
  4789. +      }
  4790. +#else
  4791. +        /*cache_clear( PhysDMABuffer, 512 ); */
  4792. +        copy_buffer(DMABuffer, ReqData);
  4793. +#endif
  4794. +    }
  4795. +    if (++ReqCnt < CURRENT->current_nr_sectors) {
  4796. +        /* read next sector */
  4797. +        setup_req_params(SelectedDrive);
  4798. +        do_fd_action(SelectedDrive);
  4799. +    } else {
  4800. +        /* all sectors finished */
  4801. +        CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
  4802. +        CURRENT->sector += CURRENT->current_nr_sectors;
  4803. +        end_request(1);
  4804. +        redo_fd_request();
  4805. +    }
  4806. +    return;
  4807. +
  4808. +  err_end:
  4809. +#ifdef TRACKBUFFER
  4810. +  BufferDrive = -1;
  4811. +#endif
  4812. +
  4813. +    fd_error();
  4814. +}
  4815. +
  4816. +
  4817. +static void fd_times_out(unsigned long dummy)
  4818. +{
  4819. +    SET_IRQ_HANDLER(NULL);
  4820. +    /* If the timeout occured while the readtrack_check timer was
  4821. +     * active, we need to cancel it, else bad things will happen */
  4822. +    del_timer( &readtrack_timer ); 
  4823. +    FDC1772_WRITE(FDC1772REG_CMD, FDC1772CMD_FORCI);
  4824. +    udelay(25);
  4825. +
  4826. +    printk("floppy timeout\n");
  4827. +    STOP_TIMEOUT();        /* hmm - should we do this ? */
  4828. +    fd_error();
  4829. +}
  4830. +
  4831. +
  4832. +/* The (noop) seek operation here is needed to make the WP bit in the
  4833. + * FDC1772 status register accessible for check_change. If the last disk
  4834. + * operation would have been a RDSEC, this bit would always read as 0
  4835. + * no matter what :-( To save time, the seek goes to the track we're
  4836. + * already on.
  4837. + */
  4838. +
  4839. +static void finish_fdc(void)
  4840. +{
  4841. +    /* DAG - just try without this dummy seek! */
  4842. +    finish_fdc_done(0);
  4843. +    return;
  4844. +
  4845. +    if (!NeedSeek) {
  4846. +        finish_fdc_done(0);
  4847. +    } else {
  4848. +        DPRINT(("finish_fdc: dummy seek started\n"));
  4849. +        FDC1772_WRITE(FDC1772REG_DATA, unit[SelectedDrive].track);
  4850. +        SET_IRQ_HANDLER(finish_fdc_done);
  4851. +        FDC1772_WRITE(FDC1772REG_CMD, FDC1772CMD_SEEK);
  4852. +        MotorOn = 1;
  4853. +        START_TIMEOUT();
  4854. +        /* we must wait for the IRQ here, because the ST-DMA is
  4855. +         * released immediatly afterwards and the interrupt may be
  4856. +         * delivered to the wrong driver.
  4857. +         */
  4858. +    }
  4859. +}
  4860. +
  4861. +
  4862. +static void finish_fdc_done(int dummy)
  4863. +{
  4864. +    unsigned long flags;
  4865. +
  4866. +    DPRINT(("finish_fdc_done entered\n"));
  4867. +    STOP_TIMEOUT();
  4868. +    NeedSeek = 0;
  4869. +
  4870. +    if ((timer_active & (1 << FLOPPY_TIMER)) &&
  4871. +        timer_table[FLOPPY_TIMER].expires < jiffies + 5)
  4872. +        /* If the check for a disk change is done too early after this
  4873. +         * last seek command, the WP bit still reads wrong :-((
  4874. +         */
  4875. +        timer_table[FLOPPY_TIMER].expires = jiffies + 5;
  4876. +    else {
  4877. +        /*      START_CHECK_CHANGE_TIMER( CHECK_CHANGE_DELAY ); */
  4878. +    };
  4879. +    del_timer(&motor_off_timer);
  4880. +    START_MOTOR_OFF_TIMER(FD_MOTOR_OFF_DELAY);
  4881. +
  4882. +    save_flags(flags);
  4883. +    cli();
  4884. +    /* stdma_release(); - not sure if I should do something DAG  */
  4885. +    fdc_busy = 0;
  4886. +    wake_up(&fdc_wait);
  4887. +    restore_flags(flags);
  4888. +
  4889. +    DPRINT(("finish_fdc() finished\n"));
  4890. +}
  4891. +
  4892. +
  4893. +/* Prevent "aliased" accesses. */
  4894. +static fd_ref[4] =
  4895. +{0, 0, 0, 0};
  4896. +static fd_device[4] =
  4897. +{0, 0, 0, 0};
  4898. +
  4899. +/*
  4900. + * Current device number. Taken either from the block header or from the
  4901. + * format request descriptor.
  4902. + */
  4903. +#define CURRENT_DEVICE (CURRENT->rq_dev)
  4904. +
  4905. +/* Current error count. */
  4906. +#define CURRENT_ERRORS (CURRENT->errors)
  4907. +
  4908. +
  4909. +/* dummy for blk.h */
  4910. +static void floppy_off(unsigned int nr)
  4911. +{
  4912. +}
  4913. +
  4914. +
  4915. +/* On the old arcs write protect depends on the particular model
  4916. +   of machine.  On the A310, R140, and A440 there is a disc changed
  4917. +   detect, however on the A4x0/1 range there is not.  There
  4918. +   is nothing to tell you which machine your on.
  4919. +   At the moment I'm just marking changed always. I've
  4920. +   left the Atari's 'change on write protect change' code in this
  4921. +   part (but nothing sets it).
  4922. +   RiscOS apparently checks the disc serial number etc. to detect changes
  4923. +   - but if it sees a disc change line go high (?) it flips to using
  4924. +   it. Well  maybe I'll add that in the future (!?)
  4925. +*/
  4926. +static int check_floppy_change(dev_t dev)
  4927. +{
  4928. +    unsigned int drive = (dev & 0x03);
  4929. +
  4930. +    if (MAJOR(dev) != MAJOR_NR) {
  4931. +        printk("floppy_changed: not a floppy\n");
  4932. +        return 0;
  4933. +    }
  4934. +    if (test_bit(drive, &fake_change)) {
  4935. +        /* simulated change (e.g. after formatting) */
  4936. +        return 1;
  4937. +    }
  4938. +    if (test_bit(drive, &changed_floppies)) {
  4939. +        /* surely changed (the WP signal changed at least once) */
  4940. +        return 1;
  4941. +    }
  4942. +    if (unit[drive].wpstat) {
  4943. +        /* WP is on -> could be changed: to be sure, buffers should be
  4944. +           * invalidated...
  4945. +         */
  4946. +        return 1;
  4947. +    }
  4948. +    return 1; /* DAG - was 0 */
  4949. +}
  4950. +
  4951. +static int floppy_revalidate(dev_t dev)
  4952. +{
  4953. +    int drive = dev & 3;
  4954. +
  4955. +    if (test_bit(drive, &changed_floppies) || test_bit(drive, &fake_change)
  4956. +        || unit[drive].disktype == 0) {
  4957. +#ifdef TRACKBUFFER
  4958. +      BufferDrive = -1;
  4959. +#endif
  4960. +        clear_bit(drive, &fake_change);
  4961. +        clear_bit(drive, &changed_floppies);
  4962. +        unit[drive].disktype = 0;
  4963. +    }
  4964. +    return 0;
  4965. +}
  4966. +
  4967. +static __inline__ void copy_buffer(void *from, void *to)
  4968. +{
  4969. +    ulong *p1 = (ulong *) from, *p2 = (ulong *) to;
  4970. +    int cnt;
  4971. +
  4972. +    for (cnt = 512 / 4; cnt; cnt--)
  4973. +        *p2++ = *p1++;
  4974. +}
  4975. +
  4976. +
  4977. +/* This sets up the global variables describing the current request. */
  4978. +
  4979. +static void setup_req_params(int drive)
  4980. +{
  4981. +    int block = ReqBlock + ReqCnt;
  4982. +
  4983. +    ReqTrack = block / unit[drive].disktype->spt;
  4984. +    ReqSector = block - ReqTrack * unit[drive].disktype->spt + 1;
  4985. +    ReqSide = ReqTrack & 1;
  4986. +    ReqTrack >>= 1;
  4987. +    ReqData = ReqBuffer + 512 * ReqCnt;
  4988. +
  4989. +#ifdef TRACKBUFFER
  4990. +  read_track = (ReqCmd == READ && CURRENT_ERRORS == 0);
  4991. +#endif
  4992. +
  4993. +    DPRINT(("Request params: Si=%d Tr=%d Se=%d Data=%08lx\n", ReqSide,
  4994. +        ReqTrack, ReqSector, (unsigned long) ReqData));
  4995. +}
  4996. +
  4997. +
  4998. +static void redo_fd_request(void)
  4999. +{
  5000. +    int device, drive, type;
  5001. +    struct archy_floppy_struct *floppy;
  5002. +
  5003. +    DPRINT(("redo_fd_request: CURRENT=%08lx CURRENT->rq_dev=%04x CURRENT->sector=%ld\n",
  5004. +        (unsigned long) CURRENT, CURRENT ? CURRENT->rq_dev : 0,
  5005. +        CURRENT ? CURRENT->sector : 0));
  5006. +
  5007. +    if (CURRENT && CURRENT->rq_dev < 0)
  5008. +        goto the_end;
  5009. +
  5010. +      repeat:
  5011. +
  5012. +    if (!CURRENT)
  5013. +        goto the_end;
  5014. +
  5015. +    if (MAJOR(CURRENT->rq_dev) != MAJOR_NR)
  5016. +        panic(DEVICE_NAME ": request list destroyed");
  5017. +
  5018. +    if (CURRENT->bh) {
  5019. +        if (!buffer_locked(CURRENT->bh))
  5020. +            panic(DEVICE_NAME ": block not locked");
  5021. +    }
  5022. +    device = MINOR(CURRENT_DEVICE);
  5023. +    drive = device & 3;
  5024. +    type = device >> 2;
  5025. +    floppy = &unit[drive];
  5026. +
  5027. +    if (!floppy->connected) {
  5028. +        /* drive not connected */
  5029. +        printk("Unknown Device: fd%d\n", drive);
  5030. +        end_request(0);
  5031. +        goto repeat;
  5032. +    }
  5033. +    if (type == 0) {
  5034. +        if (!floppy->disktype) {
  5035. +            Probing = 1;
  5036. +            floppy->disktype = disk_type + NUM_DISK_TYPES - 1;
  5037. +            floppy_sizes[drive] = floppy->disktype->blocks >> 1;
  5038. +            floppy->autoprobe = 1;
  5039. +        }
  5040. +    } else {
  5041. +        /* user supplied disk type */
  5042. +        --type;
  5043. +        if (type >= NUM_DISK_TYPES) {
  5044. +            printk("fd%d: invalid disk format", drive);
  5045. +            end_request(0);
  5046. +            goto repeat;
  5047. +        }
  5048. +        floppy->disktype = &disk_type[type];
  5049. +        floppy_sizes[drive] = disk_type[type].blocks >> 1;
  5050. +        floppy->autoprobe = 0;
  5051. +    }
  5052. +
  5053. +    if (CURRENT->sector + 1 > floppy->disktype->blocks) {
  5054. +        end_request(0);
  5055. +        goto repeat;
  5056. +    }
  5057. +    /* stop deselect timer */
  5058. +    del_timer(&motor_off_timer);
  5059. +
  5060. +    ReqCnt = 0;
  5061. +    ReqCmd = CURRENT->cmd;
  5062. +    ReqBlock = CURRENT->sector;
  5063. +    ReqBuffer = CURRENT->buffer;
  5064. +    setup_req_params(drive);
  5065. +    do_fd_action(drive);
  5066. +
  5067. +    return;
  5068. +
  5069. +      the_end:
  5070. +    finish_fdc();
  5071. +}
  5072. +
  5073. +static void fd1772_checkint(void)
  5074. +{
  5075. +  /*printk("fd1772_checkint %d\n",fdc1772_fdc_int_done);*/
  5076. +  if (fdc1772_fdc_int_done)
  5077. +    floppy_irqconsequencehandler();
  5078. +  if (fdc_busy) {
  5079. +    queue_task(&fd1772_tq,&tq_immediate);
  5080. +    mark_bh(IMMEDIATE_BH);
  5081. +  };
  5082. +};
  5083. +
  5084. +void do_fd_request(void)
  5085. +{
  5086. +    unsigned long flags;
  5087. +
  5088. +    DPRINT(("do_fd_request for pid %d\n", current->pid));
  5089. +    if (fdc_busy) return;
  5090. +    save_flags(flags);
  5091. +    cli();
  5092. +    while (fdc_busy)
  5093. +        sleep_on(&fdc_wait);
  5094. +    fdc_busy = 1;
  5095. +    ENABLE_IRQ();
  5096. +    restore_flags(flags);
  5097. +
  5098. +    fdc1772_fdc_int_done = 0;
  5099. +
  5100. +    redo_fd_request();
  5101. +
  5102. +  queue_task(&fd1772_tq,&tq_immediate);
  5103. +  mark_bh(IMMEDIATE_BH);
  5104. +}
  5105. +
  5106. +
  5107. +static int invalidate_drive(int rdev)
  5108. +{
  5109. +    /* invalidate the buffer track to force a reread */
  5110. +#ifdef TRACKBUFFER
  5111. +  BufferDrive = -1;
  5112. +#endif
  5113. +
  5114. +    set_bit(rdev & 3, &fake_change);
  5115. +    check_disk_change(rdev);
  5116. +    return 0;
  5117. +}
  5118. +
  5119. +static int fd_ioctl(struct inode *inode, struct file *filp,
  5120. +            unsigned int cmd, unsigned long param)
  5121. +{
  5122. +#define IOCTL_MODE_BIT 8
  5123. +#define OPEN_WRITE_BIT 16
  5124. +#define IOCTL_ALLOWED (filp && (filp->f_mode & IOCTL_MODE_BIT))
  5125. +
  5126. +    int drive, device;
  5127. +
  5128. +    device = inode->i_rdev;
  5129. +    switch (cmd) {
  5130. +        RO_IOCTLS(inode->i_rdev, param);
  5131. +    }
  5132. +    drive = MINOR(device);
  5133. +    if (!IOCTL_ALLOWED)
  5134. +        return -EPERM;
  5135. +    switch (cmd) {
  5136. +    case FDFMTBEG:
  5137. +        return 0;
  5138. +        /* case FDC1772LRPRM:  ??? DAG what does this do?? 
  5139. +           unit[drive].disktype = NULL;
  5140. +           floppy_sizes[drive] = MAX_DISK_SIZE;
  5141. +           return invalidate_drive (device); */
  5142. +    case FDFMTEND:
  5143. +    case FDFLUSH:
  5144. +        return invalidate_drive(drive);
  5145. +    }
  5146. +    if (!suser())
  5147. +        return -EPERM;
  5148. +    if (drive < 0 || drive > 3)
  5149. +        return -EINVAL;
  5150. +    switch (cmd) {
  5151. +    default:
  5152. +        return -EINVAL;
  5153. +    }
  5154. +    return 0;
  5155. +}
  5156. +
  5157. +
  5158. +/* Initialize the 'unit' variable for drive 'drive' */
  5159. +
  5160. +static void fd_probe(int drive)
  5161. +{
  5162. +    unit[drive].connected = 0;
  5163. +    unit[drive].disktype = NULL;
  5164. +
  5165. +    if (!fd_test_drive_present(drive))
  5166. +        return;
  5167. +
  5168. +    unit[drive].connected = 1;
  5169. +    unit[drive].track = -1; /* If we put the auto detect back in this can go to 0 */
  5170. +    unit[drive].steprate = FDC1772STEP_6;
  5171. +    MotorOn = 1;        /* from probe restore operation! */
  5172. +}
  5173. +
  5174. +
  5175. +/* This function tests the physical presence of a floppy drive (not
  5176. + * whether a disk is inserted). This is done by issuing a restore
  5177. + * command, waiting max. 2 seconds (that should be enough to move the
  5178. + * head across the whole disk) and looking at the state of the "TR00"
  5179. + * signal. This should now be raised if there is a drive connected
  5180. + * (and there is no hardware failure :-) Otherwise, the drive is
  5181. + * declared absent.
  5182. + */
  5183. +
  5184. +static int fd_test_drive_present(int drive)
  5185. +{
  5186. +    unsigned long timeout;
  5187. +    unsigned char status;
  5188. +    int ok;
  5189. +
  5190. +    printk("fd_test_drive_present %d\n", drive);
  5191. +    if (drive > 1)
  5192. +        return (0);
  5193. +    return (1);        /* Simple hack for the moment - the autodetect doesn't seem to work on arc */
  5194. +    fd_select_drive(drive);
  5195. +
  5196. +    /* disable interrupt temporarily */
  5197. +    DISABLE_IRQ();
  5198. +    FDC1772_WRITE(FDC1772REG_TRACK, 0x00);    /* was ff00 why? */
  5199. +    FDC1772_WRITE(FDC1772REG_CMD, FDC1772CMD_RESTORE | FDC1772CMDADD_H | FDC1772STEP_6);
  5200. +
  5201. +    /*printk("fd_test_drive_present: Going into timeout loop\n"); */
  5202. +    for (ok = 0, timeout = jiffies + 2 * HZ + HZ / 2; jiffies < timeout;) {
  5203. +        /*  What does this piece of atariism do? - query for an interrupt? */
  5204. +        /*  if (!(mfp.par_dt_reg & 0x20))
  5205. +           break; */
  5206. +        /* Well this is my nearest guess - quit when we get an FDC interrupt */
  5207. +        if (IOC_FIQSTAT & 2)
  5208. +            break;
  5209. +    }
  5210. +
  5211. +    /*printk("fd_test_drive_present: Coming out of timeout loop\n"); */
  5212. +    status = FDC1772_READ(FDC1772REG_STATUS);
  5213. +    ok = (status & FDC1772STAT_TR00) != 0;
  5214. +
  5215. +    /*printk("fd_test_drive_present: ok=%d\n",ok); */
  5216. +    /* force interrupt to abort restore operation (FDC1772 would try
  5217. +     * about 50 seconds!) */
  5218. +    FDC1772_WRITE(FDC1772REG_CMD, FDC1772CMD_FORCI);
  5219. +    udelay(500);
  5220. +    status = FDC1772_READ(FDC1772REG_STATUS);
  5221. +    udelay(20);
  5222. +    /*printk("fd_test_drive_present: just before OK code %d\n",ok); */
  5223. +
  5224. +    if (ok) {
  5225. +        /* dummy seek command to make WP bit accessible */
  5226. +        FDC1772_WRITE(FDC1772REG_DATA, 0);
  5227. +        FDC1772_WRITE(FDC1772REG_CMD, FDC1772CMD_SEEK);
  5228. +        printk("fd_test_drive_present: just before wait for int\n");
  5229. +        /* DAG: Guess means wait for interrupt */
  5230. +        while (!(IOC_FIQSTAT & 2));
  5231. +        printk("fd_test_drive_present: just after wait for int\n");
  5232. +        status = FDC1772_READ(FDC1772REG_STATUS);
  5233. +    }
  5234. +    printk("fd_test_drive_present: just before ENABLE_IRQ\n");
  5235. +    ENABLE_IRQ();
  5236. +    printk("fd_test_drive_present: about to return\n");
  5237. +    return (ok);
  5238. +}
  5239. +
  5240. +
  5241. +/* Look how many and which kind of drives are connected. If there are
  5242. + * floppies, additionally start the disk-change and motor-off timers.
  5243. + */
  5244. +
  5245. +static void config_types(void)
  5246. +{
  5247. +    int drive, cnt = 0;
  5248. +
  5249. +    printk("Probing floppy drive(s):\n");
  5250. +    for (drive = 0; drive < FD_MAX_UNITS; drive++) {
  5251. +        fd_probe(drive);
  5252. +        if (unit[drive].connected) {
  5253. +            printk("fd%d\n", drive);
  5254. +            ++cnt;
  5255. +        }
  5256. +    }
  5257. +
  5258. +    if (FDC1772_READ(FDC1772REG_STATUS) & FDC1772STAT_BUSY) {
  5259. +        /* If FDC1772 is still busy from probing, give it another FORCI
  5260. +         * command to abort the operation. If this isn't done, the FDC1772
  5261. +         * will interrupt later and its IRQ line stays low, because
  5262. +         * the status register isn't read. And this will block any
  5263. +         * interrupts on this IRQ line :-(
  5264. +         */
  5265. +        FDC1772_WRITE(FDC1772REG_CMD, FDC1772CMD_FORCI);
  5266. +        udelay(500);
  5267. +        FDC1772_READ(FDC1772REG_STATUS);
  5268. +        udelay(20);
  5269. +    }
  5270. +    if (cnt > 0) {
  5271. +        START_MOTOR_OFF_TIMER(FD_MOTOR_OFF_DELAY);
  5272. +        if (cnt == 1)
  5273. +            fd_select_drive(0);
  5274. +        /*START_CHECK_CHANGE_TIMER( CHECK_CHANGE_DELAY ); */
  5275. +    }
  5276. +}
  5277. +
  5278. +/*
  5279. + * floppy_open check for aliasing (/dev/fd0 can be the same as
  5280. + * /dev/PS0 etc), and disallows simultaneous access to the same
  5281. + * drive with different device numbers.
  5282. + */
  5283. +
  5284. +static int floppy_open(struct inode *inode, struct file *filp)
  5285. +{
  5286. +    int drive;
  5287. +    int old_dev;
  5288. +
  5289. +    if (!filp) {
  5290. +        DPRINT(("Weird, open called with filp=0\n"));
  5291. +        return -EIO;
  5292. +    }
  5293. +    drive = MINOR(inode->i_rdev) & 3;
  5294. +    if ((MINOR(inode->i_rdev) >> 2) > NUM_DISK_TYPES)
  5295. +        return -ENXIO;
  5296. +
  5297. +    old_dev = fd_device[drive];
  5298. +
  5299. +    if (fd_ref[drive])
  5300. +        if (old_dev != inode->i_rdev)
  5301. +            return -EBUSY;
  5302. +
  5303. +    if (fd_ref[drive] == -1 || (fd_ref[drive] && filp->f_flags & O_EXCL))
  5304. +        return -EBUSY;
  5305. +
  5306. +    if (filp->f_flags & O_EXCL)
  5307. +        fd_ref[drive] = -1;
  5308. +    else
  5309. +        fd_ref[drive]++;
  5310. +
  5311. +    fd_device[drive] = inode->i_rdev;
  5312. +
  5313. +    if (old_dev && old_dev != inode->i_rdev)
  5314. +        invalidate_buffers(old_dev);
  5315. +
  5316. +    /* Allow ioctls if we have write-permissions even if read-only open */
  5317. +    if (filp->f_mode & 2 || permission(inode, 2) == 0)
  5318. +        filp->f_mode |= IOCTL_MODE_BIT;
  5319. +    if (filp->f_mode & 2)
  5320. +        filp->f_mode |= OPEN_WRITE_BIT;
  5321. +
  5322. +    if (filp->f_flags & O_NDELAY)
  5323. +        return 0;
  5324. +
  5325. +    if (filp->f_mode & 3) {
  5326. +        check_disk_change(inode->i_rdev);
  5327. +        if (filp->f_mode & 2) {
  5328. +            if (unit[drive].wpstat) {
  5329. +                floppy_release(inode, filp);
  5330. +                return -EROFS;
  5331. +            }
  5332. +        }
  5333. +    }
  5334. +    return 0;
  5335. +}
  5336. +
  5337. +
  5338. +static void floppy_release(struct inode *inode, struct file *filp)
  5339. +{
  5340. +    int drive;
  5341. +
  5342. +    drive = inode->i_rdev & 3;
  5343. +
  5344. +    if (!filp || (filp->f_mode & (2 | OPEN_WRITE_BIT)))
  5345. +        /* if the file is mounted OR (writable now AND writable at open
  5346. +           time) Linus: Does this cover all cases? */
  5347. +        block_fsync(inode, filp);
  5348. +
  5349. +    if (fd_ref[drive] < 0)
  5350. +        fd_ref[drive] = 0;
  5351. +    else if (!fd_ref[drive]--) {
  5352. +        printk("floppy_release with fd_ref == 0");
  5353. +        fd_ref[drive] = 0;
  5354. +    }
  5355. +}
  5356. +
  5357. +static struct file_operations floppy_fops =
  5358. +{
  5359. +    NULL,            /* lseek - default */
  5360. +    block_read,        /* read - general block-dev read */
  5361. +    block_write,        /* write - general block-dev write */
  5362. +    NULL,            /* readdir - bad */
  5363. +    NULL,            /* select */
  5364. +    fd_ioctl,        /* ioctl */
  5365. +    NULL,            /* mmap */
  5366. +    floppy_open,        /* open */
  5367. +    floppy_release,        /* release */
  5368. +    block_fsync,        /* fsync */
  5369. +    NULL,            /* fasync */
  5370. +    check_floppy_change,    /* media_change */
  5371. +    floppy_revalidate,    /* revalidate */
  5372. +};
  5373. +
  5374. +
  5375. +int floppy_init(void)
  5376. +{
  5377. +    int i;
  5378. +
  5379. +    if (register_blkdev(MAJOR_NR, "fd", &floppy_fops)) {
  5380. +        printk("Unable to get major %d for floppy\n", MAJOR_NR);
  5381. +        return;
  5382. +    }
  5383. +    /* Actually this does almost nothing - we actually do this by starting DMA
  5384. +       on channel 1 */
  5385. +    /*if (request_irq(FIQ_FD1772+16,fdc1772_comendhandler,SA_INTERRUPT,"fd1772")) {
  5386. +       printk("Unable to grab IRQ%d for the floppy (1772) driver\n",FIQ_FD1772+16);
  5387. +       return ;
  5388. +       }; */
  5389. +
  5390. +    if (request_dma(FLOPPY_DMA, "fd1772")) {
  5391. +        printk("Unable to grab DMA%d for the floppy (1772) driver\n", FLOPPY_DMA);
  5392. +        free_irq(FIQ_FD1772 + 16);
  5393. +        return;
  5394. +    };
  5395. +
  5396. +    if (request_dma(FIQ_FD1772, "fd1772 end")) {
  5397. +        printk("Unable to grab DMA%d for the floppy (1772) driver\n", FIQ_FD1772);
  5398. +        free_irq(FIQ_FD1772 + 16);
  5399. +        return;
  5400. +    };
  5401. +    enable_dma(FIQ_FD1772);    /* This inserts a call to our command end routine */
  5402. +
  5403. +    /* initialize variables */
  5404. +    SelectedDrive = -1;
  5405. +#ifdef TRACKBUFFER
  5406. +  BufferDrive = -1;
  5407. +#endif
  5408. +
  5409. +    /* initialize check_change timer */
  5410. +    timer_table[FLOPPY_TIMER].fn = check_change;
  5411. +    timer_active &= ~(1 << FLOPPY_TIMER);
  5412. +
  5413. +
  5414. +#ifdef TRACKBUFFER
  5415. +  DMABuffer = (char *)kmalloc((MAX_SECTORS+1)*512); /* Atari uses 512 - I want to eventually cope with 1K sectors */
  5416. +  TrackBuffer = DMABuffer + 512;
  5417. +#else
  5418. +    /* Allocate memory for the DMAbuffer - on the Atari this takes it
  5419. +       out of some special memory... */
  5420. +    DMABuffer = (char *) kmalloc(2048);    /* Copes with pretty large sectors */
  5421. +#endif
  5422. +#ifdef TRACKBUFFER  
  5423. +  BufferDrive = BufferSide = BufferTrack = -1;
  5424. +#endif
  5425. +
  5426. +    for (i = 0; i < FD_MAX_UNITS; i++) {
  5427. +        unit[i].track = -1;
  5428. +    }
  5429. +
  5430. +    for (i = 0; i < 256; i++)
  5431. +        if ((i >> 2) > 0 && (i >> 2) <= NUM_DISK_TYPES)
  5432. +            floppy_sizes[i] = disk_type[(i >> 2) - 1].blocks >> 1;
  5433. +        else
  5434. +            floppy_sizes[i] = MAX_DISK_SIZE;
  5435. +
  5436. +    blk_size[MAJOR_NR] = floppy_sizes;
  5437. +    blksize_size[MAJOR_NR] = floppy_blocksizes;
  5438. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  5439. +
  5440. +    config_types();
  5441. +
  5442. +    return 0;
  5443. +}
  5444. +
  5445. +/* Just a dummy at the moment */
  5446. +void floppy_setup(char *str, int *ints)
  5447. +{
  5448. +}
  5449. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/fd1772dma.S linux/arch/arm/drivers/block/fd1772dma.S
  5450. --- linux.orig/arch/arm/drivers/block/fd1772dma.S    Thu Jan  1 01:00:00 1970
  5451. +++ linux/arch/arm/drivers/block/fd1772dma.S    Sat Sep  7 21:09:51 1996
  5452. @@ -0,0 +1,100 @@
  5453. +#include <asm/hardware.h>
  5454. +
  5455. +@ Code for DMA with the 1772 fdc
  5456. +.text
  5457. +
  5458. +
  5459. +  .global _fdc1772_dataaddr
  5460. +_fdc1772_fiqdata:
  5461. +@ Number of bytes left to DMA
  5462. +  .global _fdc1772_bytestogo
  5463. +_fdc1772_bytestogo:
  5464. +  .word 0
  5465. +@ Place to put/get data from in DMA
  5466. +  .global _fdc1772_dataaddr
  5467. +_fdc1772_dataaddr:
  5468. +  .word 0
  5469. +  
  5470. +  .global _fdc1772_fdc_int_done
  5471. +_fdc1772_fdc_int_done:
  5472. +  .word 0
  5473. +  .global _fdc1772_comendstatus
  5474. +_fdc1772_comendstatus:
  5475. +  .word 0
  5476. +
  5477. +@ We hang this off DMA channel 1
  5478. +    .global _fdc1772_comendhandler
  5479. +_fdc1772_comendhandler:
  5480. +  mov      r8,#IOC_BASE
  5481. +  ldrb     r9,[r8,#0x34]    @ IOC FIQ status
  5482. +  tst      r9,#2
  5483. +  subeqs   pc,r14,#4        @ should I leave a space here
  5484. +  orr      r9,r8,#0x10000   @ FDC base
  5485. +  adr      r8,_fdc1772_fdc_int_done
  5486. +  ldrb     r10,[r9,#0]  @ FDC status
  5487. +  mov      r9,#1        @ Got a FIQ flag
  5488. +  stmia    r8,{r9,r10}
  5489. +  subs     pc,r14,#4
  5490. +
  5491. +
  5492. +    .global _fdc1772_dma_read
  5493. +_fdc1772_dma_read:
  5494. +  mov      r8,#IOC_BASE
  5495. +  ldrb     r9,[r8,#0x34]    @ IOC FIQ status
  5496. +  tst      r9,#1
  5497. +  beq      _fdc1772_dma_read_notours
  5498. +  orr      r8,r8,#0x10000   @ FDC base
  5499. +  ldrb     r10,[r8,#0xc]   @ Read from FDC data reg (also clears interrupt)
  5500. +  ldmia    r11,{r8,r9}
  5501. +  subs     r8,r8,#1        @ One less byte to go
  5502. +  @ If there was somewhere for this data to go then store it and update pointers
  5503. +  strplb   r10,[r9],#1     @ Store the data and increment the pointer
  5504. +  stmplia  r11,{r8,r9}     @ Update count/pointers
  5505. +  @ Handle any other interrupts if there are any
  5506. +_fdc1772_dma_read_notours:
  5507. +  @ Cant branch because this code has been copied down to the FIQ vector
  5508. +  ldr pc,[pc,#-4]
  5509. +  .word _fdc1772_comendhandler
  5510. +  .global _fdc1772_dma_read_end
  5511. +_fdc1772_dma_read_end:
  5512. +
  5513. +    .global _fdc1772_dma_write
  5514. +_fdc1772_dma_write:
  5515. +  mov      r8,#IOC_BASE
  5516. +  ldrb     r9,[r8,#0x34]    @ IOC FIQ status
  5517. +  tst      r9,#1
  5518. +  beq      _fdc1772_dma_write_notours
  5519. +  orr      r8,r8,#0x10000   @ FDC base
  5520. +  ldmia    r11,{r9,r10}
  5521. +  subs     r9,r9,#1        @ One less byte to go
  5522. +  @ If there really is some data then get it, store it and update count
  5523. +  ldrplb   r12,[r10],#1
  5524. +  strplb   r12,[r8,#0xc]   @ write it to FDC data reg
  5525. +  stmplia  r11,{r9,r10}    @ Update count and pointer - should clear interrupt
  5526. +  @ Handle any other interrupts
  5527. +_fdc1772_dma_write_notours:
  5528. +  @ Cant branch because this code has been copied down to the FIQ vector
  5529. +  ldr pc,[pc,#-4]
  5530. +  .word _fdc1772_comendhandler
  5531. +
  5532. +  .global _fdc1772_dma_write_end
  5533. +_fdc1772_dma_write_end:
  5534. +  
  5535. +
  5536. +@ Setup the FIQ R11 to point to the data and store the count, address
  5537. +@ for this dma
  5538. +@ R0=count
  5539. +@ R1=address
  5540. +  .global _fdc1772_setupdma
  5541. +_fdc1772_setupdma:
  5542. +    @ The big job is flipping in and out of FIQ mode
  5543. +    adr    r2,_fdc1772_fiqdata    @ This is what we really came here for
  5544. +  stmia  r2,{r0,r1}
  5545. +    mov    r3, pc
  5546. +    teqp    pc,#0x0c000001    @ Disable FIQs, IRQs and switch to FIQ mode
  5547. +    mov    r0,r0          @ NOP
  5548. +    mov r11,r2
  5549. +    teqp    r3,#0        @ Normal mode
  5550. +    mov    r0,r0        @ NOP
  5551. +  mov pc,r14
  5552. +
  5553. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/floppy.c linux/arch/arm/drivers/block/floppy.c
  5554. --- linux.orig/arch/arm/drivers/block/floppy.c    Thu Jan  1 01:00:00 1970
  5555. +++ linux/arch/arm/drivers/block/floppy.c    Fri Sep  6 21:08:31 1996
  5556. @@ -0,0 +1,4318 @@
  5557. +/*
  5558. + *  linux/arch/arm/drivers/block/floppy.c
  5559. + *  [ was linux/drivers/block/floppy.c ]
  5560. + *
  5561. + *  Copyright (C) 1991, 1992  Linus Torvalds
  5562. + *  Copyright (C) 1993, 1994  Alain Knaff
  5563. + *  Modifications Copyright (C) 1995 Russell King
  5564. + */
  5565. +/*
  5566. + * 02.12.91 - Changed to static variables to indicate need for reset
  5567. + * and recalibrate. This makes some things easier (output_byte reset
  5568. + * checking etc), and means less interrupt jumping in case of errors,
  5569. + * so the code is hopefully easier to understand.
  5570. + */
  5571. +
  5572. +/*
  5573. + * This file is certainly a mess. I've tried my best to get it working,
  5574. + * but I don't like programming floppies, and I have only one anyway.
  5575. + * Urgel. I should check for more errors, and do more graceful error
  5576. + * recovery. Seems there are problems with several drives. I've tried to
  5577. + * correct them. No promises.
  5578. + */
  5579. +
  5580. +/*
  5581. + * As with hd.c, all routines within this file can (and will) be called
  5582. + * by interrupts, so extreme caution is needed. A hardware interrupt
  5583. + * handler may not sleep, or a kernel panic will happen. Thus I cannot
  5584. + * call "floppy-on" directly, but have to set a special timer interrupt
  5585. + * etc.
  5586. + */
  5587. +
  5588. +/*
  5589. + * 28.02.92 - made track-buffering routines, based on the routines written
  5590. + * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
  5591. + */
  5592. +
  5593. +/*
  5594. + * Automatic floppy-detection and formatting written by Werner Almesberger
  5595. + * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
  5596. + * the floppy-change signal detection.
  5597. + */
  5598. +
  5599. +/*
  5600. + * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
  5601. + * FDC data overrun bug, added some preliminary stuff for vertical
  5602. + * recording support.
  5603. + *
  5604. + * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
  5605. + *
  5606. + * TODO: Errors are still not counted properly.
  5607. + */
  5608. +
  5609. +/* 1992/9/20
  5610. + * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
  5611. + * modeled after the freeware MS-DOS program fdformat/88 V1.8 by
  5612. + * Christoph H. Hochst\"atter.
  5613. + * I have fixed the shift values to the ones I always use. Maybe a new
  5614. + * ioctl() should be created to be able to modify them.
  5615. + * There is a bug in the driver that makes it impossible to format a
  5616. + * floppy as the first thing after bootup.
  5617. + */
  5618. +
  5619. +/*
  5620. + * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
  5621. + * this helped the floppy driver as well. Much cleaner, and still seems to
  5622. + * work.
  5623. + */
  5624. +
  5625. +/* 1994/6/24 --bbroad-- added the floppy table entries and made
  5626. + * minor modifications to allow 2.88 floppies to be run.
  5627. + */
  5628. +
  5629. +/* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
  5630. + * disk types.
  5631. + */
  5632. +
  5633. +/*
  5634. + * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
  5635. + * format bug fixes, but unfortunately some new bugs too...
  5636. + */
  5637. +
  5638. +/* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
  5639. + * errors to allow safe writing by specialized programs.
  5640. + */
  5641. +
  5642. +/* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
  5643. + * by defining bit 1 of the "stretch" parameter to mean put sectors on the
  5644. + * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
  5645. + * drives are "upside-down").
  5646. + */
  5647. +
  5648. +/*
  5649. + * 1995/8/26 -- Andreas Busse -- added Mips support.
  5650. + */
  5651. +
  5652. +/*
  5653. + * 1995/8/16 -- Russell King -- altered method for turning floppy drives on
  5654. + * for the arm.
  5655. + */
  5656. +
  5657. +/*
  5658. + * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
  5659. + * features to asm/floppy.h.
  5660. + */
  5661. +
  5662. +
  5663. +#define FLOPPY_SANITY_CHECK
  5664. +#undef  FLOPPY_SILENT_DCL_CLEAR
  5665. +
  5666. +#define DEBUGT 2
  5667. +#define DCL_DEBUG /* debug disk change line */
  5668. +
  5669. +/* do print messages for unexpected interrupts */
  5670. +static int print_unex=1;
  5671. +#include <linux/utsname.h>
  5672. +#include <linux/module.h>
  5673. +
  5674. +/* the following is the mask of allowed drives. By default units 2 and
  5675. + * 3 of both floppy controllers are disabled, because switching on the
  5676. + * motor of these drives causes system hangs on some PCI computers. drive
  5677. + * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
  5678. + * a drive is allowed. */
  5679. +static int allowed_drive_mask=0x33;
  5680. +
  5681. +#define FLOPPY_IRQ 12
  5682. +#define FLOPPY_DMA 2
  5683. +#define FDC1 0x3f0
  5684. +#define N_DRIVE 8
  5685. +#define N_FDC 1
  5686. +static int FDC2=-1;
  5687. +#define FLOPPY0_TYPE 4
  5688. +#define FLOPPY1_TYPE 4
  5689. +
  5690. +#include <linux/sched.h>
  5691. +#include <linux/fs.h>
  5692. +#include <linux/kernel.h>
  5693. +#include <linux/timer.h>
  5694. +#include <linux/tqueue.h>
  5695. +#define FDPATCHES
  5696. +#include <linux/fdreg.h>
  5697. +
  5698. +
  5699. +#include <linux/fd.h>
  5700. +
  5701. +
  5702. +#define OLDFDRAWCMD 0x020d /* send a raw command to the FDC */
  5703. +
  5704. +struct old_floppy_raw_cmd {
  5705. +  void *data;
  5706. +  long length;
  5707. +
  5708. +  unsigned char rate;
  5709. +  unsigned char flags;
  5710. +  unsigned char cmd_count;
  5711. +  unsigned char cmd[9];
  5712. +  unsigned char reply_count;
  5713. +  unsigned char reply[7];
  5714. +  int track;
  5715. +};
  5716. +
  5717. +#include <linux/errno.h>
  5718. +#include <linux/malloc.h>
  5719. +#include <linux/mm.h>
  5720. +#include <linux/string.h>
  5721. +#include <linux/fcntl.h>
  5722. +#include <linux/delay.h>
  5723. +
  5724. +#include <linux/ioport.h>
  5725. +#include <linux/interrupt.h>
  5726. +
  5727. +#include <asm/dma.h>
  5728. +#include <asm/irq.h>
  5729. +#include <asm/system.h>
  5730. +#include <asm/io.h>
  5731. +#include <asm/segment.h>
  5732. +
  5733. +static int use_virtual_dma=0; /* virtual DMA for Intel */
  5734. +static unsigned short virtual_dma_port=0x3f0;
  5735. +void floppy_interrupt(int irq, void *dev_id, struct pt_regs * regs);
  5736. +static int set_dor(int fdc, char mask, char data);
  5737. +static inline int __get_order(unsigned long size);
  5738. +#include <asm/floppy.h>
  5739. +
  5740. +
  5741. +#define MAJOR_NR FLOPPY_MAJOR
  5742. +
  5743. +#include <linux/blk.h>
  5744. +#include <linux/cdrom.h> /* for the compatibility eject ioctl */
  5745. +
  5746. +
  5747. +#ifndef FLOPPY_MOTOR_MASK
  5748. +#define FLOPPY_MOTOR_MASK 0xf0
  5749. +#endif
  5750. +
  5751. +#ifndef fd_get_dma_residue
  5752. +#define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
  5753. +#endif
  5754. +
  5755. +/* Dma Memory related stuff */
  5756. +
  5757. +/* Pure 2^n version of get_order */
  5758. +static inline int __get_order(unsigned long size)
  5759. +{
  5760. +    int order;
  5761. +
  5762. +    size = (size-1) >> (PAGE_SHIFT-1);
  5763. +    order = -1;
  5764. +    do {
  5765. +        size >>= 1;
  5766. +        order++;
  5767. +    } while (size);
  5768. +    return order;
  5769. +}
  5770. +
  5771. +#ifndef fd_dma_mem_free
  5772. +#define fd_dma_mem_free(addr, size) free_pages(addr, __get_order(size))
  5773. +#endif
  5774. +
  5775. +#ifndef fd_dma_mem_alloc
  5776. +#define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,__get_order(size))
  5777. +#endif
  5778. +
  5779. +/* End dma memory related stuff */
  5780. +
  5781. +static unsigned int fake_change = 0;
  5782. +static int initialising=1;
  5783. +
  5784. +static inline int TYPE(kdev_t x) {
  5785. +    return  (MINOR(x)>>2) & 0x1f;
  5786. +}
  5787. +static inline int DRIVE(kdev_t x) {
  5788. +    return (MINOR(x)&0x03) | ((MINOR(x)&0x80) >> 5);
  5789. +}
  5790. +#define ITYPE(x) (((x)>>2) & 0x1f)
  5791. +#define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
  5792. +#define UNIT(x) ((x) & 0x03)        /* drive on fdc */
  5793. +#define FDC(x) (((x) & 0x04) >> 2)  /* fdc of drive */
  5794. +#define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
  5795. +                /* reverse mapping from unit and fdc to drive */
  5796. +#define DP (&drive_params[current_drive])
  5797. +#define DRS (&drive_state[current_drive])
  5798. +#define DRWE (&write_errors[current_drive])
  5799. +#define FDCS (&fdc_state[fdc])
  5800. +#define CLEARF(x) (clear_bit(x##_BIT, &DRS->flags))
  5801. +#define SETF(x) (set_bit(x##_BIT, &DRS->flags))
  5802. +#define TESTF(x) (test_bit(x##_BIT, &DRS->flags))
  5803. +
  5804. +#define UDP (&drive_params[drive])
  5805. +#define UDRS (&drive_state[drive])
  5806. +#define UDRWE (&write_errors[drive])
  5807. +#define UFDCS (&fdc_state[FDC(drive)])
  5808. +#define UCLEARF(x) (clear_bit(x##_BIT, &UDRS->flags))
  5809. +#define USETF(x) (set_bit(x##_BIT, &UDRS->flags))
  5810. +#define UTESTF(x) (test_bit(x##_BIT, &UDRS->flags))
  5811. +
  5812. +#define DPRINT(format, args...) printk(DEVICE_NAME "%d: " format, current_drive , ## args)
  5813. +
  5814. +#define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
  5815. +#define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
  5816. +
  5817. +#define CLEARSTRUCT(x) memset((x), 0, sizeof(*(x)))
  5818. +
  5819. +#define INT_OFF save_flags(flags); cli()
  5820. +#define INT_ON  restore_flags(flags)
  5821. +
  5822. +/* read/write */
  5823. +#define COMMAND raw_cmd->cmd[0]
  5824. +#define DR_SELECT raw_cmd->cmd[1]
  5825. +#define TRACK raw_cmd->cmd[2]
  5826. +#define HEAD raw_cmd->cmd[3]
  5827. +#define SECTOR raw_cmd->cmd[4]
  5828. +#define SIZECODE raw_cmd->cmd[5]
  5829. +#define SECT_PER_TRACK raw_cmd->cmd[6]
  5830. +#define GAP raw_cmd->cmd[7]
  5831. +#define SIZECODE2 raw_cmd->cmd[8]
  5832. +#define NR_RW 9
  5833. +
  5834. +/* format */
  5835. +#define F_SIZECODE raw_cmd->cmd[2]
  5836. +#define F_SECT_PER_TRACK raw_cmd->cmd[3]
  5837. +#define F_GAP raw_cmd->cmd[4]
  5838. +#define F_FILL raw_cmd->cmd[5]
  5839. +#define NR_F 6
  5840. +
  5841. +/*
  5842. + * Maximum disk size (in kilobytes). This default is used whenever the
  5843. + * current disk size is unknown.
  5844. + * [Now it is rather a minimum]
  5845. + */
  5846. +#define MAX_DISK_SIZE 2 /* 3984*/
  5847. +
  5848. +#define K_64    0x10000        /* 64kB */
  5849. +
  5850. +/*
  5851. + * globals used by 'result()'
  5852. + */
  5853. +#define MAX_REPLIES 16
  5854. +static unsigned char reply_buffer[MAX_REPLIES];
  5855. +static int inr; /* size of reply buffer, when called from interrupt */
  5856. +#define ST0 (reply_buffer[0])
  5857. +#define ST1 (reply_buffer[1])
  5858. +#define ST2 (reply_buffer[2])
  5859. +#define ST3 (reply_buffer[0]) /* result of GETSTATUS */
  5860. +#define R_TRACK (reply_buffer[3])
  5861. +#define R_HEAD (reply_buffer[4])
  5862. +#define R_SECTOR (reply_buffer[5])
  5863. +#define R_SIZECODE (reply_buffer[6])
  5864. +
  5865. +#define SEL_DLY (2*HZ/100)
  5866. +
  5867. +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
  5868. +/*
  5869. + * this struct defines the different floppy drive types.
  5870. + */
  5871. +static struct {
  5872. +    struct floppy_drive_params params;
  5873. +    const char *name; /* name printed while booting */
  5874. +} default_drive_params[]= {
  5875. +/* NOTE: the time values in jiffies should be in msec!
  5876. + CMOS drive type
  5877. +  |     Maximum data rate supported by drive type
  5878. +  |     |   Head load time, msec
  5879. +  |     |   |   Head unload time, msec (not used)
  5880. +  |     |   |   |     Step rate interval, usec
  5881. +  |     |   |   |     |       Time needed for spinup time (jiffies)
  5882. +  |     |   |   |     |       |      Timeout for spinning down (jiffies)
  5883. +  |     |   |   |     |       |      |   Spindown offset (where disk stops)
  5884. +  |     |   |   |     |       |      |   |     Select delay
  5885. +  |     |   |   |     |       |      |   |     |     RPS
  5886. +  |     |   |   |     |       |      |   |     |     |    Max number of tracks
  5887. +  |     |   |   |     |       |      |   |     |     |    |     Interrupt timeout
  5888. +  |     |   |   |     |       |      |   |     |     |    |     |   Max nonintlv. sectors
  5889. +  |     |   |   |     |       |      |   |     |     |    |     |   | -Max Errors- flags */
  5890. +{{0,  500, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
  5891. +      0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
  5892. +
  5893. +{{1,  300, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
  5894. +      0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
  5895. +
  5896. +{{2,  500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
  5897. +      0, { 2, 5, 6,23,10,20,11, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
  5898. +
  5899. +{{3,  250, 16, 16, 3000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  5900. +      0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
  5901. +#if 0
  5902. +{{4,  500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  5903. +      0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
  5904. +#else
  5905. +{{4,  500, 16, 16, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,0}, FTD_MSG,
  5906. +      0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
  5907. +#endif
  5908. +{{5, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  5909. +      0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
  5910. +
  5911. +{{6, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  5912. +      0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
  5913. +/*    |  --autodetected formats---   |      |      |
  5914. + *    read_track                     |      |    Name printed when booting
  5915. + *                                   |     Native format
  5916. + *                                 Frequency of disk change checks */
  5917. +};
  5918. +
  5919. +static struct floppy_drive_params drive_params[N_DRIVE];
  5920. +static struct floppy_drive_struct drive_state[N_DRIVE];
  5921. +static struct floppy_write_errors write_errors[N_DRIVE];
  5922. +static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
  5923. +
  5924. +/*
  5925. + * This struct defines the different floppy types.
  5926. + *
  5927. + * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
  5928. + * types (e.g. 360kB diskette in 1.2MB drive, etc.).  Bit 1 of 'stretch'
  5929. + * tells if the disk is in Commodore 1581 format, which means side 0 sectors
  5930. + * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
  5931. + * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
  5932. + * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
  5933. + * side 0 is on physical side 0 (but with the misnamed sector IDs).
  5934. + * 'stretch' should probably be renamed to something more general, like
  5935. + * 'options'.  Other parameters should be self-explanatory (see also
  5936. + * setfdprm(8)).
  5937. + */
  5938. +/*
  5939. +             Size
  5940. +             |  Sectors per track
  5941. +             |  | Head
  5942. +             |  | |  Tracks
  5943. +             |  | |  | Stretch
  5944. +             |  | |  | |  Gap 1 size
  5945. +             |  | |  | |    |  Data rate, | 0x40 for perp
  5946. +         |  | |  | |    |    |  Spec1 (stepping rate, head unload
  5947. +             |  | |  | |    |    |    |    /fmt gap (gap2) */
  5948. +static struct floppy_struct floppy_type[32] = {
  5949. +    {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL    },    /*  0 no testing    */
  5950. +    {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360"  }, /*  1 360KB PC      */
  5951. +    { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" },    /*  2 1.2MB AT      */
  5952. +    {  720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360"  },    /*  3 360KB SS 3.5" */
  5953. +    { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720"  },    /*  4 720KB 3.5"    */
  5954. +    {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360"  },    /*  5 360KB AT      */
  5955. +    { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720"  },    /*  6 720KB AT      */
  5956. +    { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" },    /*  7 1.44MB 3.5"   */
  5957. +    { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" },    /*  8 2.88MB 3.5"   */
  5958. +    { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" },    /*  9 3.12MB 3.5"   */
  5959. +
  5960. +    { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25"  */
  5961. +    { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5"   */
  5962. +    {  820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410"  },    /* 12 410KB 5.25"   */
  5963. +    { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820"  },    /* 13 820KB 3.5"    */
  5964. +    { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" },    /* 14 1.48MB 5.25"  */
  5965. +    { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" },    /* 15 1.72MB 3.5"   */
  5966. +    {  840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420"  },    /* 16 420KB 5.25"   */
  5967. +    { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830"  },    /* 17 830KB 3.5"    */
  5968. +    { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" },    /* 18 1.49MB 5.25"  */
  5969. +    { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5"  */
  5970. +
  5971. +    { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880"  }, /* 20 880KB 5.25"   */
  5972. +    { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5"   */
  5973. +    { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5"   */
  5974. +    { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25"   */
  5975. +    { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5"   */
  5976. +    { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5"   */
  5977. +    { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5"   */
  5978. +    { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5"   */
  5979. +    { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5"   */
  5980. +
  5981. +    { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5"   */
  5982. +    { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800"  },    /* 30 800KB 3.5"    */
  5983. +    { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5"    */
  5984. +};
  5985. +
  5986. +#define    NUMBER(x)    (sizeof(x) / sizeof(*(x)))
  5987. +#define SECTSIZE (_FD_SECTSIZE(*floppy))
  5988. +
  5989. +/* Auto-detection: Disk type used until the next media change occurs. */
  5990. +static struct floppy_struct *current_type[N_DRIVE] = {
  5991. +    NULL, NULL, NULL, NULL,
  5992. +    NULL, NULL, NULL, NULL
  5993. +};
  5994. +
  5995. +/*
  5996. + * User-provided type information. current_type points to
  5997. + * the respective entry of this array.
  5998. + */
  5999. +static struct floppy_struct user_params[N_DRIVE];
  6000. +
  6001. +static int floppy_sizes[256];
  6002. +static int floppy_blocksizes[256] = { 0, };
  6003. +
  6004. +/*
  6005. + * The driver is trying to determine the correct media format
  6006. + * while probing is set. rw_interrupt() clears it after a
  6007. + * successful access.
  6008. + */
  6009. +static int probing = 0;
  6010. +
  6011. +/* Synchronization of FDC access. */
  6012. +#define FD_COMMAND_NONE -1
  6013. +#define FD_COMMAND_ERROR 2
  6014. +#define FD_COMMAND_OKAY 3
  6015. +
  6016. +static volatile int command_status = FD_COMMAND_NONE, fdc_busy = 0;
  6017. +static struct wait_queue *fdc_wait = NULL, *command_done = NULL;
  6018. +#define NO_SIGNAL (!(current->signal & ~current->blocked) || !interruptible)
  6019. +#define CALL(x) if ((x) == -EINTR) return -EINTR
  6020. +#define ECALL(x) if ((ret = (x))) return ret;
  6021. +#define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
  6022. +#define WAIT(x) _WAIT((x),interruptible)
  6023. +#define IWAIT(x) _WAIT((x),1)
  6024. +
  6025. +/* Errors during formatting are counted here. */
  6026. +static int format_errors;
  6027. +
  6028. +/* Format request descriptor. */
  6029. +static struct format_descr format_req;
  6030. +
  6031. +/*
  6032. + * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
  6033. + * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
  6034. + * H is head unload time (1=16ms, 2=32ms, etc)
  6035. + */
  6036. +
  6037. +/*
  6038. + * Track buffer
  6039. + * Because these are written to by the DMA controller, they must
  6040. + * not contain a 64k byte boundary crossing, or data will be
  6041. + * corrupted/lost.
  6042. + */
  6043. +static char *floppy_track_buffer=NULL;
  6044. +static int max_buffer_sectors=0;
  6045. +
  6046. +static int *errors;
  6047. +typedef void (*done_f)(int);
  6048. +static struct cont_t {
  6049. +    void (*interrupt)(void); /* this is called after the interrupt of the
  6050. +                  * main command */
  6051. +    void (*redo)(void); /* this is called to retry the operation */
  6052. +    void (*error)(void); /* this is called to tally an error */
  6053. +    done_f done; /* this is called to say if the operation has
  6054. +              * succeeded/failed */
  6055. +} *cont=NULL;
  6056. +
  6057. +static void floppy_ready(void);
  6058. +static void floppy_start(void);
  6059. +static void process_fd_request(void);
  6060. +static void recalibrate_floppy(void);
  6061. +static void floppy_shutdown(void);
  6062. +
  6063. +static int floppy_grab_irq_and_dma(void);
  6064. +static void floppy_release_irq_and_dma(void);
  6065. +
  6066. +/*
  6067. + * The "reset" variable should be tested whenever an interrupt is scheduled,
  6068. + * after the commands have been sent. This is to ensure that the driver doesn't
  6069. + * get wedged when the interrupt doesn't come because of a failed command.
  6070. + * reset doesn't need to be tested before sending commands, because
  6071. + * output_byte is automatically disabled when reset is set.
  6072. + */
  6073. +#define CHECK_RESET { if ( FDCS->reset ){ reset_fdc(); return ; } }
  6074. +static void reset_fdc(void);
  6075. +
  6076. +/*
  6077. + * These are global variables, as that's the easiest way to give
  6078. + * information to interrupts. They are the data used for the current
  6079. + * request.
  6080. + */
  6081. +#define NO_TRACK -1
  6082. +#define NEED_1_RECAL -2
  6083. +#define NEED_2_RECAL -3
  6084. +
  6085. +/* */
  6086. +static int usage_count = 0;
  6087. +
  6088. +
  6089. +/* buffer related variables */
  6090. +static int buffer_track = -1;
  6091. +static int buffer_drive = -1;
  6092. +static int buffer_min = -1;
  6093. +static int buffer_max = -1;
  6094. +
  6095. +/* fdc related variables, should end up in a struct */
  6096. +static struct floppy_fdc_state fdc_state[N_FDC];
  6097. +static int fdc; /* current fdc */
  6098. +
  6099. +static struct floppy_struct *_floppy = floppy_type;
  6100. +static unsigned char current_drive = 0;
  6101. +static long current_count_sectors = 0;
  6102. +static unsigned char sector_t; /* sector in track */
  6103. +
  6104. +#ifndef fd_eject
  6105. +#define fd_eject(x) -EINVAL
  6106. +#endif
  6107. +
  6108. +/*
  6109. + * Floppy_selects1 is the list of DOR's to select a drive n
  6110. + * Floppy_selects2 is the list of DOR's to select drive fd
  6111. + * On initialisation, the floppy list is scanned, and the drives allocated
  6112. + * in the order that they are found.  This is done by seeking the drive
  6113. + * to a non-zero track, and then restoring it to track 0.  If an error occurs,
  6114. + * then there is no floppy drive present.
  6115. + */
  6116. +/*extern*/ int no_floppies;
  6117. +unsigned char floppy_selects1[]={ 0x10, 0x21, 0x23, 0x33 };
  6118. +unsigned char floppy_selects2[]={ 0   , 0   , 0   , 0    };
  6119. +
  6120. +#define fd_disable_dma()    disable_dma(FLOPPY_DMA)
  6121. +#define fd_clear_dma_ff()    clear_dma_ff(FLOPPY_DMA)
  6122. +#define fd_set_dma_mode(mode)    set_dma_mode(FLOPPY_DMA, (mode))
  6123. +#define fd_set_dma_addr(addr)    set_dma_addr(FLOPPY_DMA, (addr))
  6124. +#define fd_set_dma_count(len)    set_dma_count(FLOPPY_DMA, (len))
  6125. +#define fd_enable_dma()        enable_dma(FLOPPY_DMA)
  6126. +#define fd_cacheflush(addr, sz)
  6127. +#define fd_outb(val,port)    outb_p((val),(port))
  6128. +#define fd_inb(port)        inb_p((port))
  6129. +#define fd_request_irq()    request_irq(FLOPPY_IRQ, floppy_interrupt,SA_INTERRUPT|SA_SAMPLE_RANDOM,"floppy",NULL)
  6130. +#define fd_free_irq()        free_irq(FLOPPY_IRQ,NULL)
  6131. +#define fd_request_dma()    request_dma(FLOPPY_DMA,"floppy")
  6132. +#define fd_free_dma()        free_dma(FLOPPY_DMA)
  6133. +#define fd_enable_irq()        enable_irq(FLOPPY_IRQ)
  6134. +#define fd_disable_irq()    disable_irq(FLOPPY_IRQ)
  6135. +
  6136. +#ifdef DEBUGT
  6137. +static long unsigned debugtimer;
  6138. +#endif
  6139. +
  6140. +/*
  6141. + * Debugging
  6142. + * =========
  6143. + */
  6144. +static inline void set_debugt(void)
  6145. +{
  6146. +#ifdef DEBUGT
  6147. +    debugtimer = jiffies;
  6148. +#endif
  6149. +}
  6150. +
  6151. +static inline void debugt(const char *message)
  6152. +{
  6153. +#ifdef DEBUGT
  6154. +  if ( DP->flags & DEBUGT )
  6155. +    printk("%s dtime=%lu\n", message, jiffies-debugtimer );
  6156. +#endif
  6157. +}
  6158. +
  6159. +typedef void (*timeout_fn)(unsigned long);
  6160. +static struct timer_list fd_timeout ={ NULL, NULL, 0, 0,
  6161. +                    (timeout_fn) floppy_shutdown };
  6162. +
  6163. +static const char *timeout_message;
  6164. +
  6165. +#ifdef FLOPPY_SANITY_CHECK
  6166. +static void is_alive(const char *message)
  6167. +{
  6168. +    /* this routine checks whether the floppy driver is "alive" */
  6169. +    if (fdc_busy && command_status < 2 && !fd_timeout.prev){
  6170. +        DPRINT("timeout handler died: %s\n",message);
  6171. +    }
  6172. +}
  6173. +#endif
  6174. +
  6175. +#ifdef FLOPPY_SANITY_CHECK
  6176. +
  6177. +#define OLOGSIZE 20
  6178. +
  6179. +static void (*lasthandler)(void) = NULL;
  6180. +static int interruptjiffies=0;
  6181. +static int resultjiffies=0;
  6182. +static int resultsize=0;
  6183. +static int lastredo=0;
  6184. +
  6185. +static struct output_log {
  6186. +    unsigned char data;
  6187. +    unsigned char status;
  6188. +    unsigned long jiffies;
  6189. +} output_log[OLOGSIZE];
  6190. +
  6191. +static int output_log_pos=0;
  6192. +#endif
  6193. +
  6194. +#define CURRENTD -1
  6195. +#define MAXTIMEOUT -2
  6196. +
  6197. +static void reschedule_timeout(int drive, const char *message, int marg)
  6198. +{
  6199. +    if (drive == CURRENTD )
  6200. +        drive = current_drive;
  6201. +    del_timer(&fd_timeout);
  6202. +    if (drive < 0 || drive > N_DRIVE) {
  6203. +        fd_timeout.expires = jiffies + 20*HZ;
  6204. +        drive = 0;
  6205. +    } else
  6206. +        fd_timeout.expires = jiffies + UDP->timeout;
  6207. +    add_timer(&fd_timeout);
  6208. +    if (UDP->flags & FD_DEBUG) {
  6209. +        DPRINT("reschedule timeout ");
  6210. +        printk(message, marg);
  6211. +        printk("\n");
  6212. +    }
  6213. +    timeout_message = message;
  6214. +}
  6215. +
  6216. +static int maximum(int a, int b)
  6217. +{
  6218. +    if(a > b)
  6219. +        return a;
  6220. +    else
  6221. +        return b;
  6222. +}
  6223. +#define INFBOUND(a,b) (a)=maximum((a),(b));
  6224. +
  6225. +static int minimum(int a, int b)
  6226. +{
  6227. +    if(a < b)
  6228. +        return a;
  6229. +    else
  6230. +        return b;
  6231. +}
  6232. +#define SUPBOUND(a,b) (a)=minimum((a),(b));
  6233. +
  6234. +
  6235. +/*
  6236. + * Bottom half floppy driver.
  6237. + * ==========================
  6238. + *
  6239. + * This part of the file contains the code talking directly to the hardware,
  6240. + * and also the main service loop (seek-configure-spinup-command)
  6241. + */
  6242. +
  6243. +/*
  6244. + * disk change.
  6245. + * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
  6246. + * and the last_checked date.
  6247. + *
  6248. + * last_checked is the date of the last check which showed 'no disk change'
  6249. + * FD_DISK_CHANGE is set under two conditions:
  6250. + * 1. The floppy has been changed after some i/o to that floppy already
  6251. + *    took place.
  6252. + * 2. No floppy disk is in the drive. This is done in order to ensure that
  6253. + *    requests are quickly flushed in case there is no disk in the drive. It
  6254. + *    follows that FD_DISK_CHANGE can only be cleared if there is a disk in
  6255. + *    the drive.
  6256. + *
  6257. + * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
  6258. + * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
  6259. + *  each seek. If a disk is present, the disk change line should also be
  6260. + *  cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
  6261. + *  change line is set, this means either that no disk is in the drive, or
  6262. + *  that it has been removed since the last seek.
  6263. + *
  6264. + * This means that we really have a third possibility too:
  6265. + *  The floppy has been changed after the last seek.
  6266. + */
  6267. +
  6268. +static int disk_change(int drive)
  6269. +{
  6270. +    int fdc=FDC(drive);
  6271. +#ifdef FLOPPY_SANITY_CHECK
  6272. +    if(jiffies - UDRS->select_date < UDP->select_delay)
  6273. +        DPRINT("WARNING disk change called early\n");
  6274. +    if(! (FDCS->dor & (0x10 << UNIT(drive))) ||
  6275. +       (FDCS->dor & 3) != UNIT(drive) ||
  6276. +       fdc != FDC(drive)){
  6277. +           DPRINT("probing disk change on unselected drive\n");
  6278. +           DPRINT("drive=%d fdc=%d dor=%x\n",drive, FDC(drive),
  6279. +               (unsigned int)FDCS->dor);
  6280. +    }
  6281. +#endif
  6282. +
  6283. +#ifdef DCL_DEBUG
  6284. +    if (UDP->flags & FD_DEBUG){
  6285. +        DPRINT("checking disk change line for drive %d\n",drive);
  6286. +        DPRINT("jiffies=%ld\n", jiffies);
  6287. +        DPRINT("disk change line=%x\n", fd_inb(FD_DIR)&0x80);
  6288. +        DPRINT("flags=%x\n",UDRS->flags);
  6289. +    }
  6290. +#endif
  6291. +    if (UDP->flags & FD_BROKEN_DCL)
  6292. +        return UTESTF(FD_DISK_CHANGED);
  6293. +    if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80){
  6294. +        USETF(FD_VERIFY); /* verify write protection */
  6295. +        if(UDRS->maxblock){
  6296. +            /* mark it changed */
  6297. +            USETF(FD_DISK_CHANGED);
  6298. +        }
  6299. +
  6300. +        /* invalidate its geometry */
  6301. +        if (UDRS->keep_data >= 0) {
  6302. +            if ((UDP->flags & FTD_MSG) &&
  6303. +                current_type[drive] != NULL)
  6304. +                DPRINT("Disk type is undefined after "
  6305. +                       "disk change\n");
  6306. +            current_type[drive] = NULL;
  6307. +            floppy_sizes[TOMINOR(current_drive)] = MAX_DISK_SIZE;
  6308. +        }
  6309. +
  6310. +        /*USETF(FD_DISK_NEWCHANGE);*/
  6311. +        return 1;
  6312. +    } else {
  6313. +        UDRS->last_checked=jiffies;
  6314. +        UCLEARF(FD_DISK_NEWCHANGE);
  6315. +    }
  6316. +    return 0;
  6317. +}
  6318. +
  6319. +static inline int is_selected(int dor, int unit)
  6320. +{
  6321. +    return ( (dor  & (0x10 << unit)) && (dor &3) == unit);
  6322. +}
  6323. +
  6324. +static inline void arm_set_dor(int dor)
  6325. +{
  6326. +    if(dor & 0xf0)
  6327. +        fd_outb((dor & 0x0c) | floppy_selects1[dor & 3], FD_DOR);
  6328. +    else
  6329. +        fd_outb((dor & 0x0c), FD_DOR);
  6330. +}
  6331. +
  6332. +static int set_dor(int fdc, char mask, char data)
  6333. +{
  6334. +    register unsigned char drive, unit, newdor,olddor;
  6335. +
  6336. +    if (FDCS->address == -1)
  6337. +        return -1;
  6338. +
  6339. +    olddor = FDCS->dor;
  6340. +    newdor =  (olddor & mask) | data;
  6341. +    if ( newdor != olddor ){
  6342. +        unit = olddor & 0x3;
  6343. +        if(is_selected(olddor, unit) && !is_selected(newdor, unit)){
  6344. +            drive = REVDRIVE(fdc,unit);
  6345. +#ifdef DCL_DEBUG
  6346. +            if (UDP->flags & FD_DEBUG){
  6347. +                DPRINT("calling disk change from set_dor\n");
  6348. +            }
  6349. +#endif
  6350. +            disk_change(drive);
  6351. +        }
  6352. +        FDCS->dor = newdor;
  6353. +        arm_set_dor(newdor);
  6354. +
  6355. +        unit = newdor & 0x3;
  6356. +        if(!is_selected(olddor, unit) && is_selected(newdor, unit)){
  6357. +            drive = REVDRIVE(fdc,unit);
  6358. +            UDRS->select_date = jiffies;
  6359. +        }
  6360. +    }
  6361. +    if (newdor & FLOPPY_MOTOR_MASK)
  6362. +        floppy_grab_irq_and_dma();
  6363. +    if (olddor & FLOPPY_MOTOR_MASK)
  6364. +        floppy_release_irq_and_dma();
  6365. +    return olddor;
  6366. +}
  6367. +
  6368. +static void twaddle(void)
  6369. +{
  6370. +    if (DP->select_delay)
  6371. +        return;
  6372. +    arm_set_dor(FDCS->dor & ~(0x10<<UNIT(current_drive)));
  6373. +    arm_set_dor(FDCS->dor);
  6374. +    DRS->select_date = jiffies;
  6375. +}
  6376. +
  6377. +/* reset all driver information about the current fdc. This is needed after
  6378. + * a reset, and after a raw command. */
  6379. +static void reset_fdc_info(int mode)
  6380. +{
  6381. +    int drive;
  6382. +
  6383. +    FDCS->spec1 = FDCS->spec2 = -1;
  6384. +    FDCS->need_configure = 1;
  6385. +    FDCS->perp_mode = 1;
  6386. +    FDCS->rawcmd = 0;
  6387. +    for ( drive = 0; drive < N_DRIVE; drive++)
  6388. +        if (FDC(drive) == fdc &&
  6389. +            ( mode || UDRS->track != NEED_1_RECAL))
  6390. +            UDRS->track = NEED_2_RECAL;
  6391. +}
  6392. +
  6393. +/* selects the fdc and drive, and enables the fdc's input/dma. */
  6394. +static void set_fdc(int drive)
  6395. +{
  6396. +    if ( drive >= 0 && drive < N_DRIVE){
  6397. +        fdc = FDC(drive);
  6398. +        current_drive = drive;
  6399. +    }
  6400. +    if (fdc != 1 && fdc != 0) {
  6401. +        printk("bad fdc value\n");
  6402. +        return;
  6403. +    }
  6404. +    set_dor(fdc,~0,8);
  6405. +#if N_FDC > 1
  6406. +    set_dor(1-fdc, ~8, 0);
  6407. +#endif
  6408. +    if (FDCS->rawcmd == 2)
  6409. +        reset_fdc_info(1);
  6410. +    if (fd_inb(FD_STATUS) != STATUS_READY)
  6411. +        FDCS->reset = 1;
  6412. +}
  6413. +
  6414. +/* locks the driver */
  6415. +static int lock_fdc(int drive, int interruptible)
  6416. +{
  6417. +    unsigned long flags;
  6418. +
  6419. +    if(!usage_count){
  6420. +        printk("trying to lock fdc while usage count=0\n");
  6421. +        return -1;
  6422. +    }
  6423. +    floppy_grab_irq_and_dma();
  6424. +    INT_OFF;
  6425. +    while (fdc_busy && NO_SIGNAL)
  6426. +        interruptible_sleep_on(&fdc_wait);
  6427. +    if(fdc_busy){
  6428. +        INT_ON;
  6429. +        return -EINTR;
  6430. +    }
  6431. +    fdc_busy = 1;
  6432. +    INT_ON;
  6433. +    command_status = FD_COMMAND_NONE;
  6434. +    reschedule_timeout(drive, "lock fdc", 0);
  6435. +    set_fdc(drive);
  6436. +    return 0;
  6437. +}
  6438. +
  6439. +#define LOCK_FDC(drive,interruptible) \
  6440. +if(lock_fdc(drive,interruptible)) return -EINTR;
  6441. +
  6442. +
  6443. +/* unlocks the driver */
  6444. +static inline void unlock_fdc(void)
  6445. +{
  6446. +    raw_cmd = 0;
  6447. +    if (!fdc_busy)
  6448. +        DPRINT("FDC access conflict!\n");
  6449. +
  6450. +    if ( DEVICE_INTR )
  6451. +        DPRINT("device interrupt still active at FDC release: %p!\n",
  6452. +            DEVICE_INTR);
  6453. +    command_status = FD_COMMAND_NONE;
  6454. +    del_timer(&fd_timeout);
  6455. +    cont = NULL;
  6456. +    fdc_busy = 0;
  6457. +    floppy_release_irq_and_dma();
  6458. +    wake_up(&fdc_wait);
  6459. +}
  6460. +
  6461. +/* switches the motor off after a given timeout */
  6462. +static void motor_off_callback(unsigned long nr)
  6463. +{
  6464. +    unsigned char mask = ~(0x10 << UNIT(nr));
  6465. +
  6466. +    set_dor( FDC(nr), mask, 0 );
  6467. +}
  6468. +
  6469. +static struct timer_list motor_off_timer[N_DRIVE] = {
  6470. +    { NULL, NULL, 0, 0, motor_off_callback },
  6471. +    { NULL, NULL, 0, 1, motor_off_callback },
  6472. +    { NULL, NULL, 0, 2, motor_off_callback },
  6473. +    { NULL, NULL, 0, 3, motor_off_callback },
  6474. +    { NULL, NULL, 0, 4, motor_off_callback },
  6475. +    { NULL, NULL, 0, 5, motor_off_callback },
  6476. +    { NULL, NULL, 0, 6, motor_off_callback },
  6477. +    { NULL, NULL, 0, 7, motor_off_callback }
  6478. +};
  6479. +
  6480. +/* schedules motor off */
  6481. +static void floppy_off(unsigned int drive)
  6482. +{
  6483. +    unsigned long volatile delta;
  6484. +    register int fdc=FDC(drive);
  6485. +
  6486. +    if( !(FDCS->dor & ( 0x10 << UNIT(drive))))
  6487. +        return;
  6488. +
  6489. +    del_timer(motor_off_timer+drive);
  6490. +
  6491. +    /* make spindle stop in a position which minimizes spinup time
  6492. +     * next time */
  6493. +    if ( UDP->rps ){
  6494. +        delta = jiffies - UDRS->first_read_date + HZ -
  6495. +            UDP->spindown_offset;
  6496. +        delta = (( delta * UDP->rps) % HZ ) / UDP->rps;
  6497. +        motor_off_timer[drive].expires = jiffies + UDP->spindown - delta;
  6498. +    }
  6499. +    add_timer(motor_off_timer+drive);
  6500. +}
  6501. +
  6502. +/*
  6503. + * cycle through all N_DRIVE floppy drives, for disk change testing.
  6504. + * stopping at current drive. This is done before any long operation, to
  6505. + * be sure to have up to date disk change information.
  6506. + */
  6507. +static void scandrives(void)
  6508. +{
  6509. +    int i, drive, saved_drive;
  6510. +
  6511. +    if (DP->select_delay)
  6512. +        return;
  6513. +
  6514. +    saved_drive = current_drive;
  6515. +    for(i=0; i< N_DRIVE; i++){
  6516. +        drive = (saved_drive + i + 1 ) % N_DRIVE;
  6517. +        if ( UDRS->fd_ref == 0 || UDP->select_delay != 0)
  6518. +            continue; /* skip closed drives */
  6519. +        set_fdc(drive);
  6520. +        if(! (set_dor( fdc, ~3, UNIT(drive) | ( 0x10 << UNIT(drive))) &
  6521. +              (0x10 << UNIT(drive))))
  6522. +            /* switch the motor off again, if it was off to
  6523. +             * begin with */
  6524. +            set_dor( fdc, ~( 0x10 << UNIT(drive) ), 0 );
  6525. +    }
  6526. +    set_fdc(saved_drive);
  6527. +}
  6528. +
  6529. +static void empty(void)
  6530. +{
  6531. +}
  6532. +
  6533. +static struct tq_struct floppy_tq =
  6534. +{ 0, 0, 0, 0 };
  6535. +
  6536. +static struct timer_list fd_timer ={ NULL, NULL, 0, 0, 0 };
  6537. +
  6538. +static void cancel_activity(void)
  6539. +{
  6540. +    CLEAR_INTR;
  6541. +    floppy_tq.routine = (void *)(void *) empty;
  6542. +    del_timer(&fd_timer);
  6543. +}
  6544. +
  6545. +/* this function makes sure that the disk stays in the drive during the
  6546. + * transfer */
  6547. +static void fd_watchdog(void)
  6548. +{
  6549. +#ifdef DCL_DEBUG
  6550. +    if (DP->flags & FD_DEBUG){
  6551. +        DPRINT("calling disk change from watchdog\n");
  6552. +    }
  6553. +#endif
  6554. +
  6555. +    if ( disk_change(current_drive) ){
  6556. +        DPRINT("disk removed during i/o\n");
  6557. +        cancel_activity();
  6558. +        cont->done(0);
  6559. +        reset_fdc();
  6560. +    } else {
  6561. +        del_timer(&fd_timer);
  6562. +        fd_timer.function = (timeout_fn) fd_watchdog;
  6563. +        fd_timer.expires = jiffies + HZ / 10;
  6564. +        add_timer(&fd_timer);
  6565. +    }
  6566. +}
  6567. +
  6568. +static void main_command_interrupt(void)
  6569. +{
  6570. +    del_timer(&fd_timer);
  6571. +    cont->interrupt();
  6572. +}
  6573. +
  6574. +/* waits for a delay (spinup or select) to pass */
  6575. +static int wait_for_completion(int delay, timeout_fn function)
  6576. +{
  6577. +    if ( FDCS->reset ){
  6578. +        reset_fdc(); /* do the reset during sleep to win time
  6579. +                  * if we don't need to sleep, it's a good
  6580. +                  * occasion anyways */
  6581. +        return 1;
  6582. +    }
  6583. +
  6584. +    if ((signed) (jiffies - delay) < 0) {
  6585. +        del_timer(&fd_timer);
  6586. +        fd_timer.function = function;
  6587. +        fd_timer.expires = delay;
  6588. +        add_timer(&fd_timer);
  6589. +        return 1;
  6590. +    }
  6591. +    return 0;
  6592. +}
  6593. +
  6594. +static int hlt_disabled=0;
  6595. +static void floppy_disable_hlt(void)
  6596. +{
  6597. +    unsigned long flags;
  6598. +
  6599. +    INT_OFF;
  6600. +    if(!hlt_disabled){
  6601. +        hlt_disabled=1;
  6602. +#ifdef HAVE_DISABLE_HLT
  6603. +        disable_hlt();
  6604. +#endif
  6605. +    }
  6606. +    INT_ON;
  6607. +}
  6608. +
  6609. +static void floppy_enable_hlt(void)
  6610. +{
  6611. +    unsigned long flags;
  6612. +
  6613. +    INT_OFF;
  6614. +    if(hlt_disabled){
  6615. +        hlt_disabled=0;
  6616. +#ifdef HAVE_DISABLE_HLT
  6617. +        enable_hlt();
  6618. +#endif
  6619. +    }
  6620. +    INT_ON;
  6621. +}
  6622. +
  6623. +
  6624. +static void setup_DMA(void)
  6625. +{
  6626. +    unsigned long flags;
  6627. +
  6628. +#ifdef FLOPPY_SANITY_CHECK
  6629. +    if (raw_cmd->length == 0){
  6630. +        int i;
  6631. +
  6632. +        printk("zero dma transfer size:");
  6633. +        for(i=0; i< raw_cmd->cmd_count; i++)
  6634. +            printk("%x,", raw_cmd->cmd[i]);
  6635. +        printk("\n");
  6636. +        cont->done(0);
  6637. +        FDCS->reset = 1;
  6638. +        return;
  6639. +    }
  6640. +#if 0
  6641. +    if ((long) raw_cmd->kernel_data % 512 ){
  6642. +        printk("non aligned address: %p\n", raw_cmd->kernel_data );
  6643. +        cont->done(0);
  6644. +        FDCS->reset=1;
  6645. +        return;
  6646. +    }
  6647. +    if (CROSS_64KB(raw_cmd->kernel_data, raw_cmd->length)) {
  6648. +        printk("DMA crossing 64-K boundary %p-%p\n",
  6649. +               raw_cmd->kernel_data,
  6650. +               raw_cmd->kernel_data + raw_cmd->length);
  6651. +        cont->done(0);
  6652. +        FDCS->reset=1;
  6653. +        return;
  6654. +    }
  6655. +#endif
  6656. +#endif
  6657. +    INT_OFF;
  6658. +    fd_disable_dma();
  6659. +    fd_clear_dma_ff();
  6660. +    fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
  6661. +    fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ)?
  6662. +             DMA_MODE_READ : DMA_MODE_WRITE);
  6663. +    fd_set_dma_addr(virt_to_bus(raw_cmd->kernel_data));
  6664. +    fd_set_dma_count(raw_cmd->length);
  6665. +    virtual_dma_port = FDCS->address;
  6666. +    fd_enable_dma();
  6667. +    INT_ON;
  6668. +    floppy_disable_hlt();
  6669. +}
  6670. +
  6671. +void show_floppy(void);
  6672. +
  6673. +/* waits until the fdc becomes ready */
  6674. +static int wait_til_ready(void)
  6675. +{
  6676. +    int counter, status;
  6677. +    if(FDCS->reset)
  6678. +        return -1;
  6679. +    for (counter = 0; counter < 10000; counter++) {
  6680. +        status = fd_inb(FD_STATUS);
  6681. +        if (status & STATUS_READY)
  6682. +            return status;
  6683. +    }
  6684. +    if (!initialising) {
  6685. +        DPRINT("Getstatus times out (%x) on fdc %d\n",
  6686. +            status, fdc);
  6687. +        show_floppy();
  6688. +    }
  6689. +    FDCS->reset = 1;
  6690. +    return -1;
  6691. +}
  6692. +
  6693. +/* sends a command byte to the fdc */
  6694. +static int output_byte(char byte)
  6695. +{
  6696. +    int status;
  6697. +
  6698. +    if ((status = wait_til_ready()) < 0)
  6699. +        return -1;
  6700. +    if ((status & (STATUS_READY|STATUS_DIR|STATUS_DMA)) == STATUS_READY){
  6701. +        fd_outb(byte,FD_DATA);
  6702. +#ifdef FLOPPY_SANITY_CHECK
  6703. +        output_log[output_log_pos].data = byte;
  6704. +        output_log[output_log_pos].status = status;
  6705. +        output_log[output_log_pos].jiffies = jiffies;
  6706. +        output_log_pos = (output_log_pos + 1) % OLOGSIZE;
  6707. +#endif
  6708. +        return 0;
  6709. +    }
  6710. +    FDCS->reset = 1;
  6711. +    if (!initialising) {
  6712. +        DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
  6713. +            byte, fdc, status);
  6714. +        show_floppy();
  6715. +    }
  6716. +    return -1;
  6717. +}
  6718. +#define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
  6719. +
  6720. +/* gets the response from the fdc */
  6721. +static int result(void)
  6722. +{
  6723. +    int i, status;
  6724. +
  6725. +    for(i=0; i < MAX_REPLIES; i++) {
  6726. +        if ((status = wait_til_ready()) < 0)
  6727. +            break;
  6728. +        status &= STATUS_DIR|STATUS_READY|STATUS_BUSY|STATUS_DMA;
  6729. +        if ((status & ~STATUS_BUSY) == STATUS_READY){
  6730. +#ifdef FLOPPY_SANITY_CHECK
  6731. +            resultjiffies = jiffies;
  6732. +            resultsize = i;
  6733. +#endif
  6734. +            return i;
  6735. +        }
  6736. +        if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY))
  6737. +            reply_buffer[i] = fd_inb(FD_DATA);
  6738. +        else
  6739. +            break;
  6740. +    }
  6741. +    if (!initialising) {
  6742. +        DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
  6743. +            fdc, status, i);
  6744. +        show_floppy();
  6745. +    }
  6746. +    FDCS->reset = 1;
  6747. +    return -1;
  6748. +}
  6749. +
  6750. +#define MORE_OUTPUT -2
  6751. +/* does the fdc need more output? */
  6752. +static int need_more_output(void)
  6753. +{
  6754. +    int status;
  6755. +    if ((status = wait_til_ready()) < 0)
  6756. +        return -1;
  6757. +    if ((status & (STATUS_READY|STATUS_DIR|STATUS_DMA)) == STATUS_READY)
  6758. +        return MORE_OUTPUT;
  6759. +    return result();
  6760. +}
  6761. +
  6762. +/* Set perpendicular mode as required, based on data rate, if supported.
  6763. + * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
  6764. + */
  6765. +static inline void perpendicular_mode(void)
  6766. +{
  6767. +    unsigned char perp_mode;
  6768. +
  6769. +    if (raw_cmd->rate & 0x40){
  6770. +        switch(raw_cmd->rate & 3){
  6771. +            case 0:
  6772. +                perp_mode=2;
  6773. +                break;
  6774. +            case 3:
  6775. +                perp_mode=3;
  6776. +                break;
  6777. +            default:
  6778. +                DPRINT("Invalid data rate for perpendicular mode!\n");
  6779. +                cont->done(0);
  6780. +                FDCS->reset = 1; /* convenient way to return to
  6781. +                          * redo without to much hassle (deep
  6782. +                          * stack et al. */
  6783. +                return;
  6784. +        }
  6785. +    } else
  6786. +        perp_mode = 0;
  6787. +
  6788. +    if ( FDCS->perp_mode == perp_mode )
  6789. +        return;
  6790. +    if (FDCS->version >= FDC_82077_ORIG) {
  6791. +        output_byte(FD_PERPENDICULAR);
  6792. +        output_byte(perp_mode);
  6793. +        FDCS->perp_mode = perp_mode;
  6794. +    } else if (perp_mode) {
  6795. +        DPRINT("perpendicular mode not supported by this FDC.\n");
  6796. +    }
  6797. +} /* perpendicular_mode */
  6798. +
  6799. +static int fifo_depth = 0xa;
  6800. +static int no_fifo = 0;
  6801. +
  6802. +static int fdc_configure(void)
  6803. +{
  6804. +    /* Turn on FIFO */
  6805. +    output_byte(FD_CONFIGURE);
  6806. +    if(need_more_output() != MORE_OUTPUT)
  6807. +        return 0;
  6808. +    output_byte(0);
  6809. +    output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
  6810. +    output_byte(0); /* pre-compensation from track
  6811. +               0 upwards */
  6812. +    return 1;
  6813. +}
  6814. +
  6815. +#define NOMINAL_DTR 500
  6816. +
  6817. +/* Issue a "SPECIFY" command to set the step rate time, head unload time,
  6818. + * head load time, and DMA disable flag to values needed by floppy.
  6819. + *
  6820. + * The value "dtr" is the data transfer rate in Kbps.  It is needed
  6821. + * to account for the data rate-based scaling done by the 82072 and 82077
  6822. + * FDC types.  This parameter is ignored for other types of FDCs (i.e.
  6823. + * 8272a).
  6824. + *
  6825. + * Note that changing the data transfer rate has a (probably deleterious)
  6826. + * effect on the parameters subject to scaling for 82072/82077 FDCs, so
  6827. + * fdc_specify is called again after each data transfer rate
  6828. + * change.
  6829. + *
  6830. + * srt: 1000 to 16000 in microseconds
  6831. + * hut: 16 to 240 milliseconds
  6832. + * hlt: 2 to 254 milliseconds
  6833. + *
  6834. + * These values are rounded up to the next highest available delay time.
  6835. + */
  6836. +static void fdc_specify(void)
  6837. +{
  6838. +    unsigned char spec1, spec2;
  6839. +    int srt, hlt, hut;
  6840. +    unsigned long dtr = NOMINAL_DTR;
  6841. +    unsigned long scale_dtr = NOMINAL_DTR;
  6842. +    int hlt_max_code = 0x7f;
  6843. +    int hut_max_code = 0xf;
  6844. +
  6845. +    if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
  6846. +        fdc_configure();
  6847. +        FDCS->need_configure = 0;
  6848. +        /*DPRINT("FIFO enabled\n");*/
  6849. +    }
  6850. +
  6851. +    switch (raw_cmd->rate & 0x03) {
  6852. +        case 3:
  6853. +            dtr = 1000;
  6854. +            break;
  6855. +        case 1:
  6856. +            dtr = 300;
  6857. +            if (FDCS->version >= FDC_82078) {
  6858. +                /* chose the default rate table, not the one
  6859. +                 * where 1 = 2 Mbps */
  6860. +                output_byte(FD_DRIVESPEC);
  6861. +                if(need_more_output() == MORE_OUTPUT) {
  6862. +                    output_byte(UNIT(current_drive));
  6863. +                    output_byte(0xc0);
  6864. +                }
  6865. +            }
  6866. +            break;
  6867. +        case 2:
  6868. +            dtr = 250;
  6869. +            break;
  6870. +    }
  6871. +
  6872. +    if (FDCS->version >= FDC_82072) {
  6873. +        scale_dtr = dtr;
  6874. +        hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
  6875. +        hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
  6876. +    }
  6877. +
  6878. +    /* Convert step rate from microseconds to milliseconds and 4 bits */
  6879. +    srt = 16 - (DP->srt*scale_dtr/1000 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  6880. +    SUPBOUND(srt, 0xf);
  6881. +    INFBOUND(srt, 0);
  6882. +
  6883. +    hlt = (DP->hlt*scale_dtr/2 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  6884. +    if (hlt < 0x01)
  6885. +        hlt = 0x01;
  6886. +    else if (hlt > 0x7f)
  6887. +        hlt = hlt_max_code;
  6888. +
  6889. +    hut = (DP->hut*scale_dtr/16 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  6890. +    if (hut < 0x1)
  6891. +        hut = 0x1;
  6892. +    else if (hut > 0xf)
  6893. +        hut = hut_max_code;
  6894. +
  6895. +    spec1 = (srt << 4) | hut;
  6896. +    spec2 = (hlt << 1) | (use_virtual_dma & 1);
  6897. +
  6898. +    /* If these parameters did not change, just return with success */
  6899. +    if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
  6900. +        /* Go ahead and set spec1 and spec2 */
  6901. +        output_byte(FD_SPECIFY);
  6902. +        output_byte(FDCS->spec1 = spec1);
  6903. +        output_byte(FDCS->spec2 = spec2);
  6904. +    }
  6905. +} /* fdc_specify */
  6906. +
  6907. +/* Set the FDC's data transfer rate on behalf of the specified drive.
  6908. + * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
  6909. + * of the specify command (i.e. using the fdc_specify function).
  6910. + */
  6911. +static int fdc_dtr(void)
  6912. +{
  6913. +    /* If data rate not already set to desired value, set it. */
  6914. +    if ((raw_cmd->rate & 3) == FDCS->dtr)
  6915. +        return 0;
  6916. +
  6917. +    /* Set dtr */
  6918. +    fd_outb(raw_cmd->rate & 3, FD_DCR);
  6919. +
  6920. +    /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
  6921. +     * need a stabilization period of several milliseconds to be
  6922. +     * enforced after data rate changes before R/W operations.
  6923. +     * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
  6924. +     */
  6925. +    FDCS->dtr = raw_cmd->rate & 3;
  6926. +    return(wait_for_completion(jiffies+2*HZ/100,
  6927. +                   (timeout_fn) floppy_ready));
  6928. +} /* fdc_dtr */
  6929. +
  6930. +static void tell_sector(void)
  6931. +{
  6932. +    printk(": track %d, head %d, sector %d, size %d",
  6933. +           R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
  6934. +} /* tell_sector */
  6935. +
  6936. +
  6937. +/*
  6938. + * OK, this error interpreting routine is called after a
  6939. + * DMA read/write has succeeded
  6940. + * or failed, so we check the results, and copy any buffers.
  6941. + * hhb: Added better error reporting.
  6942. + * ak: Made this into a separate routine.
  6943. + */
  6944. +static int interpret_errors(void)
  6945. +{
  6946. +    char bad;
  6947. +int res = get_dma_residue(FLOPPY_DMA);
  6948. +if(res) {printk("\n-- DMA residue (%d)",res); tell_sector(); printk("\n");}
  6949. +    if (inr!=7) {
  6950. +        DPRINT("-- FDC reply error");
  6951. +        FDCS->reset = 1;
  6952. +        return 1;
  6953. +    }
  6954. +
  6955. +    /* check IC to find cause of interrupt */
  6956. +    switch (ST0 & ST0_INTR) {
  6957. +        case 0x40:    /* error occurred during command execution */
  6958. +            if (ST1 & ST1_EOC)
  6959. +                return 0; /* occurs with pseudo-DMA */
  6960. +            bad = 1;
  6961. +            if (ST1 & ST1_WP) {
  6962. +                DPRINT("Drive is write protected\n");
  6963. +                CLEARF(FD_DISK_WRITABLE);
  6964. +                cont->done(0);
  6965. +                bad = 2;
  6966. +            } else if (ST1 & ST1_ND) {
  6967. +                SETF(FD_NEED_TWADDLE);
  6968. +            } else if (ST1 & ST1_OR) {
  6969. +                if (DP->flags & FTD_MSG )
  6970. +                    DPRINT("Over/Underrun - retrying\n");
  6971. +                bad = 0;
  6972. +            }else if(*errors >= DP->max_errors.reporting){
  6973. +                DPRINT("");
  6974. +                if (ST0 & ST0_ECE) {
  6975. +                    printk("Recalibrate failed!");
  6976. +                } else if (ST2 & ST2_CRC) {
  6977. +                    printk("data CRC error");
  6978. +                    tell_sector();
  6979. +                } else if (ST1 & ST1_CRC) {
  6980. +                    printk("CRC error");
  6981. +                    tell_sector();
  6982. +                } else if ((ST1 & (ST1_MAM|ST1_ND)) || (ST2 & ST2_MAM)) {
  6983. +                    if (!probing) {
  6984. +                        printk("sector not found");
  6985. +                        tell_sector();
  6986. +                    } else
  6987. +                        printk("probe failed...");
  6988. +                } else if (ST2 & ST2_WC) {    /* seek error */
  6989. +                    printk("wrong cylinder");
  6990. +                } else if (ST2 & ST2_BC) {    /* cylinder marked as bad */
  6991. +                    printk("bad cylinder");
  6992. +                } else {
  6993. +                    printk("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x", ST0, ST1, ST2);
  6994. +                    tell_sector();
  6995. +                }
  6996. +                printk("\n");
  6997. +
  6998. +            }
  6999. +            if ( ST2 & ST2_WC || ST2 & ST2_BC)
  7000. +                /* wrong cylinder => recal */
  7001. +                DRS->track = NEED_2_RECAL;
  7002. +            return bad;
  7003. +        case 0x80: /* invalid command given */
  7004. +            DPRINT("Invalid FDC command given!\n");
  7005. +            cont->done(0);
  7006. +            return 2;
  7007. +        case 0xc0:
  7008. +            DPRINT("Abnormal termination caused by polling\n");
  7009. +            cont->error();
  7010. +            return 2;
  7011. +        default: /* (0) Normal command termination */
  7012. +            return 0;
  7013. +    }
  7014. +}
  7015. +
  7016. +/*
  7017. + * This routine is called when everything should be correctly set up
  7018. + * for the transfer (i.e. floppy motor is on, the correct floppy is
  7019. + * selected, and the head is sitting on the right track).
  7020. + */
  7021. +static void setup_rw_floppy(void)
  7022. +{
  7023. +    int i,ready_date,r, flags,dflags;
  7024. +    timeout_fn function;
  7025. +
  7026. +    flags = raw_cmd->flags;
  7027. +    if ( flags & ( FD_RAW_READ | FD_RAW_WRITE))
  7028. +        flags |= FD_RAW_INTR;
  7029. +
  7030. +    if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)){
  7031. +        ready_date = DRS->spinup_date + DP->spinup;
  7032. +        /* If spinup will take a long time, rerun scandrives
  7033. +         * again just before spinup completion. Beware that
  7034. +         * after scandrives, we must again wait for selection.
  7035. +         */
  7036. +        if ((signed) (ready_date - jiffies) > DP->select_delay){
  7037. +            ready_date -= DP->select_delay;
  7038. +            function = (timeout_fn) floppy_start;
  7039. +        } else
  7040. +            function = (timeout_fn) setup_rw_floppy;
  7041. +
  7042. +        /* wait until the floppy is spinning fast enough */
  7043. +        if (wait_for_completion(ready_date,function))
  7044. +            return;
  7045. +    }
  7046. +    dflags = DRS->flags;
  7047. +
  7048. +    if ( (flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
  7049. +        setup_DMA();
  7050. +
  7051. +    if ( flags & FD_RAW_INTR )
  7052. +        SET_INTR(main_command_interrupt);
  7053. +
  7054. +    r=0;
  7055. +    for(i=0; i< raw_cmd->cmd_count; i++)
  7056. +        r|=output_byte( raw_cmd->cmd[i] );
  7057. +
  7058. +#ifdef DEBUGT
  7059. +    debugt("rw_command: ");
  7060. +#endif
  7061. +    if (r) {
  7062. +        cont->error();
  7063. +        reset_fdc();
  7064. +        return;
  7065. +    }
  7066. +
  7067. +    if ( ! ( flags & FD_RAW_INTR )){
  7068. +        inr = result();
  7069. +        cont->interrupt();
  7070. +    } else if ( flags & FD_RAW_NEED_DISK )
  7071. +        fd_watchdog();
  7072. +}
  7073. +
  7074. +static int blind_seek;
  7075. +
  7076. +/*
  7077. + * This is the routine called after every seek (or recalibrate) interrupt
  7078. + * from the floppy controller.
  7079. + */
  7080. +static void seek_interrupt(void)
  7081. +{
  7082. +#ifdef DEBUGT
  7083. +    debugt("seek interrupt:");
  7084. +#endif
  7085. +    if (inr != 2 || (ST0 & 0xF8) != 0x20 ) {
  7086. +        DPRINT("seek failed\n");
  7087. +        DRS->track = NEED_2_RECAL;
  7088. +        cont->error();
  7089. +        cont->redo();
  7090. +        return;
  7091. +    }
  7092. +    if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek){
  7093. +#ifdef DCL_DEBUG
  7094. +        if (DP->flags & FD_DEBUG){
  7095. +            DPRINT("clearing NEWCHANGE flag because of effective seek\n");
  7096. +            DPRINT("jiffies=%ld\n", jiffies);
  7097. +        }
  7098. +#endif
  7099. +        CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
  7100. +        DRS->select_date = jiffies;
  7101. +    }
  7102. +    DRS->track = ST1;
  7103. +    floppy_ready();
  7104. +}
  7105. +
  7106. +static void check_wp(void)
  7107. +{
  7108. +    if (TESTF(FD_VERIFY)) {
  7109. +        /* check write protection */
  7110. +        output_byte( FD_GETSTATUS );
  7111. +        output_byte( UNIT(current_drive) );
  7112. +        if ( result() != 1 ){
  7113. +            FDCS->reset = 1;
  7114. +            return;
  7115. +        }
  7116. +        CLEARF(FD_VERIFY);
  7117. +        CLEARF(FD_NEED_TWADDLE);
  7118. +#ifdef DCL_DEBUG
  7119. +        if (DP->flags & FD_DEBUG){
  7120. +            DPRINT("checking whether disk is write protected\n");
  7121. +            DPRINT("wp=%x\n",ST3 & 0x40);
  7122. +        }
  7123. +#endif
  7124. +        if (!( ST3  & 0x40))
  7125. +            SETF(FD_DISK_WRITABLE);
  7126. +        else
  7127. +            CLEARF(FD_DISK_WRITABLE);
  7128. +    }
  7129. +}
  7130. +
  7131. +static void seek_floppy(void)
  7132. +{
  7133. +    int track;
  7134. +
  7135. +    blind_seek=0;
  7136. +
  7137. +#ifdef DCL_DEBUG
  7138. +    if (DP->flags & FD_DEBUG){
  7139. +        DPRINT("calling disk change from seek\n");
  7140. +    }
  7141. +#endif
  7142. +
  7143. +    if (!TESTF(FD_DISK_NEWCHANGE) &&
  7144. +        disk_change(current_drive) &&
  7145. +        (raw_cmd->flags & FD_RAW_NEED_DISK)){
  7146. +        /* the media changed flag should be cleared after the seek.
  7147. +         * If it isn't, this means that there is really no disk in
  7148. +         * the drive.
  7149. +         */
  7150. +        SETF(FD_DISK_CHANGED);
  7151. +        cont->done(0);
  7152. +        cont->redo();
  7153. +        return;
  7154. +    }
  7155. +    if ( DRS->track <= NEED_1_RECAL ){
  7156. +        recalibrate_floppy();
  7157. +        return;
  7158. +    } else if (TESTF(FD_DISK_NEWCHANGE) &&
  7159. +           (raw_cmd->flags & FD_RAW_NEED_DISK) &&
  7160. +           (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
  7161. +        /* we seek to clear the media-changed condition. Does anybody
  7162. +         * know a more elegant way, which works on all drives? */
  7163. +        if ( raw_cmd->track )
  7164. +            track = raw_cmd->track - 1;
  7165. +        else {
  7166. +            if(DP->flags & FD_SILENT_DCL_CLEAR){
  7167. +                set_dor(fdc, ~ (0x10 << UNIT(current_drive)), 0);
  7168. +                blind_seek = 1;
  7169. +                raw_cmd->flags |= FD_RAW_NEED_SEEK;
  7170. +            }
  7171. +            track = 1;
  7172. +        }
  7173. +    } else {
  7174. +        check_wp();
  7175. +        if (raw_cmd->track != DRS->track &&
  7176. +            (raw_cmd->flags & FD_RAW_NEED_SEEK))
  7177. +            track = raw_cmd->track;
  7178. +        else {
  7179. +            setup_rw_floppy();
  7180. +            return;
  7181. +        }
  7182. +    }
  7183. +
  7184. +    SET_INTR(seek_interrupt);
  7185. +    output_byte(FD_SEEK);
  7186. +    output_byte(UNIT(current_drive));
  7187. +    LAST_OUT(track);
  7188. +#ifdef DEBUGT
  7189. +    debugt("seek command:");
  7190. +#endif
  7191. +}
  7192. +
  7193. +static void recal_interrupt(void)
  7194. +{
  7195. +#ifdef DEBUGT
  7196. +    debugt("recal interrupt:");
  7197. +#endif
  7198. +    if (inr !=2 )
  7199. +        FDCS->reset = 1;
  7200. +    else if (ST0 & ST0_ECE) {
  7201. +               switch(DRS->track){
  7202. +                   case NEED_1_RECAL:
  7203. +#ifdef DEBUGT
  7204. +                debugt("recal interrupt need 1 recal:");
  7205. +#endif
  7206. +                /* after a second recalibrate, we still haven't
  7207. +                 * reached track 0. Probably no drive. Raise an
  7208. +                 * error, as failing immediately might upset
  7209. +                 * computers possessed by the Devil :-) */
  7210. +                cont->error();
  7211. +                cont->redo();
  7212. +                return;
  7213. +            case NEED_2_RECAL:
  7214. +#ifdef DEBUGT
  7215. +                debugt("recal interrupt need 2 recal:");
  7216. +#endif
  7217. +                /* If we already did a recalibrate,
  7218. +                 * and we are not at track 0, this
  7219. +                 * means we have moved. (The only way
  7220. +                 * not to move at recalibration is to
  7221. +                 * be already at track 0.) Clear the
  7222. +                 * new change flag */
  7223. +#ifdef DCL_DEBUG
  7224. +                if (DP->flags & FD_DEBUG){
  7225. +                    DPRINT("clearing NEWCHANGE flag because of second recalibrate\n");
  7226. +                }
  7227. +#endif
  7228. +
  7229. +                CLEARF(FD_DISK_NEWCHANGE);
  7230. +                DRS->select_date = jiffies;
  7231. +                /* fall through */
  7232. +            default:
  7233. +#ifdef DEBUGT
  7234. +                debugt("recal interrupt default:");
  7235. +#endif
  7236. +                /* Recalibrate moves the head by at
  7237. +                 * most 80 steps. If after one
  7238. +                 * recalibrate we don't have reached
  7239. +                 * track 0, this might mean that we
  7240. +                 * started beyond track 80.  Try
  7241. +                 * again.  */
  7242. +                DRS->track = NEED_1_RECAL;
  7243. +                break;
  7244. +        }
  7245. +    } else
  7246. +        DRS->track = ST1;
  7247. +    floppy_ready();
  7248. +}
  7249. +
  7250. +static void print_result(char *message, int inr)
  7251. +{
  7252. +    int i;
  7253. +
  7254. +    DPRINT("%s ", message);
  7255. +    if (inr >= 0)
  7256. +        for(i=0; i<inr; i++)
  7257. +            printk("repl[%d]=%x ", i, reply_buffer[i]);
  7258. +        printk("\n");
  7259. +}
  7260. +
  7261. +/* interrupt handler */
  7262. +void floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  7263. +{
  7264. +    void (*handler)(void) = DEVICE_INTR;
  7265. +    int do_print;
  7266. +
  7267. +    lasthandler = handler;
  7268. +    interruptjiffies = jiffies;
  7269. +
  7270. +    fd_disable_dma();
  7271. +    floppy_enable_hlt();
  7272. +    CLEAR_INTR;
  7273. +    if ( fdc >= N_FDC || FDCS->address == -1){
  7274. +        /* we don't even know which FDC is the culprit */
  7275. +        printk("DOR0=%x\n", (unsigned int)fdc_state[0].dor);
  7276. +        printk("floppy interrupt on bizarre fdc %d\n",fdc);
  7277. +        printk("handler=%p\n", handler);
  7278. +        is_alive("bizarre fdc");
  7279. +        return;
  7280. +    }
  7281. +
  7282. +    FDCS->reset = 0;
  7283. +    /* We have to clear the reset flag here, because apparently on boxes
  7284. +     * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
  7285. +     * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
  7286. +     * emission of the SENSEI's.
  7287. +     * It is OK to emit floppy commands because we are in an interrupt
  7288. +     * handler here, and thus we have to fear no interference of other
  7289. +     * activity.
  7290. +     */
  7291. +
  7292. +    do_print = !handler && print_unex && !initialising;
  7293. +
  7294. +    inr = result();
  7295. +    if (do_print)
  7296. +        print_result("unexpected interrupt", inr);
  7297. +    if (inr == 0) {
  7298. +        do {
  7299. +            output_byte(FD_SENSEI);
  7300. +            inr = result();
  7301. +            if(do_print)
  7302. +                print_result("sensei", inr);
  7303. +        } while ( (ST0 & 0x83) != UNIT(current_drive) && inr == 2);
  7304. +    }
  7305. +    if (handler) {
  7306. +        if(intr_count >= 2) {
  7307. +            /* expected interrupt */        
  7308. +            floppy_tq.routine = (void *)(void *) handler;
  7309. +            queue_task_irq(&floppy_tq, &tq_immediate);
  7310. +            mark_bh(IMMEDIATE_BH);
  7311. +        } else
  7312. +            handler();
  7313. +    } else
  7314. +        FDCS->reset = 1;
  7315. +    is_alive("normal interrupt end");
  7316. +}
  7317. +
  7318. +static void recalibrate_floppy(void)
  7319. +{
  7320. +#ifdef DEBUGT
  7321. +    debugt("recalibrate floppy:");
  7322. +#endif
  7323. +    SET_INTR(recal_interrupt);
  7324. +    output_byte(FD_RECALIBRATE);
  7325. +    LAST_OUT(UNIT(current_drive));
  7326. +}
  7327. +
  7328. +/*
  7329. + * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
  7330. + */
  7331. +static void reset_interrupt(void)
  7332. +{
  7333. +#ifdef DEBUGT
  7334. +    debugt("reset interrupt:");
  7335. +#endif
  7336. +    result();        /* get the status ready for set_fdc */
  7337. +    if (FDCS->reset) {
  7338. +        printk("reset set in interrupt, calling %p\n", cont->error);
  7339. +        cont->error(); /* a reset just after a reset. BAD! */
  7340. +    }
  7341. +    cont->redo();
  7342. +}
  7343. +
  7344. +/*
  7345. + * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
  7346. + * or by setting the self clearing bit 7 of STATUS (newer FDCs)
  7347. + */
  7348. +static void reset_fdc(void)
  7349. +{
  7350. +    SET_INTR(reset_interrupt);
  7351. +    FDCS->reset = 0;
  7352. +    reset_fdc_info(0);
  7353. +
  7354. +    /* Pseudo-DMA may intercept 'reset finished' interrupt.  */
  7355. +    /* Irrelevant for systems with true DMA (i386).          */
  7356. +    fd_disable_dma();
  7357. +
  7358. +    if (FDCS->version >= FDC_82072A)
  7359. +        fd_outb(0x80 | (FDCS->dtr &3), FD_STATUS);
  7360. +    else {
  7361. +        arm_set_dor(FDCS->dor & ~0x04);
  7362. +        udelay(FD_RESET_DELAY);
  7363. +        arm_set_dor(FDCS->dor);
  7364. +    }
  7365. +}
  7366. +
  7367. +void show_floppy(void)
  7368. +{
  7369. +    int i;
  7370. +
  7371. +    printk("\n");
  7372. +    printk("floppy driver state\n");
  7373. +    printk("-------------------\n");
  7374. +    printk("now=%ld last interrupt=%d last called handler=%p\n",
  7375. +        jiffies, interruptjiffies, lasthandler);
  7376. +
  7377. +
  7378. +#ifdef FLOPPY_SANITY_CHECK
  7379. +    printk("timeout_message=%s\n", timeout_message);
  7380. +    printk("last output bytes:\n");
  7381. +    for(i=0; i < OLOGSIZE; i++)
  7382. +        printk("%2x %2x %ld\n",
  7383. +            output_log[(i+output_log_pos) % OLOGSIZE].data,
  7384. +            output_log[(i+output_log_pos) % OLOGSIZE].status,
  7385. +            output_log[(i+output_log_pos) % OLOGSIZE].jiffies);
  7386. +    printk("last result at %d\n", resultjiffies);
  7387. +    printk("last redo_fd_request at %d\n", lastredo);
  7388. +    for(i=0; i<resultsize; i++){
  7389. +        printk("%2x ", reply_buffer[i]);
  7390. +    }
  7391. +    printk("\n");
  7392. +#endif
  7393. +
  7394. +    printk("status=%x\n", fd_inb(FD_STATUS));
  7395. +    printk("fdc_busy=%d\n", fdc_busy);
  7396. +    if( DEVICE_INTR)
  7397. +        printk("DEVICE_INTR=%p\n", DEVICE_INTR);
  7398. +    if(floppy_tq.sync)
  7399. +        printk("floppy_tq.routine=%p\n", floppy_tq.routine);
  7400. +    if(fd_timer.prev)
  7401. +        printk("fd_timer.function=%p\n", fd_timer.function);
  7402. +    if(fd_timeout.prev){
  7403. +        printk("timer_table=%p\n",fd_timeout.function);
  7404. +        printk("expires=%ld\n",fd_timeout.expires-jiffies);
  7405. +        printk("now=%ld\n",jiffies);
  7406. +    }
  7407. +    printk("cont=%p\n", cont);
  7408. +    printk("CURRENT=%p\n", CURRENT);
  7409. +    printk("command_status=%d\n", command_status);
  7410. +    printk("\n");
  7411. +}
  7412. +
  7413. +static void floppy_shutdown(void)
  7414. +{
  7415. +    if (!initialising)
  7416. +        show_floppy();
  7417. +    cancel_activity();
  7418. +    sti();
  7419. +
  7420. +    floppy_enable_hlt();
  7421. +    fd_disable_dma();
  7422. +    /* avoid dma going to a random drive after shutdown */
  7423. +    
  7424. +    if(!initialising)
  7425. +        DPRINT("floppy timeout called\n");
  7426. +    FDCS->reset = 1;
  7427. +    if (cont){
  7428. +        cont->done(0);
  7429. +        cont->redo(); /* this will recall reset when needed */
  7430. +    } else {
  7431. +        printk("no cont in shutdown!\n");
  7432. +        process_fd_request();
  7433. +    }
  7434. +    is_alive("floppy shutdown");
  7435. +}
  7436. +/*typedef void (*timeout_fn)(unsigned long);*/
  7437. +
  7438. +/* start motor, check media-changed condition and write protection */
  7439. +static int start_motor( void (*function)(void)  )
  7440. +{
  7441. +    int mask, data;
  7442. +
  7443. +    mask = 0xfc;
  7444. +    data = UNIT(current_drive);
  7445. +    if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)){
  7446. +        if(!(FDCS->dor & ( 0x10 << UNIT(current_drive) ) )){
  7447. +            set_debugt();
  7448. +            /* no read since this drive is running */
  7449. +            DRS->first_read_date = 0;
  7450. +            /* note motor start time if motor is not yet running */
  7451. +            DRS->spinup_date = jiffies;
  7452. +            data |= (0x10 << UNIT(current_drive));
  7453. +        }
  7454. +    } else
  7455. +        if (FDCS->dor & ( 0x10 << UNIT(current_drive) ) )
  7456. +            mask &= ~(0x10 << UNIT(current_drive));
  7457. +
  7458. +    /* starts motor and selects floppy */
  7459. +    del_timer(motor_off_timer + current_drive);
  7460. +    set_dor( fdc, mask, data);
  7461. +
  7462. +    /* wait_for_completion also schedules reset if needed. */
  7463. +    return(wait_for_completion(DRS->select_date+DP->select_delay,
  7464. +                   (timeout_fn) function));
  7465. +}
  7466. +
  7467. +static void floppy_ready(void)
  7468. +{
  7469. +    CHECK_RESET;
  7470. +    if(start_motor(floppy_ready)) return;
  7471. +    if(fdc_dtr()) return;
  7472. +
  7473. +#ifdef DCL_DEBUG
  7474. +    if (DP->flags & FD_DEBUG){
  7475. +        DPRINT("calling disk change from floppy_ready\n");
  7476. +    }
  7477. +#endif
  7478. +
  7479. +    if(!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
  7480. +       disk_change(current_drive) &&
  7481. +       !DP->select_delay)
  7482. +           twaddle(); /* this clears the dcl on certain drive/controller
  7483. +                   * combinations */
  7484. +
  7485. +    if ( raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)){
  7486. +        perpendicular_mode();
  7487. +        fdc_specify(); /* must be done here because of hut, hlt ... */
  7488. +        seek_floppy();
  7489. +    } else
  7490. +        setup_rw_floppy();
  7491. +}
  7492. +
  7493. +static void floppy_start(void)
  7494. +{
  7495. +    reschedule_timeout(CURRENTD, "floppy start", 0);
  7496. +
  7497. +    scandrives();
  7498. +#ifdef DCL_DEBUG
  7499. +    if (DP->flags & FD_DEBUG){
  7500. +        DPRINT("setting NEWCHANGE in floppy_start\n");
  7501. +    }
  7502. +#endif
  7503. +    SETF(FD_DISK_NEWCHANGE);
  7504. +    floppy_ready();
  7505. +}
  7506. +
  7507. +/*
  7508. + * ========================================================================
  7509. + * here ends the bottom half. Exported routines are:
  7510. + * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
  7511. + * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
  7512. + * Initialization also uses output_byte, result, set_dor, floppy_interrupt
  7513. + * and set_dor.
  7514. + * ========================================================================
  7515. + */
  7516. +/*
  7517. + * General purpose continuations.
  7518. + * ==============================
  7519. + */
  7520. +
  7521. +static void do_wakeup(void)
  7522. +{
  7523. +    reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
  7524. +    cont = 0;
  7525. +    command_status += 2;
  7526. +    wake_up(&command_done);
  7527. +}
  7528. +
  7529. +static struct cont_t wakeup_cont={
  7530. +    empty,
  7531. +    do_wakeup,
  7532. +    empty,
  7533. +    (done_f)empty
  7534. +};
  7535. +
  7536. +
  7537. +static struct cont_t intr_cont={
  7538. +    empty,
  7539. +    process_fd_request,
  7540. +    empty,
  7541. +    (done_f) empty
  7542. +};
  7543. +
  7544. +static int wait_til_done( void (*handler)(void ), int interruptible )
  7545. +{
  7546. +    int ret;
  7547. +    unsigned long flags;
  7548. +
  7549. +    floppy_tq.routine = (void *)(void *) handler;
  7550. +    queue_task(&floppy_tq, &tq_immediate);
  7551. +    mark_bh(IMMEDIATE_BH);
  7552. +    INT_OFF;
  7553. +    while(command_status < 2 && NO_SIGNAL){
  7554. +        is_alive("wait_til_done");
  7555. +        if (interruptible)
  7556. +            interruptible_sleep_on(&command_done);
  7557. +        else
  7558. +            sleep_on(&command_done);
  7559. +    }
  7560. +    if(command_status < 2){
  7561. +        cancel_activity();
  7562. +        cont = &intr_cont;
  7563. +        reset_fdc();
  7564. +        INT_ON;
  7565. +        return -EINTR;
  7566. +    }
  7567. +    INT_ON;
  7568. +
  7569. +    if ( FDCS->reset )
  7570. +        command_status = FD_COMMAND_ERROR;
  7571. +    if ( command_status == FD_COMMAND_OKAY )
  7572. +        ret=0;
  7573. +    else
  7574. +        ret=-EIO;
  7575. +    command_status = FD_COMMAND_NONE;
  7576. +    return ret;
  7577. +}
  7578. +
  7579. +static void generic_done(int result)
  7580. +{
  7581. +    command_status = result;
  7582. +    cont = &wakeup_cont;
  7583. +}
  7584. +
  7585. +static void generic_success(void)
  7586. +{
  7587. +    cont->done(1);
  7588. +}
  7589. +
  7590. +static void generic_failure(void)
  7591. +{
  7592. +    cont->done(0);
  7593. +}
  7594. +
  7595. +static void success_and_wakeup(void)
  7596. +{
  7597. +    generic_success();
  7598. +    cont->redo();
  7599. +}
  7600. +
  7601. +
  7602. +/*
  7603. + * formatting and rw support.
  7604. + * ==========================
  7605. + */
  7606. +
  7607. +static int next_valid_format(void)
  7608. +{
  7609. +    int probed_format;
  7610. +
  7611. +    probed_format = DRS->probed_format;
  7612. +    while(1){
  7613. +        if ( probed_format >= 8 ||
  7614. +            ! DP->autodetect[probed_format] ){
  7615. +            DRS->probed_format = 0;
  7616. +            return 1;
  7617. +        }
  7618. +        if ( floppy_type[DP->autodetect[probed_format]].sect ){
  7619. +            DRS->probed_format = probed_format;
  7620. +            return 0;
  7621. +        }
  7622. +        probed_format++;
  7623. +    }
  7624. +}
  7625. +
  7626. +static void bad_flp_intr(void)
  7627. +{
  7628. +    if ( probing ){
  7629. +        DRS->probed_format++;
  7630. +        if ( !next_valid_format())
  7631. +            return;
  7632. +    }
  7633. +    (*errors)++;
  7634. +    INFBOUND(DRWE->badness, *errors);
  7635. +    if (*errors > DP->max_errors.abort)
  7636. +        cont->done(0);
  7637. +    if (*errors > DP->max_errors.reset)
  7638. +        FDCS->reset = 1;
  7639. +    else if (*errors > DP->max_errors.recal)
  7640. +        DRS->track = NEED_2_RECAL;
  7641. +}
  7642. +
  7643. +static void set_floppy(kdev_t device)
  7644. +{
  7645. +    if (TYPE(device))
  7646. +        _floppy = TYPE(device) + floppy_type;
  7647. +    else
  7648. +        _floppy = current_type[ DRIVE(device) ];
  7649. +}
  7650. +
  7651. +/*
  7652. + * formatting support.
  7653. + * ===================
  7654. + */
  7655. +static void format_interrupt(void)
  7656. +{
  7657. +    switch (interpret_errors()){
  7658. +        case 1:
  7659. +            cont->error();
  7660. +        case 2:
  7661. +            break;
  7662. +        case 0:
  7663. +            cont->done(1);
  7664. +    }
  7665. +    cont->redo();
  7666. +}
  7667. +
  7668. +#define CODE2SIZE (ssize = ( ( 1 << SIZECODE ) + 3 ) >> 2)
  7669. +#define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80 ) >>1))
  7670. +#define CT(x) ( (x) | 0x40 )
  7671. +static void setup_format_params(int track)
  7672. +{
  7673. +    struct fparm {
  7674. +        unsigned char track,head,sect,size;
  7675. +    } *here = (struct fparm *)floppy_track_buffer;
  7676. +    int il,n;
  7677. +    int count,head_shift,track_shift;
  7678. +
  7679. +    raw_cmd = &default_raw_cmd;
  7680. +    raw_cmd->track = track;
  7681. +    
  7682. +    raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
  7683. +        FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
  7684. +    raw_cmd->rate = _floppy->rate & 0x43;
  7685. +    raw_cmd->cmd_count = NR_F;
  7686. +    COMMAND = FM_MODE(_floppy,FD_FORMAT);
  7687. +    DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy,format_req.head);
  7688. +    F_SIZECODE = FD_SIZECODE(_floppy);
  7689. +    F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
  7690. +    F_GAP = _floppy->fmt_gap;
  7691. +    F_FILL = FD_FILL_BYTE;
  7692. +
  7693. +    raw_cmd->kernel_data = floppy_track_buffer;
  7694. +    raw_cmd->length = 4 * F_SECT_PER_TRACK;
  7695. +
  7696. +    /* allow for about 30ms for data transport per track */
  7697. +    head_shift  = (F_SECT_PER_TRACK + 5) / 6;
  7698. +
  7699. +    /* a ``cylinder'' is two tracks plus a little stepping time */
  7700. +    track_shift = 2 * head_shift + 3;
  7701. +
  7702. +    /* position of logical sector 1 on this track */
  7703. +    n = (track_shift * format_req.track + head_shift * format_req.head )
  7704. +        % F_SECT_PER_TRACK;
  7705. +
  7706. +    /* determine interleave */
  7707. +    il = 1;
  7708. +    if (_floppy->sect > DP->interleave_sect && F_SIZECODE == 2)
  7709. +        il++;
  7710. +
  7711. +    /* initialize field */
  7712. +    for (count = 0; count < F_SECT_PER_TRACK; ++count) {
  7713. +        here[count].track = format_req.track;
  7714. +        here[count].head = format_req.head;
  7715. +        here[count].sect = 0;
  7716. +        here[count].size = F_SIZECODE;
  7717. +    }
  7718. +    /* place logical sectors */
  7719. +    for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
  7720. +        here[n].sect = count;
  7721. +        n = (n+il) % F_SECT_PER_TRACK;
  7722. +        if (here[n].sect) { /* sector busy, find next free sector */
  7723. +            ++n;
  7724. +            if (n>= F_SECT_PER_TRACK) {
  7725. +                n-=F_SECT_PER_TRACK;
  7726. +                while (here[n].sect) ++n;
  7727. +            }
  7728. +        }
  7729. +    }
  7730. +}
  7731. +
  7732. +static void redo_format(void)
  7733. +{
  7734. +    buffer_track = -1;
  7735. +    setup_format_params(format_req.track << STRETCH(_floppy));
  7736. +    floppy_start();
  7737. +#ifdef DEBUGT
  7738. +    debugt("queue format request");
  7739. +#endif
  7740. +}
  7741. +
  7742. +static struct cont_t format_cont={
  7743. +    format_interrupt,
  7744. +    redo_format,
  7745. +    bad_flp_intr,
  7746. +    generic_done };
  7747. +
  7748. +static int do_format(kdev_t device, struct format_descr *tmp_format_req)
  7749. +{
  7750. +    int ret;
  7751. +    int drive=DRIVE(device);
  7752. +
  7753. +    LOCK_FDC(drive,1);
  7754. +    set_floppy(device);
  7755. +    if (!_floppy ||
  7756. +        _floppy->track > DP->tracks ||
  7757. +        tmp_format_req->track >= _floppy->track ||
  7758. +        tmp_format_req->head >= _floppy->head ||
  7759. +        (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
  7760. +        !_floppy->fmt_gap) {
  7761. +        process_fd_request();
  7762. +        return -EINVAL;
  7763. +    }
  7764. +    format_req = *tmp_format_req;
  7765. +    format_errors = 0;
  7766. +    cont = &format_cont;
  7767. +    errors = &format_errors;
  7768. +    IWAIT(redo_format);
  7769. +    process_fd_request();
  7770. +    return ret;
  7771. +}
  7772. +
  7773. +/*
  7774. + * Buffer read/write and support
  7775. + * =============================
  7776. + */
  7777. +
  7778. +/* new request_done. Can handle physical sectors which are smaller than a
  7779. + * logical buffer */
  7780. +static void request_done(int uptodate)
  7781. +{
  7782. +    int block;
  7783. +
  7784. +    probing = 0;
  7785. +    reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
  7786. +
  7787. +    if (!CURRENT){
  7788. +        DPRINT("request list destroyed in floppy request done\n");
  7789. +        return;
  7790. +    }
  7791. +
  7792. +    if (uptodate){
  7793. +        /* maintain values for invalidation on geometry
  7794. +         * change */
  7795. +        block = current_count_sectors + CURRENT->sector;
  7796. +        INFBOUND(DRS->maxblock, block);
  7797. +        if (block > _floppy->sect)
  7798. +            DRS->maxtrack = 1;
  7799. +
  7800. +        /* unlock chained buffers */
  7801. +        while (current_count_sectors && CURRENT &&
  7802. +               current_count_sectors >= CURRENT->current_nr_sectors ){
  7803. +            current_count_sectors -= CURRENT->current_nr_sectors;
  7804. +            CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
  7805. +            CURRENT->sector += CURRENT->current_nr_sectors;
  7806. +            end_request(1);
  7807. +        }
  7808. +        if ( current_count_sectors && CURRENT){
  7809. +            /* "unlock" last subsector */
  7810. +            CURRENT->buffer += current_count_sectors <<9;
  7811. +            CURRENT->current_nr_sectors -= current_count_sectors;
  7812. +            CURRENT->nr_sectors -= current_count_sectors;
  7813. +            CURRENT->sector += current_count_sectors;
  7814. +            return;
  7815. +        }
  7816. +
  7817. +        if ( current_count_sectors && ! CURRENT )
  7818. +            DPRINT("request list destroyed in floppy request done\n");
  7819. +
  7820. +    } else {
  7821. +        if(CURRENT->cmd == WRITE) {
  7822. +            /* record write error information */
  7823. +            DRWE->write_errors++;
  7824. +            if(DRWE->write_errors == 1) {
  7825. +                DRWE->first_error_sector = CURRENT->sector;
  7826. +                DRWE->first_error_generation = DRS->generation;
  7827. +            }
  7828. +            DRWE->last_error_sector = CURRENT->sector;
  7829. +            DRWE->last_error_generation = DRS->generation;
  7830. +        }
  7831. +        end_request(0);
  7832. +    }
  7833. +}
  7834. +
  7835. +/* Interrupt handler evaluating the result of the r/w operation */
  7836. +static void rw_interrupt(void)
  7837. +{
  7838. +    int nr_sectors, ssize, eoc;
  7839. +
  7840. +    if ( ! DRS->first_read_date )
  7841. +        DRS->first_read_date = jiffies;
  7842. +
  7843. +    nr_sectors = 0;
  7844. +    CODE2SIZE;
  7845. +
  7846. +    if(ST1 & ST1_EOC)
  7847. +        eoc = 1;
  7848. +    else
  7849. +        eoc = 0;
  7850. +    nr_sectors = ((R_TRACK-TRACK)*_floppy->head+R_HEAD-HEAD) *
  7851. +        _floppy->sect + ((R_SECTOR-SECTOR+eoc) <<  SIZECODE >> 2) -
  7852. +        (sector_t % _floppy->sect) % ssize;
  7853. +
  7854. +#ifdef FLOPPY_SANITY_CHECK
  7855. +    if ( nr_sectors > current_count_sectors + ssize -
  7856. +         (current_count_sectors + sector_t) % ssize +
  7857. +         sector_t % ssize){
  7858. +        DPRINT("long rw: %x instead of %lx\n",
  7859. +            nr_sectors, current_count_sectors);
  7860. +        printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
  7861. +        printk("rh=%d h=%d\n", R_HEAD, HEAD);
  7862. +        printk("rt=%d t=%d\n", R_TRACK, TRACK);
  7863. +        printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
  7864. +               sector_t, ssize);
  7865. +    }
  7866. +#endif
  7867. +    INFBOUND(nr_sectors,0);
  7868. +    SUPBOUND(current_count_sectors, nr_sectors);
  7869. +
  7870. +    switch (interpret_errors()){
  7871. +        case 2:
  7872. +            cont->redo();
  7873. +            return;
  7874. +        case 1:
  7875. +            if (  !current_count_sectors){
  7876. +                cont->error();
  7877. +                cont->redo();
  7878. +                return;
  7879. +            }
  7880. +            break;
  7881. +        case 0:
  7882. +            if (  !current_count_sectors){
  7883. +                cont->redo();
  7884. +                return;
  7885. +            }
  7886. +            current_type[current_drive] = _floppy;
  7887. +            floppy_sizes[TOMINOR(current_drive) ]= _floppy->size>>1;
  7888. +            break;
  7889. +    }
  7890. +
  7891. +    if (probing) {
  7892. +        if (DP->flags & FTD_MSG)
  7893. +            DPRINT("Auto-detected floppy type %s in fd%d\n",
  7894. +                _floppy->name,current_drive);
  7895. +        current_type[current_drive] = _floppy;
  7896. +        floppy_sizes[TOMINOR(current_drive)] = _floppy->size >> 1;
  7897. +        probing = 0;
  7898. +    }
  7899. +
  7900. +    if ( CT(COMMAND) != FD_READ ||
  7901. +         raw_cmd->kernel_data == CURRENT->buffer ){
  7902. +        /* transfer directly from buffer */
  7903. +        cont->done(1);
  7904. +    } else if ( CT(COMMAND) == FD_READ){
  7905. +        buffer_track = raw_cmd->track;
  7906. +        buffer_drive = current_drive;
  7907. +        INFBOUND(buffer_max, nr_sectors + sector_t);
  7908. +    }
  7909. +    cont->redo();
  7910. +}
  7911. +
  7912. +/* Compute maximal contiguous buffer size. */
  7913. +static int buffer_chain_size(void)
  7914. +{
  7915. +    struct buffer_head *bh;
  7916. +    int size;
  7917. +    char *base;
  7918. +
  7919. +    base = CURRENT->buffer;
  7920. +    size = CURRENT->current_nr_sectors << 9;
  7921. +    bh = CURRENT->bh;
  7922. +
  7923. +    if(bh){
  7924. +        bh = bh->b_reqnext;
  7925. +        while ( bh && bh->b_data == base + size ){
  7926. +            size += bh->b_size;
  7927. +            bh = bh->b_reqnext;
  7928. +        }
  7929. +    }
  7930. +    return size >> 9;
  7931. +}
  7932. +
  7933. +/* Compute the maximal transfer size */
  7934. +static int transfer_size(int ssize, int max_sector, int max_size)
  7935. +{
  7936. +    SUPBOUND(max_sector, sector_t + max_size);
  7937. +
  7938. +    /* alignment */
  7939. +    max_sector -= (max_sector % _floppy->sect ) % ssize;
  7940. +
  7941. +    /* transfer size, beginning not aligned */
  7942. +    current_count_sectors = max_sector - sector_t ;
  7943. +
  7944. +    return max_sector;
  7945. +}
  7946. +
  7947. +/*
  7948. + * Move data from/to the track buffer to/from the buffer cache.
  7949. + */
  7950. +static void copy_buffer(int ssize, int max_sector, int max_sector_2)
  7951. +{
  7952. +    int remaining; /* number of transferred 512-byte sectors */
  7953. +    struct buffer_head *bh;
  7954. +    char *buffer, *dma_buffer;
  7955. +    int size;
  7956. +
  7957. +    max_sector = transfer_size(ssize,
  7958. +                   minimum(max_sector, max_sector_2),
  7959. +                   CURRENT->nr_sectors);
  7960. +
  7961. +    if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
  7962. +        buffer_max > sector_t + CURRENT->nr_sectors)
  7963. +        current_count_sectors = minimum(buffer_max - sector_t,
  7964. +                        CURRENT->nr_sectors);
  7965. +
  7966. +    remaining = current_count_sectors << 9;
  7967. +#ifdef FLOPPY_SANITY_CHECK
  7968. +    if ((remaining >> 9) > CURRENT->nr_sectors  &&
  7969. +        CT(COMMAND) == FD_WRITE ){
  7970. +        DPRINT("in copy buffer\n");
  7971. +        printk("current_count_sectors=%ld\n", current_count_sectors);
  7972. +        printk("remaining=%d\n", remaining >> 9);
  7973. +        printk("CURRENT->nr_sectors=%ld\n",CURRENT->nr_sectors);
  7974. +        printk("CURRENT->current_nr_sectors=%ld\n",
  7975. +               CURRENT->current_nr_sectors);
  7976. +        printk("max_sector=%d\n", max_sector);
  7977. +        printk("ssize=%d\n", ssize);
  7978. +    }
  7979. +#endif
  7980. +
  7981. +    buffer_max = maximum(max_sector, buffer_max);
  7982. +
  7983. +    dma_buffer = floppy_track_buffer + ((sector_t - buffer_min) << 9);
  7984. +
  7985. +    bh = CURRENT->bh;
  7986. +    size = CURRENT->current_nr_sectors << 9;
  7987. +    buffer = CURRENT->buffer;
  7988. +
  7989. +    while ( remaining > 0){
  7990. +        SUPBOUND(size, remaining);
  7991. +#ifdef FLOPPY_SANITY_CHECK
  7992. +        if (dma_buffer + size >
  7993. +            floppy_track_buffer + (max_buffer_sectors << 10) ||
  7994. +            dma_buffer < floppy_track_buffer ){
  7995. +            DPRINT("buffer overrun in copy buffer %d\n",
  7996. +                (int) ((floppy_track_buffer - dma_buffer) >>9));
  7997. +            printk("sector_t=%d buffer_min=%d\n",
  7998. +                   sector_t, buffer_min);
  7999. +            printk("current_count_sectors=%ld\n",
  8000. +                   current_count_sectors);
  8001. +            if ( CT(COMMAND) == FD_READ )
  8002. +                printk("read\n");
  8003. +            if ( CT(COMMAND) == FD_READ )
  8004. +                printk("write\n");
  8005. +            break;
  8006. +        }
  8007. +        if ( ((unsigned long)buffer) % 512 )
  8008. +            DPRINT("%p buffer not aligned\n", buffer);
  8009. +#endif
  8010. +        if (CT(COMMAND) == FD_READ)
  8011. +            memcpy( buffer, dma_buffer, size);
  8012. +        else
  8013. +            memcpy( dma_buffer, buffer, size);
  8014. +        remaining -= size;
  8015. +        if ( !remaining)
  8016. +            break;
  8017. +
  8018. +        dma_buffer += size;
  8019. +        bh = bh->b_reqnext;
  8020. +#ifdef FLOPPY_SANITY_CHECK
  8021. +        if ( !bh){
  8022. +            DPRINT("bh=null in copy buffer after copy\n");
  8023. +            break;
  8024. +        }
  8025. +#endif
  8026. +        size = bh->b_size;
  8027. +        buffer = bh->b_data;
  8028. +    }
  8029. +#ifdef FLOPPY_SANITY_CHECK
  8030. +    if ( remaining ){
  8031. +        if ( remaining > 0 )
  8032. +            max_sector -= remaining >> 9;
  8033. +        DPRINT("weirdness: remaining %d\n", remaining>>9);
  8034. +    }
  8035. +#endif
  8036. +}
  8037. +
  8038. +/*
  8039. + * Formulate a read/write request.
  8040. + * this routine decides where to load the data (directly to buffer, or to
  8041. + * tmp floppy area), how much data to load (the size of the buffer, the whole
  8042. + * track, or a single sector)
  8043. + * All floppy_track_buffer handling goes in here. If we ever add track buffer
  8044. + * allocation on the fly, it should be done here. No other part should need
  8045. + * modification.
  8046. + */
  8047. +
  8048. +static int make_raw_rw_request(void)
  8049. +{
  8050. +    int aligned_sector_t;
  8051. +    int max_sector, max_size, tracksize, ssize;
  8052. +
  8053. +    set_fdc(DRIVE(CURRENT->rq_dev));
  8054. +
  8055. +    raw_cmd = &default_raw_cmd;
  8056. +    raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
  8057. +        FD_RAW_NEED_SEEK;
  8058. +    raw_cmd->cmd_count = NR_RW;
  8059. +    if (CURRENT->cmd == READ){
  8060. +        raw_cmd->flags |= FD_RAW_READ;
  8061. +        COMMAND = FM_MODE(_floppy,FD_READ);
  8062. +    } else if (CURRENT->cmd == WRITE){
  8063. +        raw_cmd->flags |= FD_RAW_WRITE;
  8064. +        COMMAND = FM_MODE(_floppy,FD_WRITE);
  8065. +    } else {
  8066. +        DPRINT("make_raw_rw_request: unknown command\n");
  8067. +        return 0;
  8068. +    }
  8069. +
  8070. +    max_sector = _floppy->sect * _floppy->head;
  8071. +    
  8072. +    TRACK = CURRENT->sector / max_sector;
  8073. +    sector_t = CURRENT->sector % max_sector;
  8074. +    if (_floppy->track && TRACK >= _floppy->track )
  8075. +        return 0;
  8076. +    HEAD = sector_t / _floppy->sect;
  8077. +
  8078. +    if (((_floppy->stretch & FD_SWAPSIDES) || TESTF(FD_NEED_TWADDLE)) &&
  8079. +        sector_t < _floppy->sect)
  8080. +        max_sector = _floppy->sect;
  8081. +
  8082. +    /* 2M disks have phantom sectors on the first track */
  8083. +    if ((_floppy->rate & FD_2M ) && (!TRACK) && (!HEAD)){
  8084. +        max_sector = 2 * _floppy->sect / 3;
  8085. +        if (sector_t >= max_sector){
  8086. +            current_count_sectors = minimum(_floppy->sect - sector_t,
  8087. +                            CURRENT->nr_sectors);
  8088. +            return 1;
  8089. +        }
  8090. +        SIZECODE = 2;
  8091. +    } else
  8092. +        SIZECODE = FD_SIZECODE(_floppy);
  8093. +    raw_cmd->rate = _floppy->rate & 0x43;
  8094. +    if ((_floppy->rate & FD_2M) &&
  8095. +        (TRACK || HEAD ) &&
  8096. +        raw_cmd->rate == 2)
  8097. +        raw_cmd->rate = 1;
  8098. +
  8099. +    if ( SIZECODE )
  8100. +        SIZECODE2 = 0xff;
  8101. +    else
  8102. +        SIZECODE2 = 0x80;
  8103. +    raw_cmd->track = TRACK << STRETCH(_floppy);
  8104. +    DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy,HEAD);
  8105. +    GAP = _floppy->gap;
  8106. +    CODE2SIZE;
  8107. +    SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
  8108. +    SECTOR = ((sector_t % _floppy->sect) << 2 >> SIZECODE) + 1;
  8109. +    tracksize = _floppy->sect - _floppy->sect % ssize;
  8110. +    if ( tracksize < _floppy->sect ){
  8111. +        SECT_PER_TRACK ++;
  8112. +        if (  tracksize <= sector_t % _floppy->sect)
  8113. +            SECTOR--;
  8114. +        while ( tracksize <= sector_t % _floppy->sect){
  8115. +            while( tracksize + ssize > _floppy->sect ){
  8116. +                SIZECODE--;
  8117. +                ssize >>= 1;
  8118. +            }
  8119. +            SECTOR++; SECT_PER_TRACK ++;
  8120. +            tracksize += ssize;
  8121. +        }
  8122. +        max_sector = HEAD * _floppy->sect + tracksize;
  8123. +    } else if ( !TRACK && !HEAD && !( _floppy->rate & FD_2M ) && probing)
  8124. +        max_sector = _floppy->sect;
  8125. +
  8126. +    aligned_sector_t = sector_t - ( sector_t % _floppy->sect ) % ssize;
  8127. +    max_size = CURRENT->nr_sectors;
  8128. +    if ((raw_cmd->track == buffer_track) &&
  8129. +        (current_drive == buffer_drive) &&
  8130. +        (sector_t >= buffer_min) && (sector_t < buffer_max)) {
  8131. +        /* data already in track buffer */
  8132. +        if (CT(COMMAND) == FD_READ) {
  8133. +            copy_buffer(1, max_sector, buffer_max);
  8134. +            return 1;
  8135. +        }
  8136. +    } else if (aligned_sector_t != sector_t || CURRENT->nr_sectors < ssize){
  8137. +        if (CT(COMMAND) == FD_WRITE){
  8138. +            if(sector_t + CURRENT->nr_sectors > ssize &&
  8139. +               sector_t + CURRENT->nr_sectors < ssize + ssize)
  8140. +                max_size = ssize + ssize;
  8141. +            else
  8142. +                max_size = ssize;
  8143. +        }
  8144. +        raw_cmd->flags &= ~FD_RAW_WRITE;
  8145. +        raw_cmd->flags |= FD_RAW_READ;
  8146. +        COMMAND = FM_MODE(_floppy,FD_READ);
  8147. +    } else if ((unsigned long)CURRENT->buffer < MAX_DMA_ADDRESS ) {
  8148. +#if 0
  8149. +        unsigned long dma_limit;
  8150. +#endif
  8151. +        int direct, indirect;
  8152. +
  8153. +        indirect= transfer_size(ssize,max_sector,max_buffer_sectors*2) -
  8154. +            sector_t;
  8155. +
  8156. +        /*
  8157. +         * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
  8158. +         * on a 64 bit machine!
  8159. +         */
  8160. +        max_size = buffer_chain_size();
  8161. +#if 0
  8162. +        dma_limit = (MAX_DMA_ADDRESS - ((unsigned long) CURRENT->buffer)) >> 9;
  8163. +        if ((unsigned long) max_size > dma_limit) {
  8164. +            max_size = dma_limit;
  8165. +        }
  8166. +        /* 64 kb boundaries */
  8167. +        if (CROSS_64KB(CURRENT->buffer, max_size << 9))
  8168. +            max_size = ( K_64 - ((long) CURRENT->buffer) % K_64)>>9;
  8169. +#endif
  8170. +        direct = transfer_size(ssize,max_sector,max_size) - sector_t;
  8171. +        /*
  8172. +         * We try to read tracks, but if we get too many errors, we
  8173. +         * go back to reading just one sector at a time.
  8174. +         *
  8175. +         * This means we should be able to read a sector even if there
  8176. +         * are other bad sectors on this track.
  8177. +         */
  8178. +        if (!direct ||
  8179. +            (indirect * 2 > direct * 3 &&
  8180. +             *errors < DP->max_errors.read_track &&
  8181. +             /*!TESTF( FD_NEED_TWADDLE) &&*/
  8182. +             ((!probing || (DP->read_track&(1<<DRS->probed_format)))))){
  8183. +            max_size = CURRENT->nr_sectors;
  8184. +        } else {
  8185. +            raw_cmd->kernel_data = CURRENT->buffer;
  8186. +            raw_cmd->length = current_count_sectors << 9;
  8187. +            if (raw_cmd->length == 0){
  8188. +                DPRINT("zero dma transfer attempted from make_raw_request\n");
  8189. +                DPRINT("indirect=%d direct=%d sector_t=%d",
  8190. +                    indirect, direct, sector_t);
  8191. +                return 0;
  8192. +            }
  8193. +            return 2;
  8194. +        }
  8195. +    }
  8196. +
  8197. +    if ( CT(COMMAND) == FD_READ )
  8198. +        max_size = max_sector; /* unbounded */
  8199. +
  8200. +    /* claim buffer track if needed */
  8201. +    if (buffer_track != raw_cmd->track ||  /* bad track */
  8202. +        buffer_drive !=current_drive || /* bad drive */
  8203. +        sector_t > buffer_max ||
  8204. +        sector_t < buffer_min ||
  8205. +        ((CT(COMMAND) == FD_READ ||
  8206. +          (aligned_sector_t == sector_t && CURRENT->nr_sectors >= ssize ))&&
  8207. +         max_sector > 2 * max_buffer_sectors + buffer_min &&
  8208. +         max_size + sector_t > 2 * max_buffer_sectors + buffer_min)
  8209. +        /* not enough space */ ){
  8210. +        buffer_track = -1;
  8211. +        buffer_drive = current_drive;
  8212. +        buffer_max = buffer_min = aligned_sector_t;
  8213. +    }
  8214. +    raw_cmd->kernel_data = floppy_track_buffer +
  8215. +        ((aligned_sector_t-buffer_min )<<9);
  8216. +
  8217. +    if ( CT(COMMAND) == FD_WRITE ){
  8218. +        /* copy write buffer to track buffer.
  8219. +         * if we get here, we know that the write
  8220. +         * is either aligned or the data already in the buffer
  8221. +         * (buffer will be overwritten) */
  8222. +#ifdef FLOPPY_SANITY_CHECK
  8223. +        if (sector_t != aligned_sector_t && buffer_track == -1 )
  8224. +            DPRINT("internal error offset !=0 on write\n");
  8225. +#endif
  8226. +        buffer_track = raw_cmd->track;
  8227. +        buffer_drive = current_drive;
  8228. +        copy_buffer(ssize, max_sector, 2*max_buffer_sectors+buffer_min);
  8229. +    } else
  8230. +        transfer_size(ssize, max_sector,
  8231. +                  2*max_buffer_sectors+buffer_min-aligned_sector_t);
  8232. +
  8233. +    /* round up current_count_sectors to get dma xfer size */
  8234. +    raw_cmd->length = sector_t+current_count_sectors-aligned_sector_t;
  8235. +    raw_cmd->length = ((raw_cmd->length -1)|(ssize-1))+1;
  8236. +    raw_cmd->length <<= 9;
  8237. +#ifdef FLOPPY_SANITY_CHECK
  8238. +    if ((raw_cmd->length < current_count_sectors << 9) ||
  8239. +        (raw_cmd->kernel_data != CURRENT->buffer &&
  8240. +         CT(COMMAND) == FD_WRITE &&
  8241. +         (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
  8242. +          aligned_sector_t < buffer_min )) ||
  8243. +        raw_cmd->length % ( 128 << SIZECODE ) ||
  8244. +        raw_cmd->length <= 0 || current_count_sectors <= 0){
  8245. +        DPRINT("fractionary current count b=%lx s=%lx\n",
  8246. +            raw_cmd->length, current_count_sectors);
  8247. +        if ( raw_cmd->kernel_data != CURRENT->buffer )
  8248. +            printk("addr=%d, length=%ld\n",
  8249. +                   (int) ((raw_cmd->kernel_data -
  8250. +                       floppy_track_buffer ) >> 9),
  8251. +                   current_count_sectors);
  8252. +        printk("st=%d ast=%d mse=%d msi=%d\n",
  8253. +               sector_t, aligned_sector_t, max_sector, max_size);
  8254. +        printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
  8255. +        printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
  8256. +               COMMAND, SECTOR, HEAD, TRACK);
  8257. +        printk("buffer drive=%d\n", buffer_drive);
  8258. +        printk("buffer track=%d\n", buffer_track);
  8259. +        printk("buffer_min=%d\n", buffer_min );
  8260. +        printk("buffer_max=%d\n", buffer_max );
  8261. +        return 0;
  8262. +    }
  8263. +
  8264. +    if (raw_cmd->kernel_data != CURRENT->buffer ){
  8265. +        if (raw_cmd->kernel_data < floppy_track_buffer ||
  8266. +            current_count_sectors < 0 ||
  8267. +            raw_cmd->length < 0 ||
  8268. +            raw_cmd->kernel_data + raw_cmd->length >
  8269. +            floppy_track_buffer + (max_buffer_sectors  << 10)){
  8270. +            DPRINT("buffer overrun in schedule dma\n");
  8271. +            printk("sector_t=%d buffer_min=%d current_count=%ld\n",
  8272. +                   sector_t, buffer_min,
  8273. +                   raw_cmd->length >> 9 );
  8274. +            printk("current_count_sectors=%ld\n",
  8275. +                   current_count_sectors);
  8276. +            if ( CT(COMMAND) == FD_READ )
  8277. +                printk("read\n");
  8278. +            if ( CT(COMMAND) == FD_READ )
  8279. +                printk("write\n");
  8280. +            return 0;
  8281. +        }
  8282. +    } else if (raw_cmd->length > CURRENT->nr_sectors << 9 ||
  8283. +           current_count_sectors > CURRENT->nr_sectors){
  8284. +        DPRINT("buffer overrun in direct transfer\n");
  8285. +        return 0;
  8286. +    } else if ( raw_cmd->length < current_count_sectors << 9 ){
  8287. +        DPRINT("more sectors than bytes\n");
  8288. +        printk("bytes=%ld\n", raw_cmd->length >> 9 );
  8289. +        printk("sectors=%ld\n", current_count_sectors);
  8290. +    }
  8291. +    if (raw_cmd->length == 0){
  8292. +        DPRINT("zero dma transfer attempted from make_raw_request\n");
  8293. +        return 0;
  8294. +    }
  8295. +#endif
  8296. +    return 2;
  8297. +}
  8298. +
  8299. +static void redo_fd_request(void)
  8300. +{
  8301. +#define REPEAT {request_done(0); continue; }
  8302. +    kdev_t device;
  8303. +    int tmp;
  8304. +
  8305. +    lastredo = jiffies;
  8306. +    if (current_drive < N_DRIVE)
  8307. +        floppy_off(current_drive);
  8308. +
  8309. +    if (CURRENT && CURRENT->rq_status == RQ_INACTIVE){
  8310. +        CLEAR_INTR;
  8311. +        unlock_fdc();
  8312. +        return;
  8313. +    }
  8314. +
  8315. +    while(1){
  8316. +        if (!CURRENT) {
  8317. +            CLEAR_INTR;
  8318. +            unlock_fdc();
  8319. +            return;
  8320. +        }
  8321. +        if (MAJOR(CURRENT->rq_dev) != MAJOR_NR)
  8322. +            panic(DEVICE_NAME ": request list destroyed");
  8323. +        if (CURRENT->bh && !buffer_locked(CURRENT->bh))
  8324. +            panic(DEVICE_NAME ": block not locked");
  8325. +
  8326. +        device = CURRENT->rq_dev;
  8327. +        set_fdc( DRIVE(device));
  8328. +        reschedule_timeout(CURRENTD, "redo fd request", 0);
  8329. +
  8330. +        set_floppy(device);
  8331. +        raw_cmd = & default_raw_cmd;
  8332. +        raw_cmd->flags = 0;
  8333. +        if(start_motor(redo_fd_request)) return;
  8334. +        disk_change(current_drive);
  8335. +        if(test_bit(current_drive, &fake_change) ||
  8336. +           TESTF(FD_DISK_CHANGED)){
  8337. +            DPRINT("disk absent or changed during operation\n");
  8338. +            REPEAT;
  8339. +        }
  8340. +        if (!_floppy) { /* Autodetection */
  8341. +            if (!probing){
  8342. +                DRS->probed_format = 0;
  8343. +                if ( next_valid_format() ){
  8344. +                    DPRINT("no autodetectable formats\n");
  8345. +                    _floppy = NULL;
  8346. +                    REPEAT;
  8347. +                }
  8348. +            }
  8349. +            probing = 1;
  8350. +            _floppy = floppy_type+DP->autodetect[DRS->probed_format];
  8351. +        } else
  8352. +            probing = 0;
  8353. +        errors = & (CURRENT->errors);
  8354. +        tmp = make_raw_rw_request();
  8355. +        if ( tmp < 2 ){
  8356. +            request_done(tmp);
  8357. +            continue;
  8358. +        }
  8359. +
  8360. +        if (TESTF(FD_NEED_TWADDLE))
  8361. +            twaddle();
  8362. +        floppy_tq.routine = (void *)(void *) floppy_start;
  8363. +        queue_task(&floppy_tq, &tq_immediate);
  8364. +        mark_bh(IMMEDIATE_BH);
  8365. +#ifdef DEBUGT
  8366. +        debugt("queue fd request");
  8367. +#endif
  8368. +        return;
  8369. +    }
  8370. +#undef REPEAT
  8371. +}
  8372. +
  8373. +static struct cont_t rw_cont={
  8374. +    rw_interrupt,
  8375. +    redo_fd_request,
  8376. +    bad_flp_intr,
  8377. +    request_done };
  8378. +
  8379. +static struct tq_struct request_tq =
  8380. +{ 0, 0, (void *) (void *) redo_fd_request, 0 };
  8381. +
  8382. +static void process_fd_request(void)
  8383. +{
  8384. +    cont = &rw_cont;
  8385. +    queue_task(&request_tq, &tq_immediate);
  8386. +    mark_bh(IMMEDIATE_BH);
  8387. +}
  8388. +
  8389. +static void do_fd_request(void)
  8390. +{
  8391. +    sti();
  8392. +    if (fdc_busy){
  8393. +        /* fdc busy, this new request will be treated when the
  8394. +           current one is done */
  8395. +        is_alive("do fd request, old request running");
  8396. +        return;
  8397. +    }
  8398. +    lock_fdc(MAXTIMEOUT,0);
  8399. +    process_fd_request();
  8400. +    is_alive("do fd request");
  8401. +}
  8402. +
  8403. +static struct cont_t poll_cont={
  8404. +    success_and_wakeup,
  8405. +    floppy_ready,
  8406. +    generic_failure,
  8407. +    generic_done };
  8408. +
  8409. +static int poll_drive(int interruptible, int flag)
  8410. +{
  8411. +    int ret;
  8412. +    /* no auto-sense, just clear dcl */
  8413. +    raw_cmd = &default_raw_cmd;
  8414. +    raw_cmd->flags= flag;
  8415. +    raw_cmd->track=0;
  8416. +    raw_cmd->cmd_count=0;
  8417. +    cont = &poll_cont;
  8418. +#ifdef DCL_DEBUG
  8419. +    if (DP->flags & FD_DEBUG){
  8420. +        DPRINT("setting NEWCHANGE in poll_drive\n");
  8421. +    }
  8422. +#endif
  8423. +    SETF(FD_DISK_NEWCHANGE);
  8424. +    WAIT(floppy_ready);
  8425. +    return ret;
  8426. +}
  8427. +
  8428. +/*
  8429. + * User triggered reset
  8430. + * ====================
  8431. + */
  8432. +
  8433. +static void reset_intr(void)
  8434. +{
  8435. +    printk("weird, reset interrupt called\n");
  8436. +}
  8437. +
  8438. +static struct cont_t reset_cont={
  8439. +    reset_intr,
  8440. +    success_and_wakeup,
  8441. +    generic_failure,
  8442. +    generic_done };
  8443. +
  8444. +static int user_reset_fdc(int drive, int arg, int interruptible)
  8445. +{
  8446. +    int ret;
  8447. +
  8448. +    ret=0;
  8449. +    LOCK_FDC(drive,interruptible);
  8450. +    if(arg == FD_RESET_ALWAYS)
  8451. +        FDCS->reset=1;
  8452. +    if ( FDCS->reset ){
  8453. +        cont = &reset_cont;
  8454. +        WAIT(reset_fdc);
  8455. +    }
  8456. +    process_fd_request();
  8457. +    return ret;
  8458. +}
  8459. +
  8460. +/*
  8461. + * Misc Ioctl's and support
  8462. + * ========================
  8463. + */
  8464. +static int fd_copyout(void *param, const void *address, int size)
  8465. +{
  8466. +    int ret;
  8467. +
  8468. +    ECALL(verify_area(VERIFY_WRITE,param,size));
  8469. +    memcpy_tofs(param,(void *) address, size);
  8470. +    return 0;
  8471. +}
  8472. +
  8473. +static int fd_copyin(void *param, void *address, int size)
  8474. +{
  8475. +    int ret;
  8476. +
  8477. +    ECALL(verify_area(VERIFY_READ,param,size));
  8478. +    memcpy_fromfs((void *) address, param, size);
  8479. +    return 0;
  8480. +}
  8481. +
  8482. +#define COPYOUT(x) ECALL(fd_copyout( (void *)param, &(x), sizeof(x)))
  8483. +#define COPYIN(x) ECALL(fd_copyin( (void *)param, &(x), sizeof(x)))
  8484. +
  8485. +static inline const char *drive_name(int type, int drive)
  8486. +{
  8487. +    struct floppy_struct *floppy;
  8488. +
  8489. +    if ( type )
  8490. +        floppy = floppy_type + type;
  8491. +    else {
  8492. +        if ( UDP->native_format )
  8493. +            floppy = floppy_type + UDP->native_format;
  8494. +        else
  8495. +            return "(null)";
  8496. +    }
  8497. +    if ( floppy->name )
  8498. +        return floppy->name;
  8499. +    else
  8500. +        return "(null)";
  8501. +}
  8502. +
  8503. +
  8504. +/* raw commands */
  8505. +static void raw_cmd_done(int flag)
  8506. +{
  8507. +    int i;
  8508. +
  8509. +    if(!flag) {
  8510. +        raw_cmd->flags |= FD_RAW_FAILURE;
  8511. +        raw_cmd->flags |= FD_RAW_HARDFAILURE;
  8512. +    } else {
  8513. +        raw_cmd->reply_count = inr;
  8514. +        for( i=0; i< raw_cmd->reply_count; i++)
  8515. +            raw_cmd->reply[i] = reply_buffer[i];
  8516. +
  8517. +        if ( raw_cmd->flags & ( FD_RAW_READ | FD_RAW_WRITE ))
  8518. +            raw_cmd->length = fd_get_dma_residue();
  8519. +
  8520. +        if( (raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
  8521. +            (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
  8522. +            raw_cmd->flags |= FD_RAW_FAILURE;
  8523. +
  8524. +        if( disk_change(current_drive) )
  8525. +            raw_cmd->flags |= FD_RAW_DISK_CHANGE;
  8526. +        else
  8527. +            raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
  8528. +        if(raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
  8529. +            motor_off_callback(current_drive);
  8530. +
  8531. +        if(raw_cmd->next &&
  8532. +           (!(raw_cmd->flags & FD_RAW_FAILURE) ||
  8533. +            !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
  8534. +           ((raw_cmd->flags & FD_RAW_FAILURE) ||
  8535. +            !(raw_cmd->flags &FD_RAW_STOP_IF_SUCCESS))) {
  8536. +            raw_cmd = raw_cmd->next;
  8537. +            return;
  8538. +        }
  8539. +    }
  8540. +    generic_done(flag);
  8541. +}
  8542. +
  8543. +
  8544. +static struct cont_t raw_cmd_cont={
  8545. +    success_and_wakeup,
  8546. +    floppy_start,
  8547. +    generic_failure,
  8548. +    raw_cmd_done
  8549. +};
  8550. +
  8551. +static inline int raw_cmd_copyout(int cmd, char *param,
  8552. +                  struct floppy_raw_cmd *ptr)
  8553. +{
  8554. +    struct old_floppy_raw_cmd old_raw_cmd;
  8555. +    int ret;
  8556. +
  8557. +    while(ptr) {
  8558. +        if(cmd == OLDFDRAWCMD) {
  8559. +            old_raw_cmd.flags = ptr->flags;
  8560. +            old_raw_cmd.data = ptr->data;
  8561. +            old_raw_cmd.length = ptr->length;
  8562. +            old_raw_cmd.rate = ptr->rate;
  8563. +            old_raw_cmd.reply_count = ptr->reply_count;
  8564. +            memcpy(old_raw_cmd.reply, ptr->reply, 7);
  8565. +            COPYOUT(old_raw_cmd);
  8566. +            param += sizeof(old_raw_cmd);
  8567. +        } else {
  8568. +            COPYOUT(*ptr);
  8569. +            param += sizeof(struct floppy_raw_cmd);
  8570. +        }
  8571. +
  8572. +        if ( (ptr->flags & FD_RAW_READ) && ptr->buffer_length){
  8573. +            if(ptr->length>=0 && ptr->length<=ptr->buffer_length)
  8574. +                ECALL(fd_copyout(ptr->data,
  8575. +                         ptr->kernel_data,
  8576. +                         ptr->buffer_length -
  8577. +                         ptr->length));
  8578. +        }
  8579. +        ptr = ptr->next;
  8580. +    }
  8581. +    return 0;
  8582. +}
  8583. +
  8584. +
  8585. +static void raw_cmd_free(struct floppy_raw_cmd **ptr)
  8586. +{
  8587. +    struct floppy_raw_cmd *next,*this;
  8588. +
  8589. +    this = *ptr;
  8590. +    *ptr = 0;
  8591. +    while(this) {
  8592. +        if (this->buffer_length) {
  8593. +            fd_dma_mem_free((unsigned long)this->kernel_data,
  8594. +                    this->buffer_length);
  8595. +            this->buffer_length = 0;
  8596. +        }
  8597. +        next = this->next;
  8598. +        kfree(this);
  8599. +        this = next;
  8600. +    }
  8601. +}
  8602. +
  8603. +
  8604. +static inline int raw_cmd_copyin(int cmd, char *param,
  8605. +                 struct floppy_raw_cmd **rcmd)
  8606. +{
  8607. +    struct floppy_raw_cmd *ptr;
  8608. +    struct old_floppy_raw_cmd old_raw_cmd;
  8609. +    int ret;
  8610. +    int i;
  8611. +
  8612. +    *rcmd = 0;
  8613. +    while(1) {
  8614. +        ptr = (struct floppy_raw_cmd *)
  8615. +            kmalloc(sizeof (struct floppy_raw_cmd ), GFP_USER);
  8616. +        if (!ptr)
  8617. +            return -ENOMEM;
  8618. +        *rcmd = ptr;
  8619. +        if(cmd == OLDFDRAWCMD){
  8620. +            COPYIN(old_raw_cmd);
  8621. +            ptr->flags = old_raw_cmd.flags;
  8622. +            ptr->data = old_raw_cmd.data;
  8623. +            ptr->length = old_raw_cmd.length;
  8624. +            ptr->rate = old_raw_cmd.rate;
  8625. +            ptr->cmd_count = old_raw_cmd.cmd_count;
  8626. +            ptr->track = old_raw_cmd.track;
  8627. +            ptr->phys_length = 0;
  8628. +            ptr->next = 0;
  8629. +            ptr->buffer_length = 0;
  8630. +            memcpy(ptr->cmd, old_raw_cmd.cmd, 9);
  8631. +            param += sizeof(struct old_floppy_raw_cmd);
  8632. +            if(ptr->cmd_count > 9)
  8633. +                return -EINVAL;
  8634. +        } else {
  8635. +            COPYIN(*ptr);
  8636. +            ptr->next = 0;
  8637. +            ptr->buffer_length = 0;
  8638. +            param += sizeof(struct floppy_raw_cmd);
  8639. +            if (ptr->cmd_count > 33)
  8640. +                /* the command may now also take up the space
  8641. +                 * initially intended for the reply & the
  8642. +                 * reply count. Needed for long 82078 commands
  8643. +                 * such as RESTORE, which takes ... 17 command
  8644. +                 * bytes. Murphy's law #137: When you reserve
  8645. +                 * 16 bytes for a structure, you'll one day
  8646. +                 * discover that you really need 17...
  8647. +                 */
  8648. +                return -EINVAL;
  8649. +        }
  8650. +
  8651. +        for(i=0; i< 16; i++)
  8652. +            ptr->reply[i] = 0;
  8653. +        ptr->resultcode = 0;
  8654. +        ptr->kernel_data = 0;
  8655. +
  8656. +        if(ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
  8657. +            if (ptr->length <= 0)
  8658. +                return -EINVAL;
  8659. +            ptr->kernel_data =(char*)fd_dma_mem_alloc(ptr->length);
  8660. +            if(!ptr->kernel_data)
  8661. +                return -ENOMEM;
  8662. +            ptr->buffer_length = ptr->length;
  8663. +        }
  8664. +        if ( ptr->flags & FD_RAW_READ )
  8665. +            ECALL( verify_area( VERIFY_WRITE, ptr->data,
  8666. +                        ptr->length ));
  8667. +        if(ptr->flags & FD_RAW_WRITE)
  8668. +            ECALL(fd_copyin(ptr->data, ptr->kernel_data,
  8669. +                    ptr->length));
  8670. +        rcmd = & (ptr->next);
  8671. +        if( ! (ptr->flags & FD_RAW_MORE))
  8672. +            return 0;
  8673. +        ptr->rate &= 0x43;
  8674. +    }
  8675. +}
  8676. +
  8677. +
  8678. +static int raw_cmd_ioctl(int cmd, void *param)
  8679. +{
  8680. +    int drive, ret, ret2;
  8681. +    struct floppy_raw_cmd *my_raw_cmd;
  8682. +
  8683. +    if ( FDCS->rawcmd <= 1 )
  8684. +        FDCS->rawcmd = 1;
  8685. +    for ( drive= 0; drive < N_DRIVE; drive++){
  8686. +        if ( FDC(drive) != fdc)
  8687. +            continue;
  8688. +        if ( drive == current_drive ){
  8689. +            if ( UDRS->fd_ref > 1 ){
  8690. +                FDCS->rawcmd = 2;
  8691. +                break;
  8692. +            }
  8693. +        } else if ( UDRS->fd_ref ){
  8694. +            FDCS->rawcmd = 2;
  8695. +            break;
  8696. +        }
  8697. +    }
  8698. +
  8699. +    if(FDCS->reset)
  8700. +        return -EIO;
  8701. +
  8702. +    ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
  8703. +    if (ret) {
  8704. +        raw_cmd_free(&my_raw_cmd);
  8705. +        return ret;
  8706. +    }
  8707. +    
  8708. +    raw_cmd = my_raw_cmd;
  8709. +    cont = &raw_cmd_cont;
  8710. +    ret=wait_til_done(floppy_start,1);
  8711. +#ifdef DCL_DEBUG
  8712. +    if (DP->flags & FD_DEBUG){
  8713. +        DPRINT("calling disk change from raw_cmd ioctl\n");
  8714. +    }
  8715. +#endif
  8716. +
  8717. +    if (ret != -EINTR && FDCS->reset)
  8718. +        ret = -EIO;
  8719. +
  8720. +    DRS->track = NO_TRACK;
  8721. +
  8722. +    ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
  8723. +    if(!ret)
  8724. +        ret = ret2;
  8725. +    raw_cmd_free(&my_raw_cmd);
  8726. +    return ret;
  8727. +}
  8728. +
  8729. +static int invalidate_drive(kdev_t rdev)
  8730. +{
  8731. +    /* invalidate the buffer track to force a reread */
  8732. +    set_bit( DRIVE(rdev), &fake_change);
  8733. +    process_fd_request();
  8734. +    check_disk_change(rdev);
  8735. +    return 0;
  8736. +}
  8737. +
  8738. +
  8739. +static inline void clear_write_error(int drive)
  8740. +{
  8741. +    CLEARSTRUCT(UDRWE);
  8742. +}
  8743. +
  8744. +static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
  8745. +                int drive, int type, kdev_t device)
  8746. +{
  8747. +    int cnt;
  8748. +
  8749. +    /* sanity checking for parameters.*/
  8750. +    if (g->sect <= 0 ||
  8751. +        g->head <= 0 ||
  8752. +        g->track <= 0 ||
  8753. +        g->track > UDP->tracks>>STRETCH(g) ||
  8754. +        /* check if reserved bits are set */
  8755. +        (g->stretch&~(FD_STRETCH|FD_SWAPSIDES)) != 0)
  8756. +        return -EINVAL;
  8757. +    if (type) {
  8758. +        if (!suser())
  8759. +            return -EPERM;
  8760. +        LOCK_FDC(drive,1);
  8761. +        for (cnt = 0; cnt < N_DRIVE; cnt++){
  8762. +            if (ITYPE(drive_state[cnt].fd_device) == type &&
  8763. +                drive_state[cnt].fd_ref)
  8764. +                set_bit(drive, &fake_change);
  8765. +        }
  8766. +        floppy_type[type] = *g;
  8767. +        floppy_type[type].name="user format";
  8768. +        for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
  8769. +        floppy_sizes[cnt]= floppy_sizes[cnt+0x80]=
  8770. +                   floppy_type[type].size>>1;
  8771. +        process_fd_request();
  8772. +        for ( cnt = 0; cnt < N_DRIVE; cnt++){
  8773. +            if (ITYPE(drive_state[cnt].fd_device) == type &&
  8774. +                drive_state[cnt].fd_ref)
  8775. +                check_disk_change(
  8776. +                    MKDEV(FLOPPY_MAJOR,
  8777. +                          drive_state[cnt].fd_device));
  8778. +        }
  8779. +    } else {
  8780. +        LOCK_FDC(drive,1);
  8781. +        if ( cmd != FDDEFPRM )
  8782. +            /* notice a disk change immediately, else
  8783. +             * we loose our settings immediately*/
  8784. +            CALL(poll_drive(1, FD_RAW_NEED_DISK));
  8785. +            user_params[drive] = *g;
  8786. +            if (buffer_drive == drive)
  8787. +                SUPBOUND(buffer_max, user_params[drive].sect);
  8788. +            current_type[drive] = &user_params[drive];
  8789. +            floppy_sizes[drive] = user_params[drive].size >> 1;
  8790. +            if (cmd == FDDEFPRM)
  8791. +                DRS->keep_data = -1;
  8792. +            else
  8793. +                DRS->keep_data = 1;
  8794. +            /* invalidation. Invalidate only when needed, i.e.
  8795. +             * when there are already sectors in the buffer cache
  8796. +             * whose number will change. This is useful, because
  8797. +             * mtools often changes the geometry of the disk after
  8798. +             * looking at the boot block */
  8799. +            if (DRS->maxblock > user_params[drive].sect || DRS->maxtrack)
  8800. +                invalidate_drive(device);
  8801. +            else
  8802. +                process_fd_request();
  8803. +    }
  8804. +    return 0;
  8805. +}            
  8806. +            
  8807. +/* handle obsolete ioctl's */
  8808. +static struct translation_entry {
  8809. +    int newcmd;
  8810. +    int oldcmd;
  8811. +    int oldsize; /* size of 0x00xx-style ioctl. Reflects old structures, thus
  8812. +              * use numeric values. NO SIZEOFS */
  8813. +} translation_table[]= {
  8814. +    {FDCLRPRM,          0,  0},
  8815. +    {FDSETPRM,          1, 28},
  8816. +    {FDDEFPRM,          2, 28},
  8817. +    {FDGETPRM,          3, 28},
  8818. +    {FDMSGON,           4,  0},
  8819. +    {FDMSGOFF,          5,  0},
  8820. +    {FDFMTBEG,          6,  0},
  8821. +    {FDFMTTRK,          7, 12},
  8822. +    {FDFMTEND,          8,  0},
  8823. +    {FDSETEMSGTRESH,   10,  0},
  8824. +    {FDFLUSH,          11,  0},
  8825. +    {FDSETMAXERRS,     12, 20},
  8826. +    {OLDFDRAWCMD,      30,  0},
  8827. +    {FDGETMAXERRS,     14, 20},
  8828. +    {FDGETDRVTYP,      16, 16},
  8829. +    {FDSETDRVPRM,      20, 88},
  8830. +    {FDGETDRVPRM,      21, 88},
  8831. +    {FDGETDRVSTAT,     22, 52},
  8832. +    {FDPOLLDRVSTAT,    23, 52},
  8833. +    {FDRESET,          24,  0},
  8834. +    {FDGETFDCSTAT,     25, 40},
  8835. +    {FDWERRORCLR,      27,  0},
  8836. +    {FDWERRORGET,      28, 24},
  8837. +    {FDRAWCMD,          0,  0},
  8838. +    {FDEJECT,           0,  0},
  8839. +    {FDTWADDLE,        40,  0} };
  8840. +
  8841. +static inline int normalize_0x02xx_ioctl(int *cmd, int *size)
  8842. +{
  8843. +    int i;
  8844. +
  8845. +    for (i=0; i < ARRAY_SIZE(translation_table); i++) {
  8846. +        if ((*cmd & 0xffff) == (translation_table[i].newcmd & 0xffff)){
  8847. +            *size = _IOC_SIZE(*cmd);
  8848. +            *cmd = translation_table[i].newcmd;
  8849. +            if (*size > _IOC_SIZE(*cmd)) {
  8850. +                printk("ioctl not yet supported\n");
  8851. +                return -EFAULT;
  8852. +            }
  8853. +            return 0;
  8854. +        }
  8855. +    }
  8856. +    return -EINVAL;
  8857. +}
  8858. +
  8859. +static inline int xlate_0x00xx_ioctl(int *cmd, int *size)
  8860. +{
  8861. +    int i;
  8862. +    /* old ioctls' for kernels <= 1.3.33 */
  8863. +    /* When the next even release will come around, we'll start
  8864. +     * warning against these.
  8865. +     * When the next odd release will come around, we'll fail with
  8866. +     * -EINVAL */
  8867. +    if(strcmp(system_utsname.version, "1.4.0") >= 0)
  8868. +        printk("obsolete floppy ioctl %x\n", *cmd);
  8869. +    if((system_utsname.version[0] == '1' &&
  8870. +        strcmp(system_utsname.version, "1.5.0") >= 0) ||
  8871. +       (system_utsname.version[0] >= '2' &&
  8872. +        strcmp(system_utsname.version, "2.1.0") >= 0))
  8873. +        return -EINVAL;
  8874. +    for (i=0; i < ARRAY_SIZE(translation_table); i++) {
  8875. +        if (*cmd == translation_table[i].oldcmd) {
  8876. +            *size = translation_table[i].oldsize;
  8877. +            *cmd = translation_table[i].newcmd;
  8878. +            return 0;
  8879. +        }
  8880. +    }
  8881. +    return -EINVAL;
  8882. +}
  8883. +
  8884. +static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
  8885. +            unsigned long param)
  8886. +{
  8887. +#define IOCTL_MODE_BIT 8
  8888. +#define OPEN_WRITE_BIT 16
  8889. +#define IOCTL_ALLOWED (filp && (filp->f_mode & IOCTL_MODE_BIT))
  8890. +#define OUT(c,x) case c: outparam = (const char *) (x); break
  8891. +#define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
  8892. +
  8893. +    int i,drive,type;
  8894. +    kdev_t device;
  8895. +    int ret;
  8896. +    int size;
  8897. +    union inparam {
  8898. +        struct floppy_struct g; /* geometry */
  8899. +        struct format_descr f;
  8900. +        struct floppy_max_errors max_errors;
  8901. +        struct floppy_drive_params dp;
  8902. +    } inparam; /* parameters coming from user space */
  8903. +    const char *outparam; /* parameters passed back to user space */
  8904. +
  8905. +    device = inode->i_rdev;
  8906. +    switch (cmd) {
  8907. +        RO_IOCTLS(device,param);
  8908. +    }
  8909. +    type = TYPE(device);
  8910. +    drive = DRIVE(device);
  8911. +
  8912. +    /* convert compatibility eject ioctls into floppy eject ioctl.
  8913. +     * We do this in order to provide a means to eject floppy disks before
  8914. +     * installing the new fdutils package */
  8915. +    if(cmd == CDROMEJECT || /* CD-ROM eject */
  8916. +       cmd == 0x6470 /* SunOS floppy eject */) {
  8917. +           DPRINT("obsolete eject ioctl\n");
  8918. +           DPRINT("please use floppycontrol --eject\n");
  8919. +           cmd = FDEJECT;
  8920. +    }
  8921. +
  8922. +    /* convert the old style command into a new style command */
  8923. +    if ((cmd & 0xff00) == 0x0200) {
  8924. +        ECALL(normalize_0x02xx_ioctl(&cmd, &size));
  8925. +    } else if ((cmd & 0xff00) == 0x0000) {
  8926. +        ECALL(xlate_0x00xx_ioctl(&cmd, &size));
  8927. +    } else
  8928. +        return -EINVAL;
  8929. +
  8930. +    /* permission checks */
  8931. +    if (((cmd & 0x80) && !suser()) ||
  8932. +         ((cmd & 0x40) && !IOCTL_ALLOWED))
  8933. +        return -EPERM;
  8934. +
  8935. +    /* verify writability of result, and fail early */
  8936. +    if (_IOC_DIR(cmd) & _IOC_READ)
  8937. +        ECALL(verify_area(VERIFY_WRITE,(void *) param, size));
  8938. +
  8939. +    /* copyin */
  8940. +    CLEARSTRUCT(&inparam);
  8941. +    if (_IOC_DIR(cmd) & _IOC_WRITE)
  8942. +        ECALL(fd_copyin((void *)param, &inparam, size))
  8943. +
  8944. +    switch (cmd) {
  8945. +        case FDEJECT:
  8946. +            if (UDRS->fd_ref != 1)
  8947. +                /* somebody else has this drive open */
  8948. +                return -EBUSY;
  8949. +            LOCK_FDC(drive,1);
  8950. +
  8951. +            /* do the actual eject. Fails on
  8952. +             * non-Sparc architectures */
  8953. +            ret=fd_eject(UNIT(drive));
  8954. +
  8955. +            USETF(FD_DISK_CHANGED);
  8956. +            USETF(FD_VERIFY);
  8957. +            process_fd_request();
  8958. +            return ret;
  8959. +        case FDCLRPRM:
  8960. +            LOCK_FDC(drive,1);
  8961. +            current_type[drive] = NULL;
  8962. +            floppy_sizes[drive] = MAX_DISK_SIZE;
  8963. +            UDRS->keep_data = 0;
  8964. +            return invalidate_drive(device);
  8965. +        case FDSETPRM:
  8966. +        case FDDEFPRM:
  8967. +            return set_geometry(cmd, & inparam.g,
  8968. +                        drive, type, device);
  8969. +        case FDGETPRM:
  8970. +            LOCK_FDC(drive,1);
  8971. +            CALL(poll_drive(1,0));
  8972. +            process_fd_request();
  8973. +            if (type)
  8974. +                outparam = (char *) &floppy_type[type];
  8975. +            else
  8976. +                outparam = (char *) current_type[drive];
  8977. +            if(!outparam)
  8978. +                return -ENODEV;
  8979. +            break;
  8980. +
  8981. +        case FDMSGON:
  8982. +            UDP->flags |= FTD_MSG;
  8983. +            return 0;
  8984. +        case FDMSGOFF:
  8985. +            UDP->flags &= ~FTD_MSG;
  8986. +            return 0;
  8987. +
  8988. +        case FDFMTBEG:
  8989. +            LOCK_FDC(drive,1);
  8990. +            CALL(poll_drive(1, FD_RAW_NEED_DISK));
  8991. +            ret = UDRS->flags;
  8992. +            process_fd_request();
  8993. +            if(ret & FD_VERIFY)
  8994. +                return -ENODEV;
  8995. +            if(!(ret & FD_DISK_WRITABLE))
  8996. +                return -EROFS;
  8997. +            return 0;
  8998. +        case FDFMTTRK:
  8999. +            if (UDRS->fd_ref != 1)
  9000. +                return -EBUSY;
  9001. +            return do_format(device, &inparam.f);
  9002. +        case FDFMTEND:
  9003. +        case FDFLUSH:
  9004. +            LOCK_FDC(drive,1);
  9005. +            return invalidate_drive(device);
  9006. +
  9007. +        case FDSETEMSGTRESH:
  9008. +            UDP->max_errors.reporting =
  9009. +            (unsigned short) (param & 0x0f);
  9010. +            return 0;
  9011. +        OUT(FDGETMAXERRS, &UDP->max_errors);
  9012. +        IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
  9013. +
  9014. +        case FDGETDRVTYP:
  9015. +            outparam = drive_name(type,drive);
  9016. +            SUPBOUND(size,strlen(outparam)+1);
  9017. +            break;
  9018. +
  9019. +        IN(FDSETDRVPRM, UDP, dp);
  9020. +        OUT(FDGETDRVPRM, UDP);
  9021. +
  9022. +        case FDPOLLDRVSTAT:
  9023. +            LOCK_FDC(drive,1);
  9024. +            CALL(poll_drive(1, FD_RAW_NEED_DISK));
  9025. +            process_fd_request();
  9026. +            /* fall through */
  9027. +        OUT(FDGETDRVSTAT, UDRS);
  9028. +
  9029. +        case FDRESET:
  9030. +            return user_reset_fdc(drive, (int)param, 1);
  9031. +
  9032. +        OUT(FDGETFDCSTAT,UFDCS);
  9033. +
  9034. +        case FDWERRORCLR:
  9035. +            CLEARSTRUCT(UDRWE);
  9036. +            return 0;
  9037. +        OUT(FDWERRORGET,UDRWE);
  9038. +
  9039. +        case OLDFDRAWCMD:
  9040. +        case FDRAWCMD:
  9041. +            if (type)
  9042. +                return -EINVAL;
  9043. +            LOCK_FDC(drive,1);
  9044. +            set_floppy(device);
  9045. +            CALL(i = raw_cmd_ioctl(cmd,(void *) param));
  9046. +            process_fd_request();
  9047. +            return i;
  9048. +        
  9049. +        case FDTWADDLE:
  9050. +            LOCK_FDC(drive,1);
  9051. +            twaddle();
  9052. +            process_fd_request();
  9053. +            return 0;
  9054. +
  9055. +        default:
  9056. +            return -EINVAL;
  9057. +    }
  9058. +
  9059. +    if (_IOC_DIR(cmd) & _IOC_READ)
  9060. +        return fd_copyout((void *)param, outparam, size);
  9061. +    else
  9062. +        return 0;
  9063. +#undef IOCTL_ALLOWED
  9064. +#undef OUT
  9065. +#undef IN
  9066. +}
  9067. +
  9068. +static void config_types(void)
  9069. +{
  9070. +    int first=1;
  9071. +    int drive;
  9072. +
  9073. +    /* read drive info out of physical CMOS */
  9074. +    drive=0;
  9075. +    if (!UDP->cmos )
  9076. +        UDP->cmos= FLOPPY0_TYPE;
  9077. +    drive=1;
  9078. +    if (!UDP->cmos && FLOPPY1_TYPE)
  9079. +        UDP->cmos = FLOPPY1_TYPE;
  9080. +
  9081. +    /* XXX */
  9082. +    /* additional physical CMOS drive detection should go here */
  9083. +
  9084. +    for (drive=0; drive < N_DRIVE; drive++){
  9085. +        if (UDP->cmos >= 16)
  9086. +            UDP->cmos = 0;
  9087. +        if (UDP->cmos >= 0 && UDP->cmos <= NUMBER(default_drive_params))
  9088. +            memcpy((char *) UDP,
  9089. +                   (char *) (&default_drive_params[(int)UDP->cmos].params),
  9090. +                   sizeof(struct floppy_drive_params));
  9091. +        if (UDP->cmos){
  9092. +            if (first)
  9093. +                printk(KERN_INFO "Floppy drive(s): ");
  9094. +            else
  9095. +                printk(", ");
  9096. +            first=0;
  9097. +            if (UDP->cmos > 0 ){
  9098. +                allowed_drive_mask |= 1 << drive;
  9099. +                printk("fd%d is %s", drive,
  9100. +                    default_drive_params[(int)UDP->cmos].name);
  9101. +            } else
  9102. +                printk("fd%d is unknown type %d",drive,
  9103. +                       (unsigned int)UDP->cmos);
  9104. +        }
  9105. +    }
  9106. +    if(!first)
  9107. +        printk("\n");
  9108. +}
  9109. +
  9110. +static int floppy_read(struct inode * inode, struct file * filp,
  9111. +               char * buf, int count)
  9112. +{
  9113. +    int drive = DRIVE(inode->i_rdev);
  9114. +
  9115. +    check_disk_change(inode->i_rdev);
  9116. +    if (UTESTF(FD_DISK_CHANGED))
  9117. +        return -ENXIO;
  9118. +    return block_read(inode, filp, buf, count);
  9119. +}
  9120. +
  9121. +static int floppy_write(struct inode * inode, struct file * filp,
  9122. +                const char * buf, int count)
  9123. +{
  9124. +    int block;
  9125. +    int ret;
  9126. +    int drive = DRIVE(inode->i_rdev);
  9127. +
  9128. +    if (!UDRS->maxblock)
  9129. +        UDRS->maxblock=1;/* make change detectable */
  9130. +    check_disk_change(inode->i_rdev);
  9131. +    if (UTESTF(FD_DISK_CHANGED))
  9132. +        return -ENXIO;
  9133. +    if (!UTESTF(FD_DISK_WRITABLE))
  9134. +        return -EROFS;
  9135. +    block = (filp->f_pos + count) >> 9;
  9136. +    INFBOUND(UDRS->maxblock, block);
  9137. +    ret= block_write(inode, filp, buf, count);
  9138. +    return ret;
  9139. +}
  9140. +
  9141. +static void floppy_release(struct inode * inode, struct file * filp)
  9142. +{
  9143. +    int drive;
  9144. +
  9145. +    drive = DRIVE(inode->i_rdev);
  9146. +
  9147. +    if( !filp || (filp->f_mode & (2 | OPEN_WRITE_BIT)))
  9148. +        /* if the file is mounted OR (writable now AND writable at
  9149. +         * open time) Linus: Does this cover all cases? */
  9150. +        block_fsync(inode,filp);
  9151. +
  9152. +    if (UDRS->fd_ref < 0)
  9153. +        UDRS->fd_ref=0;
  9154. +    else if (!UDRS->fd_ref--) {
  9155. +        DPRINT("floppy_release with fd_ref == 0");
  9156. +        UDRS->fd_ref = 0;
  9157. +    }
  9158. +    floppy_release_irq_and_dma();
  9159. +}
  9160. +
  9161. +/*
  9162. + * floppy_open check for aliasing (/dev/fd0 can be the same as
  9163. + * /dev/PS0 etc), and disallows simultaneous access to the same
  9164. + * drive with different device numbers.
  9165. + */
  9166. +#define RETERR(x) do{floppy_release(inode,filp); return -(x);}while(0)
  9167. +
  9168. +static int floppy_open(struct inode * inode, struct file * filp)
  9169. +{
  9170. +    int drive;
  9171. +    int old_dev;
  9172. +    int try;
  9173. +    char *tmp;
  9174. +
  9175. +    if (!filp) {
  9176. +        DPRINT("Weird, open called with filp=0\n");
  9177. +        return -EIO;
  9178. +    }
  9179. +
  9180. +    drive = DRIVE(inode->i_rdev);
  9181. +    if (drive >= N_DRIVE ||
  9182. +        !( allowed_drive_mask & ( 1 << drive)) ||
  9183. +        fdc_state[FDC(drive)].version == FDC_NONE)
  9184. +        return -ENXIO;
  9185. +
  9186. +    if (TYPE(inode->i_rdev) >= NUMBER(floppy_type))
  9187. +        return -ENXIO;
  9188. +    old_dev = UDRS->fd_device;
  9189. +    if (UDRS->fd_ref && old_dev != MINOR(inode->i_rdev))
  9190. +        return -EBUSY;
  9191. +
  9192. +    if(!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)){
  9193. +        USETF(FD_DISK_CHANGED);
  9194. +        USETF(FD_VERIFY);
  9195. +    }
  9196. +
  9197. +    if(UDRS->fd_ref == -1 ||
  9198. +       (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
  9199. +        return -EBUSY;
  9200. +
  9201. +    if (floppy_grab_irq_and_dma())
  9202. +        return -EBUSY;
  9203. +
  9204. +    if (filp->f_flags & O_EXCL)
  9205. +        UDRS->fd_ref = -1;
  9206. +    else
  9207. +        UDRS->fd_ref++;
  9208. +
  9209. +    if (!floppy_track_buffer){
  9210. +        /* if opening an ED drive, reserve a big buffer,
  9211. +         * else reserve a small one */
  9212. +        if ((UDP->cmos == 6) || (UDP->cmos == 5))
  9213. +            try = 64; /* Only 48 actually useful */
  9214. +        else
  9215. +            try = 32; /* Only 24 actually useful */
  9216. +
  9217. +        tmp=(char *)fd_dma_mem_alloc(1024 * try);
  9218. +        if (!tmp) {
  9219. +            try >>= 1; /* buffer only one side */
  9220. +            INFBOUND(try, 16);
  9221. +            tmp= (char *)fd_dma_mem_alloc(1024*try);
  9222. +        }
  9223. +        if (!tmp) {
  9224. +            DPRINT("Unable to allocate DMA memory\n");
  9225. +            RETERR(ENXIO);
  9226. +        }
  9227. +        if (floppy_track_buffer)
  9228. +            fd_dma_mem_free((unsigned long)tmp,try*1024);
  9229. +        else {
  9230. +            buffer_min = buffer_max = -1;
  9231. +            floppy_track_buffer = tmp;
  9232. +            max_buffer_sectors = try;
  9233. +        }
  9234. +    }
  9235. +
  9236. +    UDRS->fd_device = MINOR(inode->i_rdev);
  9237. +    if (old_dev != -1 && old_dev != MINOR(inode->i_rdev)) {
  9238. +        if (buffer_drive == drive)
  9239. +            buffer_track = -1;
  9240. +        invalidate_buffers(MKDEV(FLOPPY_MAJOR,old_dev));
  9241. +    }
  9242. +
  9243. +    /* Allow ioctls if we have write-permissions even if read-only open */
  9244. +    if ((filp->f_mode & 2) || (permission(inode,2) == 0))
  9245. +        filp->f_mode |= IOCTL_MODE_BIT;
  9246. +    if (filp->f_mode & 2)
  9247. +        filp->f_mode |= OPEN_WRITE_BIT;
  9248. +
  9249. +    if (UFDCS->rawcmd == 1)
  9250. +           UFDCS->rawcmd = 2;
  9251. +
  9252. +    if (filp->f_flags & O_NDELAY)
  9253. +        return 0;
  9254. +    if (filp->f_mode & 3) {
  9255. +        UDRS->last_checked = 0;
  9256. +        check_disk_change(inode->i_rdev);
  9257. +        if (UTESTF(FD_DISK_CHANGED))
  9258. +            RETERR(ENXIO);
  9259. +    }
  9260. +    if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
  9261. +        RETERR(EROFS);
  9262. +    return 0;
  9263. +#undef RETERR
  9264. +}
  9265. +
  9266. +/*
  9267. + * Check if the disk has been changed or if a change has been faked.
  9268. + */
  9269. +static int check_floppy_change(kdev_t dev)
  9270. +{
  9271. +    int drive = DRIVE( dev );
  9272. +
  9273. +    if (MAJOR(dev) != MAJOR_NR) {
  9274. +        DPRINT("check_floppy_change: not a floppy\n");
  9275. +        return 0;
  9276. +    }
  9277. +
  9278. +    if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
  9279. +        return 1;
  9280. +
  9281. +    if (UDP->checkfreq < jiffies - UDRS->last_checked){
  9282. +        lock_fdc(drive,0);
  9283. +        poll_drive(0,0);
  9284. +        process_fd_request();
  9285. +    }
  9286. +
  9287. +    if(UTESTF(FD_DISK_CHANGED) ||
  9288. +       UTESTF(FD_VERIFY) ||
  9289. +       test_bit(drive, &fake_change) ||
  9290. +       (!TYPE(dev) && !current_type[drive]))
  9291. +        return 1;
  9292. +    return 0;
  9293. +}
  9294. +
  9295. +/* revalidate the floppy disk, i.e. trigger format autodetection by reading
  9296. + * the bootblock (block 0). "Autodetection" is also needed to check whether
  9297. + * there is a disk in the drive at all... Thus we also do it for fixed
  9298. + * geometry formats */
  9299. +static int floppy_revalidate(kdev_t dev)
  9300. +{
  9301. +#define NO_GEOM (!current_type[drive] && !TYPE(dev))
  9302. +    struct buffer_head * bh;
  9303. +    int drive=DRIVE(dev);
  9304. +    int cf;
  9305. +
  9306. +    if(UTESTF(FD_DISK_CHANGED) ||
  9307. +       UTESTF(FD_VERIFY) ||
  9308. +       test_bit(drive, &fake_change) ||
  9309. +       NO_GEOM){
  9310. +        lock_fdc(drive,0);
  9311. +        cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
  9312. +        if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)){
  9313. +            process_fd_request(); /* already done by another thread */
  9314. +            return 0;
  9315. +        }
  9316. +        UDRS->maxblock = 0;
  9317. +        UDRS->maxtrack = 0;
  9318. +        if (buffer_drive == drive)
  9319. +            buffer_track = -1;
  9320. +        clear_bit(drive, &fake_change);
  9321. +        UCLEARF(FD_DISK_CHANGED);
  9322. +        if (cf)
  9323. +            UDRS->generation++;
  9324. +        if (NO_GEOM){
  9325. +            /* auto-sensing */
  9326. +            int size = floppy_blocksizes[MINOR(dev)];
  9327. +            if (!size)
  9328. +                size = 1024;
  9329. +            if (!(bh = getblk(dev,0,size))){
  9330. +                process_fd_request();
  9331. +                return 1;
  9332. +            }
  9333. +            if ( bh && !buffer_uptodate(bh))
  9334. +                ll_rw_block(READ, 1, &bh);
  9335. +            process_fd_request();
  9336. +            wait_on_buffer(bh);
  9337. +            brelse(bh);
  9338. +            return 0;
  9339. +        }
  9340. +        if (cf)
  9341. +            poll_drive(0, FD_RAW_NEED_DISK);
  9342. +        process_fd_request();
  9343. +    }
  9344. +    return 0;
  9345. +}
  9346. +
  9347. +static struct file_operations floppy_fops = {
  9348. +    NULL,            /* lseek - default */
  9349. +    floppy_read,        /* read - general block-dev read */
  9350. +    floppy_write,        /* write - general block-dev write */
  9351. +    NULL,                   /* readdir - bad */
  9352. +    NULL,            /* select */
  9353. +    fd_ioctl,        /* ioctl */
  9354. +    NULL,            /* mmap */
  9355. +    floppy_open,        /* open */
  9356. +    floppy_release,        /* release */
  9357. +    block_fsync,        /* fsync */
  9358. +    NULL,            /* fasync */
  9359. +    check_floppy_change,    /* media_change */
  9360. +    floppy_revalidate,    /* revalidate */
  9361. +};
  9362. +
  9363. +/*
  9364. + * Floppy Driver initialization
  9365. + * =============================
  9366. + */
  9367. +
  9368. +/* Determine the floppy disk controller type */
  9369. +/* This routine was written by David C. Niemi */
  9370. +static char get_fdc_version(void)
  9371. +{
  9372. +    int r;
  9373. +
  9374. +    output_byte(FD_DUMPREGS);    /* 82072 and better know DUMPREGS */
  9375. +    if (FDCS->reset)
  9376. +        return FDC_NONE;
  9377. +    if ((r = result()) <= 0x00)
  9378. +        return FDC_NONE;    /* No FDC present ??? */
  9379. +    if ((r==1) && (reply_buffer[0] == 0x80)){
  9380. +        printk(KERN_INFO "FDC %d is an 8272A\n",fdc);
  9381. +        return FDC_8272A;    /* 8272a/765 don't know DUMPREGS */
  9382. +    }
  9383. +    if (r != 10) {
  9384. +        printk("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
  9385. +               fdc, r);
  9386. +        return FDC_UNKNOWN;
  9387. +    }
  9388. +
  9389. +    if(!fdc_configure()) {
  9390. +        printk(KERN_INFO "FDC %d is an 82072\n",fdc);
  9391. +        return FDC_82072;       /* 82072 doesn't know CONFIGURE */
  9392. +    }
  9393. +
  9394. +    output_byte(FD_PERPENDICULAR);
  9395. +    if(need_more_output() == MORE_OUTPUT) {
  9396. +        output_byte(0);
  9397. +    } else {
  9398. +        printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
  9399. +        return FDC_82072A;    /* 82072A as found on Sparcs. */
  9400. +    }
  9401. +
  9402. +    output_byte(FD_UNLOCK);
  9403. +    r = result();
  9404. +    if ((r == 1) && (reply_buffer[0] == 0x80)){
  9405. +        printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
  9406. +        return FDC_82077_ORIG;    /* Pre-1991 82077, doesn't know
  9407. +                     * LOCK/UNLOCK */
  9408. +    }
  9409. +    if ((r != 1) || (reply_buffer[0] != 0x00)) {
  9410. +        printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
  9411. +               fdc, r);
  9412. +        return FDC_UNKNOWN;
  9413. +    }
  9414. +    output_byte(FD_PARTID);
  9415. +    r = result();
  9416. +    if (r != 1) {
  9417. +        printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
  9418. +               fdc, r);
  9419. +        return FDC_UNKNOWN;
  9420. +    }
  9421. +    if (reply_buffer[0] == 0x80) {
  9422. +        printk(KERN_INFO "FDC %d is a post-1991 82077\n",fdc);
  9423. +        return FDC_82077;    /* Revised 82077AA passes all the tests */
  9424. +    }
  9425. +    switch (reply_buffer[0] >> 5) {
  9426. +        case 0x0:
  9427. +            /* Either a 82078-1 or a 82078SL running at 5Volt */
  9428. +            printk(KERN_INFO "FDC %d is an 82078.\n",fdc);
  9429. +            return FDC_82078;
  9430. +        case 0x1:
  9431. +            printk(KERN_INFO "FDC %d is a 44pin 82078\n",fdc);
  9432. +            return FDC_82078;
  9433. +        case 0x2:
  9434. +            printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
  9435. +            return FDC_S82078B;
  9436. +        case 0x3:
  9437. +            printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n", fdc);
  9438. +            return FDC_87306;
  9439. +        default:
  9440. +            printk(KERN_INFO "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
  9441. +                   fdc, reply_buffer[0] >> 5);
  9442. +            return FDC_82078_UNKN;
  9443. +    }
  9444. +} /* get_fdc_version */
  9445. +
  9446. +/* lilo configuration */
  9447. +
  9448. +/* we make the invert_dcl function global. One day, somebody might
  9449. + * want to centralize all thinkpad related options into one lilo option,
  9450. + * there are just so many thinkpad related quirks!
  9451. + */
  9452. +void floppy_invert_dcl(int *ints,int param)
  9453. +{
  9454. +    int i;
  9455. +
  9456. +    for (i=0; i < ARRAY_SIZE(default_drive_params); i++){
  9457. +        if (param)
  9458. +            default_drive_params[i].params.flags |= 0x80;
  9459. +        else
  9460. +            default_drive_params[i].params.flags &= ~0x80;
  9461. +    }
  9462. +    DPRINT("Configuring drives for inverted dcl\n");
  9463. +}
  9464. +
  9465. +static void daring(int *ints,int param)
  9466. +{
  9467. +    int i;
  9468. +
  9469. +    for (i=0; i < ARRAY_SIZE(default_drive_params); i++){
  9470. +        if (param){
  9471. +            default_drive_params[i].params.select_delay = 0;
  9472. +            default_drive_params[i].params.flags |= FD_SILENT_DCL_CLEAR;
  9473. +        } else {
  9474. +            default_drive_params[i].params.select_delay = 2*HZ/100;
  9475. +            default_drive_params[i].params.flags &= ~FD_SILENT_DCL_CLEAR;
  9476. +        }
  9477. +    }
  9478. +    DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
  9479. +}
  9480. +
  9481. +static void set_cmos(int *ints, int dummy)
  9482. +{
  9483. +    int current_drive=0;
  9484. +
  9485. +    if (ints[0] != 2) {
  9486. +        DPRINT("wrong number of parameters for cmos\n");
  9487. +        return;
  9488. +    }
  9489. +    current_drive = ints[1];
  9490. +    if (current_drive < 0 || current_drive >= 8) {
  9491. +        DPRINT("bad drive for set_cmos\n");
  9492. +        return;
  9493. +    }
  9494. +    if (current_drive >= 4 && !FDC2)
  9495. +        FDC2 = 0x370;
  9496. +    if (ints[2] <= 0 ||
  9497. +        (ints[2] >= NUMBER(default_drive_params) && ints[2] != 16)){
  9498. +        DPRINT("bad cmos code %d\n", ints[2]);
  9499. +        return;
  9500. +    }
  9501. +    DP->cmos = ints[2];
  9502. +    DPRINT("setting cmos code to %d\n", ints[2]);
  9503. +}
  9504. +
  9505. +static struct param_table {
  9506. +    const char *name;
  9507. +    void (*fn)(int *ints, int param);
  9508. +    int *var;
  9509. +    int def_param;
  9510. +} config_params[]={
  9511. +    { "allowed_drive_mask", 0, &allowed_drive_mask, 0xff },
  9512. +    { "all_drives", 0, &allowed_drive_mask, 0xff },
  9513. +    { "asus_pci", 0, &allowed_drive_mask, 0x33 },
  9514. +
  9515. +    { "daring", daring, 0, 1 },
  9516. +
  9517. +    { "two_fdc", 0, &FDC2, 0x370 },
  9518. +    { "one_fdc", 0, &FDC2, 0 },
  9519. +
  9520. +    { "thinkpad", floppy_invert_dcl, 0, 1 },
  9521. +
  9522. +    { "nodma", 0, &use_virtual_dma, 1 },
  9523. +    { "omnibook", 0, &use_virtual_dma, 1 },
  9524. +    { "dma", 0, &use_virtual_dma, 0 },
  9525. +
  9526. +    { "fifo_depth", 0, &fifo_depth, 0xa },
  9527. +    { "nofifo", 0, &no_fifo, 0x20 },
  9528. +    { "usefifo", 0, &no_fifo, 0 },
  9529. +
  9530. +    { "cmos", set_cmos, 0, 0 },
  9531. +    
  9532. +    { "unexpected_interrupts", 0, &print_unex, 1 },
  9533. +    { "no_unexpected_interrupts", 0, &print_unex, 0 },
  9534. +    { "L40SX", 0, &print_unex, 0 } };
  9535. +
  9536. +#define FLOPPY_SETUP
  9537. +void floppy_setup(char *str, int *ints)
  9538. +{
  9539. +    int i;
  9540. +    int param;
  9541. +    if (str)
  9542. +        for (i=0; i< ARRAY_SIZE(config_params); i++){
  9543. +            if (strcmp(str,config_params[i].name) == 0){
  9544. +                if (ints[0])
  9545. +                    param = ints[1];
  9546. +                else
  9547. +                    param = config_params[i].def_param;
  9548. +                if(config_params[i].fn)
  9549. +                    config_params[i].fn(ints,param);
  9550. +                if(config_params[i].var) {
  9551. +                    DPRINT("%s=%d\n", str, param);
  9552. +                    *config_params[i].var = param;
  9553. +                }
  9554. +                return;
  9555. +            }
  9556. +        }
  9557. +    if (str) {
  9558. +        DPRINT("unknown floppy option [%s]\n", str);
  9559. +
  9560. +        DPRINT("allowed options are:");
  9561. +        for (i=0; i< ARRAY_SIZE(config_params); i++)
  9562. +            printk(" %s",config_params[i].name);
  9563. +        printk("\n");
  9564. +    } else
  9565. +        DPRINT("botched floppy option\n");
  9566. +    DPRINT("Read linux/arch/arm/drivers/block/README.fd\n");
  9567. +}
  9568. +
  9569. +int floppy_init(void)
  9570. +{
  9571. +    int i,unit,drive;
  9572. +    int have_no_fdc = -EIO;
  9573. +
  9574. +    raw_cmd = NULL;
  9575. +
  9576. +    if (register_blkdev(MAJOR_NR,"fd",&floppy_fops)) {
  9577. +        printk("Unable to get major %d for floppy\n",MAJOR_NR);
  9578. +        return -EBUSY;
  9579. +    }
  9580. +
  9581. +    for(i=0; i<256; i++)
  9582. +        if (ITYPE(i))
  9583. +            floppy_sizes[i] = floppy_type[ITYPE(i)].size >> 1;
  9584. +        else
  9585. +            floppy_sizes[i] = MAX_DISK_SIZE;
  9586. +
  9587. +    blk_size[MAJOR_NR] = floppy_sizes;
  9588. +    blksize_size[MAJOR_NR] = floppy_blocksizes;
  9589. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  9590. +    reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
  9591. +    config_types();
  9592. +
  9593. +    for (i = 0 ; i < N_FDC ; i++) {
  9594. +        fdc = i;
  9595. +        CLEARSTRUCT(FDCS);
  9596. +        FDCS->dtr = -1;
  9597. +        FDCS->dor = 0x4;
  9598. +    }
  9599. +
  9600. +    fdc_state[0].address = FDC1;
  9601. +#if N_FDC > 1
  9602. +    fdc_state[1].address = FDC2;
  9603. +#endif
  9604. +
  9605. +    if(floppy_grab_irq_and_dma()){
  9606. +        unregister_blkdev(MAJOR_NR,"fd");
  9607. +        return -EBUSY;
  9608. +    }
  9609. +
  9610. +    /* initialise drive state */
  9611. +    for (drive = 0; drive < N_DRIVE ; drive++) {
  9612. +        CLEARSTRUCT(UDRS);
  9613. +        CLEARSTRUCT(UDRWE);
  9614. +        UDRS->flags = FD_VERIFY | FD_DISK_NEWCHANGE | FD_DISK_CHANGED;
  9615. +        UDRS->fd_device = -1;
  9616. +        floppy_track_buffer = NULL;
  9617. +        max_buffer_sectors = 0;
  9618. +    }
  9619. +
  9620. +    for (i = 0 ; i < N_FDC ; i++) {
  9621. +        fdc = i;
  9622. +        FDCS->driver_version = FD_DRIVER_VERSION;
  9623. +        for(unit=0; unit<4; unit++)
  9624. +            FDCS->track[unit] = 0;
  9625. +        if (FDCS->address == -1 )
  9626. +            continue;
  9627. +        FDCS->rawcmd = 2;
  9628. +        if (user_reset_fdc(-1,FD_RESET_ALWAYS,0)){
  9629. +            FDCS->address = -1;
  9630. +            FDCS->version = FDC_NONE;
  9631. +            continue;
  9632. +        }
  9633. +        /* Try to determine the floppy controller type */
  9634. +        FDCS->version = get_fdc_version();
  9635. +        if (FDCS->version == FDC_NONE){
  9636. +            FDCS->address = -1;
  9637. +            continue;
  9638. +        }
  9639. +
  9640. +        request_region(FDCS->address, 6, "floppy");
  9641. +        request_region(FDCS->address+7, 1, "floppy DIR");
  9642. +        /* address + 6 is reserved, and may be taken by IDE.
  9643. +         * Unfortunately, Adaptec doesn't know this :-(, */
  9644. +
  9645. +        have_no_fdc = 0;
  9646. +        /* Not all FDCs seem to be able to handle the version command
  9647. +         * properly, so force a reset for the standard FDC clones,
  9648. +         * to avoid interrupt garbage.
  9649. +         */
  9650. +        user_reset_fdc(-1,FD_RESET_ALWAYS,0);
  9651. +    }
  9652. +    fdc=0;
  9653. +    del_timer(&fd_timeout);
  9654. +    current_drive = 0;
  9655. +    floppy_release_irq_and_dma();
  9656. +    initialising=0;
  9657. +    if (have_no_fdc) {
  9658. +        DPRINT("no floppy controllers found\n");
  9659. +        unregister_blkdev(MAJOR_NR,"fd");
  9660. +    }
  9661. +    return have_no_fdc;
  9662. +}
  9663. +
  9664. +static int floppy_grab_irq_and_dma(void)
  9665. +{
  9666. +    int i;
  9667. +    unsigned long flags;
  9668. +
  9669. +    INT_OFF;
  9670. +    if (usage_count++){
  9671. +        INT_ON;
  9672. +        return 0;
  9673. +    }
  9674. +    INT_ON;
  9675. +    MOD_INC_USE_COUNT;
  9676. +    for(i=0; i< N_FDC; i++){
  9677. +        if (fdc_state[i].address != -1){
  9678. +            fdc = i;
  9679. +            reset_fdc_info(1);
  9680. +            arm_set_dor(FDCS->dor);
  9681. +        }
  9682. +    }
  9683. +    fdc = 0;
  9684. +    set_dor(0, ~0, 8);  /* avoid immediate interrupt */
  9685. +
  9686. +    if (fd_request_irq()) {
  9687. +        DPRINT("Unable to grab IRQ%d for the floppy driver\n",
  9688. +            FLOPPY_IRQ);
  9689. +        MOD_DEC_USE_COUNT;
  9690. +        usage_count--;
  9691. +        return -1;
  9692. +    }
  9693. +    if (fd_request_dma()) {
  9694. +        DPRINT("Unable to grab DMA%d for the floppy driver\n",
  9695. +            FLOPPY_DMA);
  9696. +        fd_free_irq();
  9697. +        MOD_DEC_USE_COUNT;
  9698. +        usage_count--;
  9699. +        return -1;
  9700. +    }
  9701. +    for(fdc = 0; fdc < N_FDC ; fdc++)
  9702. +        if(FDCS->address != -1)
  9703. +            arm_set_dor(FDCS->dor);
  9704. +    fdc = 0;
  9705. +    fd_enable_irq();
  9706. +    return 0;
  9707. +}
  9708. +
  9709. +static void floppy_release_irq_and_dma(void)
  9710. +{
  9711. +#ifdef FLOPPY_SANITY_CHECK
  9712. +    int drive;
  9713. +#endif
  9714. +    long tmpsize;
  9715. +    unsigned long tmpaddr;
  9716. +    unsigned long flags;
  9717. +
  9718. +    INT_OFF;
  9719. +    if (--usage_count){
  9720. +        INT_ON;
  9721. +        return;
  9722. +    }
  9723. +    INT_ON;
  9724. +    fd_disable_dma();
  9725. +    fd_free_dma();
  9726. +    fd_disable_irq();
  9727. +    fd_free_irq();
  9728. +
  9729. +    set_dor(0, ~0, 8);
  9730. +#if N_FDC > 1
  9731. +    set_dor(1, ~8, 0);
  9732. +#endif
  9733. +    floppy_enable_hlt();
  9734. +
  9735. +    if (floppy_track_buffer && max_buffer_sectors) {
  9736. +        tmpsize = max_buffer_sectors*1024;
  9737. +        tmpaddr = (unsigned long)floppy_track_buffer;
  9738. +        floppy_track_buffer = NULL;
  9739. +        max_buffer_sectors = 0;
  9740. +        buffer_min = buffer_max = -1;
  9741. +        fd_dma_mem_free(tmpaddr, tmpsize);
  9742. +    }
  9743. +
  9744. +#ifdef FLOPPY_SANITY_CHECK
  9745. +    for(drive=0; drive < N_FDC * 4; drive++)
  9746. +        if( motor_off_timer[drive].next )
  9747. +            printk("motor off timer %d still active\n", drive);
  9748. +
  9749. +    if(fd_timeout.next)
  9750. +        printk("floppy timer still active:%s\n", timeout_message);
  9751. +    if (fd_timer.next)
  9752. +        printk("auxiliary floppy timer still active\n");
  9753. +    if(floppy_tq.sync)
  9754. +        printk("task queue still active\n");
  9755. +#endif
  9756. +    MOD_DEC_USE_COUNT;
  9757. +}
  9758. +
  9759. +
  9760. +#ifdef MODULE
  9761. +
  9762. +extern char *get_options(char *str, int *ints);
  9763. +
  9764. +char *floppy=NULL;
  9765. +
  9766. +static void parse_floppy_cfg_string(char *cfg)
  9767. +{
  9768. +    char *ptr;
  9769. +    int ints[11];
  9770. +
  9771. +    while(*cfg) {
  9772. +        for(ptr = cfg;*cfg && *cfg != ' ' && *cfg != '\t'; cfg++);
  9773. +        if(*cfg) {
  9774. +            *cfg = '\0';
  9775. +            cfg++;
  9776. +        }
  9777. +        if(*ptr)
  9778. +            floppy_setup(get_options(ptr,ints),ints);
  9779. +    }
  9780. +}
  9781. +
  9782. +static void mod_setup(char *pattern, void (*setup)(char *, int *))
  9783. +{
  9784. +    unsigned long i;
  9785. +    char c;
  9786. +    int j;
  9787. +    int match;
  9788. +    char buffer[100];
  9789. +    int ints[11];
  9790. +    int length = strlen(pattern)+1;
  9791. +
  9792. +    match=0;
  9793. +    j=1;
  9794. +
  9795. +    for(i=current->mm->env_start; i< current->mm->env_end; i ++){
  9796. +        c= get_fs_byte(i);
  9797. +        if(match){
  9798. +            if(j==99)
  9799. +                c='\0';
  9800. +            buffer[j] = c;
  9801. +            if(!c || c == ' ' || c == '\t'){
  9802. +                if(j){
  9803. +                    buffer[j] = '\0';
  9804. +                    setup(get_options(buffer,ints),ints);
  9805. +                }
  9806. +                j=0;
  9807. +            } else
  9808. +                j++;
  9809. +            if(!c)
  9810. +                break;
  9811. +            continue;
  9812. +        }
  9813. +        if( (!j && !c) || ( j && c == pattern[j-1]))
  9814. +            j++;
  9815. +        else
  9816. +            j=0;
  9817. +        if(j==length){
  9818. +            match=1;
  9819. +            j=0;
  9820. +        }
  9821. +    }
  9822. +}
  9823. +
  9824. +
  9825. +#ifdef __cplusplus
  9826. +extern "C" {
  9827. +#endif
  9828. +int init_module(void)
  9829. +{
  9830. +    printk(KERN_INFO "inserting floppy driver for %s\n", kernel_version);
  9831. +
  9832. +    if(floppy)
  9833. +        parse_floppy_cfg_string(floppy);
  9834. +    else
  9835. +        mod_setup("floppy=", floppy_setup);
  9836. +
  9837. +    return floppy_init();
  9838. +}
  9839. +
  9840. +void cleanup_module(void)
  9841. +{
  9842. +    int fdc, dummy;
  9843. +
  9844. +    for(fdc=0; fdc<2; fdc++)
  9845. +        if (FDCS->address != -1){
  9846. +            release_region(FDCS->address, 6);
  9847. +            release_region(FDCS->address+7, 1);
  9848. +        }
  9849. +
  9850. +    unregister_blkdev(MAJOR_NR, "fd");
  9851. +
  9852. +    blk_dev[MAJOR_NR].request_fn = 0;
  9853. +    /* eject disk, if any */
  9854. +    dummy = fd_eject(0);
  9855. +}
  9856. +
  9857. +#ifdef __cplusplus
  9858. +}
  9859. +#endif
  9860. +
  9861. +#else
  9862. +/* eject the boot floppy (if we need the drive for a different root floppy) */
  9863. +/* This should only be called at boot time when we're sure that there's no
  9864. + * resource contention. */
  9865. +void floppy_eject(void)
  9866. +{
  9867. +    int dummy;
  9868. +    floppy_grab_irq_and_dma();
  9869. +    lock_fdc(MAXTIMEOUT,0);
  9870. +    dummy=fd_eject(0);
  9871. +    process_fd_request();
  9872. +    floppy_release_irq_and_dma();
  9873. +}
  9874. +#endif
  9875. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/floppydma.S linux/arch/arm/drivers/block/floppydma.S
  9876. --- linux.orig/arch/arm/drivers/block/floppydma.S    Thu Jan  1 01:00:00 1970
  9877. +++ linux/arch/arm/drivers/block/floppydma.S    Sat Jun 22 21:55:21 1996
  9878. @@ -0,0 +1,74 @@
  9879. +/*
  9880. + * linux/arch/arm/lib/floppydma.S
  9881. + *
  9882. + * Copyright (C) 1995, 1996 Russell King
  9883. + */
  9884. +
  9885. +#include <asm/assembler.h>
  9886. +        .text
  9887. +
  9888. +LC0:        .word    _floppyfiq_len
  9889. +
  9890. +        .global    _floppy_fiqin_start
  9891. +        .global    _floppy_fiqin_end
  9892. +_floppy_fiqin_start:
  9893. +        subs    r9, r9, #1
  9894. +        ldrgtb    r12, [r11, #-4]
  9895. +        ldrleb    r12, [r11], #0
  9896. +        strb    r12, [r10], #1
  9897. +        subs    pc, lr, #4
  9898. +_floppy_fiqin_end:
  9899. +
  9900. +        .global    _floppy_fiqout_start
  9901. +        .global    _floppy_fiqout_end
  9902. +_floppy_fiqout_start:
  9903. +        subs    r9, r9, #1
  9904. +        ldrgeb    r12, [r10], #1
  9905. +        movlt    r12, #0
  9906. +        strleb    r12, [r11], #0
  9907. +        subles    pc, lr, #4
  9908. +        strb    r12, [r11, #-4]
  9909. +        subs    pc, lr, #4
  9910. +_floppy_fiqout_end:
  9911. +
  9912. +@ Params:
  9913. +@ r0 = length
  9914. +@ r1 = address
  9915. +@ r2 = floppy port
  9916. +@ Puts these into R9_fiq, R10_fiq, R11_fiq
  9917. +        .global    _floppy_fiqsetup
  9918. +_floppy_fiqsetup:
  9919. +        mov    ip, sp
  9920. +        stmfd    sp!, {fp, ip, lr, pc}
  9921. +        sub    fp, ip, #4
  9922. +        mov    r3, pc
  9923. +        teqp    pc, #0x0c000001        @ disable FIQs, IRQs, FIQ mode
  9924. +        mov    r0, r0            @ NOP
  9925. +        mov    r9, r0
  9926. +        mov    r10, r1
  9927. +        mov    r11, r2
  9928. +        teqp    r3, #0            @ back to normal
  9929. +        mov    r0, r0            @ NOP
  9930. +        ldmea    fp, {fp, sp, pc}^
  9931. +
  9932. +        .global    _floppy_fiqresidual
  9933. +_floppy_fiqresidual:
  9934. +        mov    ip, sp
  9935. +        stmfd    sp!, {fp, ip, lr, pc}
  9936. +        sub    fp, ip, #4
  9937. +        mov    r3, pc
  9938. +        teqp    pc, #0x0c000001        @ disable FIQs, IRQs, FIQ mode
  9939. +        mov    r0, r0            @ NOP
  9940. +        mov    r0, r9
  9941. +        teqp    r3, #0
  9942. +        mov    r0, r0            @ NOP
  9943. +        ldmea    fp, {fp, sp, pc}^
  9944. +        .data
  9945. +
  9946. +        .global    _floppyfiq_len
  9947. +        .global    _floppyfiq_to
  9948. +        .global    _floppyfiq_from
  9949. +
  9950. +_floppyfiq_len:    .word    0
  9951. +_floppyfiq_to:    .word    0
  9952. +_floppyfiq_from:    .word    0
  9953. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/genhd.c linux/arch/arm/drivers/block/genhd.c
  9954. --- linux.orig/arch/arm/drivers/block/genhd.c    Thu Jan  1 01:00:00 1970
  9955. +++ linux/arch/arm/drivers/block/genhd.c    Sun Aug 25 15:34:39 1996
  9956. @@ -0,0 +1,401 @@
  9957. +/*
  9958. + *  Code extracted from
  9959. + *  linux/kernel/hd.c
  9960. + *
  9961. + *  Copyright (C) 1991, 1992  Linus Torvalds
  9962. + *
  9963. + *
  9964. + *  Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
  9965. + *  in the early extended-partition checks and added DM partitions
  9966. + *
  9967. + *  Support for DiskManager v6.0x added by Mark Lord,
  9968. + *  with information provided by OnTrack.  This now works for linux fdisk
  9969. + *  and LILO, as well as loadlin and bootln.  Note that disks other than
  9970. + *  /dev/hda *must* have a "DOS" type 0x51 partition in the first slot (hda1).
  9971. + *
  9972. + *  More flexible handling of extended partitions - aeb, 950831
  9973. + *
  9974. + *  Modifications Copyright (C) 1995, 1996 Russell King
  9975. + *
  9976. + *  Origional from linux/drivers/genhd.c
  9977. + *
  9978. + *  Altered to find image files on ADFS-formatted hard drives.
  9979. + */
  9980. +
  9981. +#include <linux/config.h>
  9982. +#include <linux/fs.h>
  9983. +#include <linux/genhd.h>
  9984. +#include <linux/kernel.h>
  9985. +#include <linux/major.h>
  9986. +#include <linux/string.h>
  9987. +#ifdef CONFIG_BLK_DEV_INITRD
  9988. +#include <linux/blk.h>
  9989. +#endif
  9990. +
  9991. +#include <asm/system.h>
  9992. +
  9993. +/*
  9994. + * Many architectures don't like unaligned accesses, which is
  9995. + * frequently the case with the nr_sects and start_sect partition
  9996. + * table entries.
  9997. + */
  9998. +#include <asm/unaligned.h>
  9999. +
  10000. +#define SYS_IND(p)    get_unaligned(&p->sys_ind)
  10001. +#define NR_SECTS(p)    get_unaligned(&p->nr_sects)
  10002. +#define START_SECT(p)    get_unaligned(&p->start_sect)
  10003. +
  10004. +
  10005. +struct gendisk *gendisk_head;
  10006. +
  10007. +static int current_minor;
  10008. +extern int *blk_size[];
  10009. +extern void rd_load(void);
  10010. +extern void initrd_load(void);
  10011. +
  10012. +extern int chr_dev_init(void);
  10013. +extern int blk_dev_init(void);
  10014. +extern int scsi_dev_init(void);
  10015. +extern int net_dev_init(void);
  10016. +
  10017. +/*
  10018. + * disk_name() is used by genhd.c and md.c.
  10019. + * It formats the devicename of the indicated disk
  10020. + * into the supplied buffer, and returns a pointer
  10021. + * to that same buffer (for convenience).
  10022. + */
  10023. +char *disk_name (struct gendisk *hd, int minor, char *buf)
  10024. +{
  10025. +    unsigned int part;
  10026. +    const char *maj = hd->major_name;
  10027. +    char unit = (minor >> hd->minor_shift) + 'a';
  10028. +
  10029. +#ifdef CONFIG_BLK_DEV_IDE
  10030. +    /*
  10031. +     * IDE devices use multiple major numbers, but the drives
  10032. +     * are named as:  {hda,hdb}, {hdc,hdd}, {hde,hdf}, {hdg,hdh}..
  10033. +     * This requires special handling here.
  10034. +     */
  10035. +    switch (hd->major) {
  10036. +        case IDE3_MAJOR:
  10037. +            unit += 2;
  10038. +        case IDE2_MAJOR:
  10039. +            unit += 2;
  10040. +        case IDE1_MAJOR:
  10041. +            unit += 2;
  10042. +        case IDE0_MAJOR:
  10043. +            maj = "hd";
  10044. +    }
  10045. +#endif
  10046. +    part = minor & ((1 << hd->minor_shift) - 1);
  10047. +    if (part)
  10048. +        sprintf(buf, "%s%c%d", maj, unit, part);
  10049. +    else
  10050. +        sprintf(buf, "%s%c", maj, unit);
  10051. +    return buf;
  10052. +}
  10053. +
  10054. +void add_partition (struct gendisk *hd, int minor, int start, int size)
  10055. +{
  10056. +    char buf[8];
  10057. +    hd->part[minor].start_sect = start;
  10058. +    hd->part[minor].nr_sects   = size;
  10059. +    printk(" %s", disk_name(hd, minor, buf));
  10060. +}
  10061. +
  10062. +static inline int is_extended_partition(struct partition *p)
  10063. +{
  10064. +    return (SYS_IND(p) == DOS_EXTENDED_PARTITION ||
  10065. +        SYS_IND(p) == LINUX_EXTENDED_PARTITION);
  10066. +}
  10067. +
  10068. +#ifdef CONFIG_MSDOS_PARTITION
  10069. +/*
  10070. + * Create devices for each logical partition in an extended partition.
  10071. + * The logical partitions form a linked list, with each entry being
  10072. + * a partition table with two entries.  The first entry
  10073. + * is the real data partition (with a start relative to the partition
  10074. + * table start).  The second is a pointer to the next logical partition
  10075. + * (with a start relative to the entire extended partition).
  10076. + * We do not create a Linux partition for the partition tables, but
  10077. + * only for the actual data partitions.
  10078. + */
  10079. +
  10080. +static void extended_partition(struct gendisk *hd, kdev_t dev)
  10081. +{
  10082. +    struct buffer_head *bh;
  10083. +    struct partition *p;
  10084. +    unsigned long first_sector, first_size, this_sector, this_size;
  10085. +    int mask = (1 << hd->minor_shift) - 1;
  10086. +    int i;
  10087. +
  10088. +    first_sector = hd->part[MINOR(dev)].start_sect;
  10089. +    first_size = hd->part[MINOR(dev)].nr_sects;
  10090. +    this_sector = first_sector;
  10091. +
  10092. +    while (1) {
  10093. +        if ((current_minor & mask) == 0)
  10094. +            return;
  10095. +        if (!(bh = bread(dev,0,1024)))
  10096. +            return;
  10097. +      /*
  10098. +       * This block is from a device that we're about to stomp on.
  10099. +       * So make sure nobody thinks this block is usable.
  10100. +       */
  10101. +        bh->b_state = 0;
  10102. +
  10103. +        if (*(unsigned short *) (bh->b_data+510) != 0xAA55)
  10104. +            goto done;
  10105. +
  10106. +        p = (struct partition *) (0x1BE + bh->b_data);
  10107. +
  10108. +        this_size = hd->part[MINOR(dev)].nr_sects;
  10109. +
  10110. +        /*
  10111. +         * Usually, the first entry is the real data partition,
  10112. +         * the 2nd entry is the next extended partition, or empty,
  10113. +         * and the 3rd and 4th entries are unused.
  10114. +         * However, DRDOS sometimes has the extended partition as
  10115. +         * the first entry (when the data partition is empty),
  10116. +         * and OS/2 seems to use all four entries.
  10117. +         */
  10118. +
  10119. +        /* 
  10120. +         * First process the data partition(s)
  10121. +         */
  10122. +        for (i=0; i<4; i++, p++) {
  10123. +            if (!NR_SECTS(p) || is_extended_partition(p))
  10124. +              continue;
  10125. +
  10126. +            /* Check the 3rd and 4th entries -
  10127. +               these sometimes contain random garbage */
  10128. +            if (i >= 2
  10129. +            && START_SECT(p) + NR_SECTS(p) > this_size
  10130. +            && (this_sector + START_SECT(p) < first_sector ||
  10131. +                this_sector + START_SECT(p) + NR_SECTS(p) >
  10132. +                 first_sector + first_size))
  10133. +              continue;
  10134. +
  10135. +            add_partition(hd, current_minor, this_sector+START_SECT(p), NR_SECTS(p));
  10136. +            current_minor++;
  10137. +            if ((current_minor & mask) == 0)
  10138. +              goto done;
  10139. +        }
  10140. +        /*
  10141. +         * Next, process the (first) extended partition, if present.
  10142. +         * (So far, there seems to be no reason to make
  10143. +         *  extended_partition()  recursive and allow a tree
  10144. +         *  of extended partitions.)
  10145. +         * It should be a link to the next logical partition.
  10146. +         * Create a minor for this just long enough to get the next
  10147. +         * partition table.  The minor will be reused for the next
  10148. +         * data partition.
  10149. +         */
  10150. +        p -= 4;
  10151. +        for (i=0; i<4; i++, p++)
  10152. +          if(NR_SECTS(p) && is_extended_partition(p))
  10153. +            break;
  10154. +        if (i == 4)
  10155. +          goto done;     /* nothing left to do */
  10156. +
  10157. +        hd->part[current_minor].nr_sects = NR_SECTS(p);
  10158. +        hd->part[current_minor].start_sect = first_sector + START_SECT(p);
  10159. +        this_sector = first_sector + START_SECT(p);
  10160. +        dev = MKDEV(hd->major, current_minor);
  10161. +        brelse(bh);
  10162. +    }
  10163. +done:
  10164. +    brelse(bh);
  10165. +}
  10166. +
  10167. +static int msdos_partition(struct gendisk *hd, kdev_t dev, unsigned long first_sector)
  10168. +{
  10169. +    int i, minor = current_minor;
  10170. +    struct buffer_head *bh;
  10171. +    struct partition *p;
  10172. +    unsigned char *data;
  10173. +    int mask = (1 << hd->minor_shift) - 1;
  10174. +
  10175. +    if (!(bh = bread(dev,0,1024))) {
  10176. +        printk(" unable to read partition table\n");
  10177. +        return -1;
  10178. +    }
  10179. +    data = bh->b_data;
  10180. +    /* In some cases we modify the geometry    */
  10181. +    /*  of the drive (below), so ensure that   */ 
  10182. +    /*  nobody else tries to re-use this data. */
  10183. +    bh->b_state = 0;
  10184. +
  10185. +    if (*(unsigned short *)  (0x1fe + data) != 0xAA55) {
  10186. +        brelse(bh);
  10187. +        return 0;
  10188. +    }
  10189. +    printk (" [DOS]");
  10190. +    p = (struct partition *) (0x1be + data);
  10191. +
  10192. +    current_minor += 4;
  10193. +    for (i=1 ; i<=4 ; minor++, i++, p++) {
  10194. +        if(!NR_SECTS(p))
  10195. +            continue;
  10196. +        add_partition(hd, minor, first_sector+START_SECT(p), NR_SECTS(p));
  10197. +        if (is_extended_partition(p)) {
  10198. +            printk(" <");
  10199. +            /*
  10200. +             * If we are rereading the partition table, we need
  10201. +             * to set the size of the partition so that we will
  10202. +             * be able to bread the block containing the extended
  10203. +             * partition info.
  10204. +             */
  10205. +            hd->sizes[minor] = hd->part[minor].nr_sects
  10206. +                >> (BLOCK_SIZE_BITS - 9);
  10207. +            extended_partition(hd, MKDEV(hd->major, minor));
  10208. +            printk(" >");
  10209. +            /* prevent someone doing mkfs or mkswap on an
  10210. +               extended partition, but leave room for LILO */
  10211. +            if (hd->part[minor].nr_sects > 2)
  10212. +                hd->part[minor].nr_sects = 2;
  10213. +        }
  10214. +    }
  10215. +    /*
  10216. +     *  Check for old-style Disk Manager partition table
  10217. +     */
  10218. +    if (*(unsigned short *) (data+0xfc) == 0x55AA) {
  10219. +        p = (struct partition *) (0x1be + data);
  10220. +        for (i = 4 ; i < 16 ; i++, current_minor++) {
  10221. +            p--;
  10222. +            if ((current_minor & mask) == 0)
  10223. +                break;
  10224. +            if (!(START_SECT(p) && NR_SECTS(p)))
  10225. +                continue;
  10226. +            add_partition(hd, current_minor, START_SECT(p), NR_SECTS(p));
  10227. +        }
  10228. +    }
  10229. +    printk("\n");
  10230. +    brelse(bh);
  10231. +    return 1;
  10232. +}
  10233. +
  10234. +#endif /* CONFIG_MSDOS_PARTITION */
  10235. +
  10236. +extern int adfspart_initdev (struct gendisk *hd, kdev_t dev, int first_sector, int minor);
  10237. +
  10238. +static void check_partition(struct gendisk *hd, kdev_t dev)
  10239. +{
  10240. +    static int first_time = 1;
  10241. +    unsigned long first_sector;
  10242. +    char buf[8];
  10243. +
  10244. +    if (first_time)
  10245. +        printk("Partition check:\n");
  10246. +    first_time = 0;
  10247. +    first_sector = hd->part[MINOR(dev)].start_sect;
  10248. +
  10249. +    /*
  10250. +     * This is a kludge to allow the partition check to be
  10251. +     * skipped for specific drives (e.g. IDE cd-rom drives)
  10252. +     */
  10253. +    if ((int)first_sector == -1) {
  10254. +        hd->part[MINOR(dev)].start_sect = 0;
  10255. +        return;
  10256. +    }
  10257. +
  10258. +    printk(" %s:", disk_name(hd, MINOR(dev), buf));
  10259. +
  10260. +    if (adfspart_initdev (hd, dev, first_sector, current_minor))
  10261. +        return;
  10262. +
  10263. +#ifdef CONFIG_MSDOS_PARTITION
  10264. +    if (msdos_partition(hd, dev, first_sector))
  10265. +        return;
  10266. +#endif
  10267. +    printk(" unknown partition table\n");
  10268. +}
  10269. +
  10270. +/*
  10271. + * This function is used to re-read partition tables for removable disks.
  10272. + * Much of the cleanup from the old partition tables should have already been
  10273. + * done
  10274. + */
  10275. +
  10276. +/*
  10277. + * This function will re-read the partition tables for a given device,
  10278. + * and set things back up again.  There are some important caveats,
  10279. + * however.  You must ensure that no one is using the device, and no one
  10280. + * can start using the device while this function is being executed.
  10281. + */
  10282. +void resetup_one_dev(struct gendisk *dev, int drive)
  10283. +{
  10284. +    int i;
  10285. +    int first_minor    = drive << dev->minor_shift;
  10286. +    int end_minor    = first_minor + dev->max_p;
  10287. +
  10288. +    blk_size[dev->major] = NULL;
  10289. +    current_minor = 1 + first_minor;
  10290. +    check_partition(dev, MKDEV(dev->major, first_minor));
  10291. +
  10292. +    /*
  10293. +     * We need to set the sizes array before we will be able to access
  10294. +     * any of the partitions on this device.
  10295. +     */
  10296. +    if (dev->sizes != NULL) {    /* optional safeguard in ll_rw_blk.c */
  10297. +        for (i = first_minor; i < end_minor; i++)
  10298. +            dev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
  10299. +        blk_size[dev->major] = dev->sizes;
  10300. +    }
  10301. +}
  10302. +
  10303. +static void setup_dev(struct gendisk *dev)
  10304. +{
  10305. +    int i, drive;
  10306. +    int end_minor    = dev->max_nr * dev->max_p;
  10307. +
  10308. +    blk_size[dev->major] = NULL;
  10309. +    for (i = 0 ; i < end_minor; i++) {
  10310. +        dev->part[i].start_sect = 0;
  10311. +        dev->part[i].nr_sects = 0;
  10312. +    }
  10313. +    dev->init(dev);
  10314. +    for (drive=0 ; drive < dev->nr_real ; drive++) {
  10315. +        int first_minor = drive << dev->minor_shift;
  10316. +        current_minor = 1 + first_minor;
  10317. +        check_partition(dev, MKDEV(dev->major, first_minor));
  10318. +    }
  10319. +    if (dev->sizes != NULL) {    /* optional safeguard in ll_rw_blk.c */
  10320. +        for (i = 0; i < end_minor; i++)
  10321. +            dev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
  10322. +        blk_size[dev->major] = dev->sizes;
  10323. +    }
  10324. +}
  10325. +
  10326. +void device_setup(void)
  10327. +{
  10328. +    extern void console_map_init(void);
  10329. +    extern void adfsimg_init (void);
  10330. +    struct gendisk *p;
  10331. +    int nr=0;
  10332. +
  10333. +    chr_dev_init();
  10334. +    blk_dev_init();
  10335. +    sti();
  10336. +#ifdef CONFIG_SCSI
  10337. +    scsi_dev_init();
  10338. +#endif
  10339. +#ifdef CONFIG_INET
  10340. +    net_dev_init();
  10341. +#endif
  10342. +    console_map_init();
  10343. +#ifdef CONFIG_BLK_DEV_IMG
  10344. +    adfsimg_init ();
  10345. +#endif
  10346. +    for (p = gendisk_head ; p ; p=p->next) {
  10347. +        setup_dev(p);
  10348. +        nr += p->nr_real;
  10349. +    }
  10350. +#ifdef CONFIG_BLK_DEV_RAM
  10351. +#ifdef CONFIG_BLK_DEV_INITRD
  10352. +    if (initrd_start && mount_initrd) initrd_load();
  10353. +    else
  10354. +#endif
  10355. +    rd_load();
  10356. +#endif
  10357. +}
  10358. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/hd.c linux/arch/arm/drivers/block/hd.c
  10359. --- linux.orig/arch/arm/drivers/block/hd.c    Thu Jan  1 01:00:00 1970
  10360. +++ linux/arch/arm/drivers/block/hd.c    Tue Apr 23 23:18:07 1996
  10361. @@ -0,0 +1,1137 @@
  10362. +/*
  10363. + *  linux/arch/arm/drivers/block/hd.c
  10364. + *   [ origional file: linux/drivers/block/hd.c ]
  10365. + *
  10366. + *  Copyright (C) 1991, 1992  Linus Torvalds
  10367. + *  Modified 1995  Russell King for ARM processor.
  10368. + */
  10369. +
  10370. +/*
  10371. + * This is the low-level hd interrupt support. It traverses the
  10372. + * request-list, using interrupts to jump between functions. As
  10373. + * all the functions are called within interrupts, we may not
  10374. + * sleep. Special care is recommended.
  10375. + * 
  10376. + *  modified by Drew Eckhardt to check nr of hd's from the CMOS.
  10377. + *
  10378. + *  Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
  10379. + *  in the early extended-partition checks and added DM partitions
  10380. + *
  10381. + *  IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
  10382. + *  and general streamlining by mlord@bnr.ca (Mark Lord).
  10383. + */
  10384. +
  10385. +#define DEFAULT_MULT_COUNT  0    /* set to 0 to disable multiple mode at boot */
  10386. +#define DEFAULT_UNMASK_INTR 0    /* set to 0 to *NOT* unmask irq's more often */
  10387. +
  10388. +#include <asm/irq.h>
  10389. +#include <linux/errno.h>
  10390. +#include <linux/signal.h>
  10391. +#include <linux/sched.h>
  10392. +#include <linux/timer.h>
  10393. +#include <linux/fs.h>
  10394. +#include <linux/kernel.h>
  10395. +#include <linux/hdreg.h>
  10396. +#include <linux/genhd.h>
  10397. +#include <linux/malloc.h>
  10398. +#include <linux/string.h>
  10399. +#include <linux/ioport.h>
  10400. +
  10401. +#define REALLY_SLOW_IO
  10402. +#include <asm/system.h>
  10403. +#include <asm/io.h>
  10404. +#include <asm/segment.h>
  10405. +
  10406. +#define MAJOR_NR HD_MAJOR
  10407. +#include <linux/blk.h>
  10408. +
  10409. +#undef  HD_IRQ
  10410. +#define HD_IRQ 11
  10411. +
  10412. +static int revalidate_hddisk(kdev_t, int);
  10413. +
  10414. +#define    HD_DELAY    0
  10415. +
  10416. +#define MAX_ERRORS     16    /* Max read/write errors/sector */
  10417. +#define RESET_FREQ      8    /* Reset controller every 8th retry */
  10418. +#define RECAL_FREQ      4    /* Recalibrate every 4th retry */
  10419. +#define MAX_HD        2
  10420. +
  10421. +#define STAT_OK        (READY_STAT|SEEK_STAT)
  10422. +#define OK_STATUS(s)    (((s)&(STAT_OK|(BUSY_STAT|WRERR_STAT|ERR_STAT)))==STAT_OK)
  10423. +
  10424. +static void recal_intr(void);
  10425. +static void bad_rw_intr(void);
  10426. +
  10427. +static char recalibrate[MAX_HD] =;
  10428. +static char special_op[MAX_HD];
  10429. +static int access_count[MAX_HD];
  10430. +static char busy[MAX_HD];
  10431. +static struct wait_queue * busy_wait;
  10432. +
  10433. +static int reset;
  10434. +static int hd_error;
  10435. +
  10436. +/*
  10437. + *  This struct defines the HD's and their types.
  10438. + */
  10439. +struct hd_i_struct {
  10440. +    unsigned int head,sect,cyl,wpcom,lzone,ctl;
  10441. +    };
  10442. +static struct hd_driveid *hd_ident_info[MAX_HD];
  10443. +    
  10444. +#ifdef HD_TYPE
  10445. +static struct hd_i_struct hd_info[] = { HD_TYPE };
  10446. +struct hd_i_struct bios_info[] = { HD_TYPE };
  10447. +static int NR_HD = ((sizeof (hd_info))/(sizeof (struct hd_i_struct)));
  10448. +#else
  10449. +static struct hd_i_struct hd_info[];
  10450. +struct hd_i_struct bios_info[];
  10451. +static int NR_HD;
  10452. +#endif
  10453. +
  10454. +static struct hd_struct hd[MAX_HD<<6];
  10455. +static int hd_sizes[MAX_HD<<6];
  10456. +static int hd_blocksizes[MAX_HD<<6];
  10457. +static int hd_hardsectsizes[MAX_HD<<6];
  10458. +
  10459. +#if (HD_DELAY > 0)
  10460. +unsigned long last_req;
  10461. +
  10462. +unsigned long read_timer(void)
  10463. +{
  10464. +    unsigned long t, flags;
  10465. +    int i;
  10466. +
  10467. +    save_flags_cli (flags);
  10468. +    t = jiffies * 11932;
  10469. +        outb_p(0, 0x43);
  10470. +    i = inb_p(0x40);
  10471. +    i |= inb(0x40) << 8;
  10472. +    restore_flags(flags);
  10473. +    return(t - i);
  10474. +}
  10475. +#endif
  10476. +
  10477. +void hd_setup(char *str, int *ints)
  10478. +{
  10479. +    int hdind = 0;
  10480. +
  10481. +    if (ints[0] != 3)
  10482. +        return;
  10483. +    if (bios_info[0].head != 0)
  10484. +        hdind=1;
  10485. +    bios_info[hdind].head  = hd_info[hdind].head = ints[2];
  10486. +    bios_info[hdind].sect  = hd_info[hdind].sect = ints[3];
  10487. +    bios_info[hdind].cyl   = hd_info[hdind].cyl = ints[1];
  10488. +    bios_info[hdind].wpcom = hd_info[hdind].wpcom = 0;
  10489. +    bios_info[hdind].lzone = hd_info[hdind].lzone = ints[1];
  10490. +    bios_info[hdind].ctl   = hd_info[hdind].ctl = (ints[2] > 8 ? 8 : 0);
  10491. +    NR_HD = hdind+1;
  10492. +}
  10493. +
  10494. +static void dump_status (const char *msg, unsigned int stat)
  10495. +{
  10496. +    unsigned long flags;
  10497. +    char devc;
  10498. +
  10499. +    devc = CURRENT ? 'a' + DEVICE_NR(CURRENT->rq_dev) : '?';
  10500. +    save_flags (flags);
  10501. +    sti();
  10502. +    printk("hd%c: %s: status=0x%02x { ", devc, msg, stat & 0xff);
  10503. +    if (stat & BUSY_STAT)    printk("Busy ");
  10504. +    if (stat & READY_STAT)    printk("DriveReady ");
  10505. +    if (stat & WRERR_STAT)    printk("WriteFault ");
  10506. +    if (stat & SEEK_STAT)    printk("SeekComplete ");
  10507. +    if (stat & DRQ_STAT)    printk("DataRequest ");
  10508. +    if (stat & ECC_STAT)    printk("CorrectedError ");
  10509. +    if (stat & INDEX_STAT)    printk("Index ");
  10510. +    if (stat & ERR_STAT)    printk("Error ");
  10511. +    printk("}\n");
  10512. +    if ((stat & ERR_STAT) == 0) {
  10513. +        hd_error = 0;
  10514. +    } else {
  10515. +        hd_error = inb(HD_ERROR);
  10516. +        printk("hd%c: %s: error=0x%02x { ", devc, msg, hd_error & 0xff);
  10517. +        if (hd_error & BBD_ERR)        printk("BadSector ");
  10518. +        if (hd_error & ECC_ERR)        printk("UncorrectableError ");
  10519. +        if (hd_error & ID_ERR)        printk("SectorIdNotFound ");
  10520. +        if (hd_error & ABRT_ERR)    printk("DriveStatusError ");
  10521. +        if (hd_error & TRK0_ERR)    printk("TrackZeroNotFound ");
  10522. +        if (hd_error & MARK_ERR)    printk("AddrMarkNotFound ");
  10523. +        printk("}");
  10524. +        if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
  10525. +            printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
  10526. +                inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
  10527. +            if (CURRENT)
  10528. +                printk(", sector=%ld", CURRENT->sector);
  10529. +        }
  10530. +        printk("\n");
  10531. +    }
  10532. +    restore_flags (flags);
  10533. +}
  10534. +
  10535. +void check_status(void)
  10536. +{
  10537. +    int i = inb_p(HD_STATUS);
  10538. +
  10539. +    if (!OK_STATUS(i)) {
  10540. +        dump_status("check_status", i);
  10541. +        bad_rw_intr();
  10542. +    }
  10543. +}
  10544. +
  10545. +static int controller_busy(void)
  10546. +{
  10547. +    int retries = 100000;
  10548. +    unsigned char status;
  10549. +
  10550. +    do {
  10551. +        status = inb_p(HD_STATUS);
  10552. +    } while ((status & BUSY_STAT) && --retries);
  10553. +    return status;
  10554. +}
  10555. +
  10556. +static int status_ok(void)
  10557. +{
  10558. +    unsigned char status = inb_p(HD_STATUS);
  10559. +
  10560. +    if (status & BUSY_STAT)
  10561. +        return 1;    /* Ancient, but does it make sense??? */
  10562. +    if (status & WRERR_STAT)
  10563. +        return 0;
  10564. +    if (!(status & READY_STAT))
  10565. +        return 0;
  10566. +    if (!(status & SEEK_STAT))
  10567. +        return 0;
  10568. +    return 1;
  10569. +}
  10570. +
  10571. +static int controller_ready(unsigned int drive, unsigned int head)
  10572. +{
  10573. +    int retry = 100;
  10574. +
  10575. +    do {
  10576. +        if (controller_busy() & BUSY_STAT)
  10577. +            return 0;
  10578. +        outb_p(0xA0 | (drive<<4) | head, HD_CURRENT);
  10579. +        if (status_ok())
  10580. +            return 1;
  10581. +    } while (--retry);
  10582. +    return 0;
  10583. +}
  10584. +
  10585. +static void hd_out(unsigned int drive,unsigned int nsect,unsigned int sect,
  10586. +        unsigned int head,unsigned int cyl,unsigned int cmd,
  10587. +        void (*intr_addr)(void))
  10588. +{
  10589. +    unsigned short port;
  10590. +
  10591. +#if (HD_DELAY > 0)
  10592. +    while (read_timer() - last_req < HD_DELAY)
  10593. +        /* nothing */;
  10594. +#endif
  10595. +    if (reset)
  10596. +        return;
  10597. +    if (!controller_ready(drive, head)) {
  10598. +        reset = 1;
  10599. +        return;
  10600. +    }
  10601. +    SET_INTR(intr_addr);
  10602. +    outb_p(hd_info[drive].ctl,HD_CMD);
  10603. +    port=HD_DATA;
  10604. +    outb_p(hd_info[drive].wpcom>>2,++port);
  10605. +    outb_p(nsect,++port);
  10606. +    outb_p(sect,++port);
  10607. +    outb_p(cyl,++port);
  10608. +    outb_p(cyl>>8,++port);
  10609. +    outb_p(0xA0|(drive<<4)|head,++port);
  10610. +    outb_p(cmd,++port);
  10611. +}
  10612. +
  10613. +static void hd_request (void);
  10614. +static unsigned int identified  [MAX_HD]; /* 1 = drive ID already displayed   */
  10615. +static unsigned int unmask_intr [MAX_HD]; /* 1 = unmask IRQs during I/O       */
  10616. +static unsigned int max_mult    [MAX_HD]; /* max sectors for MultMode         */
  10617. +static unsigned int mult_req    [MAX_HD]; /* requested MultMode count         */
  10618. +static unsigned int mult_count  [MAX_HD]; /* currently enabled MultMode count */
  10619. +static struct request WCURRENT;
  10620. +
  10621. +static void fixstring (unsigned char *s, int bytecount)
  10622. +{
  10623. +    unsigned char *p, *end = &s[bytecount &= ~1];    /* bytecount must be even */
  10624. +
  10625. +    /* convert from big-endian to little-endian */
  10626. +    for (p = end ; p != s;) {
  10627. +        unsigned short *pp = (unsigned short *) (p -= 2);
  10628. +        *pp = (*pp >> 8) | (*pp << 8);
  10629. +    }
  10630. +
  10631. +    /* strip leading blanks */
  10632. +    while (s != end && *s == ' ')
  10633. +        ++s;
  10634. +
  10635. +    /* compress internal blanks and strip trailing blanks */
  10636. +    while (s != end && *s) {
  10637. +        if (*s++ != ' ' || (s != end && *s && *s != ' '))
  10638. +            *p++ = *(s-1);
  10639. +    }
  10640. +
  10641. +    /* wipe out trailing garbage */
  10642. +    while (p != end)
  10643. +        *p++ = '\0';
  10644. +}
  10645. +
  10646. +static void identify_intr(void)
  10647. +{
  10648. +    unsigned int dev = DEVICE_NR(CURRENT->rq_dev);
  10649. +    unsigned short stat = inb_p(HD_STATUS);
  10650. +    struct hd_driveid *id = hd_ident_info[dev];
  10651. +
  10652. +    if (unmask_intr[dev])
  10653. +        sti();
  10654. +    if (stat & (BUSY_STAT|ERR_STAT)) {
  10655. +        printk ("  hd%c: non-IDE device, %dMB, CHS=%d/%d/%d\n", dev+'a',
  10656. +            hd_info[dev].cyl*hd_info[dev].head*hd_info[dev].sect / 2048,
  10657. +            hd_info[dev].cyl, hd_info[dev].head, hd_info[dev].sect);
  10658. +        if (id != NULL) {
  10659. +            hd_ident_info[dev] = NULL;
  10660. +            kfree_s (id, 512);
  10661. +        }
  10662. +    } else {
  10663. +        insw(HD_DATA, id, 256); /* get ID info */
  10664. +        max_mult[dev] = id->max_multsect;
  10665. +        if ((id->field_valid&1) && id->cur_cyls && id->cur_heads && (id->cur_heads <= 16) && id->cur_sectors) {
  10666. +            /*
  10667. +             * Extract the physical drive geometry for our use.
  10668. +             * Note that we purposely do *not* update the bios_info.
  10669. +             * This way, programs that use it (like fdisk) will 
  10670. +             * still have the same logical view as the BIOS does,
  10671. +             * which keeps the partition table from being screwed.
  10672. +             */
  10673. +            hd_info[dev].cyl  = id->cur_cyls;
  10674. +            hd_info[dev].head = id->cur_heads;
  10675. +            hd_info[dev].sect = id->cur_sectors; 
  10676. +        }
  10677. +        fixstring (id->serial_no, sizeof(id->serial_no));
  10678. +        fixstring (id->fw_rev, sizeof(id->fw_rev));
  10679. +        fixstring (id->model, sizeof(id->model));
  10680. +        printk ("  hd%c: %.40s, %dMB w/%dKB Cache, CHS=%d/%d/%d, MaxMult=%d\n",
  10681. +            dev+'a', id->model, id->cyls*id->heads*id->sectors/2048,
  10682. +            id->buf_size/2, bios_info[dev].cyl, bios_info[dev].head,
  10683. +            bios_info[dev].sect, id->max_multsect);
  10684. +        /*
  10685. +         * Early model Quantum drives go weird at this point,
  10686. +         *   but doing a recalibrate seems to "fix" them.
  10687. +         * (Doing a full reset confuses some other model Quantums)
  10688. +         */
  10689. +        if (!strncmp(id->model, "QUANTUM", 7))
  10690. +            special_op[dev] = recalibrate[dev] = 1;
  10691. +    }
  10692. +#if (HD_DELAY > 0)
  10693. +    last_req = read_timer();
  10694. +#endif
  10695. +    hd_request();
  10696. +    return;
  10697. +}
  10698. +
  10699. +static void set_multmode_intr(void)
  10700. +{
  10701. +    unsigned int dev = DEVICE_NR(CURRENT->rq_dev), stat = inb_p(HD_STATUS);
  10702. +
  10703. +    if (unmask_intr[dev])
  10704. +        sti();
  10705. +    if (stat & (BUSY_STAT|ERR_STAT)) {
  10706. +        mult_req[dev] = mult_count[dev] = 0;
  10707. +        dump_status("set multmode failed", stat);
  10708. +    } else {
  10709. +        if ((mult_count[dev] = mult_req[dev]))
  10710. +            printk ("  hd%c: enabled %d-sector multiple mode\n",
  10711. +                dev+'a', mult_count[dev]);
  10712. +        else
  10713. +            printk ("  hd%c: disabled multiple mode\n", dev+'a');
  10714. +    }
  10715. +#if (HD_DELAY > 0)
  10716. +    last_req = read_timer();
  10717. +#endif
  10718. +    hd_request();
  10719. +    return;
  10720. +}
  10721. +
  10722. +static int drive_busy(void)
  10723. +{
  10724. +    unsigned int i;
  10725. +    unsigned char c;
  10726. +
  10727. +    for (i = 0; i < 500000 ; i++) {
  10728. +        c = inb_p(HD_STATUS);
  10729. +        if ((c & (BUSY_STAT | READY_STAT | SEEK_STAT)) == STAT_OK)
  10730. +            return 0;
  10731. +    }
  10732. +    dump_status("reset timed out", c);
  10733. +    return 1;
  10734. +}
  10735. +
  10736. +static void reset_controller(void)
  10737. +{
  10738. +    int    i;
  10739. +
  10740. +    outb_p(4,HD_CMD);
  10741. +    for(i = 0; i < 1000; i++) barrier();
  10742. +    outb_p(hd_info[0].ctl & 0x0f,HD_CMD);
  10743. +    for(i = 0; i < 1000; i++) barrier();
  10744. +    if (drive_busy())
  10745. +        printk("hd: controller still busy\n");
  10746. +    else if ((hd_error = inb(HD_ERROR)) != 1)
  10747. +        printk("hd: controller reset failed: %02x\n",hd_error);
  10748. +}
  10749. +
  10750. +static void reset_hd(void)
  10751. +{
  10752. +    static int i;
  10753. +
  10754. +repeat:
  10755. +    if (reset) {
  10756. +        reset = 0;
  10757. +        i = -1;
  10758. +        reset_controller();
  10759. +    } else {
  10760. +        check_status();
  10761. +        if (reset)
  10762. +            goto repeat;
  10763. +    }
  10764. +    if (++i < NR_HD) {
  10765. +        special_op[i] = recalibrate[i] = 1;
  10766. +        if (unmask_intr[i]) {
  10767. +            unmask_intr[i] = DEFAULT_UNMASK_INTR;
  10768. +            printk("hd%c: reset irq-unmasking to %d\n",i+'a',
  10769. +                DEFAULT_UNMASK_INTR);
  10770. +        }
  10771. +        if (mult_req[i] || mult_count[i]) {
  10772. +            mult_count[i] = 0;
  10773. +            mult_req[i] = DEFAULT_MULT_COUNT;
  10774. +            printk("hd%c: reset multiple mode to %d\n",i+'a',
  10775. +                DEFAULT_MULT_COUNT);
  10776. +        }
  10777. +        hd_out(i,hd_info[i].sect,hd_info[i].sect,hd_info[i].head-1,
  10778. +            hd_info[i].cyl,WIN_SPECIFY,&reset_hd);
  10779. +        if (reset)
  10780. +            goto repeat;
  10781. +    } else
  10782. +        hd_request();
  10783. +}
  10784. +
  10785. +/*
  10786. + * Ok, don't know what to do with the unexpected interrupts: on some machines
  10787. + * doing a reset and a retry seems to result in an eternal loop. Right now I
  10788. + * ignore it, and just set the timeout.
  10789. + *
  10790. + * On laptops (and "green" PCs), an unexpected interrupt occurs whenever the
  10791. + * drive enters "idle", "standby", or "sleep" mode, so if the status looks
  10792. + * "good", we just ignore the interrupt completely.
  10793. + */
  10794. +void unexpected_hd_interrupt(void)
  10795. +{
  10796. +    unsigned int stat = inb_p(HD_STATUS);
  10797. +
  10798. +    if (stat & (BUSY_STAT|DRQ_STAT|ECC_STAT|ERR_STAT)) {
  10799. +        dump_status ("unexpected interrupt", stat);
  10800. +        SET_TIMER;
  10801. +    }
  10802. +}
  10803. +
  10804. +/*
  10805. + * bad_rw_intr() now tries to be a bit smarter and does things
  10806. + * according to the error returned by the controller.
  10807. + * -Mika Liljeberg (liljeber@cs.Helsinki.FI)
  10808. + */
  10809. +static void bad_rw_intr(void)
  10810. +{
  10811. +    int dev;
  10812. +
  10813. +    if (!CURRENT)
  10814. +        return;
  10815. +    dev = DEVICE_NR(CURRENT->rq_dev);
  10816. +    if (++CURRENT->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
  10817. +        end_request(0);
  10818. +        special_op[dev] = recalibrate[dev] = 1;
  10819. +    } else if (CURRENT->errors % RESET_FREQ == 0)
  10820. +        reset = 1;
  10821. +    else if ((hd_error & TRK0_ERR) || CURRENT->errors % RECAL_FREQ == 0)
  10822. +        special_op[dev] = recalibrate[dev] = 1;
  10823. +    /* Otherwise just retry */
  10824. +}
  10825. +
  10826. +static inline int wait_DRQ(void)
  10827. +{
  10828. +    int retries = 100000, stat;
  10829. +
  10830. +    while (--retries > 0)
  10831. +        if ((stat = inb_p(HD_STATUS)) & DRQ_STAT)
  10832. +            return 0;
  10833. +    dump_status("wait_DRQ", stat);
  10834. +    return -1;
  10835. +}
  10836. +
  10837. +static void read_intr(void)
  10838. +{
  10839. +    unsigned int dev = DEVICE_NR(CURRENT->rq_dev);
  10840. +    int i, retries = 100000, msect = mult_count[dev], nsect;
  10841. +
  10842. +    if (unmask_intr[dev])
  10843. +        sti();            /* permit other IRQs during xfer */
  10844. +    do {
  10845. +        i = (unsigned) inb_p(HD_STATUS);
  10846. +        if (i & BUSY_STAT)
  10847. +            continue;
  10848. +        if (!OK_STATUS(i))
  10849. +            break;
  10850. +        if (i & DRQ_STAT)
  10851. +            goto ok_to_read;
  10852. +    } while (--retries > 0);
  10853. +    dump_status("read_intr", i);
  10854. +    bad_rw_intr();
  10855. +    hd_request();
  10856. +    return;
  10857. +ok_to_read:
  10858. +    if (msect) {
  10859. +        if ((nsect = CURRENT->current_nr_sectors) > msect)
  10860. +            nsect = msect;
  10861. +        msect -= nsect;
  10862. +    } else
  10863. +        nsect = 1;
  10864. +    insw(HD_DATA,CURRENT->buffer,nsect<<8);
  10865. +    CURRENT->sector += nsect;
  10866. +    CURRENT->buffer += nsect<<9;
  10867. +    CURRENT->errors = 0;
  10868. +    i = (CURRENT->nr_sectors -= nsect);
  10869. +
  10870. +#ifdef DEBUG
  10871. +    printk("hd%c: read: sectors(%ld-%ld), remaining=%ld, buffer=0x%08lx\n",
  10872. +        dev+'a', CURRENT->sector, CURRENT->sector+nsect,
  10873. +        CURRENT->nr_sectors, (unsigned long) CURRENT->buffer+(nsect<<9));
  10874. +#endif
  10875. +    if ((CURRENT->current_nr_sectors -= nsect) <= 0)
  10876. +        end_request(1);
  10877. +    if (i > 0) {
  10878. +        if (msect)
  10879. +            goto ok_to_read;
  10880. +        SET_INTR(&read_intr);
  10881. +        return;
  10882. +    }
  10883. +    (void) inb_p(HD_STATUS);
  10884. +#if (HD_DELAY > 0)
  10885. +    last_req = read_timer();
  10886. +#endif
  10887. +    if (CURRENT)
  10888. +        hd_request();
  10889. +    return;
  10890. +}
  10891. +
  10892. +static inline void multwrite (unsigned int dev)
  10893. +{
  10894. +    unsigned int mcount = mult_count[dev];
  10895. +
  10896. +    while (mcount--) {
  10897. +        outsw(HD_DATA,WCURRENT.buffer,256);
  10898. +        if (!--WCURRENT.nr_sectors)
  10899. +            return;
  10900. +        WCURRENT.buffer += 512;
  10901. +        if (!--WCURRENT.current_nr_sectors) {
  10902. +            WCURRENT.bh = WCURRENT.bh->b_reqnext;
  10903. +            if (WCURRENT.bh == NULL)
  10904. +                panic("buffer list corrupted\n");
  10905. +            WCURRENT.current_nr_sectors = WCURRENT.bh->b_size>>9;
  10906. +            WCURRENT.buffer             = WCURRENT.bh->b_data;
  10907. +        }
  10908. +    }
  10909. +}
  10910. +
  10911. +static void multwrite_intr(void)
  10912. +{
  10913. +    int i;
  10914. +    unsigned int dev = DEVICE_NR(WCURRENT.rq_dev);
  10915. +
  10916. +    if (unmask_intr[dev])
  10917. +        sti();
  10918. +    if (OK_STATUS(i=inb_p(HD_STATUS))) {
  10919. +        if (i & DRQ_STAT) {
  10920. +            if (WCURRENT.nr_sectors) {
  10921. +                multwrite(dev);
  10922. +                SET_INTR(&multwrite_intr);
  10923. +                return;
  10924. +            }
  10925. +        } else {
  10926. +            if (!WCURRENT.nr_sectors) {    /* all done? */
  10927. +                for (i = CURRENT->nr_sectors; i > 0;){
  10928. +                    i -= CURRENT->current_nr_sectors;
  10929. +                    end_request(1);
  10930. +                }
  10931. +#if (HD_DELAY > 0)
  10932. +                last_req = read_timer();
  10933. +#endif
  10934. +                if (CURRENT)
  10935. +                    hd_request();
  10936. +                return;
  10937. +            }
  10938. +        }
  10939. +    }
  10940. +    dump_status("multwrite_intr", i);
  10941. +    bad_rw_intr();
  10942. +    hd_request();
  10943. +}
  10944. +
  10945. +static void write_intr(void)
  10946. +{
  10947. +    int i;
  10948. +    int retries = 100000;
  10949. +
  10950. +    if (unmask_intr[DEVICE_NR(WCURRENT.rq_dev)])
  10951. +        sti();
  10952. +    do {
  10953. +        i = (unsigned) inb_p(HD_STATUS);
  10954. +        if (i & BUSY_STAT)
  10955. +            continue;
  10956. +        if (!OK_STATUS(i))
  10957. +            break;
  10958. +        if ((CURRENT->nr_sectors <= 1) || (i & DRQ_STAT))
  10959. +            goto ok_to_write;
  10960. +    } while (--retries > 0);
  10961. +    dump_status("write_intr", i);
  10962. +    bad_rw_intr();
  10963. +    hd_request();
  10964. +    return;
  10965. +ok_to_write:
  10966. +    CURRENT->sector++;
  10967. +    i = --CURRENT->nr_sectors;
  10968. +    --CURRENT->current_nr_sectors;
  10969. +    CURRENT->buffer += 512;
  10970. +    if (!i || (CURRENT->bh && !SUBSECTOR(i)))
  10971. +        end_request(1);
  10972. +    if (i > 0) {
  10973. +        SET_INTR(&write_intr);
  10974. +        outsw(HD_DATA,CURRENT->buffer,256);
  10975. +        sti();
  10976. +    } else {
  10977. +#if (HD_DELAY > 0)
  10978. +        last_req = read_timer();
  10979. +#endif
  10980. +        hd_request();
  10981. +    }
  10982. +    return;
  10983. +}
  10984. +
  10985. +static void recal_intr(void)
  10986. +{
  10987. +    check_status();
  10988. +#if (HD_DELAY > 0)
  10989. +    last_req = read_timer();
  10990. +#endif
  10991. +    hd_request();
  10992. +}
  10993. +
  10994. +/*
  10995. + * This is another of the error-routines I don't know what to do with. The
  10996. + * best idea seems to just set reset, and start all over again.
  10997. + */
  10998. +static void hd_times_out(void)
  10999. +{
  11000. +    unsigned int dev;
  11001. +
  11002. +    DEVICE_INTR = NULL;
  11003. +    if (!CURRENT)
  11004. +        return;
  11005. +    disable_irq(HD_IRQ);
  11006. +    sti();
  11007. +    reset = 1;
  11008. +    dev = DEVICE_NR(CURRENT->rq_dev);
  11009. +    printk("hd%c: timeout\n", dev+'a');
  11010. +    if (++CURRENT->errors >= MAX_ERRORS) {
  11011. +#ifdef DEBUG
  11012. +        printk("hd%c: too many errors\n", dev+'a');
  11013. +#endif
  11014. +        end_request(0);
  11015. +    }
  11016. +    cli();
  11017. +    hd_request();
  11018. +    enable_irq(HD_IRQ);
  11019. +}
  11020. +
  11021. +int do_special_op (unsigned int dev)
  11022. +{
  11023. +    if (recalibrate[dev]) {
  11024. +        recalibrate[dev] = 0;
  11025. +        hd_out(dev,hd_info[dev].sect,0,0,0,WIN_RESTORE,&recal_intr);
  11026. +        return reset;
  11027. +    }
  11028. +    if (!identified[dev]) {
  11029. +        identified[dev]  = 1;
  11030. +        unmask_intr[dev] = DEFAULT_UNMASK_INTR;
  11031. +        mult_req[dev]    = DEFAULT_MULT_COUNT;
  11032. +        hd_out(dev,0,0,0,0,WIN_IDENTIFY,&identify_intr);
  11033. +        return reset;
  11034. +    }
  11035. +    if (mult_req[dev] != mult_count[dev]) {
  11036. +        hd_out(dev,mult_req[dev],0,0,0,WIN_SETMULT,&set_multmode_intr);
  11037. +        return reset;
  11038. +    }
  11039. +    if (hd_info[dev].head > 16) {
  11040. +        printk ("hd%c: cannot handle device with more than 16 heads - giving up\n", dev+'a');
  11041. +        end_request(0);
  11042. +    }
  11043. +    special_op[dev] = 0;
  11044. +    return 1;
  11045. +}
  11046. +
  11047. +/*
  11048. + * The driver enables interrupts as much as possible.  In order to do this,
  11049. + * (a) the device-interrupt is disabled before entering hd_request(),
  11050. + * and (b) the timeout-interrupt is disabled before the sti().
  11051. + *
  11052. + * Interrupts are still masked (by default) whenever we are exchanging
  11053. + * data/cmds with a drive, because some drives seem to have very poor
  11054. + * tolerance for latency during I/O.  For devices which don't suffer from
  11055. + * that problem (most don't), the unmask_intr[] flag can be set to unmask
  11056. + * other interrupts during data/cmd transfers (by defining DEFAULT_UNMASK_INTR
  11057. + * to 1, or by using "hdparm -u1 /dev/hd?" from the shell).
  11058. + */
  11059. +static void hd_request(void)
  11060. +{
  11061. +    unsigned int dev, block, nsect, sec, track, head, cyl;
  11062. +
  11063. +    if (CURRENT && CURRENT->rq_status == RQ_INACTIVE) return;
  11064. +    if (DEVICE_INTR)
  11065. +        return;
  11066. +repeat:
  11067. +    timer_active &= ~(1<<HD_TIMER);
  11068. +    sti();
  11069. +    INIT_REQUEST;
  11070. +    if (reset) {
  11071. +        cli();
  11072. +        reset_hd();
  11073. +        return;
  11074. +    }
  11075. +    dev = MINOR(CURRENT->rq_dev);
  11076. +    block = CURRENT->sector;
  11077. +    nsect = CURRENT->nr_sectors;
  11078. +    if (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects || ((block+nsect) > hd[dev].nr_sects)) {
  11079. +#ifdef DEBUG
  11080. +        if (dev >= (NR_HD<<6))
  11081. +            printk("hd: bad minor number: device=%s\n",
  11082. +                   kdevname(CURRENT->rq_dev));
  11083. +        else
  11084. +            printk("hd%c: bad access: block=%d, count=%d\n",
  11085. +                (MINOR(CURRENT->rq_dev)>>6)+'a', block, nsect);
  11086. +#endif
  11087. +        end_request(0);
  11088. +        goto repeat;
  11089. +    }
  11090. +    block += hd[dev].start_sect;
  11091. +    dev >>= 6;
  11092. +    if (special_op[dev]) {
  11093. +        if (do_special_op(dev))
  11094. +            goto repeat;
  11095. +        return;
  11096. +    }
  11097. +    sec   = block % hd_info[dev].sect + 1;
  11098. +    track = block / hd_info[dev].sect;
  11099. +    head  = track % hd_info[dev].head;
  11100. +    cyl   = track / hd_info[dev].head;
  11101. +#ifdef DEBUG
  11102. +    printk("hd%c: %sing: CHS=%d/%d/%d, sectors=%d, buffer=0x%08lx\n",
  11103. +        dev+'a', (CURRENT->cmd == READ)?"read":"writ",
  11104. +        cyl, head, sec, nsect, (unsigned long) CURRENT->buffer);
  11105. +#endif
  11106. +    if (!unmask_intr[dev])
  11107. +        cli();
  11108. +    if (CURRENT->cmd == READ) {
  11109. +        unsigned int cmd = mult_count[dev] > 1 ? WIN_MULTREAD : WIN_READ;
  11110. +        hd_out(dev,nsect,sec,head,cyl,cmd,&read_intr);
  11111. +        if (reset)
  11112. +            goto repeat;
  11113. +        return;
  11114. +    }
  11115. +    if (CURRENT->cmd == WRITE) {
  11116. +printk ("hd%c: write disabled\n", (MINOR(CURRENT->rq_dev)>>6)+'a');
  11117. +end_request (0);
  11118. +goto repeat;
  11119. +        if (mult_count[dev])
  11120. +            hd_out(dev,nsect,sec,head,cyl,WIN_MULTWRITE,&multwrite_intr);
  11121. +        else
  11122. +            hd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr);
  11123. +        if (reset)
  11124. +            goto repeat;
  11125. +        if (wait_DRQ()) {
  11126. +            bad_rw_intr();
  11127. +            goto repeat;
  11128. +        }
  11129. +        if (mult_count[dev]) {
  11130. +            WCURRENT = *CURRENT;
  11131. +            multwrite(dev);
  11132. +        } else
  11133. +            outsw(HD_DATA,CURRENT->buffer,256);
  11134. +        return;
  11135. +    }
  11136. +    panic("unknown hd-command");
  11137. +}
  11138. +
  11139. +static void do_hd_request (void)
  11140. +{
  11141. +    disable_irq(HD_IRQ);
  11142. +    hd_request();
  11143. +    enable_irq(HD_IRQ);
  11144. +}
  11145. +
  11146. +static int hd_ioctl(struct inode * inode, struct file * file,
  11147. +    unsigned int cmd, unsigned long arg)
  11148. +{
  11149. +    struct hd_geometry *loc = (struct hd_geometry *) arg;
  11150. +    int dev, err;
  11151. +    unsigned long flags;
  11152. +
  11153. +    if ((!inode) || !(inode->i_rdev))
  11154. +        return -EINVAL;
  11155. +    dev = DEVICE_NR(inode->i_rdev);
  11156. +    if (dev >= NR_HD)
  11157. +        return -EINVAL;
  11158. +    switch (cmd) {
  11159. +        case HDIO_GETGEO:
  11160. +            if (!loc)  return -EINVAL;
  11161. +            err = verify_area(VERIFY_WRITE, loc, sizeof(*loc));
  11162. +            if (err)
  11163. +                return err;
  11164. +            put_user(bios_info[dev].head,
  11165. +                (char *) &loc->heads);
  11166. +            put_user(bios_info[dev].sect,
  11167. +                (char *) &loc->sectors);
  11168. +            put_user(bios_info[dev].cyl,
  11169. +                (short *) &loc->cylinders);
  11170. +            put_user(hd[MINOR(inode->i_rdev)].start_sect,
  11171. +                (long *) &loc->start);
  11172. +            return 0;
  11173. +        case BLKRASET:
  11174. +            if(!suser())  return -EACCES;
  11175. +            if(arg > 0xff) return -EINVAL;
  11176. +            read_ahead[MAJOR(inode->i_rdev)] = arg;
  11177. +            return 0;
  11178. +        case BLKRAGET:
  11179. +            if (!arg)  return -EINVAL;
  11180. +            err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  11181. +            if (err)
  11182. +                return err;
  11183. +            put_user(read_ahead[MAJOR(inode->i_rdev)],(long *) arg);
  11184. +            return 0;
  11185. +             case BLKGETSIZE:   /* Return device size */
  11186. +            if (!arg)  return -EINVAL;
  11187. +            err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  11188. +            if (err)
  11189. +                return err;
  11190. +            put_user(hd[MINOR(inode->i_rdev)].nr_sects, (long *) arg);
  11191. +            return 0;
  11192. +        case BLKFLSBUF:
  11193. +            if(!suser())  return -EACCES;
  11194. +            fsync_dev(inode->i_rdev);
  11195. +            invalidate_buffers(inode->i_rdev);
  11196. +            return 0;
  11197. +
  11198. +        case BLKRRPART: /* Re-read partition tables */
  11199. +            return revalidate_hddisk(inode->i_rdev, 1);
  11200. +
  11201. +        case HDIO_SET_UNMASKINTR:
  11202. +            if (!suser()) return -EACCES;
  11203. +            if ((arg > 1) || (MINOR(inode->i_rdev) & 0x3F))
  11204. +                return -EINVAL;
  11205. +            unmask_intr[dev] = arg;
  11206. +            return 0;
  11207. +
  11208. +                case HDIO_GET_UNMASKINTR:
  11209. +            if (!arg)  return -EINVAL;
  11210. +            err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  11211. +            if (err)
  11212. +                return err;
  11213. +            put_user(unmask_intr[dev], (long *) arg);
  11214. +            return 0;
  11215. +
  11216. +                case HDIO_GET_MULTCOUNT:
  11217. +            if (!arg)  return -EINVAL;
  11218. +            err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  11219. +            if (err)
  11220. +                return err;
  11221. +            put_user(mult_count[dev], (long *) arg);
  11222. +            return 0;
  11223. +
  11224. +        case HDIO_SET_MULTCOUNT:
  11225. +            if (!suser()) return -EACCES;
  11226. +            if (MINOR(inode->i_rdev) & 0x3F) return -EINVAL;
  11227. +            save_flags(flags);
  11228. +            cli();    /* a prior request might still be in progress */
  11229. +            if (arg > max_mult[dev])
  11230. +                err = -EINVAL;    /* out of range for device */
  11231. +            else if (mult_req[dev] != mult_count[dev]) {
  11232. +                special_op[dev] = 1;
  11233. +                err = -EBUSY;    /* busy, try again */
  11234. +            } else {
  11235. +                mult_req[dev] = arg;
  11236. +                special_op[dev] = 1;
  11237. +                err = 0;
  11238. +            }
  11239. +            restore_flags(flags);
  11240. +            return err;
  11241. +
  11242. +        case HDIO_GET_IDENTITY:
  11243. +            if (!arg)  return -EINVAL;
  11244. +            if (MINOR(inode->i_rdev) & 0x3F) return -EINVAL;
  11245. +            if (hd_ident_info[dev] == NULL)  return -ENOMSG;
  11246. +            err = verify_area(VERIFY_WRITE, (char *) arg, sizeof(struct hd_driveid));
  11247. +            if (err)
  11248. +                return err;
  11249. +            memcpy_tofs((char *)arg, (char *) hd_ident_info[dev], sizeof(struct hd_driveid));
  11250. +            return 0;
  11251. +
  11252. +        RO_IOCTLS(inode->i_rdev,arg);
  11253. +        default:
  11254. +            return -EINVAL;
  11255. +    }
  11256. +}
  11257. +
  11258. +static int hd_open(struct inode * inode, struct file * filp)
  11259. +{
  11260. +    int target;
  11261. +    target =  DEVICE_NR(inode->i_rdev);
  11262. +
  11263. +    if (target >= NR_HD)
  11264. +        return -ENODEV;
  11265. +    while (busy[target])
  11266. +        sleep_on(&busy_wait);
  11267. +    access_count[target]++;
  11268. +    return 0;
  11269. +}
  11270. +
  11271. +/*
  11272. + * Releasing a block device means we sync() it, so that it can safely
  11273. + * be forgotten about...
  11274. + */
  11275. +static void hd_release(struct inode * inode, struct file * file)
  11276. +{
  11277. +        int target;
  11278. +    sync_dev(inode->i_rdev);
  11279. +
  11280. +    target =  DEVICE_NR(inode->i_rdev);
  11281. +    access_count[target]--;
  11282. +
  11283. +}
  11284. +
  11285. +static void hd_geninit(struct gendisk *);
  11286. +
  11287. +static struct gendisk hd_gendisk = {
  11288. +    MAJOR_NR,    /* Major number */    
  11289. +    "hd",        /* Major name */
  11290. +    6,        /* Bits to shift to get real from partition */
  11291. +    1 << 6,        /* Number of partitions per real */
  11292. +    MAX_HD,        /* maximum number of real */
  11293. +    hd_geninit,    /* init function */
  11294. +    hd,        /* hd struct */
  11295. +    hd_sizes,    /* block sizes */
  11296. +    0,        /* number */
  11297. +    (void *) bios_info,    /* internal */
  11298. +    NULL        /* next */
  11299. +};
  11300. +    
  11301. +static void hd_interrupt(int irq, struct pt_regs *regs)
  11302. +{
  11303. +    void (*handler)(void) = DEVICE_INTR;
  11304. +
  11305. +    DEVICE_INTR = NULL;
  11306. +    timer_active &= ~(1<<HD_TIMER);
  11307. +    if (!handler)
  11308. +        handler = unexpected_hd_interrupt;
  11309. +    handler();
  11310. +    sti();
  11311. +}
  11312. +
  11313. +/*
  11314. + * Since we find out the physical drive geometry, we don't touch that.
  11315. + * We only alter the logical disk geometry that is passed to user programs.
  11316. + * [as per PC Linux].
  11317. + */
  11318. +void hd_set_geometry (kdev_t dev, unsigned char secspertrack, unsigned char heads,
  11319. +        unsigned long discsize, unsigned int secsize)
  11320. +{
  11321. +    int minor = MINOR(dev);
  11322. +    int drv = minor >> 6;
  11323. +
  11324. +    if (bios_info[drv].cyl == 1) {
  11325. +    bios_info[drv].cyl = discsize / (secspertrack * heads * secsize);
  11326. +    bios_info[drv].head = heads;
  11327. +    bios_info[drv].wpcom = -1;
  11328. +    bios_info[drv].ctl = 8;
  11329. +    bios_info[drv].lzone = bios_info[drv].cyl - 1;
  11330. +    bios_info[drv].sect = secspertrack;
  11331. +    }
  11332. +    hd[minor].start_sect = 0;
  11333. +    hd[minor].nr_sects = discsize / secsize;
  11334. +}
  11335. +
  11336. +/*
  11337. + * This is the harddisk IRQ description. The SA_INTERRUPT in sa_flags
  11338. + * means we run the IRQ-handler with interrupts disabled: this is bad for
  11339. + * interrupt latency, but anything else has led to problems on some
  11340. + * machines...
  11341. + *
  11342. + * We enable interrupts in some of the routines after making sure it's
  11343. + * safe.
  11344. + */
  11345. +static void hd_geninit(struct gendisk *dev)
  11346. +{
  11347. +    int i;
  11348. +
  11349. +    if (!NR_HD) {
  11350. +        int drive;
  11351. +        extern int number_ide_drives;
  11352. +        /*
  11353. +         * Default settings
  11354. +         *
  11355. +         * If we don't know anything about the drive, then set it
  11356. +         * so that we have enough to read the boot sector of the
  11357. +         * ADFS drive.  This means that you *MUST* specify the
  11358. +         * drive parameters of *all* drives if you have one IDE
  11359. +         * drive that is not ADFS formatted.
  11360. +         */
  11361. +        for (drive=0 ; drive<2 ; drive++) {
  11362. +            bios_info[drive].cyl   = hd_info[drive].cyl = 1;
  11363. +            bios_info[drive].head  = hd_info[drive].head = 1;
  11364. +            bios_info[drive].wpcom = hd_info[drive].wpcom = -1;
  11365. +            bios_info[drive].ctl   = hd_info[drive].ctl = 8;
  11366. +            bios_info[drive].lzone = hd_info[drive].lzone = 1;
  11367. +            bios_info[drive].sect  = hd_info[drive].sect = 17;
  11368. +        }
  11369. +
  11370. +        /*
  11371. +         * We only set this to the one that the host OS gave us
  11372. +         * if the user has not defined any types.
  11373. +         */
  11374. +        NR_HD = number_ide_drives;
  11375. +    }
  11376. +
  11377. +    i = NR_HD;
  11378. +    while (i-- > 0) {
  11379. +        /*
  11380. +         * The newer E-IDE BIOSs handle drives larger than 1024
  11381. +         * cylinders by increasing the number of logical heads
  11382. +         * to keep the number of logical cylinders below the
  11383. +         * sacred INT13 limit of 1024 (10 bits).  If that is
  11384. +         * what's happening here, we'll find out and correct
  11385. +         * it later when "identifying" the drive.
  11386. +         */
  11387. +        hd[i<<6].nr_sects = bios_info[i].head *
  11388. +                bios_info[i].sect * bios_info[i].cyl;
  11389. +        hd_ident_info[i] = (struct hd_driveid *) kmalloc(512,GFP_KERNEL);
  11390. +        special_op[i] = 1;
  11391. +    }
  11392. +    if (NR_HD) {
  11393. +        if (request_irq(HD_IRQ, hd_interrupt, SA_INTERRUPT, "hd")) {
  11394. +            printk("hd: unable to get IRQ%d for the harddisk driver\n",HD_IRQ);
  11395. +            NR_HD = 0;
  11396. +        } else {
  11397. +            request_region(HD_DATA, 8, "hd");
  11398. +            request_region(HD_CMD, 1, "hd(cmd)");
  11399. +        }
  11400. +    }
  11401. +    hd_gendisk.nr_real = NR_HD;
  11402. +
  11403. +    for (i = 0; i < (MAX_HD << 6); i++) {
  11404. +        hd_blocksizes[i] = 1024;
  11405. +        hd_hardsectsizes[i] = 512;
  11406. +    }
  11407. +    blksize_size[MAJOR_NR] = hd_blocksizes;
  11408. +    hardsect_size[MAJOR_NR] = hd_hardsectsizes;
  11409. +}
  11410. +
  11411. +static struct file_operations hd_fops = {
  11412. +    NULL,            /* lseek - default */
  11413. +    block_read,        /* read - general block-dev read */
  11414. +    block_write,        /* write - general block-dev write */
  11415. +    NULL,            /* readdir - bad */
  11416. +    NULL,            /* select */
  11417. +    hd_ioctl,        /* ioctl */
  11418. +    NULL,            /* mmap */
  11419. +    hd_open,        /* open */
  11420. +    hd_release,        /* release */
  11421. +    block_fsync        /* fsync */
  11422. +};
  11423. +
  11424. +int hd_init(void)
  11425. +{
  11426. +    if (register_blkdev(MAJOR_NR,"hd",&hd_fops)) {
  11427. +        printk("hd: unable to get major %d for harddisk\n",MAJOR_NR);
  11428. +        return -1;
  11429. +    }
  11430. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  11431. +    read_ahead[MAJOR_NR] = 8;        /* 8 sector (4kB) read-ahead */
  11432. +    hd_gendisk.next = gendisk_head;
  11433. +    gendisk_head = &hd_gendisk;
  11434. +    timer_table[HD_TIMER].fn = hd_times_out;
  11435. +    return 0;
  11436. +}
  11437. +
  11438. +#define DEVICE_BUSY busy[target]
  11439. +#define USAGE access_count[target]
  11440. +#define CAPACITY (bios_info[target].head*bios_info[target].sect*bios_info[target].cyl)
  11441. +/* We assume that the the bios parameters do not change, so the disk capacity
  11442. +   will not change */
  11443. +#undef MAYBE_REINIT
  11444. +#define GENDISK_STRUCT hd_gendisk
  11445. +
  11446. +/*
  11447. + * This routine is called to flush all partitions and partition tables
  11448. + * for a changed scsi disk, and then re-read the new partition table.
  11449. + * If we are revalidating a disk because of a media change, then we
  11450. + * enter with usage == 0.  If we are using an ioctl, we automatically have
  11451. + * usage == 1 (we need an open channel to use an ioctl :-), so this
  11452. + * is our limit.
  11453. + */
  11454. +static int revalidate_hddisk(kdev_t dev, int maxusage)
  11455. +{
  11456. +    int target;
  11457. +    struct gendisk * gdev;
  11458. +    int max_p;
  11459. +    int start;
  11460. +    int i;
  11461. +    long flags;
  11462. +
  11463. +    target = DEVICE_NR(dev);
  11464. +    gdev = &GENDISK_STRUCT;
  11465. +
  11466. +    save_flags_cli (flags);
  11467. +    if (DEVICE_BUSY || USAGE > maxusage) {
  11468. +        restore_flags(flags);
  11469. +        return -EBUSY;
  11470. +    };
  11471. +    DEVICE_BUSY = 1;
  11472. +    restore_flags(flags);
  11473. +
  11474. +    max_p = gdev->max_p;
  11475. +    start = target << gdev->minor_shift;
  11476. +
  11477. +    for (i=max_p - 1; i >=0 ; i--) {
  11478. +        int minor = start + i;
  11479. +        kdev_t devi = MKDEV(MAJOR_NR, minor);
  11480. +        sync_dev(devi);
  11481. +        invalidate_inodes(devi);
  11482. +        invalidate_buffers(devi);
  11483. +        gdev->part[minor].start_sect = 0;
  11484. +        gdev->part[minor].nr_sects = 0;
  11485. +    };
  11486. +
  11487. +#ifdef MAYBE_REINIT
  11488. +    MAYBE_REINIT;
  11489. +#endif
  11490. +
  11491. +    gdev->part[start].nr_sects = CAPACITY;
  11492. +    resetup_one_dev(gdev, target);
  11493. +
  11494. +    DEVICE_BUSY = 0;
  11495. +    wake_up(&busy_wait);
  11496. +    return 0;
  11497. +}
  11498. +
  11499. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/ide-ics.c linux/arch/arm/drivers/block/ide-ics.c
  11500. --- linux.orig/arch/arm/drivers/block/ide-ics.c    Thu Jan  1 01:00:00 1970
  11501. +++ linux/arch/arm/drivers/block/ide-ics.c    Sun Jun 16 19:37:45 1996
  11502. @@ -0,0 +1,88 @@
  11503. +/*
  11504. + * linux/arch/arm/drivers/block/ide-ics.c
  11505. + *
  11506. + * Copyright (c) 1996 Russell King.
  11507. + *
  11508. + * Changelog:
  11509. + *  08-06-1996    RMK    Created
  11510. + */
  11511. +
  11512. +#ifdef MODULE
  11513. +#include <linux/module.h>
  11514. +#include <linux/version.h>
  11515. +#endif
  11516. +#include <linux/errno.h>
  11517. +
  11518. +#include <asm/ecard.h>
  11519. +
  11520. +static const int icside_prods[] = {};
  11521. +static const int icside_manus[] = {};
  11522. +
  11523. +#ifndef MODULE
  11524. +
  11525. +int icside_init (void)
  11526. +{
  11527. +    struct expansion_card *ec;
  11528. +    unsigned long port;
  11529. +    int i;
  11530. +
  11531. +    while (1) {
  11532. +    if ((ec = ecard_find (0, sizeof (icside_prods) / sizeof (int), icside_prods, icside_manus))
  11533. +        == NULL)
  11534. +        break;
  11535. +
  11536. +    port = ((unsigned long)ecard_address (ec->slot_no, ECARD_MEMC, 0)) >> 2;
  11537. +
  11538. +    ecard_claim (ec);
  11539. +
  11540. +    i = ide_register_port (port, ec->irq, 16);
  11541. +    if (i < 0)
  11542. +        return i;
  11543. +    }
  11544. +    return 0;
  11545. +}
  11546. +
  11547. +#else
  11548. +static struct expansion_card *ec[MAX_ECARDS];
  11549. +
  11550. +int init_module (void)
  11551. +{
  11552. +    int i, j = 0;
  11553. +
  11554. +    for (i = 0; i < MAX_ECARDS; i++)
  11555. +    ec[i] = NULL;
  11556. +
  11557. +    while (1) {
  11558. +    unsigned long port;
  11559. +    if ((ec[j] = ecard_find (0, sizeof (icside_prods) / sizeof (int), icside_prods, icside_manus))
  11560. +        == NULL)
  11561. +        break;
  11562. +
  11563. +    port = ((unsigned long)ecard_address (ec[j]->slot_no, ECARD_MEMC, 0)) >> 2;
  11564. +
  11565. +    ecard_claim (ec[j]);
  11566. +
  11567. +    i = ide_register_port (port, ec[j]->irq, 16);
  11568. +    if (i < 0)
  11569. +        return i;
  11570. +    j ++;
  11571. +    }
  11572. +    return 0;
  11573. +}
  11574. +
  11575. +void cleanup_module (void)
  11576. +{
  11577. +    int i;
  11578. +    
  11579. +    for (i = 0; i < MAX_ECARDS; i++)
  11580. +    if (ec[i]) {
  11581. +        unsigned long port;
  11582. +        port = ((unsigned long)ecard_address (ec[i]->slot_no, ECARD_MEMC, 0)) >> 2;
  11583. +
  11584. +        ide_unregister_port (port, ec[i]->irq, 16);
  11585. +        ecard_release (ec[i]);
  11586. +        ec[i] = NULL;
  11587. +    }
  11588. +}
  11589. +#endif
  11590. +
  11591. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/ide.c linux/arch/arm/drivers/block/ide.c
  11592. --- linux.orig/arch/arm/drivers/block/ide.c    Thu Jan  1 01:00:00 1970
  11593. +++ linux/arch/arm/drivers/block/ide.c    Sat Aug 17 23:23:26 1996
  11594. @@ -0,0 +1,3384 @@
  11595. +/*
  11596. + *  linux/drivers/block/ide.c    Version 5.51  Aug  10, 1996
  11597. + *
  11598. + *  Copyright (C) 1994-1996  Linus Torvalds & authors (see below)
  11599. + */
  11600. +#define _IDE_C        /* needed by <linux/blk.h> */
  11601. +
  11602. +/*
  11603. + *  Maintained by Mark Lord  <mlord@pobox.com>
  11604. + *            and Gadi Oxman <gadio@netvision.net.il>
  11605. + *
  11606. + * This is the multiple IDE interface driver, as evolved from hd.c.
  11607. + * It supports up to four IDE interfaces, on one or more IRQs (usually 14 & 15).
  11608. + * There can be up to two drives per interface, as per the ATA-2 spec.
  11609. + *
  11610. + * Primary:    ide0, port 0x1f0; major=3;  hda is minor=0; hdb is minor=64
  11611. + * Secondary:  ide1, port 0x170; major=22; hdc is minor=0; hdd is minor=64
  11612. + * Tertiary:   ide2, port 0x???; major=33; hde is minor=0; hdf is minor=64
  11613. + * Quaternary: ide3, port 0x???; major=34; hdg is minor=0; hdh is minor=64
  11614. + *
  11615. + * It is easy to extend ide.c to handle more than four interfaces:
  11616. + *
  11617. + *    Change the MAX_HWIFS constant in ide.h.
  11618. + *
  11619. + *    Define some new major numbers (in major.h), and insert them into
  11620. + *    the ide_hwif_to_major table in ide.c.
  11621. + *
  11622. + *    Fill in the extra values for the new interfaces into the two tables
  11623. + *    inside ide.c:  default_io_base[]  and  default_irqs[].
  11624. + *
  11625. + *    Create the new request handlers by cloning "do_ide3_request()"
  11626. + *    for each new interface, and add them to the switch statement
  11627. + *    in the ide_init() function in ide.c.
  11628. + *
  11629. + *    Recompile, create the new /dev/ entries, and it will probably work.
  11630. + *
  11631. + *  From hd.c:
  11632. + *  |
  11633. + *  | It traverses the request-list, using interrupts to jump between functions.
  11634. + *  | As nearly all functions can be called within interrupts, we may not sleep.
  11635. + *  | Special care is recommended.  Have Fun!
  11636. + *  |
  11637. + *  | modified by Drew Eckhardt to check nr of hd's from the CMOS.
  11638. + *  |
  11639. + *  | Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
  11640. + *  | in the early extended-partition checks and added DM partitions.
  11641. + *  |
  11642. + *  | Early work on error handling by Mika Liljeberg (liljeber@cs.Helsinki.FI).
  11643. + *  |
  11644. + *  | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
  11645. + *  | and general streamlining by Mark Lord (mlord@pobox.com).
  11646. + *
  11647. + *  October, 1994 -- Complete line-by-line overhaul for linux 1.1.x, by:
  11648. + *
  11649. + *    Mark Lord    (mlord@pobox.com)        (IDE Perf.Pkg)
  11650. + *    Delman Lee    (delman@mipg.upenn.edu)        ("Mr. atdisk2")
  11651. + *    Scott Snyder    (snyder@fnald0.fnal.gov)    (ATAPI IDE cd-rom)
  11652. + *
  11653. + *  This was a rewrite of just about everything from hd.c, though some original
  11654. + *  code is still sprinkled about.  Think of it as a major evolution, with
  11655. + *  inspiration from lots of linux users, esp.  hamish@zot.apana.org.au
  11656. + *
  11657. + *  Version 1.0 ALPHA    initial code, primary i/f working okay
  11658. + *  Version 1.3 BETA    dual i/f on shared irq tested & working!
  11659. + *  Version 1.4 BETA    added auto probing for irq(s)
  11660. + *  Version 1.5 BETA    added ALPHA (untested) support for IDE cd-roms,
  11661. + *  ...
  11662. + *  Version 3.5        correct the bios_cyl field if it's too small
  11663. + *  (linux 1.1.76)     (to help fdisk with brain-dead BIOSs)
  11664. + *  Version 3.6        cosmetic corrections to comments and stuff
  11665. + *  (linux 1.1.77)    reorganise probing code to make it understandable
  11666. + *            added halfway retry to probing for drive identification
  11667. + *            added "hdx=noprobe" command line option
  11668. + *            allow setting multmode even when identification fails
  11669. + *  Version 3.7        move set_geometry=1 from do_identify() to ide_init()
  11670. + *            increase DRQ_WAIT to eliminate nuisance messages
  11671. + *            wait for DRQ_STAT instead of DATA_READY during probing
  11672. + *              (courtesy of Gary Thomas gary@efland.UU.NET)
  11673. + *  Version 3.8        fixed byte-swapping for confused Mitsumi cdrom drives
  11674. + *            update of ide-cd.c from Scott, allows blocksize=1024
  11675. + *            cdrom probe fixes, inspired by jprang@uni-duisburg.de
  11676. + *  Version 3.9        don't use LBA if lba_capacity looks funny
  11677. + *            correct the drive capacity calculations
  11678. + *            fix probing for old Seagates without IDE_ALTSTATUS_REG
  11679. + *            fix byte-ordering for some NEC cdrom drives
  11680. + *  Version 3.10    disable multiple mode by default; was causing trouble
  11681. + *  Version 3.11    fix mis-identification of old WD disks as cdroms
  11682. + *  Version 3,12    simplify logic for selecting initial mult_count
  11683. + *              (fixes problems with buggy WD drives)
  11684. + *  Version 3.13    remove excess "multiple mode disabled" messages
  11685. + *  Version 3.14    fix ide_error() handling of BUSY_STAT
  11686. + *            fix byte-swapped cdrom strings (again.. arghh!)
  11687. + *            ignore INDEX bit when checking the ALTSTATUS reg
  11688. + *  Version 3.15    add SINGLE_THREADED flag for use with dual-CMD i/f
  11689. + *            ignore WRERR_STAT for non-write operations
  11690. + *            added vlb_sync support for DC-2000A & others,
  11691. + *             (incl. some Promise chips), courtesy of Frank Gockel
  11692. + *  Version 3.16    convert vlb_32bit and vlb_sync into runtime flags
  11693. + *            add ioctls to get/set VLB flags (HDIO_[SG]ET_CHIPSET)
  11694. + *            rename SINGLE_THREADED to SUPPORT_SERIALIZE,
  11695. + *            add boot flag to "serialize" operation for CMD i/f
  11696. + *            add optional support for DTC2278 interfaces,
  11697. + *             courtesy of andy@cercle.cts.com (Dyan Wile).
  11698. + *            add boot flag to enable "dtc2278" probe
  11699. + *            add probe to avoid EATA (SCSI) interfaces,
  11700. + *             courtesy of neuffer@goofy.zdv.uni-mainz.de.
  11701. + *  Version 4.00    tidy up verify_area() calls - heiko@colossus.escape.de
  11702. + *            add flag to ignore WRERR_STAT for some drives
  11703. + *             courtesy of David.H.West@um.cc.umich.edu
  11704. + *            assembly syntax tweak to vlb_sync
  11705. + *            removable drive support from scuba@cs.tu-berlin.de
  11706. + *            add transparent support for DiskManager-6.0x "Dynamic
  11707. + *             Disk Overlay" (DDO), most of this is in genhd.c
  11708. + *            eliminate "multiple mode turned off" message at boot
  11709. + *  Version 4.10    fix bug in ioctl for "hdparm -c3"
  11710. + *            fix DM6:DDO support -- now works with LILO, fdisk, ...
  11711. + *            don't treat some naughty WD drives as removable
  11712. + *  Version 4.11    updated DM6 support using info provided by OnTrack
  11713. + *  Version 5.00    major overhaul, multmode setting fixed, vlb_sync fixed
  11714. + *            added support for 3rd/4th/alternative IDE ports
  11715. + *            created ide.h; ide-cd.c now compiles separate from ide.c
  11716. + *            hopefully fixed infinite "unexpected_intr" from cdroms
  11717. + *            zillions of other changes and restructuring
  11718. + *            somehow reduced overall memory usage by several kB
  11719. + *            probably slowed things down slightly, but worth it
  11720. + *  Version 5.01    AT LAST!!  Finally understood why "unexpected_intr"
  11721. + *             was happening at various times/places:  whenever the
  11722. + *             ide-interface's ctl_port was used to "mask" the irq,
  11723. + *             it also would trigger an edge in the process of masking
  11724. + *             which would result in a self-inflicted interrupt!!
  11725. + *             (such a stupid way to build a hardware interrupt mask).
  11726. + *             This is now fixed (after a year of head-scratching).
  11727. + *  Version 5.02    got rid of need for {enable,disable}_irq_list()
  11728. + *  Version 5.03    tune-ups, comments, remove "busy wait" from drive resets
  11729. + *            removed PROBE_FOR_IRQS option -- no longer needed
  11730. + *            OOOPS!  fixed "bad access" bug for 2nd drive on an i/f
  11731. + *  Version 5.04    changed "ira %d" to "irq %d" in DEBUG message
  11732. + *            added more comments, cleaned up unexpected_intr()
  11733. + *            OOOPS!  fixed null pointer problem in ide reset code
  11734. + *            added autodetect for Triton chipset -- no effect yet
  11735. + *  Version 5.05    OOOPS!  fixed bug in revalidate_disk()
  11736. + *            OOOPS!  fixed bug in ide_do_request()
  11737. + *            added ATAPI reset sequence for cdroms
  11738. + *  Version 5.10    added Bus-Mastered DMA support for Triton Chipset
  11739. + *            some (mostly) cosmetic changes
  11740. + *  Version 5.11    added ht6560b support by malafoss@snakemail.hut.fi
  11741. + *            reworked PCI scanning code
  11742. + *            added automatic RZ1000 detection/support
  11743. + *            added automatic PCI CMD640 detection/support
  11744. + *            added option for VLB CMD640 support
  11745. + *            tweaked probe to find cdrom on hdb with disks on hda,hdc
  11746. + *  Version 5.12    some performance tuning
  11747. + *            added message to alert user to bad /dev/hd[cd] entries
  11748. + *            OOOPS!  fixed bug in atapi reset
  11749. + *            driver now forces "serialize" again for all cmd640 chips
  11750. + *            noticed REALLY_SLOW_IO had no effect, moved it to ide.c
  11751. + *            made do_drive_cmd() into public ide_do_drive_cmd()
  11752. + *  Version 5.13    fixed typo ('B'), thanks to houston@boyd.geog.mcgill.ca
  11753. + *            fixed ht6560b support
  11754. + *  Version 5.13b (sss)    fix problem in calling ide_cdrom_setup()
  11755. + *            don't bother invalidating nonexistent partitions
  11756. + *  Version 5.14    fixes to cmd640 support.. maybe it works now(?)
  11757. + *            added & tested full EZ-DRIVE support -- don't use LILO!
  11758. + *            don't enable 2nd CMD640 PCI port during init - conflict
  11759. + *  Version 5.15    bug fix in init_cmd640_vlb()
  11760. + *            bug fix in interrupt sharing code
  11761. + *  Version 5.16    ugh.. fix "serialize" support, broken in 5.15
  11762. + *            remove "Huh?" from cmd640 code
  11763. + *            added qd6580 interface speed select from Colten Edwards
  11764. + *  Version 5.17    kludge around bug in BIOS32 on Intel triton motherboards
  11765. + *  Version 5.18    new CMD640 code, moved to cmd640.c, #include'd for now
  11766. + *            new UMC8672 code, moved to umc8672.c, #include'd for now
  11767. + *            disallow turning on DMA when h/w not capable of DMA
  11768. + *  Version 5.19    fix potential infinite timeout on resets
  11769. + *            extend reset poll into a general purpose polling scheme
  11770. + *            add atapi tape drive support from Gadi Oxman
  11771. + *            simplify exit from _intr routines -- no IDE_DO_REQUEST
  11772. + *  Version 5.20    leave current rq on blkdev request list during I/O
  11773. + *            generalized ide_do_drive_cmd() for tape/cdrom driver use
  11774. + *  Version 5.21    fix nasty cdrom/tape bug (ide_preempt was messed up)
  11775. + *  Version 5.22    fix ide_xlate_1024() to work with/without drive->id
  11776. + *  Version 5.23    miscellaneous touch-ups
  11777. + *  Version 5.24    fix #if's for SUPPORT_CMD640
  11778. + *  Version 5.25    more touch-ups, fix cdrom resets, ...
  11779. + *            cmd640.c now configs/compiles separate from ide.c
  11780. + *  Version 5.26    keep_settings now maintains the using_dma flag
  11781. + *            fix [EZD] remap message to only output at boot time
  11782. + *            fix "bad /dev/ entry" message to say hdc, not hdc0
  11783. + *            fix ide_xlate_1024() to respect user specified CHS
  11784. + *            use CHS from partn table if it looks translated
  11785. + *            re-merged flags chipset,vlb_32bit,vlb_sync into io_32bit
  11786. + *            keep track of interface chipset type, when known
  11787. + *            add generic PIO mode "tuneproc" mechanism
  11788. + *            fix cmd640_vlb option
  11789. + *            fix ht6560b support (was completely broken)
  11790. + *            umc8672.c now configures/compiles separate from ide.c
  11791. + *            move dtc2278 support to dtc2278.c
  11792. + *            move ht6560b support to ht6560b.c
  11793. + *            move qd6580  support to qd6580.c
  11794. + *            add  ali14xx support in ali14xx.c
  11795. + * Version 5.27        add [no]autotune parameters to help cmd640
  11796. + *            move rz1000  support to rz1000.c
  11797. + * Version 5.28        #include "ide_modes.h"
  11798. + *            fix disallow_unmask: now per-interface "no_unmask" bit
  11799. + *            force io_32bit to be the same on drive pairs of dtc2278
  11800. + *            improved IDE tape error handling, and tape DMA support
  11801. + *            bugfix in ide_do_drive_cmd() for cdroms + serialize
  11802. + * Version 5.29        fixed non-IDE check for too many physical heads
  11803. + *            don't use LBA if capacity is smaller than CHS
  11804. + * Version 5.30        remove real_devices kludge, formerly used by genhd.c
  11805. + * Version 5.32        change "KB" to "kB"
  11806. + *            fix serialize (was broken in kernel 1.3.72)
  11807. + *            add support for "hdparm -I"
  11808. + *            use common code for disk/tape/cdrom IDE_DRIVE_CMDs
  11809. + *            add support for Promise DC4030VL caching card
  11810. + *            improved serialize support
  11811. + *            put partition check back into alphabetical order
  11812. + *            add config option for PCMCIA baggage
  11813. + *            try to make PCMCIA support safer to use
  11814. + *            improve security on ioctls(): all are suser() only
  11815. + * Version 5.33        improve handling of HDIO_DRIVE_CMDs that read data
  11816. + * Version 5.34        fix irq-sharing problem from 5.33
  11817. + *            fix cdrom ioctl problem from 5.33
  11818. + * Version 5.35        cosmetic changes
  11819. + *            fix cli() problem in try_to_identify()
  11820. + * Version 5.36        fixes to optional PCMCIA support
  11821. + * Version 5.37        don't use DMA when "noautotune" is specified
  11822. + * Version 5.37a (go)    fix shared irq probing (was broken in kernel 1.3.72)
  11823. + *            call unplug_device() from ide_do_drive_cmd()
  11824. + * Version 5.38        add "hdx=none" option, courtesy of Joel Maslak
  11825. + *            mask drive irq after use, if sharing with another hwif
  11826. + *            add code to help debug weird cmd640 problems
  11827. + * Version 5.39        fix horrible error in earlier irq sharing "fix"
  11828. + * Version 5.40        fix serialization -- was broken in 5.39
  11829. + *            help sharing by masking device irq after probing
  11830. + * Version 5.41        more fixes to irq sharing/serialize detection
  11831. + *            disable io_32bit by default on drive reset
  11832. + * Version 5.42        simplify irq-masking after probe
  11833. + *            fix NULL pointer deref in save_match()
  11834. + * Version 5.43        Ugh.. unexpected_intr is back: try to exterminate it
  11835. + * Version 5.44        Fix for "irq probe failed" on cmd640
  11836. + *            change path on message regarding MAKEDEV.ide
  11837. + *            add a throttle to the unexpected_intr() messages
  11838. + * Version 5.45        fix ugly parameter parsing bugs (thanks Derek)
  11839. + *            include Gadi's magic fix for cmd640 unexpected_intr
  11840. + *            include mc68000 patches from Geert Uytterhoeven
  11841. + *            add Gadi's fix for PCMCIA cdroms
  11842. + * Version 5.46        remove the mc68000 #ifdefs for 2.0.x
  11843. + * Version 5.47        fix set_tune race condition
  11844. + *            fix bug in earlier PCMCIA cdrom update
  11845. + * Version 5.48        if def'd, invoke CMD640_DUMP_REGS when irq probe fails
  11846. + *            lengthen the do_reset1() pulse, for laptops
  11847. + *            add idebus=xx parameter for cmd640 and ali chipsets
  11848. + *            no_unmask flag now per-drive instead of per-hwif
  11849. + *            fix tune_req so that it gets done immediately
  11850. + *            fix missing restore_flags() in ide_ioctl
  11851. + *            prevent use of io_32bit on cmd640 with no prefetch
  11852. + * Version 5.49        fix minor quirks in probing routines
  11853. + * Version 5.50        allow values as small as 20 for idebus=
  11854. + * Version 5.51        force non io_32bit in drive_cmd_intr()
  11855. + *            change delay_10ms() to delay_50ms() to fix problems
  11856. + *
  11857. + *--------------------------------------------------------------------------------
  11858. + *  Ported to ARM architecture by Russell King (rmk92@ecs.soton.ac.uk)
  11859. + *--------------------------------------------------------------------------------
  11860. + *  Some additional driver compile-time options are in ide.h
  11861. + *
  11862. + *  To do, in likely order of completion:
  11863. + *    - modify kernel to obtain BIOS geometry for drives on 2nd/3rd/4th i/f
  11864. + */
  11865. +
  11866. +#undef REALLY_SLOW_IO        /* most systems can safely undef this */
  11867. +
  11868. +#include <linux/config.h>
  11869. +#include <linux/types.h>
  11870. +#include <linux/string.h>
  11871. +#include <linux/kernel.h>
  11872. +#include <linux/delay.h>
  11873. +#include <linux/timer.h>
  11874. +#include <linux/mm.h>
  11875. +#include <linux/ioport.h>
  11876. +#include <linux/interrupt.h>
  11877. +#include <linux/major.h>
  11878. +#include <linux/blkdev.h>
  11879. +#include <linux/errno.h>
  11880. +#include <linux/hdreg.h>
  11881. +#include <linux/genhd.h>
  11882. +#include <linux/malloc.h>
  11883. +
  11884. +#include <asm/byteorder.h>
  11885. +#include <asm/irq.h>
  11886. +#include <asm/segment.h>
  11887. +#include <asm/io.h>
  11888. +
  11889. +#ifdef CONFIG_PCI
  11890. +#include <linux/bios32.h>
  11891. +#include <linux/pci.h>
  11892. +#endif /* CONFIG_PCI */
  11893. +
  11894. +#include "ide.h"
  11895. +#include "ide_modes.h"
  11896. +
  11897. +#define IS_PROMISE_DRIVE (0)    /* auto-NULLs out Promise code */
  11898. +
  11899. +static const byte    ide_hwif_to_major[MAX_HWIFS] = {IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR};
  11900. +static const unsigned long default_io_base[MAX_HWIFS] = {0x1f0};
  11901. +static const byte    default_irqs[MAX_HWIFS]     = {11};
  11902. +static int    idebus_parameter; /* holds the "idebus=" parameter */
  11903. +static int    system_bus_speed; /* holds what we think is VESA/PCI bus speed */
  11904. +
  11905. +/*
  11906. + * This is declared extern in ide.h, for access by other IDE modules:
  11907. + */
  11908. +ide_hwif_t    ide_hwifs[MAX_HWIFS];    /* master data repository */
  11909. +
  11910. +#if (DISK_RECOVERY_TIME > 0)
  11911. +#error DISK_RECOVERY_TIME is not supported on the ARM.
  11912. +/*
  11913. + * For really screwy hardware (hey, at least it *can* be used with Linux)
  11914. + * we can enforce a minimum delay time between successive operations.
  11915. + */
  11916. +static unsigned long read_timer(void)
  11917. +{
  11918. +    unsigned long t, flags;
  11919. +    int i;
  11920. +
  11921. +    save_flags(flags);
  11922. +    cli();
  11923. +    t = jiffies * 11932;
  11924. +        outb_p(0, 0x43);
  11925. +    i = inb_p(0x40);
  11926. +    i |= inb(0x40) << 8;
  11927. +    restore_flags(flags);
  11928. +    return (t - i);
  11929. +}
  11930. +
  11931. +static void set_recovery_timer (ide_hwif_t *hwif)
  11932. +{
  11933. +    hwif->last_time = read_timer();
  11934. +}
  11935. +#define SET_RECOVERY_TIMER(drive) set_recovery_timer (drive)
  11936. +
  11937. +#else
  11938. +
  11939. +#define SET_RECOVERY_TIMER(drive)
  11940. +
  11941. +#endif /* DISK_RECOVERY_TIME */
  11942. +
  11943. +
  11944. +/*
  11945. + * Do not even *think* about calling this!
  11946. + */
  11947. +static void init_hwif_data (unsigned int index)
  11948. +{
  11949. +    byte *p;
  11950. +    unsigned int unit;
  11951. +    ide_hwif_t *hwif = &ide_hwifs[index];
  11952. +
  11953. +    /* bulk initialize hwif & drive info with zeros */
  11954. +    p = ((byte *) hwif) + sizeof(ide_hwif_t);
  11955. +    do {
  11956. +        *--p = 0;
  11957. +    } while (p > (byte *) hwif);
  11958. +
  11959. +    /* fill in any non-zero initial values */
  11960. +    hwif->index     = index;
  11961. +    hwif->noprobe    = (index > 1);
  11962. +    hwif->io.io_base    = default_io_base[index];
  11963. +    hwif->io.ctl_port    = hwif->io.io_base ? hwif->io.io_base+0x206 : 0x000;
  11964. +    hwif->io.io_size    = 1;
  11965. +#ifdef CONFIG_BLK_DEV_HD
  11966. +    if (hwif->io_base == HD_DATA)
  11967. +        hwif->noprobe = 1; /* may be overridden by ide_setup() */
  11968. +#endif /* CONFIG_BLK_DEV_HD */
  11969. +    hwif->major    = ide_hwif_to_major[index];
  11970. +    hwif->name[0]    = 'i';
  11971. +    hwif->name[1]    = 'd';
  11972. +    hwif->name[2]    = 'e';
  11973. +    hwif->name[3]    = '0' + index;
  11974. +#ifdef CONFIG_BLK_DEV_IDETAPE
  11975. +    hwif->tape_drive = NULL;
  11976. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  11977. +    for (unit = 0; unit < MAX_DRIVES; ++unit) {
  11978. +        ide_drive_t *drive = &hwif->drives[unit];
  11979. +
  11980. +        drive->select.all        = (unit<<4)|0xa0;
  11981. +        drive->hwif            = hwif;
  11982. +        drive->ctl            = 0x08;
  11983. +        drive->ready_stat        = READY_STAT;
  11984. +        drive->bad_wstat        = BAD_W_STAT;
  11985. +        drive->special.b.recalibrate    = 1;
  11986. +        drive->special.b.set_geometry    = 1;
  11987. +        drive->name[0]            = 'h';
  11988. +        drive->name[1]            = 'd';
  11989. +        drive->name[2]            = 'a' + (index * MAX_DRIVES) + unit;
  11990. +    }
  11991. +}
  11992. +
  11993. +/*
  11994. + * init_ide_data() sets reasonable default values into all fields
  11995. + * of all instances of the hwifs and drives, but only on the first call.
  11996. + * Subsequent calls have no effect (they don't wipe out anything).
  11997. + *
  11998. + * This routine is normally called at driver initialization time,
  11999. + * but may also be called MUCH earlier during kernel "command-line"
  12000. + * parameter processing.  As such, we cannot depend on any other parts
  12001. + * of the kernel (such as memory allocation) to be functioning yet.
  12002. + *
  12003. + * This is too bad, as otherwise we could dynamically allocate the
  12004. + * ide_drive_t structs as needed, rather than always consuming memory
  12005. + * for the max possible number (MAX_HWIFS * MAX_DRIVES) of them.
  12006. + */
  12007. +#define MAGIC_COOKIE 0x12345678
  12008. +static void init_ide_data (void)
  12009. +{
  12010. +    unsigned int index;
  12011. +    static unsigned long magic_cookie = MAGIC_COOKIE;
  12012. +
  12013. +    if (magic_cookie != MAGIC_COOKIE)
  12014. +        return;        /* already initialized */
  12015. +    magic_cookie = 0;
  12016. +
  12017. +    for (index = 0; index < MAX_HWIFS; ++index)
  12018. +        init_hwif_data(index);
  12019. +
  12020. +    idebus_parameter = 0;
  12021. +    system_bus_speed = 0;
  12022. +}
  12023. +
  12024. +/*
  12025. + * ide_system_bus_speed() returns what we think is the system VESA/PCI
  12026. + * bus speed (in Mhz).  This is used for calculating interface PIO timings.
  12027. + * The default is 40 for known PCI systems, 50 otherwise.
  12028. + * The "idebus=xx" parameter can be used to override this value.
  12029. + * The actual value to be used is computed/displayed the first time through.
  12030. + */
  12031. +int ide_system_bus_speed (void)
  12032. +{
  12033. +    if (!system_bus_speed) {
  12034. +        if (idebus_parameter)
  12035. +        system_bus_speed = idebus_parameter;    /* user supplied value */
  12036. +#ifdef CONFIG_PCI
  12037. +        else if (pcibios_present())
  12038. +            system_bus_speed = 40;  /* safe default value for PCI */
  12039. +#endif /* CONFIG_PCI */
  12040. +        else
  12041. +            system_bus_speed = 50;    /* safe default value for VESA and PCI */
  12042. +        printk("ide: Assuming %dMhz system bus speed for PIO modes; override with idebus=xx\n", system_bus_speed);
  12043. +    }
  12044. +    return system_bus_speed;
  12045. +}
  12046. +
  12047. +/*
  12048. + * This is used for most PIO data transfers *from* the IDE interface
  12049. + */
  12050. +void ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  12051. +{
  12052. +    unsigned long io_base  = HWIF(drive)->io.io_base;
  12053. +    unsigned long data_reg = io_base+HWIF(drive)->io.io_size*IDE_DATA_OFFSET;
  12054. +
  12055. +    insw(data_reg, buffer, wcount<<1);
  12056. +}
  12057. +
  12058. +/*
  12059. + * This is used for most PIO data transfers *to* the IDE interface
  12060. + */
  12061. +void ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  12062. +{
  12063. +    unsigned long io_base  = HWIF(drive)->io.io_base;
  12064. +    unsigned long data_reg = io_base+HWIF(drive)->io.io_size*IDE_DATA_OFFSET;
  12065. +
  12066. +    outsw(data_reg, buffer, wcount<<1);
  12067. +}
  12068. +
  12069. +/*
  12070. + * This should get invoked any time we exit the driver to
  12071. + * wait for an interrupt response from a drive.  handler() points
  12072. + * at the appropriate code to handle the next interrupt, and a
  12073. + * timer is started to prevent us from waiting forever in case
  12074. + * something goes wrong (see the timer_expiry() handler later on).
  12075. + */
  12076. +void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout)
  12077. +{
  12078. +    ide_hwgroup_t *hwgroup = HWGROUP(drive);
  12079. +#ifdef DEBUG
  12080. +    if (hwgroup->handler != NULL) {
  12081. +        printk("%s: ide_set_handler: handler not null; old=%p, new=%p\n",
  12082. +            drive->name, hwgroup->handler, handler);
  12083. +    }
  12084. +#endif
  12085. +    hwgroup->handler       = handler;
  12086. +    hwgroup->timer.expires = jiffies + timeout;
  12087. +    add_timer(&(hwgroup->timer));
  12088. +}
  12089. +
  12090. +/*
  12091. + * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
  12092. + * value for this drive (from its reported identification information).
  12093. + *
  12094. + * Returns:    1 if lba_capacity looks sensible
  12095. + *        0 otherwise
  12096. + */
  12097. +static int lba_capacity_is_ok (struct hd_driveid *id)
  12098. +{
  12099. +    unsigned long lba_sects   = id->lba_capacity;
  12100. +    unsigned long chs_sects   = id->cyls * id->heads * id->sectors;
  12101. +    unsigned long _10_percent = chs_sects / 10;
  12102. +
  12103. +    /* perform a rough sanity check on lba_sects:  within 10% is "okay" */
  12104. +    if ((lba_sects - chs_sects) < _10_percent)
  12105. +        return 1;    /* lba_capacity is good */
  12106. +
  12107. +    /* some drives have the word order reversed */
  12108. +    lba_sects = (lba_sects << 16) | (lba_sects >> 16);
  12109. +    if ((lba_sects - chs_sects) < _10_percent) {
  12110. +        id->lba_capacity = lba_sects;    /* fix it */
  12111. +        return 1;    /* lba_capacity is (now) good */
  12112. +    }
  12113. +    return 0;    /* lba_capacity value is bad */
  12114. +}
  12115. +
  12116. +/*
  12117. + * current_capacity() returns the capacity (in sectors) of a drive
  12118. + * according to its current geometry/LBA settings.
  12119. + */
  12120. +static unsigned long current_capacity (ide_drive_t  *drive)
  12121. +{
  12122. +    struct hd_driveid *id = drive->id;
  12123. +    unsigned long capacity = drive->cyl * drive->head * drive->sect;
  12124. +
  12125. +    if (!drive->present)
  12126. +        return 0;
  12127. +    if (drive->media != ide_disk)
  12128. +        return 0x7fffffff;    /* cdrom or tape */
  12129. +    drive->select.b.lba = 0;
  12130. +    /* Determine capacity, and use LBA if the drive properly supports it */
  12131. +    if (id != NULL && (id->capability & 2) && lba_capacity_is_ok(id)) {
  12132. +        if (id->lba_capacity >= capacity) {
  12133. +            capacity = id->lba_capacity;
  12134. +            drive->select.b.lba = 1;
  12135. +        }
  12136. +    }
  12137. +    return (capacity - drive->sect0);
  12138. +}
  12139. +
  12140. +/*
  12141. + * ide_geninit() is called exactly *once* for each major, from genhd.c,
  12142. + * at the beginning of the initial partition check for the drives.
  12143. + */
  12144. +static void ide_geninit (struct gendisk *gd)
  12145. +{
  12146. +    unsigned int unit;
  12147. +    ide_hwif_t *hwif = gd->real_devices;
  12148. +
  12149. +    for (unit = 0; unit < gd->nr_real; ++unit) {
  12150. +        ide_drive_t *drive = &hwif->drives[unit];
  12151. +#ifdef CONFIG_BLK_DEV_IDECD
  12152. +        if (drive->present && drive->media == ide_cdrom)
  12153. +            ide_cdrom_setup(drive);
  12154. +#endif /* CONFIG_BLK_DEV_IDECD */
  12155. +#ifdef CONFIG_BLK_DEV_IDETAPE
  12156. +        if (drive->present && drive->media == ide_tape)
  12157. +            idetape_setup(drive);
  12158. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  12159. +        drive->part[0].nr_sects = current_capacity(drive);
  12160. +        if (!drive->present || drive->media != ide_disk) {
  12161. +            drive->part[0].start_sect = -1; /* skip partition check */
  12162. +        }
  12163. +    }
  12164. +}
  12165. +
  12166. +/*
  12167. + * init_gendisk() (as opposed to ide_geninit) is called for each major device,
  12168. + * after probing for drives, to allocate partition tables and other data
  12169. + * structures needed for the routines in genhd.c.  ide_geninit() gets called
  12170. + * somewhat later, during the partition check.
  12171. + */
  12172. +static void init_gendisk (ide_hwif_t *hwif)
  12173. +{
  12174. +    struct gendisk *gd, **gdp;
  12175. +    unsigned int unit, units, minors;
  12176. +    int *bs, *hs;
  12177. +
  12178. +    /* figure out maximum drive number on the interface */
  12179. +    for (units = MAX_DRIVES; units > 0; --units) {
  12180. +        if (hwif->drives[units-1].present)
  12181. +            break;
  12182. +    }
  12183. +    minors    = units * (1<<PARTN_BITS);
  12184. +    gd        = kmalloc (sizeof(struct gendisk), GFP_KERNEL);
  12185. +    gd->sizes = kmalloc (minors * sizeof(int), GFP_KERNEL);
  12186. +    gd->part  = kmalloc (minors * sizeof(struct hd_struct), GFP_KERNEL);
  12187. +    bs        = kmalloc (minors*sizeof(int), GFP_KERNEL);
  12188. +    hs        = kmalloc (minors*sizeof(int), GFP_KERNEL);
  12189. +
  12190. +    memset(gd->part, 0, minors * sizeof(struct hd_struct));
  12191. +
  12192. +    /* cdroms and msdos f/s are examples of non-1024 blocksizes */
  12193. +    blksize_size[hwif->major] = bs;
  12194. +    hardsect_size[hwif->major] = hs;
  12195. +    for (unit = 0; unit < minors; ++unit) {
  12196. +        *bs++ = BLOCK_SIZE;
  12197. +        *hs++ = SECTOR_WORDS << 2;
  12198. +    }
  12199. +
  12200. +    for (unit = 0; unit < units; ++unit)
  12201. +        hwif->drives[unit].part = &gd->part[unit << PARTN_BITS];
  12202. +
  12203. +    gd->major    = hwif->major;        /* our major device number */
  12204. +    gd->major_name    = IDE_MAJOR_NAME;    /* treated special in genhd.c */
  12205. +    gd->minor_shift    = PARTN_BITS;        /* num bits for partitions */
  12206. +    gd->max_p    = 1<<PARTN_BITS;    /* 1 + max partitions / drive */
  12207. +    gd->max_nr    = units;        /* max num real drives */
  12208. +    gd->nr_real    = units;        /* current num real drives */
  12209. +    gd->init    = ide_geninit;        /* initialization function */
  12210. +    gd->real_devices= hwif;            /* ptr to internal data */
  12211. +    gd->next    = NULL;            /* linked list of major devs */
  12212. +
  12213. +    for (gdp = &gendisk_head; *gdp; gdp = &((*gdp)->next)) ;
  12214. +    hwif->gd = *gdp = gd;            /* link onto tail of list */
  12215. +}
  12216. +
  12217. +static void do_reset1 (ide_drive_t *, int);        /* needed below */
  12218. +
  12219. +#ifdef CONFIG_BLK_DEV_IDEATAPI
  12220. +/*
  12221. + * atapi_reset_pollfunc() gets invoked to poll the interface for completion every 50ms
  12222. + * during an atapi drive reset operation. If the drive has not yet responded,
  12223. + * and we have not yet hit our maximum waiting time, then the timer is restarted
  12224. + * for another 50ms.
  12225. + */
  12226. +static void atapi_reset_pollfunc (ide_drive_t *drive)
  12227. +{
  12228. +    ide_hwgroup_t *hwgroup = HWGROUP(drive);
  12229. +    byte stat;
  12230. +
  12231. +    OUT_BYTE (drive->select.all, IDE_SELECT_REG);
  12232. +    udelay (10);
  12233. +
  12234. +    if (OK_STAT(stat=GET_STAT(), 0, BUSY_STAT)) {
  12235. +        printk("%s: ATAPI reset complete\n", drive->name);
  12236. +    } else {
  12237. +        if (jiffies < hwgroup->poll_timeout) {
  12238. +            ide_set_handler (drive, &atapi_reset_pollfunc, HZ/20);
  12239. +            return;    /* continue polling */
  12240. +        }
  12241. +        hwgroup->poll_timeout = 0;    /* end of polling */
  12242. +        printk("%s: ATAPI reset timed-out, status=0x%02x\n", drive->name, stat);
  12243. +        do_reset1 (drive, 1);    /* do it the old fashioned way */
  12244. +    }
  12245. +    hwgroup->poll_timeout = 0;    /* done polling */
  12246. +}
  12247. +#endif /* CONFIG_BLK_DEV_IDEATAPI */
  12248. +
  12249. +/*
  12250. + * reset_pollfunc() gets invoked to poll the interface for completion every 50ms
  12251. + * during an ide reset operation. If the drives have not yet responded,
  12252. + * and we have not yet hit our maximum waiting time, then the timer is restarted
  12253. + * for another 50ms.
  12254. + */
  12255. +static void reset_pollfunc (ide_drive_t *drive)
  12256. +{
  12257. +    ide_hwgroup_t *hwgroup = HWGROUP(drive);
  12258. +    ide_hwif_t *hwif = HWIF(drive);
  12259. +    byte tmp;
  12260. +
  12261. +    if (!OK_STAT(tmp=GET_STAT(), 0, BUSY_STAT)) {
  12262. +        if (jiffies < hwgroup->poll_timeout) {
  12263. +            ide_set_handler (drive, &reset_pollfunc, HZ/20);
  12264. +            return;    /* continue polling */
  12265. +        }
  12266. +        printk("%s: reset timed-out, status=0x%02x\n", hwif->name, tmp);
  12267. +    } else  {
  12268. +        printk("%s: reset: ", hwif->name);
  12269. +        if ((tmp = GET_ERR()) == 1)
  12270. +            printk("success\n");
  12271. +        else {
  12272. +#if FANCY_STATUS_DUMPS
  12273. +            printk("master: ");
  12274. +            switch (tmp & 0x7f) {
  12275. +                case 1: printk("passed");
  12276. +                    break;
  12277. +                case 2: printk("formatter device error");
  12278. +                    break;
  12279. +                case 3: printk("sector buffer error");
  12280. +                    break;
  12281. +                case 4: printk("ECC circuitry error");
  12282. +                    break;
  12283. +                case 5: printk("controlling MPU error");
  12284. +                    break;
  12285. +                default:printk("error (0x%02x?)", tmp);
  12286. +            }
  12287. +            if (tmp & 0x80)
  12288. +                printk("; slave: failed");
  12289. +            printk("\n");
  12290. +#else
  12291. +            printk("failed\n");
  12292. +#endif /* FANCY_STATUS_DUMPS */
  12293. +        }
  12294. +    }
  12295. +    hwgroup->poll_timeout = 0;    /* done polling */
  12296. +}
  12297. +
  12298. +/*
  12299. + * do_reset1() attempts to recover a confused drive by resetting it.
  12300. + * Unfortunately, resetting a disk drive actually resets all devices on
  12301. + * the same interface, so it can really be thought of as resetting the
  12302. + * interface rather than resetting the drive.
  12303. + *
  12304. + * ATAPI devices have their own reset mechanism which allows them to be
  12305. + * individually reset without clobbering other devices on the same interface.
  12306. + *
  12307. + * Unfortunately, the IDE interface does not generate an interrupt to let
  12308. + * us know when the reset operation has finished, so we must poll for this.
  12309. + * Equally poor, though, is the fact that this may a very long time to complete,
  12310. + * (up to 30 seconds worstcase).  So, instead of busy-waiting here for it,
  12311. + * we set a timer to poll at 50ms intervals.
  12312. + */
  12313. +static void do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
  12314. +{
  12315. +    unsigned int unit;
  12316. +    unsigned long flags;
  12317. +    ide_hwif_t *hwif = HWIF(drive);
  12318. +    ide_hwgroup_t *hwgroup = HWGROUP(drive);
  12319. +
  12320. +    save_flags(flags);
  12321. +    cli();        /* Why ? */
  12322. +
  12323. +#ifdef CONFIG_BLK_DEV_IDEATAPI
  12324. +    /* For an ATAPI device, first try an ATAPI SRST. */
  12325. +    if (drive->media != ide_disk) {
  12326. +        if (!do_not_try_atapi) {
  12327. +            if (!drive->keep_settings) {
  12328. +                drive->unmask = 0;
  12329. +                drive->io_32bit = 0;
  12330. +            }
  12331. +            OUT_BYTE (drive->select.all, IDE_SELECT_REG);
  12332. +            udelay (20);
  12333. +            OUT_BYTE (WIN_SRST, IDE_COMMAND_REG);
  12334. +            hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
  12335. +            ide_set_handler (drive, &atapi_reset_pollfunc, HZ/20);
  12336. +            restore_flags (flags);
  12337. +            return;
  12338. +        }
  12339. +    }
  12340. +#endif /* CONFIG_BLK_DEV_IDEATAPI */
  12341. +
  12342. +    /*
  12343. +     * First, reset any device state data we were maintaining
  12344. +     * for any of the drives on this interface.
  12345. +     */
  12346. +    for (unit = 0; unit < MAX_DRIVES; ++unit) {
  12347. +        ide_drive_t *rdrive = &hwif->drives[unit];
  12348. +        rdrive->special.all = 0;
  12349. +        rdrive->special.b.set_geometry = 1;
  12350. +        rdrive->special.b.recalibrate  = 1;
  12351. +        if (OK_TO_RESET_CONTROLLER)
  12352. +            rdrive->mult_count = 0;
  12353. +        if (!rdrive->keep_settings) {
  12354. +            rdrive->mult_req = 0;
  12355. +            rdrive->unmask = 0;
  12356. +            rdrive->io_32bit = 0;
  12357. +            if (rdrive->using_dma) {
  12358. +                rdrive->using_dma = 0;
  12359. +                printk("%s: disabled DMA\n", rdrive->name);
  12360. +            }
  12361. +        }
  12362. +        if (rdrive->mult_req != rdrive->mult_count)
  12363. +            rdrive->special.b.set_multmode = 1;
  12364. +    }
  12365. +
  12366. +#if OK_TO_RESET_CONTROLLER
  12367. +    /*
  12368. +     * Note that we also set nIEN while resetting the device,
  12369. +     * to mask unwanted interrupts from the interface during the reset.
  12370. +     * However, due to the design of PC hardware, this will cause an
  12371. +     * immediate interrupt due to the edge transition it produces.
  12372. +     * This single interrupt gives us a "fast poll" for drives that
  12373. +     * recover from reset very quickly, saving us the first 50ms wait time.
  12374. +     */
  12375. +    OUT_BYTE(drive->ctl|6,IDE_CONTROL_REG);    /* set SRST and nIEN */
  12376. +    udelay(10);            /* more than enough time */
  12377. +    OUT_BYTE(drive->ctl|2,IDE_CONTROL_REG);    /* clear SRST, leave nIEN */
  12378. +    udelay(10);            /* more than enough time */
  12379. +    hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
  12380. +    ide_set_handler (drive, &reset_pollfunc, HZ/20);
  12381. +#endif    /* OK_TO_RESET_CONTROLLER */
  12382. +
  12383. +    restore_flags (flags);
  12384. +}
  12385. +
  12386. +/*
  12387. + * ide_do_reset() is the entry point to the drive/interface reset code.
  12388. + */
  12389. +void ide_do_reset (ide_drive_t *drive)
  12390. +{
  12391. +    do_reset1 (drive, 0);
  12392. +#ifdef CONFIG_BLK_DEV_IDETAPE
  12393. +    if (drive->media == ide_tape)
  12394. +        drive->tape.reset_issued=1;
  12395. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  12396. +}
  12397. +
  12398. +/*
  12399. + * Clean up after success/failure of an explicit drive cmd
  12400. + */
  12401. +void ide_end_drive_cmd (ide_drive_t *drive, byte stat, byte err)
  12402. +{
  12403. +    unsigned long flags;
  12404. +    struct request *rq = HWGROUP(drive)->rq;
  12405. +
  12406. +    if (rq->cmd == IDE_DRIVE_CMD) {
  12407. +        byte *args = (byte *) rq->buffer;
  12408. +        rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
  12409. +        if (args) {
  12410. +            args[0] = stat;
  12411. +            args[1] = err;
  12412. +            args[2] = IN_BYTE(IDE_NSECTOR_REG);
  12413. +        }
  12414. +    }
  12415. +    save_flags(flags);
  12416. +    cli();
  12417. +    blk_dev[MAJOR(rq->rq_dev)].current_request = rq->next;
  12418. +    HWGROUP(drive)->rq = NULL;
  12419. +    rq->rq_status = RQ_INACTIVE;
  12420. +    if (rq->sem != NULL)
  12421. +        up(rq->sem);
  12422. +    restore_flags(flags);
  12423. +}
  12424. +
  12425. +/*
  12426. + * Error reporting, in human readable form (luxurious, but a memory hog).
  12427. + */
  12428. +byte ide_dump_status (ide_drive_t *drive, const char *msg, byte stat)
  12429. +{
  12430. +    unsigned long flags;
  12431. +    byte err = 0;
  12432. +
  12433. +    save_flags (flags);
  12434. +    sti();
  12435. +    printk("%s: %s: status=0x%02x", drive->name, msg, stat);
  12436. +#if FANCY_STATUS_DUMPS
  12437. +    if (drive->media == ide_disk) {
  12438. +        printk(" { ");
  12439. +        if (stat & BUSY_STAT)
  12440. +            printk("Busy ");
  12441. +        else {
  12442. +            if (stat & READY_STAT)    printk("DriveReady ");
  12443. +            if (stat & WRERR_STAT)    printk("DeviceFault ");
  12444. +            if (stat & SEEK_STAT)    printk("SeekComplete ");
  12445. +            if (stat & DRQ_STAT)    printk("DataRequest ");
  12446. +            if (stat & ECC_STAT)    printk("CorrectedError ");
  12447. +            if (stat & INDEX_STAT)    printk("Index ");
  12448. +            if (stat & ERR_STAT)    printk("Error ");
  12449. +        }
  12450. +        printk("}");
  12451. +    }
  12452. +#endif    /* FANCY_STATUS_DUMPS */
  12453. +    printk("\n");
  12454. +    if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
  12455. +        err = GET_ERR();
  12456. +        printk("%s: %s: error=0x%02x", drive->name, msg, err);
  12457. +#if FANCY_STATUS_DUMPS
  12458. +        if (drive->media == ide_disk) {
  12459. +            printk(" { ");
  12460. +            if (err & BBD_ERR)    printk("BadSector ");
  12461. +            if (err & ECC_ERR)    printk("UncorrectableError ");
  12462. +            if (err & ID_ERR)    printk("SectorIdNotFound ");
  12463. +            if (err & ABRT_ERR)    printk("DriveStatusError ");
  12464. +            if (err & TRK0_ERR)    printk("TrackZeroNotFound ");
  12465. +            if (err & MARK_ERR)    printk("AddrMarkNotFound ");
  12466. +            printk("}");
  12467. +            if (err & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
  12468. +                byte cur = IN_BYTE(IDE_SELECT_REG);
  12469. +                if (cur & 0x40) {    /* using LBA? */
  12470. +                    printk(", LBAsect=%ld", (unsigned long)
  12471. +                     ((cur&0xf)<<24)
  12472. +                     |(IN_BYTE(IDE_HCYL_REG)<<16)
  12473. +                     |(IN_BYTE(IDE_LCYL_REG)<<8)
  12474. +                     | IN_BYTE(IDE_SECTOR_REG));
  12475. +                } else {
  12476. +                    printk(", CHS=%d/%d/%d",
  12477. +                     (IN_BYTE(IDE_HCYL_REG)<<8) +
  12478. +                      IN_BYTE(IDE_LCYL_REG),
  12479. +                      cur & 0xf,
  12480. +                      IN_BYTE(IDE_SECTOR_REG));
  12481. +                }
  12482. +                if (HWGROUP(drive)->rq)
  12483. +                    printk(", sector=%ld", HWGROUP(drive)->rq->sector);
  12484. +            }
  12485. +        }
  12486. +#endif    /* FANCY_STATUS_DUMPS */
  12487. +        printk("\n");
  12488. +    }
  12489. +    restore_flags (flags);
  12490. +    return err;
  12491. +}
  12492. +
  12493. +/*
  12494. + * try_to_flush_leftover_data() is invoked in response to a drive
  12495. + * unexpectedly having its DRQ_STAT bit set.  As an alternative to
  12496. + * resetting the drive, this routine tries to clear the condition
  12497. + * by read a sector's worth of data from the drive.  Of course,
  12498. + * this may not help if the drive is *waiting* for data from *us*.
  12499. + */
  12500. +static void try_to_flush_leftover_data (ide_drive_t *drive)
  12501. +{
  12502. +    int i = (drive->mult_count ? drive->mult_count : 1) * SECTOR_WORDS;
  12503. +
  12504. +    while (i > 0) {
  12505. +        unsigned long buffer[16];
  12506. +        unsigned int wcount = (i > 16) ? 16 : i;
  12507. +        i -= wcount;
  12508. +        ide_input_data (drive, buffer, wcount);
  12509. +    }
  12510. +}
  12511. +
  12512. +/*
  12513. + * ide_error() takes action based on the error returned by the controller.
  12514. + */
  12515. +void ide_error (ide_drive_t *drive, const char *msg, byte stat)
  12516. +{
  12517. +    struct request *rq;
  12518. +    byte err;
  12519. +
  12520. +    err = ide_dump_status(drive, msg, stat);
  12521. +    if ((rq = HWGROUP(drive)->rq) == NULL || drive == NULL)
  12522. +        return;
  12523. +    /* retry only "normal" I/O: */
  12524. +    if (rq->cmd == IDE_DRIVE_CMD) {
  12525. +        rq->errors = 1;
  12526. +        ide_end_drive_cmd(drive, stat, err);
  12527. +        return;
  12528. +    }
  12529. +    if (stat & BUSY_STAT) {        /* other bits are useless when BUSY */
  12530. +        rq->errors |= ERROR_RESET;
  12531. +    } else {
  12532. +        if (drive->media == ide_disk && (stat & ERR_STAT)) {
  12533. +            /* err has different meaning on cdrom and tape */
  12534. +            if (err & (BBD_ERR | ECC_ERR))    /* retries won't help these */
  12535. +                rq->errors = ERROR_MAX;
  12536. +            else if (err & TRK0_ERR)    /* help it find track zero */
  12537. +                rq->errors |= ERROR_RECAL;
  12538. +        }
  12539. +        if ((stat & DRQ_STAT) && rq->cmd != WRITE)
  12540. +            try_to_flush_leftover_data(drive);
  12541. +    }
  12542. +    if (GET_STAT() & (BUSY_STAT|DRQ_STAT))
  12543. +        rq->errors |= ERROR_RESET;    /* Mmmm.. timing problem */
  12544. +
  12545. +    if (rq->errors >= ERROR_MAX) {
  12546. +#ifdef CONFIG_BLK_DEV_IDETAPE
  12547. +        if (drive->media == ide_tape) {
  12548. +            rq->errors = 0;
  12549. +            idetape_end_request(0, HWGROUP(drive));
  12550. +        }
  12551. +        else
  12552. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  12553. +         ide_end_request(0, HWGROUP(drive));
  12554. +    }
  12555. +    else {
  12556. +        if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
  12557. +            ++rq->errors;
  12558. +            ide_do_reset(drive);
  12559. +            return;
  12560. +        } else if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
  12561. +            drive->special.b.recalibrate = 1;
  12562. +        ++rq->errors;
  12563. +    }
  12564. +}
  12565. +
  12566. +/*
  12567. + * read_intr() is the handler for disk read/multread interrupts
  12568. + */
  12569. +static void read_intr (ide_drive_t *drive)
  12570. +{
  12571. +    byte stat;
  12572. +    int i;
  12573. +    unsigned int msect, nsect;
  12574. +    struct request *rq;
  12575. +
  12576. +    if (!OK_STAT(stat=GET_STAT(),DATA_READY,BAD_R_STAT)) {
  12577. +        ide_error(drive, "read_intr", stat);
  12578. +        return;
  12579. +    }
  12580. +    msect = drive->mult_count;
  12581. +read_next:
  12582. +    rq = HWGROUP(drive)->rq;
  12583. +    if (msect) {
  12584. +        if ((nsect = rq->current_nr_sectors) > msect)
  12585. +            nsect = msect;
  12586. +        msect -= nsect;
  12587. +    } else
  12588. +        nsect = 1;
  12589. +    ide_input_data(drive, rq->buffer, nsect * SECTOR_WORDS);
  12590. +#ifdef DEBUG
  12591. +    printk("%s:  read: sectors(%ld-%ld), buffer=0x%08lx, remaining=%ld\n",
  12592. +        drive->name, rq->sector, rq->sector+nsect-1,
  12593. +        (unsigned long) rq->buffer+(nsect<<9), rq->nr_sectors-nsect);
  12594. +#endif
  12595. +    rq->sector += nsect;
  12596. +    rq->buffer += nsect<<9;
  12597. +    rq->errors = 0;
  12598. +    i = (rq->nr_sectors -= nsect);
  12599. +    if ((rq->current_nr_sectors -= nsect) <= 0)
  12600. +        ide_end_request(1, HWGROUP(drive));
  12601. +    if (i > 0) {
  12602. +        if (msect)
  12603. +            goto read_next;
  12604. +        ide_set_handler (drive, &read_intr, WAIT_CMD);
  12605. +    }
  12606. +}
  12607. +
  12608. +/*
  12609. + * write_intr() is the handler for disk write interrupts
  12610. + */
  12611. +static void write_intr (ide_drive_t *drive)
  12612. +{
  12613. +    byte stat;
  12614. +    int i;
  12615. +    ide_hwgroup_t *hwgroup = HWGROUP(drive);
  12616. +    struct request *rq = hwgroup->rq;
  12617. +
  12618. +    if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
  12619. +#ifdef DEBUG
  12620. +        printk("%s: write: sector %ld, buffer=0x%08lx, remaining=%ld\n",
  12621. +            drive->name, rq->sector, (unsigned long) rq->buffer,
  12622. +            rq->nr_sectors-1);
  12623. +#endif
  12624. +        if ((rq->nr_sectors == 1) ^ ((stat & DRQ_STAT) != 0)) {
  12625. +            rq->sector++;
  12626. +            rq->buffer += 512;
  12627. +            rq->errors = 0;
  12628. +            i = --rq->nr_sectors;
  12629. +            --rq->current_nr_sectors;
  12630. +            if (rq->current_nr_sectors <= 0)
  12631. +                ide_end_request(1, hwgroup);
  12632. +            if (i > 0) {
  12633. +                ide_output_data (drive, rq->buffer, SECTOR_WORDS);
  12634. +                ide_set_handler (drive, &write_intr, WAIT_CMD);
  12635. +            }
  12636. +            return;
  12637. +        }
  12638. +    }
  12639. +    ide_error(drive, "write_intr", stat);
  12640. +}
  12641. +
  12642. +/*
  12643. + * ide_multwrite() transfers a block of up to mcount sectors of data
  12644. + * to a drive as part of a disk multiple-sector write operation.
  12645. + */
  12646. +void ide_multwrite (ide_drive_t *drive, unsigned int mcount)
  12647. +{
  12648. +    struct request *rq = &HWGROUP(drive)->wrq;
  12649. +
  12650. +    do {
  12651. +        unsigned int nsect = rq->current_nr_sectors;
  12652. +        if (nsect > mcount)
  12653. +            nsect = mcount;
  12654. +        mcount -= nsect;
  12655. +
  12656. +        ide_output_data(drive, rq->buffer, nsect<<7);
  12657. +#ifdef DEBUG
  12658. +        printk("%s: multwrite: sector %ld, buffer=0x%08lx, count=%d, remaining=%ld\n",
  12659. +            drive->name, rq->sector, (unsigned long) rq->buffer,
  12660. +            nsect, rq->nr_sectors - nsect);
  12661. +#endif
  12662. +        if ((rq->nr_sectors -= nsect) <= 0)
  12663. +            break;
  12664. +        if ((rq->current_nr_sectors -= nsect) == 0) {
  12665. +            if ((rq->bh = rq->bh->b_reqnext) != NULL) {
  12666. +                rq->current_nr_sectors = rq->bh->b_size>>9;
  12667. +                rq->buffer             = rq->bh->b_data;
  12668. +            } else {
  12669. +                panic("%s: buffer list corrupted\n", drive->name);
  12670. +                break;
  12671. +            }
  12672. +        } else {
  12673. +            rq->buffer += nsect << 9;
  12674. +        }
  12675. +    } while (mcount);
  12676. +}
  12677. +
  12678. +/*
  12679. + * multwrite_intr() is the handler for disk multwrite interrupts
  12680. + */
  12681. +static void multwrite_intr (ide_drive_t *drive)
  12682. +{
  12683. +    byte stat;
  12684. +    int i;
  12685. +    ide_hwgroup_t *hwgroup = HWGROUP(drive);
  12686. +    struct request *rq = &hwgroup->wrq;
  12687. +
  12688. +    if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
  12689. +        if (stat & DRQ_STAT) {
  12690. +            if (rq->nr_sectors) {
  12691. +                ide_multwrite(drive, drive->mult_count);
  12692. +                ide_set_handler (drive, &multwrite_intr, WAIT_CMD);
  12693. +                return;
  12694. +            }
  12695. +        } else {
  12696. +            if (!rq->nr_sectors) {    /* all done? */
  12697. +                rq = hwgroup->rq;
  12698. +                for (i = rq->nr_sectors; i > 0;){
  12699. +                    i -= rq->current_nr_sectors;
  12700. +                    ide_end_request(1, hwgroup);
  12701. +                }
  12702. +                return;
  12703. +            }
  12704. +        }
  12705. +    }
  12706. +    ide_error(drive, "multwrite_intr", stat);
  12707. +}
  12708. +
  12709. +/*
  12710. + * Issue a simple drive command
  12711. + * The drive must be selected beforehand.
  12712. + */
  12713. +static void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ide_handler_t *handler)
  12714. +{
  12715. +    ide_set_handler (drive, handler, WAIT_CMD);
  12716. +    OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
  12717. +    OUT_BYTE(nsect,IDE_NSECTOR_REG);
  12718. +    OUT_BYTE(cmd,IDE_COMMAND_REG);
  12719. +}
  12720. +
  12721. +/*
  12722. + * set_multmode_intr() is invoked on completion of a WIN_SETMULT cmd.
  12723. + */
  12724. +static void set_multmode_intr (ide_drive_t *drive)
  12725. +{
  12726. +    byte stat = GET_STAT();
  12727. +
  12728. +    sti();
  12729. +    if (OK_STAT(stat,READY_STAT,BAD_STAT)) {
  12730. +        drive->mult_count = drive->mult_req;
  12731. +    } else {
  12732. +        drive->mult_req = drive->mult_count = 0;
  12733. +        drive->special.b.recalibrate = 1;
  12734. +        (void) ide_dump_status(drive, "set_multmode", stat);
  12735. +    }
  12736. +}
  12737. +
  12738. +/*
  12739. + * set_geometry_intr() is invoked on completion of a WIN_SPECIFY cmd.
  12740. + */
  12741. +static void set_geometry_intr (ide_drive_t *drive)
  12742. +{
  12743. +    byte stat = GET_STAT();
  12744. +
  12745. +    sti();
  12746. +    if (!OK_STAT(stat,READY_STAT,BAD_STAT))
  12747. +        ide_error(drive, "set_geometry_intr", stat);
  12748. +}
  12749. +
  12750. +/*
  12751. + * recal_intr() is invoked on completion of a WIN_RESTORE (recalibrate) cmd.
  12752. + */
  12753. +static void recal_intr (ide_drive_t *drive)
  12754. +{
  12755. +    byte stat = GET_STAT();
  12756. +
  12757. +    sti();
  12758. +    if (!OK_STAT(stat,READY_STAT,BAD_STAT))
  12759. +        ide_error(drive, "recal_intr", stat);
  12760. +}
  12761. +
  12762. +/*
  12763. + * drive_cmd_intr() is invoked on completion of a special DRIVE_CMD.
  12764. + */
  12765. +static void drive_cmd_intr (ide_drive_t *drive)
  12766. +{
  12767. +    struct request *rq = HWGROUP(drive)->rq;
  12768. +    byte *args = (byte *) rq->buffer;
  12769. +    byte stat = GET_STAT();
  12770. +
  12771. +    sti();
  12772. +    if ((stat & DRQ_STAT) && args && args[3]) {
  12773. +        byte io_32bit = drive->io_32bit;
  12774. +        drive->io_32bit = 0;
  12775. +        ide_input_data(drive, &args[4], args[3] * SECTOR_WORDS);
  12776. +        drive->io_32bit = io_32bit;
  12777. +        stat = GET_STAT();
  12778. +    }
  12779. +    if (OK_STAT(stat,READY_STAT,BAD_STAT))
  12780. +        ide_end_drive_cmd (drive, stat, GET_ERR());
  12781. +    else
  12782. +        ide_error(drive, "drive_cmd", stat); /* calls ide_end_drive_cmd */
  12783. +}
  12784. +
  12785. +/*
  12786. + * do_special() is used to issue WIN_SPECIFY, WIN_RESTORE, and WIN_SETMULT
  12787. + * commands to a drive.  It used to do much more, but has been scaled back.
  12788. + */
  12789. +static inline void do_special (ide_drive_t *drive)
  12790. +{
  12791. +    special_t *s = &drive->special;
  12792. +
  12793. +#ifdef DEBUG
  12794. +    printk("%s: do_special: 0x%02x\n", drive->name, s->all);
  12795. +#endif
  12796. +    if (s->b.set_geometry) {
  12797. +        s->b.set_geometry = 0;
  12798. +        if (drive->media == ide_disk) {
  12799. +            OUT_BYTE(drive->sect,IDE_SECTOR_REG);
  12800. +            OUT_BYTE(drive->cyl,IDE_LCYL_REG);
  12801. +            OUT_BYTE(drive->cyl>>8,IDE_HCYL_REG);
  12802. +            OUT_BYTE(((drive->head-1)|drive->select.all)&0xBF,IDE_SELECT_REG);
  12803. +            if (!IS_PROMISE_DRIVE)
  12804. +                ide_cmd(drive, WIN_SPECIFY, drive->sect, &set_geometry_intr);
  12805. +        }
  12806. +    } else if (s->b.recalibrate) {
  12807. +        s->b.recalibrate = 0;
  12808. +        if (drive->media == ide_disk && !IS_PROMISE_DRIVE)
  12809. +            ide_cmd(drive, WIN_RESTORE, drive->sect, &recal_intr);
  12810. +    } else if (s->b.set_tune) {
  12811. +        ide_tuneproc_t *tuneproc = HWIF(drive)->tuneproc;
  12812. +        s->b.set_tune = 0;
  12813. +        if (tuneproc != NULL)
  12814. +            tuneproc(drive, drive->tune_req);
  12815. +    } else if (s->b.set_multmode) {
  12816. +        s->b.set_multmode = 0;
  12817. +        if (drive->media == ide_disk) {
  12818. +            if (drive->id && drive->mult_req > drive->id->max_multsect)
  12819. +                drive->mult_req = drive->id->max_multsect;
  12820. +            if (!IS_PROMISE_DRIVE)
  12821. +                ide_cmd(drive, WIN_SETMULT, drive->mult_req, &set_multmode_intr);
  12822. +        } else
  12823. +            drive->mult_req = 0;
  12824. +    } else if (s->all) {
  12825. +        int special = s->all;
  12826. +        s->all = 0;
  12827. +        printk("%s: bad special flag: 0x%02x\n", drive->name, special);
  12828. +    }
  12829. +}
  12830. +
  12831. +/*
  12832. + * This routine busy-waits for the drive status to be not "busy".
  12833. + * It then checks the status for all of the "good" bits and none
  12834. + * of the "bad" bits, and if all is okay it returns 0.  All other
  12835. + * cases return 1 after invoking ide_error() -- caller should just return.
  12836. + *
  12837. + * This routine should get fixed to not hog the cpu during extra long waits..
  12838. + * That could be done by busy-waiting for the first jiffy or two, and then
  12839. + * setting a timer to wake up at half second intervals thereafter,
  12840. + * until timeout is achieved, before timing out.
  12841. + */
  12842. +int ide_wait_stat (ide_drive_t *drive, byte good, byte bad, unsigned long timeout)
  12843. +{
  12844. +    byte stat;
  12845. +    unsigned long flags;
  12846. +
  12847. +test:
  12848. +    udelay(1);    /* spec allows drive 400ns to change "BUSY" */
  12849. +    if (OK_STAT((stat = GET_STAT()), good, bad))
  12850. +        return 0;    /* fast exit for most frequent case */
  12851. +    if (!(stat & BUSY_STAT)) {
  12852. +        ide_error(drive, "status error", stat);
  12853. +        return 1;
  12854. +    }
  12855. +
  12856. +    save_flags(flags);
  12857. +    sti();
  12858. +    timeout += jiffies;
  12859. +    do {
  12860. +        if (!((stat = GET_STAT()) & BUSY_STAT)) {
  12861. +            restore_flags(flags);
  12862. +            goto test;
  12863. +        }
  12864. +    } while (jiffies <= timeout);
  12865. +
  12866. +    restore_flags(flags);
  12867. +    ide_error(drive, "status timeout", GET_STAT());
  12868. +    return 1;
  12869. +}
  12870. +
  12871. +/*
  12872. + * do_rw_disk() issues READ and WRITE commands to a disk,
  12873. + * using LBA if supported, or CHS otherwise, to address sectors.
  12874. + * It also takes care of issuing special DRIVE_CMDs.
  12875. + */
  12876. +static inline void do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
  12877. +{
  12878. +    ide_hwif_t *hwif = HWIF(drive);
  12879. +    unsigned long io_base = hwif->io.io_base;
  12880. +    unsigned long io_size = hwif->io.io_size;
  12881. +#ifdef CONFIG_BLK_DEV_PROMISE
  12882. +    int use_promise_io = 0;
  12883. +#endif /* CONFIG_BLK_DEV_PROMISE */
  12884. +
  12885. +    OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
  12886. +    OUT_BYTE(rq->nr_sectors,io_base+io_size*IDE_NSECTOR_OFFSET);
  12887. +#ifdef CONFIG_BLK_DEV_PROMISE
  12888. +    if (IS_PROMISE_DRIVE) {
  12889. +        if (hwif->is_promise2 || rq->cmd == READ) {
  12890. +            use_promise_io = 1;
  12891. +        }
  12892. +    }
  12893. +    if (drive->select.b.lba || use_promise_io) {
  12894. +#else /* !CONFIG_BLK_DEV_PROMISE */
  12895. +    if (drive->select.b.lba) {
  12896. +#endif /* CONFIG_BLK_DEV_PROMISE */
  12897. +#ifdef DEBUG
  12898. +        printk("%s: %sing: LBAsect=%ld, sectors=%ld, buffer=0x%08lx\n",
  12899. +            drive->name, (rq->cmd==READ)?"read":"writ",
  12900. +            block, rq->nr_sectors, (unsigned long) rq->buffer);
  12901. +#endif
  12902. +        OUT_BYTE(block,io_base+io_size*IDE_SECTOR_OFFSET);
  12903. +        OUT_BYTE(block>>=8,io_base+io_size*IDE_LCYL_OFFSET);
  12904. +        OUT_BYTE(block>>=8,io_base+io_size*IDE_HCYL_OFFSET);
  12905. +        OUT_BYTE(((block>>8)&0x0f)|drive->select.all,io_base+io_size*IDE_SELECT_OFFSET);
  12906. +    } else {
  12907. +        unsigned int sect,head,cyl,track;
  12908. +        track = block / drive->sect;
  12909. +        sect  = block % drive->sect + 1;
  12910. +        OUT_BYTE(sect,io_base+io_size*IDE_SECTOR_OFFSET);
  12911. +        head  = track % drive->head;
  12912. +        cyl   = track / drive->head;
  12913. +        OUT_BYTE(cyl,io_base+io_size*IDE_LCYL_OFFSET);
  12914. +        OUT_BYTE(cyl>>8,io_base+io_size*IDE_HCYL_OFFSET);
  12915. +        OUT_BYTE(head|drive->select.all,io_base+io_size*IDE_SELECT_OFFSET);
  12916. +#ifdef DEBUG
  12917. +        printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",
  12918. +            drive->name, (rq->cmd==READ)?"read":"writ", cyl,
  12919. +            head, sect, rq->nr_sectors, (unsigned long) rq->buffer);
  12920. +#endif
  12921. +    }
  12922. +#ifdef CONFIG_BLK_DEV_PROMISE
  12923. +    if (use_promise_io) {
  12924. +        do_promise_io (drive, rq);
  12925. +        return;
  12926. +    }
  12927. +#endif /* CONFIG_BLK_DEV_PROMISE */
  12928. +    if (rq->cmd == READ) {
  12929. +        ide_set_handler(drive, &read_intr, WAIT_CMD);
  12930. +        OUT_BYTE(drive->mult_count ? WIN_MULTREAD : WIN_READ, io_base+io_size*IDE_COMMAND_OFFSET);
  12931. +        return;
  12932. +    }
  12933. +    if (rq->cmd == WRITE) {
  12934. +        OUT_BYTE(drive->mult_count ? WIN_MULTWRITE : WIN_WRITE, io_base+io_size*IDE_COMMAND_OFFSET);
  12935. +        if (ide_wait_stat(drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
  12936. +            printk("%s: no DRQ after issuing %s\n", drive->name,
  12937. +                drive->mult_count ? "MULTWRITE" : "WRITE");
  12938. +            return;
  12939. +        }
  12940. +        if (!drive->unmask)
  12941. +            cli();
  12942. +        if (drive->mult_count) {
  12943. +            HWGROUP(drive)->wrq = *rq; /* scratchpad */
  12944. +            ide_set_handler (drive, &multwrite_intr, WAIT_CMD);
  12945. +            ide_multwrite(drive, drive->mult_count);
  12946. +        } else {
  12947. +            ide_set_handler (drive, &write_intr, WAIT_CMD);
  12948. +            ide_output_data(drive, rq->buffer, SECTOR_WORDS);
  12949. +        }
  12950. +        return;
  12951. +    }
  12952. +    printk("%s: bad command: %d\n", drive->name, rq->cmd);
  12953. +    ide_end_request(0, HWGROUP(drive));
  12954. +}
  12955. +
  12956. +/*
  12957. + * execute_drive_cmd() issues a special drive command,
  12958. + * usually initiated by ioctl() from the external hdparm program.
  12959. + */
  12960. +static void execute_drive_cmd (ide_drive_t *drive, struct request *rq)
  12961. +{
  12962. +    ide_hwif_t *hwif = HWIF(drive);
  12963. +    unsigned long io_base = hwif->io.io_base;
  12964. +    unsigned long io_size = hwif->io.io_size;
  12965. +    byte *args = rq->buffer;
  12966. +    if (args) {
  12967. +#ifdef DEBUG
  12968. +        printk("%s: DRIVE_CMD cmd=0x%02x sc=0x%02x fr=0x%02x xx=0x%02x\n",
  12969. +         drive->name, args[0], args[1], args[2], args[3]);
  12970. +#endif
  12971. +        OUT_BYTE(args[2],io_base+io_size*IDE_FEATURE_OFFSET);
  12972. +        ide_cmd(drive, args[0], args[1], &drive_cmd_intr);
  12973. +        return;
  12974. +    } else {
  12975. +        /*
  12976. +         * NULL is actually a valid way of waiting for
  12977. +         * all current requests to be flushed from the queue.
  12978. +         */
  12979. +#ifdef DEBUG
  12980. +        printk("%s: DRIVE_CMD (null)\n", drive->name);
  12981. +#endif
  12982. +        ide_end_drive_cmd(drive, GET_STAT(), GET_ERR());
  12983. +        return;
  12984. +    }
  12985. +}
  12986. +
  12987. +/*
  12988. + * do_request() initiates handling of a new I/O request
  12989. + */
  12990. +static inline void do_request (ide_hwif_t *hwif, struct request *rq)
  12991. +{
  12992. +    unsigned int minor, unit;
  12993. +    unsigned long block, blockend;
  12994. +    ide_drive_t *drive;
  12995. +
  12996. +    sti();
  12997. +#ifdef DEBUG
  12998. +    printk("%s: do_request: current=0x%08lx\n", hwif->name, (unsigned long) rq);
  12999. +#endif
  13000. +    minor = MINOR(rq->rq_dev);
  13001. +    unit = minor >> PARTN_BITS;
  13002. +    if (MAJOR(rq->rq_dev) != hwif->major || unit >= MAX_DRIVES) {
  13003. +        printk("%s: bad device number: %s\n",
  13004. +               hwif->name, kdevname(rq->rq_dev));
  13005. +        goto kill_rq;
  13006. +    }
  13007. +    drive = &hwif->drives[unit];
  13008. +#ifdef DEBUG
  13009. +    if (rq->bh && !buffer_locked(rq->bh)) {
  13010. +        printk("%s: block not locked\n", drive->name);
  13011. +        goto kill_rq;
  13012. +    }
  13013. +#endif
  13014. +    block    = rq->sector;
  13015. +    blockend = block + rq->nr_sectors;
  13016. +    if ((blockend < block) || (blockend > drive->part[minor&PARTN_MASK].nr_sects)) {
  13017. +        printk("%s%c: bad access: block=%ld, count=%ld\n", drive->name,
  13018. +         (minor&PARTN_MASK)?'0'+(minor&PARTN_MASK):' ', block, rq->nr_sectors);
  13019. +        goto kill_rq;
  13020. +    }
  13021. +    block += drive->part[minor&PARTN_MASK].start_sect + drive->sect0;
  13022. +#if FAKE_FDISK_FOR_EZDRIVE
  13023. +    if (block == 0 && drive->remap_0_to_1)
  13024. +        block = 1;  /* redirect MBR access to EZ-Drive partn table */
  13025. +#endif /* FAKE_FDISK_FOR_EZDRIVE */
  13026. +    ((ide_hwgroup_t *)hwif->hwgroup)->drive = drive;
  13027. +#if (DISK_RECOVERY_TIME > 0)
  13028. +    while ((read_timer() - hwif->last_time) < DISK_RECOVERY_TIME);
  13029. +#endif
  13030. +
  13031. +#ifdef CONFIG_BLK_DEV_IDETAPE
  13032. +    POLL_HWIF_TAPE_DRIVE;    /* macro from ide-tape.h */
  13033. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  13034. +
  13035. +    SELECT_DRIVE(hwif,drive);
  13036. +    if (ide_wait_stat(drive, drive->ready_stat, BUSY_STAT|DRQ_STAT, WAIT_READY)) {
  13037. +        printk("%s: drive not ready for command\n", drive->name);
  13038. +        return;
  13039. +    }
  13040. +
  13041. +    if (!drive->special.all) {
  13042. +        if (rq->cmd == IDE_DRIVE_CMD) {
  13043. +            execute_drive_cmd(drive, rq);
  13044. +            return;
  13045. +        }
  13046. +#ifdef CONFIG_BLK_DEV_IDEATAPI
  13047. +        switch (drive->media) {
  13048. +            case ide_disk:
  13049. +                do_rw_disk (drive, rq, block);
  13050. +                return;
  13051. +#ifdef CONFIG_BLK_DEV_IDECD
  13052. +            case ide_cdrom:
  13053. +                ide_do_rw_cdrom (drive, block);
  13054. +                return;
  13055. +#endif /* CONFIG_BLK_DEV_IDECD */
  13056. +#ifdef CONFIG_BLK_DEV_IDETAPE
  13057. +            case ide_tape:
  13058. +                idetape_do_request (drive, rq, block);
  13059. +                return;
  13060. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  13061. +
  13062. +            default:
  13063. +                printk("%s: media type %d not supported\n",
  13064. +                    drive->name, drive->media);
  13065. +                goto kill_rq;
  13066. +        }
  13067. +#else
  13068. +        do_rw_disk (drive, rq, block); /* simpler and faster */
  13069. +        return;
  13070. +#endif /* CONFIG_BLK_DEV_IDEATAPI */;
  13071. +    }
  13072. +    do_special(drive);
  13073. +    return;
  13074. +kill_rq:
  13075. +    ide_end_request(0, hwif->hwgroup);
  13076. +}
  13077. +
  13078. +/*
  13079. + * The driver enables interrupts as much as possible.  In order to do this,
  13080. + * (a) the device-interrupt is always masked before entry, and
  13081. + * (b) the timeout-interrupt is always disabled before entry.
  13082. + *
  13083. + * If we enter here from, say irq14, and then start a new request for irq15,
  13084. + * (possible with "serialize" option) then we cannot ensure that we exit
  13085. + * before the irq15 hits us. So, we must be careful not to let this bother us.
  13086. + *
  13087. + * Interrupts are still masked (by default) whenever we are exchanging
  13088. + * data/cmds with a drive, because some drives seem to have very poor
  13089. + * tolerance for latency during I/O.  For devices which don't suffer from
  13090. + * this problem (most don't), the unmask flag can be set using the "hdparm"
  13091. + * utility, to permit other interrupts during data/cmd transfers.
  13092. + */
  13093. +void ide_do_request (ide_hwgroup_t *hwgroup)
  13094. +{
  13095. +    cli();    /* paranoia */
  13096. +    if (hwgroup->handler != NULL) {
  13097. +        printk("%s: EEeekk!! handler not NULL in ide_do_request()\n", hwgroup->hwif->name);
  13098. +        return;
  13099. +    }
  13100. +    do {
  13101. +        ide_hwif_t *hwif = hwgroup->hwif;
  13102. +        struct request *rq;
  13103. +        if ((rq = hwgroup->rq) == NULL) {
  13104. +            if (hwif->sharing_irq && hwgroup->drive) /* set nIEN */
  13105. +                OUT_BYTE(hwgroup->drive->ctl|2,hwif->io.ctl_port);
  13106. +            /*
  13107. +             * hwgroup->next_hwif is different from hwgroup->hwif
  13108. +             * only when a request is inserted using "ide_next".
  13109. +             * This saves wear and tear on IDE tapes.
  13110. +             */
  13111. +            hwif = hwgroup->next_hwif;
  13112. +            do {
  13113. +                rq = blk_dev[hwif->major].current_request;
  13114. +                if (rq != NULL && rq->rq_status != RQ_INACTIVE)
  13115. +                    goto got_rq;
  13116. +            } while ((hwif = hwif->next) != hwgroup->next_hwif);
  13117. +            return;        /* no work left for this hwgroup */
  13118. +        }
  13119. +    got_rq:    
  13120. +        do_request(hwgroup->hwif = hwgroup->next_hwif = hwif, hwgroup->rq = rq);
  13121. +        cli();
  13122. +    } while (hwgroup->handler == NULL);
  13123. +}
  13124. +
  13125. +/*
  13126. + * do_hwgroup_request() invokes ide_do_request() after first masking
  13127. + * all possible interrupts for the current hwgroup.  This prevents race
  13128. + * conditions in the event that an unexpected interrupt occurs while
  13129. + * we are in the driver.
  13130. + *
  13131. + * Note that when an interrupt is used to reenter the driver, the first level
  13132. + * handler will already have masked the irq that triggered, but any other ones
  13133. + * for the hwgroup will still be unmasked.  The driver tries to be careful
  13134. + * about such things.
  13135. + */
  13136. +static void do_hwgroup_request (ide_hwgroup_t *hwgroup)
  13137. +{
  13138. +    if (hwgroup->handler == NULL) {
  13139. +        ide_hwif_t *hgif = hwgroup->hwif;
  13140. +        ide_hwif_t *hwif = hgif;
  13141. +        do {
  13142. +            disable_irq(hwif->irq);
  13143. +        } while ((hwif = hwif->next) != hgif);
  13144. +        ide_do_request (hwgroup);
  13145. +        do {
  13146. +            enable_irq(hwif->irq);
  13147. +        } while ((hwif = hwif->next) != hgif);
  13148. +    }
  13149. +}
  13150. +
  13151. +static void do_ide0_request (void)    /* invoked with cli() */
  13152. +{
  13153. +    do_hwgroup_request (ide_hwifs[0].hwgroup);
  13154. +}
  13155. +
  13156. +#if MAX_HWIFS > 1
  13157. +static void do_ide1_request (void)    /* invoked with cli() */
  13158. +{
  13159. +    do_hwgroup_request (ide_hwifs[1].hwgroup);
  13160. +}
  13161. +#endif
  13162. +
  13163. +#if MAX_HWIFS > 2
  13164. +static void do_ide2_request (void)    /* invoked with cli() */
  13165. +{
  13166. +    do_hwgroup_request (ide_hwifs[2].hwgroup);
  13167. +}
  13168. +#endif
  13169. +
  13170. +#if MAX_HWIFS > 3
  13171. +static void do_ide3_request (void)    /* invoked with cli() */
  13172. +{
  13173. +    do_hwgroup_request (ide_hwifs[3].hwgroup);
  13174. +}
  13175. +#endif
  13176. +
  13177. +static void timer_expiry (unsigned long data)
  13178. +{
  13179. +    ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data;
  13180. +    ide_drive_t   *drive   = hwgroup->drive;
  13181. +    unsigned long flags;
  13182. +
  13183. +    save_flags(flags);
  13184. +    cli();
  13185. +
  13186. +    if (hwgroup->poll_timeout != 0) { /* polling in progress? */
  13187. +        ide_handler_t *handler = hwgroup->handler;
  13188. +        hwgroup->handler = NULL;
  13189. +        handler(drive);
  13190. +    } else if (hwgroup->handler == NULL) {     /* not waiting for anything? */
  13191. +        sti(); /* drive must have responded just as the timer expired */
  13192. +        printk("%s: marginal timeout\n", drive->name);
  13193. +    } else {
  13194. +        hwgroup->handler = NULL;    /* abort the operation */
  13195. +        if (hwgroup->hwif->dmaproc)
  13196. +            (void) hwgroup->hwif->dmaproc (ide_dma_abort, drive);
  13197. +        ide_error(drive, "irq timeout", GET_STAT());
  13198. +    }
  13199. +    if (hwgroup->handler == NULL)
  13200. +        do_hwgroup_request (hwgroup);
  13201. +    restore_flags(flags);
  13202. +}
  13203. +
  13204. +/*
  13205. + * There's nothing really useful we can do with an unexpected interrupt,
  13206. + * other than reading the status register (to clear it), and logging it.
  13207. + * There should be no way that an irq can happen before we're ready for it,
  13208. + * so we needn't worry much about losing an "important" interrupt here.
  13209. + *
  13210. + * On laptops (and "green" PCs), an unexpected interrupt occurs whenever the
  13211. + * drive enters "idle", "standby", or "sleep" mode, so if the status looks
  13212. + * "good", we just ignore the interrupt completely.
  13213. + *
  13214. + * This routine assumes cli() is in effect when called.
  13215. + *
  13216. + * If an unexpected interrupt happens on irq15 while we are handling irq14
  13217. + * and if the two interfaces are "serialized" (CMD640), then it looks like
  13218. + * we could screw up by interfering with a new request being set up for irq15.
  13219. + *
  13220. + * In reality, this is a non-issue.  The new command is not sent unless the
  13221. + * drive is ready to accept one, in which case we know the drive is not
  13222. + * trying to interrupt us.  And ide_set_handler() is always invoked before
  13223. + * completing the issuance of any new drive command, so we will not be
  13224. + * accidently invoked as a result of any valid command completion interrupt.
  13225. + *
  13226. + */
  13227. +static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup)
  13228. +{
  13229. +    byte stat;
  13230. +    unsigned int unit;
  13231. +    ide_hwif_t *hwif = hwgroup->hwif;
  13232. +
  13233. +    /*
  13234. +     * handle the unexpected interrupt
  13235. +     */
  13236. +    do {
  13237. +        if (hwif->irq == irq) {
  13238. +            for (unit = 0; unit < MAX_DRIVES; ++unit) {
  13239. +                ide_drive_t *drive = &hwif->drives[unit];
  13240. +                if (!drive->present)
  13241. +                    continue;
  13242. +                SELECT_DRIVE(hwif,drive);
  13243. +                udelay(100);  /* Ugly, but wait_stat() may not be safe here */
  13244. +                if (!OK_STAT(stat=GET_STAT(), drive->ready_stat, BAD_STAT)) {
  13245. +                    /* Try to not flood the console with msgs */
  13246. +                    static unsigned long last_msgtime = 0;
  13247. +                    if ((last_msgtime + (HZ/2)) < jiffies) {
  13248. +                        last_msgtime = jiffies;
  13249. +                        (void) ide_dump_status(drive, "unexpected_intr", stat);
  13250. +                    }
  13251. +                }
  13252. +                if ((stat & DRQ_STAT))
  13253. +                    try_to_flush_leftover_data(drive);
  13254. +            }
  13255. +        }
  13256. +    } while ((hwif = hwif->next) != hwgroup->hwif);
  13257. +    SELECT_DRIVE(hwif,hwgroup->drive); /* Ugh.. probably interrupts current I/O */
  13258. +    udelay(100);  /* Ugly, but wait_stat() may not be safe here */
  13259. +}
  13260. +
  13261. +/*
  13262. + * entry point for all interrupts, caller does cli() for us
  13263. + */
  13264. +void ide_intr (int irq, void *dev_id, struct pt_regs *regs)
  13265. +{
  13266. +    ide_hwgroup_t *hwgroup = dev_id;
  13267. +    ide_handler_t *handler;
  13268. +
  13269. +    if (irq == hwgroup->hwif->irq && (handler = hwgroup->handler) != NULL) {
  13270. +        ide_drive_t *drive = hwgroup->drive;
  13271. +        hwgroup->handler = NULL;
  13272. +        del_timer(&(hwgroup->timer));
  13273. +        if (drive->unmask)
  13274. +            sti();
  13275. +        handler(drive);
  13276. +        cli();    /* this is necessary, as next rq may be different irq */
  13277. +        if (hwgroup->handler == NULL) {
  13278. +            SET_RECOVERY_TIMER(HWIF(drive));
  13279. +            ide_do_request(hwgroup);
  13280. +        }
  13281. +    } else {
  13282. +        unexpected_intr(irq, hwgroup);
  13283. +    }
  13284. +    cli();
  13285. +}
  13286. +
  13287. +/*
  13288. + * get_info_ptr() returns the (ide_drive_t *) for a given device number.
  13289. + * It returns NULL if the given device number does not match any present drives.
  13290. + */
  13291. +static ide_drive_t *get_info_ptr (kdev_t i_rdev)
  13292. +{
  13293. +    int        major = MAJOR(i_rdev);
  13294. +    unsigned int    h;
  13295. +
  13296. +    for (h = 0; h < MAX_HWIFS; ++h) {
  13297. +        ide_hwif_t  *hwif = &ide_hwifs[h];
  13298. +        if (hwif->present && major == hwif->major) {
  13299. +            unsigned unit = DEVICE_NR(i_rdev);
  13300. +            if (unit < MAX_DRIVES) {
  13301. +                ide_drive_t *drive = &hwif->drives[unit];
  13302. +                if (drive->present)
  13303. +                    return drive;
  13304. +            } else if (major == IDE0_MAJOR && unit < 4) {
  13305. +                printk("ide: probable bad entry for /dev/hd%c\n", 'a'+unit);
  13306. +                printk("ide: to fix it, run:  /usr/src/linux/scripts/MAKEDEV.ide\n");
  13307. +            }
  13308. +            break;
  13309. +        }
  13310. +    }
  13311. +    return NULL;
  13312. +}
  13313. +
  13314. +/*
  13315. + * This function is intended to be used prior to invoking ide_do_drive_cmd().
  13316. + */
  13317. +void ide_init_drive_cmd (struct request *rq)
  13318. +{
  13319. +    rq->buffer = NULL;
  13320. +    rq->cmd = IDE_DRIVE_CMD;
  13321. +    rq->sector = 0;
  13322. +    rq->nr_sectors = 0;
  13323. +    rq->current_nr_sectors = 0;
  13324. +    rq->sem = NULL;
  13325. +    rq->bh = NULL;
  13326. +    rq->bhtail = NULL;
  13327. +    rq->next = NULL;
  13328. +
  13329. +#if 0    /* these are done each time through ide_do_drive_cmd() */
  13330. +    rq->errors = 0;
  13331. +    rq->rq_status = RQ_ACTIVE;
  13332. +    rq->rq_dev = ????;
  13333. +#endif
  13334. +}
  13335. +
  13336. +/*
  13337. + * This function issues a special IDE device request
  13338. + * onto the request queue.
  13339. + *
  13340. + * If action is ide_wait, then then rq is queued at the end of
  13341. + * the request queue, and the function sleeps until it has been
  13342. + * processed.  This is for use when invoked from an ioctl handler.
  13343. + *
  13344. + * If action is ide_preempt, then the rq is queued at the head of
  13345. + * the request queue, displacing the currently-being-processed
  13346. + * request and this function returns immediately without waiting
  13347. + * for the new rq to be completed.  This is VERY DANGEROUS, and is
  13348. + * intended for careful use by the ATAPI tape/cdrom driver code.
  13349. + *
  13350. + * If action is ide_next, then the rq is queued immediately after
  13351. + * the currently-being-processed-request (if any), and the function
  13352. + * returns without waiting for the new rq to be completed.  As above,
  13353. + * This is VERY DANGEROUS, and is intended for careful use by the
  13354. + * ATAPI tape/cdrom driver code.
  13355. + *
  13356. + * If action is ide_end, then the rq is queued at the end of the
  13357. + * request queue, and the function returns immediately without waiting
  13358. + * for the new rq to be completed. This is again intended for careful
  13359. + * use by the ATAPI tape/cdrom driver code. (Currently used by ide-tape.c,
  13360. + * when operating in the pipelined operation mode).
  13361. + */
  13362. +int ide_do_drive_cmd (ide_drive_t *drive, struct request *rq, ide_action_t action)
  13363. +{
  13364. +    unsigned long flags;
  13365. +    unsigned int major = HWIF(drive)->major;
  13366. +    struct request *cur_rq;
  13367. +    struct blk_dev_struct *bdev = &blk_dev[major];
  13368. +    struct semaphore sem = MUTEX_LOCKED;
  13369. +
  13370. +    if (IS_PROMISE_DRIVE && rq->buffer != NULL)
  13371. +        return -ENOSYS;  /* special drive cmds not supported */
  13372. +    rq->errors = 0;
  13373. +    rq->rq_status = RQ_ACTIVE;
  13374. +    rq->rq_dev = MKDEV(major,(drive->select.b.unit)<<PARTN_BITS);
  13375. +    if (action == ide_wait)
  13376. +        rq->sem = &sem;
  13377. +    unplug_device(bdev);
  13378. +
  13379. +    save_flags(flags);
  13380. +    cli();
  13381. +    if (action == ide_next)
  13382. +        HWGROUP(drive)->next_hwif = HWIF(drive);
  13383. +    cur_rq = bdev->current_request;
  13384. +
  13385. +    if (cur_rq == NULL || action == ide_preempt) {
  13386. +        rq->next = cur_rq;
  13387. +        bdev->current_request = rq;
  13388. +        if (action == ide_preempt) {
  13389. +            HWGROUP(drive)->rq = NULL;
  13390. +        } else
  13391. +        if (HWGROUP(drive)->rq == NULL) {  /* is this necessary (?) */
  13392. +            bdev->request_fn();
  13393. +            cli();
  13394. +        }
  13395. +    } else {
  13396. +        if (action == ide_wait || action == ide_end) {
  13397. +            while (cur_rq->next != NULL)    /* find end of list */
  13398. +                cur_rq = cur_rq->next;
  13399. +        }
  13400. +        rq->next = cur_rq->next;
  13401. +        cur_rq->next = rq;
  13402. +    }
  13403. +    if (action == ide_wait  && rq->rq_status != RQ_INACTIVE)
  13404. +        down(&sem);    /* wait for it to be serviced */
  13405. +    restore_flags(flags);
  13406. +    return rq->errors ? -EIO : 0;    /* return -EIO if errors */
  13407. +}
  13408. +
  13409. +static int ide_open(struct inode * inode, struct file * filp)
  13410. +{
  13411. +    ide_drive_t *drive;
  13412. +    unsigned long flags;
  13413. +
  13414. +    if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
  13415. +        return -ENXIO;
  13416. +    save_flags(flags);
  13417. +    cli();
  13418. +    while (drive->busy)
  13419. +        sleep_on(&drive->wqueue);
  13420. +    drive->usage++;
  13421. +    restore_flags(flags);
  13422. +#ifdef CONFIG_BLK_DEV_IDECD
  13423. +    if (drive->media == ide_cdrom)
  13424. +        return ide_cdrom_open (inode, filp, drive);
  13425. +#endif    /* CONFIG_BLK_DEV_IDECD */
  13426. +#ifdef CONFIG_BLK_DEV_IDETAPE
  13427. +    if (drive->media == ide_tape)
  13428. +        return idetape_blkdev_open (inode, filp, drive);
  13429. +#endif    /* CONFIG_BLK_DEV_IDETAPE */
  13430. +    if (drive->removable) {
  13431. +        byte door_lock[] = {WIN_DOORLOCK,0,0,0};
  13432. +        struct request rq;
  13433. +        check_disk_change(inode->i_rdev);
  13434. +        ide_init_drive_cmd (&rq);
  13435. +        rq.buffer = door_lock;
  13436. +        /*
  13437. +         * Ignore the return code from door_lock,
  13438. +         * since the open() has already succeeded,
  13439. +         * and the door_lock is irrelevant at this point.
  13440. +         */
  13441. +        (void) ide_do_drive_cmd(drive, &rq, ide_wait);
  13442. +    }
  13443. +    return 0;
  13444. +}
  13445. +
  13446. +/*
  13447. + * Releasing a block device means we sync() it, so that it can safely
  13448. + * be forgotten about...
  13449. + */
  13450. +static void ide_release(struct inode * inode, struct file * file)
  13451. +{
  13452. +    ide_drive_t *drive;
  13453. +
  13454. +    if ((drive = get_info_ptr(inode->i_rdev)) != NULL) {
  13455. +        fsync_dev(inode->i_rdev);
  13456. +        drive->usage--;
  13457. +#ifdef CONFIG_BLK_DEV_IDECD
  13458. +        if (drive->media == ide_cdrom) {
  13459. +            ide_cdrom_release (inode, file, drive);
  13460. +            return;
  13461. +        }
  13462. +#endif    /* CONFIG_BLK_DEV_IDECD */
  13463. +#ifdef CONFIG_BLK_DEV_IDETAPE
  13464. +        if (drive->media == ide_tape) {
  13465. +            idetape_blkdev_release (inode, file, drive);
  13466. +            return;
  13467. +        }
  13468. +#endif    /* CONFIG_BLK_DEV_IDETAPE */
  13469. +        if (drive->removable && !drive->usage) {
  13470. +            byte door_unlock[] = {WIN_DOORUNLOCK,0,0,0};
  13471. +            struct request rq;
  13472. +            invalidate_buffers(inode->i_rdev);
  13473. +            ide_init_drive_cmd (&rq);
  13474. +            rq.buffer = door_unlock;
  13475. +            (void) ide_do_drive_cmd(drive, &rq, ide_wait);
  13476. +        }
  13477. +    }
  13478. +}
  13479. +
  13480. +/*
  13481. + * This routine is called to flush all partitions and partition tables
  13482. + * for a changed disk, and then re-read the new partition table.
  13483. + * If we are revalidating a disk because of a media change, then we
  13484. + * enter with usage == 0.  If we are using an ioctl, we automatically have
  13485. + * usage == 1 (we need an open channel to use an ioctl :-), so this
  13486. + * is our limit.
  13487. + */
  13488. +static int revalidate_disk(kdev_t i_rdev)
  13489. +{
  13490. +    ide_drive_t *drive;
  13491. +    unsigned int p, major, minor;
  13492. +    long flags;
  13493. +
  13494. +    if ((drive = get_info_ptr(i_rdev)) == NULL)
  13495. +        return -ENODEV;
  13496. +
  13497. +    major = MAJOR(i_rdev);
  13498. +    minor = drive->select.b.unit << PARTN_BITS;
  13499. +    save_flags(flags);
  13500. +    cli();
  13501. +    if (drive->busy || (drive->usage > 1)) {
  13502. +        restore_flags(flags);
  13503. +        return -EBUSY;
  13504. +    };
  13505. +    drive->busy = 1;
  13506. +    restore_flags(flags);
  13507. +
  13508. +    for (p = 0; p < (1<<PARTN_BITS); ++p) {
  13509. +        if (drive->part[p].nr_sects > 0) {
  13510. +            kdev_t devp = MKDEV(major, minor+p);
  13511. +            sync_dev           (devp);
  13512. +            invalidate_inodes  (devp);
  13513. +            invalidate_buffers (devp);
  13514. +        }
  13515. +        drive->part[p].start_sect = 0;
  13516. +        drive->part[p].nr_sects   = 0;
  13517. +    };
  13518. +
  13519. +    drive->part[0].nr_sects = current_capacity(drive);
  13520. +    if (drive->media != ide_disk)
  13521. +        drive->part[0].start_sect = -1;
  13522. +    resetup_one_dev(HWIF(drive)->gd, drive->select.b.unit);
  13523. +
  13524. +    drive->busy = 0;
  13525. +    wake_up(&drive->wqueue);
  13526. +    return 0;
  13527. +}
  13528. +
  13529. +static int write_fs_long (unsigned long useraddr, long value)
  13530. +{
  13531. +    int err;
  13532. +
  13533. +    if (NULL == (long *)useraddr)
  13534. +        return -EINVAL;
  13535. +    if ((err = verify_area(VERIFY_WRITE, (long *)useraddr, sizeof(long))))
  13536. +        return err;
  13537. +    put_user((unsigned)value, (long *) useraddr);
  13538. +    return 0;
  13539. +}
  13540. +
  13541. +static int ide_ioctl (struct inode *inode, struct file *file,
  13542. +            unsigned int cmd, unsigned long arg)
  13543. +{
  13544. +    int err;
  13545. +    ide_drive_t *drive;
  13546. +    unsigned long flags;
  13547. +    struct request rq;
  13548. +
  13549. +    if (!inode || !(inode->i_rdev))
  13550. +        return -EINVAL;
  13551. +    if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
  13552. +        return -ENODEV;
  13553. +    ide_init_drive_cmd (&rq);
  13554. +    switch (cmd) {
  13555. +        case HDIO_GETGEO:
  13556. +        {
  13557. +            struct hd_geometry *loc = (struct hd_geometry *) arg;
  13558. +            if (!loc || drive->media != ide_disk) return -EINVAL;
  13559. +            err = verify_area(VERIFY_WRITE, loc, sizeof(*loc));
  13560. +            if (err) return err;
  13561. +            put_user(drive->bios_head, (byte *) &loc->heads);
  13562. +            put_user(drive->bios_sect, (byte *) &loc->sectors);
  13563. +            put_user(drive->bios_cyl, (unsigned short *) &loc->cylinders);
  13564. +            put_user((unsigned)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].start_sect,
  13565. +                (unsigned long *) &loc->start);
  13566. +            return 0;
  13567. +        }
  13568. +        case BLKFLSBUF:
  13569. +            if (!suser()) return -EACCES;
  13570. +            fsync_dev(inode->i_rdev);
  13571. +            invalidate_buffers(inode->i_rdev);
  13572. +            return 0;
  13573. +
  13574. +        case BLKRASET:
  13575. +            if (!suser()) return -EACCES;
  13576. +            if(arg > 0xff) return -EINVAL;
  13577. +            read_ahead[MAJOR(inode->i_rdev)] = arg;
  13578. +            return 0;
  13579. +
  13580. +        case BLKRAGET:
  13581. +            return write_fs_long(arg, read_ahead[MAJOR(inode->i_rdev)]);
  13582. +
  13583. +         case BLKGETSIZE:   /* Return device size */
  13584. +            return write_fs_long(arg, drive->part[MINOR(inode->i_rdev)&PARTN_MASK].nr_sects);
  13585. +        case BLKRRPART: /* Re-read partition tables */
  13586. +            if (!suser()) return -EACCES;
  13587. +            return revalidate_disk(inode->i_rdev);
  13588. +
  13589. +        case HDIO_GET_KEEPSETTINGS:
  13590. +            return write_fs_long(arg, drive->keep_settings);
  13591. +
  13592. +        case HDIO_GET_UNMASKINTR:
  13593. +            return write_fs_long(arg, drive->unmask);
  13594. +
  13595. +        case HDIO_GET_DMA:
  13596. +            return write_fs_long(arg, drive->using_dma);
  13597. +
  13598. +        case HDIO_GET_32BIT:
  13599. +            return write_fs_long(arg, drive->io_32bit);
  13600. +
  13601. +        case HDIO_GET_MULTCOUNT:
  13602. +            return write_fs_long(arg, drive->mult_count);
  13603. +
  13604. +        case HDIO_GET_IDENTITY:
  13605. +            if (!arg || (MINOR(inode->i_rdev) & PARTN_MASK))
  13606. +                return -EINVAL;
  13607. +            if (drive->id == NULL)
  13608. +                return -ENOMSG;
  13609. +            err = verify_area(VERIFY_WRITE, (char *)arg, sizeof(*drive->id));
  13610. +            if (!err)
  13611. +                memcpy_tofs((char *)arg, (char *)drive->id, sizeof(*drive->id));
  13612. +            return err;
  13613. +
  13614. +            case HDIO_GET_NOWERR:
  13615. +            return write_fs_long(arg, drive->bad_wstat == BAD_R_STAT);
  13616. +
  13617. +        case HDIO_SET_DMA:
  13618. +            if (!suser()) return -EACCES;
  13619. +#ifdef CONFIG_BLK_DEV_IDECD
  13620. +            if (drive->media == ide_cdrom)
  13621. +                return -EPERM;
  13622. +#endif /* CONFIG_BLK_DEV_IDECD */
  13623. +            if (!drive->id || !(drive->id->capability & 1) || !HWIF(drive)->dmaproc)
  13624. +                return -EPERM;
  13625. +        case HDIO_SET_KEEPSETTINGS:
  13626. +        case HDIO_SET_UNMASKINTR:
  13627. +        case HDIO_SET_NOWERR:
  13628. +            if (arg > 1)
  13629. +                return -EINVAL;
  13630. +        case HDIO_SET_32BIT:
  13631. +            if (!suser()) return -EACCES;
  13632. +            if ((MINOR(inode->i_rdev) & PARTN_MASK))
  13633. +                return -EINVAL;
  13634. +            save_flags(flags);
  13635. +            cli();
  13636. +            switch (cmd) {
  13637. +                case HDIO_SET_DMA:
  13638. +                    if (!(HWIF(drive)->dmaproc)) {
  13639. +                        restore_flags(flags);
  13640. +                        return -EPERM;
  13641. +                    }
  13642. +                    drive->using_dma = arg;
  13643. +                    break;
  13644. +                case HDIO_SET_KEEPSETTINGS:
  13645. +                    drive->keep_settings = arg;
  13646. +                    break;
  13647. +                case HDIO_SET_UNMASKINTR:
  13648. +                    if (arg && drive->no_unmask) {
  13649. +                        restore_flags(flags);
  13650. +                        return -EPERM;
  13651. +                    }
  13652. +                    drive->unmask = arg;
  13653. +                    break;
  13654. +                case HDIO_SET_NOWERR:
  13655. +                    drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
  13656. +                    break;
  13657. +                case HDIO_SET_32BIT:
  13658. +                    if (arg > 1) {
  13659. +                        restore_flags (flags);
  13660. +                        return -EINVAL;
  13661. +                    }
  13662. +                    if (arg && drive->no_io_32bit) {
  13663. +                        restore_flags(flags);
  13664. +                        return -EPERM;
  13665. +                    }
  13666. +                    drive->io_32bit = arg;
  13667. +#ifdef CONFIG_BLK_DEV_DTC2278
  13668. +                    if (HWIF(drive)->chipset == ide_dtc2278)
  13669. +                        HWIF(drive)->drives[!drive->select.b.unit].io_32bit = arg;
  13670. +#endif /* CONFIG_BLK_DEV_DTC2278 */
  13671. +                    break;
  13672. +            }
  13673. +            restore_flags(flags);
  13674. +            return 0;
  13675. +
  13676. +        case HDIO_SET_MULTCOUNT:
  13677. +            if (!suser()) return -EACCES;
  13678. +            if (MINOR(inode->i_rdev) & PARTN_MASK)
  13679. +                return -EINVAL;
  13680. +            if (drive->id && arg > drive->id->max_multsect)
  13681. +                return -EINVAL;
  13682. +            save_flags(flags);
  13683. +            cli();
  13684. +            if (drive->special.b.set_multmode) {
  13685. +                restore_flags(flags);
  13686. +                return -EBUSY;
  13687. +            }
  13688. +            drive->mult_req = arg;
  13689. +            drive->special.b.set_multmode = 1;
  13690. +            restore_flags(flags);
  13691. +            (void) ide_do_drive_cmd (drive, &rq, ide_wait);
  13692. +            return (drive->mult_count == arg) ? 0 : -EIO;
  13693. +
  13694. +        case HDIO_DRIVE_CMD:
  13695. +        {
  13696. +            byte args[4], *argbuf = args;
  13697. +            int argsize = 4;
  13698. +            if (!suser()) return -EACCES;
  13699. +            if (NULL == (void *) arg) {
  13700. +                err = ide_do_drive_cmd(drive, &rq, ide_wait);
  13701. +            } else if (!(err = verify_area(VERIFY_READ,(void *)arg, 4))) {
  13702. +                memcpy_fromfs(args, (void *)arg, 4);
  13703. +                if (args[3]) {
  13704. +                    argsize = 4 + (SECTOR_WORDS * 4 * args[3]);
  13705. +                    argbuf = kmalloc(argsize, GFP_KERNEL);
  13706. +                    if (argbuf == NULL)
  13707. +                        return -ENOMEM;
  13708. +                    argbuf[0] = args[0];
  13709. +                    argbuf[1] = args[1];
  13710. +                    argbuf[2] = args[2];
  13711. +                    argbuf[3] = args[3];
  13712. +                }
  13713. +                if (!(err = verify_area(VERIFY_WRITE,(void *)arg, argsize))) {
  13714. +                    rq.buffer = argbuf;
  13715. +                    err = ide_do_drive_cmd(drive, &rq, ide_wait);
  13716. +                    memcpy_tofs((void *)arg, argbuf, argsize);
  13717. +                }
  13718. +                if (argsize > 4)
  13719. +                    kfree(argbuf);
  13720. +            }
  13721. +            return err;
  13722. +        }
  13723. +        case HDIO_SET_PIO_MODE:
  13724. +            if (!suser()) return -EACCES;
  13725. +            if (MINOR(inode->i_rdev) & PARTN_MASK)
  13726. +                return -EINVAL;
  13727. +            if (!HWIF(drive)->tuneproc)
  13728. +                return -ENOSYS;
  13729. +            save_flags(flags);
  13730. +            cli();
  13731. +            if (drive->special.b.set_tune) {
  13732. +                restore_flags(flags);
  13733. +                return -EBUSY;
  13734. +            }
  13735. +            drive->tune_req = (byte) arg;
  13736. +            drive->special.b.set_tune = 1;
  13737. +            restore_flags(flags);
  13738. +            (void) ide_do_drive_cmd (drive, &rq, ide_wait);
  13739. +            return 0;
  13740. +
  13741. +        RO_IOCTLS(inode->i_rdev, arg);
  13742. +
  13743. +        default:
  13744. +#ifdef CONFIG_BLK_DEV_IDECD
  13745. +            if (drive->media == ide_cdrom)
  13746. +                return ide_cdrom_ioctl(drive, inode, file, cmd, arg);
  13747. +#endif /* CONFIG_BLK_DEV_IDECD */
  13748. +#ifdef CONFIG_BLK_DEV_IDETAPE
  13749. +            if (drive->media == ide_tape)
  13750. +                return idetape_blkdev_ioctl(drive, inode, file, cmd, arg);
  13751. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  13752. +            return -EPERM;
  13753. +    }
  13754. +}
  13755. +
  13756. +static int ide_check_media_change (kdev_t i_rdev)
  13757. +{
  13758. +    ide_drive_t *drive;
  13759. +
  13760. +    if ((drive = get_info_ptr(i_rdev)) == NULL)
  13761. +        return -ENODEV;
  13762. +#ifdef CONFIG_BLK_DEV_IDECD
  13763. +    if (drive->media == ide_cdrom)
  13764. +        return ide_cdrom_check_media_change (drive);
  13765. +#endif    /* CONFIG_BLK_DEV_IDECD */
  13766. +    if (drive->removable) /* for disks */
  13767. +        return 1;    /* always assume it was changed */
  13768. +    return 0;
  13769. +}
  13770. +
  13771. +void ide_fixstring (byte *s, const int bytecount, const int byteswap)
  13772. +{
  13773. +    byte *p = s, *end = &s[bytecount & ~1]; /* bytecount must be even */
  13774. +
  13775. +    if (byteswap) {
  13776. +        /* convert from big-endian to host byte order */
  13777. +        for (p = end ; p != s;) {
  13778. +            unsigned short *pp = (unsigned short *) (p -= 2);
  13779. +            *pp = ntohs(*pp);
  13780. +        }
  13781. +    }
  13782. +
  13783. +    /* strip leading blanks */
  13784. +    while (s != end && *s == ' ')
  13785. +        ++s;
  13786. +
  13787. +    /* compress internal blanks and strip trailing blanks */
  13788. +    while (s != end && *s) {
  13789. +        if (*s++ != ' ' || (s != end && *s && *s != ' '))
  13790. +            *p++ = *(s-1);
  13791. +    }
  13792. +
  13793. +    /* wipe out trailing garbage */
  13794. +    while (p != end)
  13795. +        *p++ = '\0';
  13796. +}
  13797. +
  13798. +static inline void do_identify (ide_drive_t *drive, byte cmd)
  13799. +{
  13800. +    int bswap;
  13801. +    struct hd_driveid *id;
  13802. +    unsigned long capacity, check;
  13803. +
  13804. +    id = drive->id = kmalloc (SECTOR_WORDS*4, GFP_KERNEL);
  13805. +    ide_input_data(drive, id, SECTOR_WORDS);    /* read 512 bytes of id info */
  13806. +    sti();
  13807. +
  13808. +    /*
  13809. +     * EATA SCSI controllers do a hardware ATA emulation:  ignore them
  13810. +     */
  13811. +    if ((id->model[0] == 'P' && id->model[1] == 'M')
  13812. +     || (id->model[0] == 'S' && id->model[1] == 'K')) {
  13813. +        printk("%s: EATA SCSI HBA %.10s\n", drive->name, id->model);
  13814. +        drive->present = 0;
  13815. +        return;
  13816. +    }
  13817. +
  13818. +    /*
  13819. +     *  WIN_IDENTIFY returns little-endian info,
  13820. +     *  WIN_PIDENTIFY *usually* returns little-endian info.
  13821. +     */
  13822. +    bswap = 1;
  13823. +    if (cmd == WIN_PIDENTIFY) {
  13824. +        if ((id->model[0] == 'N' && id->model[1] == 'E') /* NEC */
  13825. +         || (id->model[0] == 'F' && id->model[1] == 'X') /* Mitsumi */
  13826. +         || (id->model[0] == 'P' && id->model[1] == 'i'))/* Pioneer */
  13827. +            bswap = 0;    /* Vertos drives may still be weird */
  13828. +    }
  13829. +    ide_fixstring (id->model,     sizeof(id->model),     bswap);
  13830. +    ide_fixstring (id->fw_rev,    sizeof(id->fw_rev),    bswap);
  13831. +    ide_fixstring (id->serial_no, sizeof(id->serial_no), bswap);
  13832. +
  13833. +#ifdef CONFIG_BLK_DEV_IDEATAPI
  13834. +    /*
  13835. +     * Check for an ATAPI device
  13836. +     */
  13837. +    if (cmd == WIN_PIDENTIFY) {
  13838. +        byte type = (id->config >> 8) & 0x1f;
  13839. +        printk("%s: %s, ATAPI ", drive->name, id->model);
  13840. +#ifdef CONFIG_BLK_DEV_PROMISE
  13841. +        if (HWIF(drive)->is_promise2) {
  13842. +            printk(" -- not supported on 2nd Promise port\n");
  13843. +            drive->present = 0;
  13844. +            return;
  13845. +        }
  13846. +#endif /* CONFIG_BLK_DEV_PROMISE */
  13847. +        switch (type) {
  13848. +            case 0:        /* Early cdrom models used zero */
  13849. +            case 5:
  13850. +#ifdef CONFIG_BLK_DEV_IDECD
  13851. +                printk ("CDROM drive\n");
  13852. +                drive->media = ide_cdrom;
  13853. +                 drive->present = 1;
  13854. +                drive->removable = 1;
  13855. +                return;
  13856. +#else
  13857. +                printk ("CDROM ");
  13858. +                break;
  13859. +#endif /* CONFIG_BLK_DEV_IDECD */
  13860. +            case 1:
  13861. +#ifdef CONFIG_BLK_DEV_IDETAPE
  13862. +                printk ("TAPE drive");
  13863. +                if (idetape_identify_device (drive,id)) {
  13864. +                    drive->media = ide_tape;
  13865. +                    drive->present = 1;
  13866. +                    drive->removable = 1;
  13867. +                    if (drive->autotune != 2 && HWIF(drive)->dmaproc != NULL) {
  13868. +                        if (!HWIF(drive)->dmaproc(ide_dma_check, drive))
  13869. +                            printk(", DMA");
  13870. +                    }
  13871. +                    printk("\n");
  13872. +                }
  13873. +                else {
  13874. +                    drive->present = 0;
  13875. +                    printk ("\nide-tape: the tape is not supported by this version of the driver\n");
  13876. +                }
  13877. +                return;
  13878. +#else
  13879. +                printk ("TAPE ");
  13880. +                break;
  13881. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  13882. +            default:
  13883. +                drive->present = 0;
  13884. +                printk("Type %d - Unknown device\n", type);
  13885. +                return;
  13886. +        }
  13887. +        drive->present = 0;
  13888. +        printk("- not supported by this kernel\n");
  13889. +        return;
  13890. +    }
  13891. +#endif /* CONFIG_BLK_DEV_IDEATAPI */
  13892. +
  13893. +    /* check for removable disks (eg. SYQUEST), ignore 'WD' drives */
  13894. +    if (id->config & (1<<7)) {    /* removable disk ? */
  13895. +        if (id->model[0] != 'W' || id->model[1] != 'D')
  13896. +            drive->removable = 1;
  13897. +    }
  13898. +
  13899. +    /* SunDisk drives: treat as non-removable, force one unit */
  13900. +    if (id->model[0] == 'S' && id->model[1] == 'u') {
  13901. +        drive->removable = 0;
  13902. +        if (drive->select.all & (1<<4)) {
  13903. +            drive->present = 0;
  13904. +            return;
  13905. +        }
  13906. +    }
  13907. +
  13908. +    drive->media = ide_disk;
  13909. +    /* Extract geometry if we did not already have one for the drive */
  13910. +    if (!drive->present) {
  13911. +        drive->present = 1;
  13912. +        drive->cyl     = drive->bios_cyl  = id->cyls;
  13913. +        drive->head    = drive->bios_head = id->heads;
  13914. +        drive->sect    = drive->bios_sect = id->sectors;
  13915. +    }
  13916. +    /* Handle logical geometry translation by the drive */
  13917. +    if ((id->field_valid & 1) && id->cur_cyls && id->cur_heads
  13918. +     && (id->cur_heads <= 16) && id->cur_sectors)
  13919. +    {
  13920. +        /*
  13921. +         * Extract the physical drive geometry for our use.
  13922. +         * Note that we purposely do *not* update the bios info.
  13923. +         * This way, programs that use it (like fdisk) will
  13924. +         * still have the same logical view as the BIOS does,
  13925. +         * which keeps the partition table from being screwed.
  13926. +         *
  13927. +         * An exception to this is the cylinder count,
  13928. +         * which we reexamine later on to correct for 1024 limitations.
  13929. +         */
  13930. +        drive->cyl  = id->cur_cyls;
  13931. +        drive->head = id->cur_heads;
  13932. +        drive->sect = id->cur_sectors;
  13933. +
  13934. +        /* check for word-swapped "capacity" field in id information */
  13935. +        capacity = drive->cyl * drive->head * drive->sect;
  13936. +        check = (id->cur_capacity0 << 16) | id->cur_capacity1;
  13937. +        if (check == capacity) {    /* was it swapped? */
  13938. +            /* yes, bring it into little-endian order: */
  13939. +            id->cur_capacity0 = (capacity >>  0) & 0xffff;
  13940. +            id->cur_capacity1 = (capacity >> 16) & 0xffff;
  13941. +        }
  13942. +    }
  13943. +    /* Use physical geometry if what we have still makes no sense */
  13944. +    if ((!drive->head || drive->head > 16) && id->heads && id->heads <= 16) {
  13945. +        drive->cyl  = id->cyls;
  13946. +        drive->head = id->heads;
  13947. +        drive->sect = id->sectors;
  13948. +    }
  13949. +    /* Correct the number of cyls if the bios value is too small */
  13950. +    if (drive->sect == drive->bios_sect && drive->head == drive->bios_head) {
  13951. +        if (drive->cyl > drive->bios_cyl)
  13952. +            drive->bios_cyl = drive->cyl;
  13953. +    }
  13954. +
  13955. +    (void) current_capacity (drive); /* initialize LBA selection */
  13956. +
  13957. +    printk ("%s: %.40s, %ldMB w/%dkB Cache, %sCHS=%d/%d/%d",
  13958. +     drive->name, id->model, current_capacity(drive)/2048L, id->buf_size/2,
  13959. +     drive->select.b.lba ? "LBA, " : "",
  13960. +     drive->bios_cyl, drive->bios_head, drive->bios_sect);
  13961. +
  13962. +    drive->mult_count = 0;
  13963. +    if (id->max_multsect) {
  13964. +        drive->mult_req = INITIAL_MULT_COUNT;
  13965. +        if (drive->mult_req > id->max_multsect)
  13966. +            drive->mult_req = id->max_multsect;
  13967. +        if (drive->mult_req || ((id->multsect_valid & 1) && id->multsect))
  13968. +            drive->special.b.set_multmode = 1;
  13969. +    }
  13970. +    if (drive->autotune != 2 && HWIF(drive)->dmaproc != NULL) {
  13971. +        if (!(HWIF(drive)->dmaproc(ide_dma_check, drive)))
  13972. +            printk(", DMA");
  13973. +    }
  13974. +    printk("\n");
  13975. +}
  13976. +
  13977. +/*
  13978. + * Delay for *at least* 50ms.  As we don't know how much time is left
  13979. + * until the next tick occurs, we wait an extra tick to be safe.
  13980. + * This is used only during the probing/polling for drives at boot time.
  13981. + */
  13982. +static void delay_50ms (void)
  13983. +{
  13984. +    unsigned long timer = jiffies + (HZ + 19)/20 + 1;
  13985. +    while (timer > jiffies);
  13986. +}
  13987. +
  13988. +/*
  13989. + * try_to_identify() sends an ATA(PI) IDENTIFY request to a drive
  13990. + * and waits for a response.  It also monitors irqs while this is
  13991. + * happening, in hope of automatically determining which one is
  13992. + * being used by the interface.
  13993. + *
  13994. + * Returns:    0  device was identified
  13995. + *        1  device timed-out (no response to identify request)
  13996. + *        2  device aborted the command (refused to identify itself)
  13997. + */
  13998. +static int try_to_identify (ide_drive_t *drive, byte cmd)
  13999. +{
  14000. +    int hd_status, rc;
  14001. +    unsigned long timeout;
  14002. +    int irqs = 0;
  14003. +
  14004. +    if (!HWIF(drive)->irq) {        /* already got an IRQ? */
  14005. +        probe_irq_off(probe_irq_on());    /* clear dangling irqs */
  14006. +        irqs = probe_irq_on();        /* start monitoring irqs */
  14007. +        OUT_BYTE(drive->ctl,IDE_CONTROL_REG);    /* enable device irq */
  14008. +    }
  14009. +
  14010. +    delay_50ms();                /* take a deep breath */
  14011. +    if ((IN_BYTE(IDE_ALTSTATUS_REG) ^ IN_BYTE(IDE_STATUS_REG)) & ~INDEX_STAT) {
  14012. +        printk("%s: probing with STATUS instead of ALTSTATUS\n", drive->name);
  14013. +        hd_status = IDE_STATUS_REG;    /* ancient Seagate drives */
  14014. +    } else
  14015. +        hd_status = IDE_ALTSTATUS_REG;    /* use non-intrusive polling */
  14016. +
  14017. +#if CONFIG_BLK_DEV_PROMISE
  14018. +    if (IS_PROMISE_DRIVE) {
  14019. +        if (promise_cmd(drive,PROMISE_IDENTIFY)) {
  14020. +            if (irqs)
  14021. +                (void) probe_irq_off(irqs);
  14022. +            return 1;
  14023. +        }
  14024. +    } else
  14025. +#endif /* CONFIG_BLK_DEV_PROMISE */
  14026. +        OUT_BYTE(cmd,IDE_COMMAND_REG);        /* ask drive for ID */
  14027. +    timeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
  14028. +    timeout += jiffies;
  14029. +    do {
  14030. +        if (jiffies > timeout) {
  14031. +            if (irqs)
  14032. +                (void) probe_irq_off(irqs);
  14033. +            return 1;    /* drive timed-out */
  14034. +        }
  14035. +        delay_50ms();        /* give drive a breather */
  14036. +    } while (IN_BYTE(hd_status) & BUSY_STAT);
  14037. +
  14038. +    delay_50ms();        /* wait for IRQ and DRQ_STAT */
  14039. +    if (OK_STAT(GET_STAT(),DRQ_STAT,BAD_R_STAT)) {
  14040. +        unsigned long flags;
  14041. +        save_flags(flags);
  14042. +        cli();            /* some systems need this */
  14043. +        do_identify(drive, cmd); /* drive returned ID */
  14044. +        rc = 0;            /* drive responded with ID */
  14045. +        (void) GET_STAT();    /* clear drive IRQ */
  14046. +        restore_flags(flags);
  14047. +    } else
  14048. +        rc = 2;            /* drive refused ID */
  14049. +    if (!HWIF(drive)->irq) {
  14050. +        irqs = probe_irq_off(irqs);    /* get our irq number */
  14051. +        if (irqs > 0) {
  14052. +            HWIF(drive)->irq = irqs; /* save it for later */
  14053. +            irqs = probe_irq_on();
  14054. +            OUT_BYTE(drive->ctl|2,IDE_CONTROL_REG); /* mask device irq */
  14055. +            udelay(5);
  14056. +            (void) probe_irq_off(irqs);
  14057. +            (void) probe_irq_off(probe_irq_on()); /* clear self-inflicted irq */
  14058. +            (void) GET_STAT();    /* clear drive IRQ */
  14059. +
  14060. +        } else {    /* Mmmm.. multiple IRQs.. don't know which was ours */
  14061. +            printk("%s: IRQ probe failed (%d)\n", drive->name, irqs);
  14062. +#ifdef CONFIG_BLK_DEV_CMD640
  14063. +#ifdef CMD640_DUMP_REGS
  14064. +            if (HWIF(drive)->chipset == ide_cmd640) {
  14065. +                printk("%s: Hmmm.. probably a driver problem.\n", drive->name);
  14066. +                CMD640_DUMP_REGS;
  14067. +            }
  14068. +#endif /* CMD640_DUMP_REGS */
  14069. +#endif /* CONFIG_BLK_DEV_CMD640 */
  14070. +        }
  14071. +    }
  14072. +    return rc;
  14073. +}
  14074. +
  14075. +/*
  14076. + * do_probe() has the difficult job of finding a drive if it exists,
  14077. + * without getting hung up if it doesn't exist, without trampling on
  14078. + * ethernet cards, and without leaving any IRQs dangling to haunt us later.
  14079. + *
  14080. + * If a drive is "known" to exist (from CMOS or kernel parameters),
  14081. + * but does not respond right away, the probe will "hang in there"
  14082. + * for the maximum wait time (about 30 seconds), otherwise it will
  14083. + * exit much more quickly.
  14084. + *
  14085. + * Returns:    0  device was identified
  14086. + *        1  device timed-out (no response to identify request)
  14087. + *        2  device aborted the command (refused to identify itself)
  14088. + *        3  bad status from device (possible for ATAPI drives)
  14089. + *        4  probe was not attempted because failure was obvious
  14090. + */
  14091. +static int do_probe (ide_drive_t *drive, byte cmd)
  14092. +{
  14093. +    int rc;
  14094. +    ide_hwif_t *hwif = HWIF(drive);
  14095. +#ifdef CONFIG_BLK_DEV_IDEATAPI
  14096. +    if (drive->present) {    /* avoid waiting for inappropriate probes */
  14097. +        if ((drive->media != ide_disk) && (cmd == WIN_IDENTIFY))
  14098. +            return 4;
  14099. +    }
  14100. +#endif    /* CONFIG_BLK_DEV_IDEATAPI */
  14101. +#ifdef DEBUG
  14102. +    printk("probing for %s: present=%d, media=%d, probetype=%s\n",
  14103. +        drive->name, drive->present, drive->media,
  14104. +        (cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
  14105. +#endif
  14106. +    SELECT_DRIVE(hwif,drive);
  14107. +    OUT_BYTE(drive->select.all,IDE_SELECT_REG);    /* select target drive */
  14108. +    delay_50ms();
  14109. +    if (IN_BYTE(IDE_SELECT_REG) != drive->select.all && !drive->present) {
  14110. +        OUT_BYTE(0xa0,IDE_SELECT_REG);    /* exit with drive0 selected */
  14111. +        delay_50ms();        /* allow BUSY_STAT to assert & clear */
  14112. +        return 3;    /* no i/f present: avoid killing ethernet cards */
  14113. +    }
  14114. +
  14115. +    if (OK_STAT(GET_STAT(),READY_STAT,BUSY_STAT)
  14116. +     || drive->present || cmd == WIN_PIDENTIFY)
  14117. +    {
  14118. +        if ((rc = try_to_identify(drive,cmd)))   /* send cmd and wait */
  14119. +            rc = try_to_identify(drive,cmd); /* failed: try again */
  14120. +        if (rc == 1)
  14121. +            printk("%s: no response (status = 0x%02x)\n", drive->name, GET_STAT());
  14122. +        (void) GET_STAT();        /* ensure drive irq is clear */
  14123. +    } else {
  14124. +        rc = 3;                /* not present or maybe ATAPI */
  14125. +    }
  14126. +    if (drive->select.b.unit != 0) {
  14127. +        OUT_BYTE(0xa0,IDE_SELECT_REG);    /* exit with drive0 selected */
  14128. +        delay_50ms();
  14129. +        (void) GET_STAT();        /* ensure drive irq is clear */
  14130. +    }
  14131. +    return rc;
  14132. +}
  14133. +
  14134. +/*
  14135. + * probe_for_drive() tests for existence of a given drive using do_probe().
  14136. + *
  14137. + * Returns:    0  no device was found
  14138. + *        1  device was found (note: drive->present might still be 0)
  14139. + */
  14140. +static inline byte probe_for_drive (ide_drive_t *drive)
  14141. +{
  14142. +    if (drive->noprobe)            /* skip probing? */
  14143. +        return drive->present;
  14144. +    if (do_probe(drive, WIN_IDENTIFY) >= 2) { /* if !(success||timed-out) */
  14145. +#ifdef CONFIG_BLK_DEV_IDEATAPI
  14146. +        (void) do_probe(drive, WIN_PIDENTIFY); /* look for ATAPI device */
  14147. +#endif    /* CONFIG_BLK_DEV_IDEATAPI */
  14148. +    }
  14149. +    if (!drive->present)
  14150. +        return 0;            /* drive not found */
  14151. +    if (drive->id == NULL) {        /* identification failed? */
  14152. +        if (drive->media == ide_disk) {
  14153. +            printk ("%s: non-IDE drive, CHS=%d/%d/%d\n",
  14154. +             drive->name, drive->cyl, drive->head, drive->sect);
  14155. +        }
  14156. +#ifdef CONFIG_BLK_DEV_IDECD
  14157. +        else if (drive->media == ide_cdrom) {
  14158. +            printk("%s: ATAPI cdrom (?)\n", drive->name);
  14159. +        }
  14160. +#endif    /* CONFIG_BLK_DEV_IDECD */
  14161. +        else {
  14162. +            drive->present = 0;    /* nuke it */
  14163. +        }
  14164. +    }
  14165. +    return 1;    /* drive was found */
  14166. +}
  14167. +
  14168. +/*
  14169. + * We query CMOS about hard disks : it could be that we have a SCSI/ESDI/etc
  14170. + * controller that is BIOS compatible with ST-506, and thus showing up in our
  14171. + * BIOS table, but not register compatible, and therefore not present in CMOS.
  14172. + *
  14173. + * Furthermore, we will assume that our ST-506 drives <if any> are the primary
  14174. + * drives in the system -- the ones reflected as drive 1 or 2.  The first
  14175. + * drive is stored in the high nibble of CMOS byte 0x12, the second in the low
  14176. + * nibble.  This will be either a 4 bit drive type or 0xf indicating use byte
  14177. + * 0x19 for an 8 bit type, drive 1, 0x1a for drive 2 in CMOS.  A non-zero value
  14178. + * means we have an AT controller hard disk for that drive.
  14179. + *
  14180. + * Of course, there is no guarantee that either drive is actually on the
  14181. + * "primary" IDE interface, but we don't bother trying to sort that out here.
  14182. + * If a drive is not actually on the primary interface, then these parameters
  14183. + * will be ignored.  This results in the user having to supply the logical
  14184. + * drive geometry as a boot parameter for each drive not on the primary i/f.
  14185. + *
  14186. + * The only "perfect" way to handle this would be to modify the setup.[cS] code
  14187. + * to do BIOS calls Int13h/Fn08h and Int13h/Fn48h to get all of the drive info
  14188. + * for us during initialization.  I have the necessary docs -- any takers?  -ml
  14189. + */
  14190. +static void probe_cmos_for_drives (ide_hwif_t *hwif)
  14191. +{
  14192. +#ifdef __i386__
  14193. +    extern struct drive_info_struct drive_info;
  14194. +    byte cmos_disks, *BIOS = (byte *) &drive_info;
  14195. +    int unit;
  14196. +
  14197. +#ifdef CONFIG_BLK_DEV_PROMISE
  14198. +    if (hwif->is_promise2)
  14199. +        return;
  14200. +#endif /* CONFIG_BLK_DEV_PROMISE */
  14201. +    outb_p(0x12,0x70);        /* specify CMOS address 0x12 */
  14202. +    cmos_disks = inb_p(0x71);    /* read the data from 0x12 */
  14203. +    /* Extract drive geometry from CMOS+BIOS if not already setup */
  14204. +    for (unit = 0; unit < MAX_DRIVES; ++unit) {
  14205. +        ide_drive_t *drive = &hwif->drives[unit];
  14206. +        if ((cmos_disks & (0xf0 >> (unit*4))) && !drive->present && !drive->nobios) {
  14207. +            drive->cyl   = drive->bios_cyl  = *(unsigned short *)BIOS;
  14208. +            drive->head  = drive->bios_head = *(BIOS+2);
  14209. +            drive->sect  = drive->bios_sect = *(BIOS+14);
  14210. +            drive->ctl   = *(BIOS+8);
  14211. +            drive->present = 1;
  14212. +        }
  14213. +        BIOS += 16;
  14214. +    }
  14215. +#endif
  14216. +}
  14217. +
  14218. +/*
  14219. + * This routine only knows how to look for drive units 0 and 1
  14220. + * on an interface, so any setting of MAX_DRIVES > 2 won't work here.
  14221. + */
  14222. +static void probe_hwif (ide_hwif_t *hwif)
  14223. +{
  14224. +    unsigned int unit;
  14225. +
  14226. +    if (hwif->noprobe)
  14227. +        return;
  14228. +    if (hwif->io.io_base == HD_DATA)
  14229. +        probe_cmos_for_drives (hwif);
  14230. +#if CONFIG_BLK_DEV_PROMISE
  14231. +    if (!hwif->is_promise2 &&
  14232. +       (check_region(hwif->io_base,8) || check_region(hwif->ctl_port,1))) {
  14233. +#else
  14234. +    if (check_region(hwif->io.io_base,8) || check_region(hwif->io.ctl_port,1)) {
  14235. +#endif /* CONFIG_BLK_DEV_PROMISE */
  14236. +        int msgout = 0;
  14237. +        for (unit = 0; unit < MAX_DRIVES; ++unit) {
  14238. +            ide_drive_t *drive = &hwif->drives[unit];
  14239. +            if (drive->present) {
  14240. +                drive->present = 0;
  14241. +                printk("%s: ERROR, PORTS ALREADY IN USE\n", drive->name);
  14242. +                msgout = 1;
  14243. +            }
  14244. +        }
  14245. +        if (!msgout)
  14246. +            printk("%s: ports already in use, skipping probe\n", hwif->name);
  14247. +    } else {
  14248. +        unsigned long flags;
  14249. +        save_flags(flags);
  14250. +
  14251. +        sti();    /* needed for jiffies and irq probing */
  14252. +        /*
  14253. +         * Second drive should only exist if first drive was found,
  14254. +         * but a lot of cdrom drives are configured as single slaves.
  14255. +         */
  14256. +        for (unit = 0; unit < MAX_DRIVES; ++unit) {
  14257. +            ide_drive_t *drive = &hwif->drives[unit];
  14258. +            (void) probe_for_drive (drive);
  14259. +            if (drive->present && drive->media == ide_disk) {
  14260. +                if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
  14261. +                    printk("%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
  14262. +                     drive->name, drive->head);
  14263. +                    drive->present = 0;
  14264. +                }
  14265. +            }
  14266. +            if (drive->present && !hwif->present) {
  14267. +                hwif->present = 1;
  14268. +                request_region(hwif->io.io_base,  8, hwif->name);
  14269. +                request_region(hwif->io.ctl_port, 1, hwif->name);
  14270. +            }
  14271. +        }
  14272. +        restore_flags(flags);
  14273. +        for (unit = 0; unit < MAX_DRIVES; ++unit) {
  14274. +            ide_drive_t *drive = &hwif->drives[unit];
  14275. +            if (drive->present && drive->media != ide_tape) {
  14276. +                ide_tuneproc_t *tuneproc = HWIF(drive)->tuneproc;
  14277. +                if (tuneproc != NULL && drive->autotune == 1)
  14278. +                    tuneproc(drive, 255);   /* auto-tune PIO mode */
  14279. +            }
  14280. +        }
  14281. +    }
  14282. +}
  14283. +
  14284. +/*
  14285. + * stridx() returns the offset of c within s,
  14286. + * or -1 if c is '\0' or not found within s.
  14287. + */
  14288. +static int stridx (const char *s, char c)
  14289. +{
  14290. +    char *i = strchr(s, c);
  14291. +    return (i && c) ? i - s : -1;
  14292. +}
  14293. +
  14294. +/*
  14295. + * match_parm() does parsing for ide_setup():
  14296. + *
  14297. + * 1. the first char of s must be '='.
  14298. + * 2. if the remainder matches one of the supplied keywords,
  14299. + *     the index (1 based) of the keyword is negated and returned.
  14300. + * 3. if the remainder is a series of no more than max_vals numbers
  14301. + *     separated by commas, the numbers are saved in vals[] and a
  14302. + *     count of how many were saved is returned.  Base10 is assumed,
  14303. + *     and base16 is allowed when prefixed with "0x".
  14304. + * 4. otherwise, zero is returned.
  14305. + */
  14306. +static int match_parm (char *s, const char *keywords[], int vals[], int max_vals)
  14307. +{
  14308. +    static const char *decimal = "0123456789";
  14309. +    static const char *hex = "0123456789abcdef";
  14310. +    int i, n;
  14311. +
  14312. +    if (*s++ == '=') {
  14313. +        /*
  14314. +         * Try matching against the supplied keywords,
  14315. +         * and return -(index+1) if we match one
  14316. +         */
  14317. +        if (keywords != NULL) {
  14318. +            for (i = 0; *keywords != NULL; ++i) {
  14319. +                if (!strcmp(s, *keywords++))
  14320. +                    return -(i+1);
  14321. +            }
  14322. +        }
  14323. +        /*
  14324. +         * Look for a series of no more than "max_vals"
  14325. +         * numeric values separated by commas, in base10,
  14326. +         * or base16 when prefixed with "0x".
  14327. +         * Return a count of how many were found.
  14328. +         */
  14329. +        for (n = 0; (i = stridx(decimal, *s)) >= 0;) {
  14330. +            vals[n] = i;
  14331. +            while ((i = stridx(decimal, *++s)) >= 0)
  14332. +                vals[n] = (vals[n] * 10) + i;
  14333. +            if (*s == 'x' && !vals[n]) {
  14334. +                while ((i = stridx(hex, *++s)) >= 0)
  14335. +                    vals[n] = (vals[n] * 0x10) + i;
  14336. +            }
  14337. +            if (++n == max_vals)
  14338. +                break;
  14339. +            if (*s == ',')
  14340. +                ++s;
  14341. +        }
  14342. +        if (!*s)
  14343. +            return n;
  14344. +    }
  14345. +    return 0;    /* zero = nothing matched */
  14346. +}
  14347. +
  14348. +/*
  14349. + * ide_setup() gets called VERY EARLY during initialization,
  14350. + * to handle kernel "command line" strings beginning with "hdx="
  14351. + * or "ide".  Here is the complete set currently supported:
  14352. + *
  14353. + * "hdx="  is recognized for all "x" from "a" to "h", such as "hdc".
  14354. + * "idex=" is recognized for all "x" from "0" to "3", such as "ide1".
  14355. + *
  14356. + * "hdx=noprobe"    : drive may be present, but do not probe for it
  14357. + * "hdx=none"        : drive is NOT present, ignore cmos and do not probe
  14358. + * "hdx=nowerr"        : ignore the WRERR_STAT bit on this drive
  14359. + * "hdx=cdrom"        : drive is present, and is a cdrom drive
  14360. + * "hdx=cyl,head,sect"    : disk drive is present, with specified geometry
  14361. + * "hdx=autotune"    : driver will attempt to tune interface speed
  14362. + *                to the fastest PIO mode supported,
  14363. + *                if possible for this drive only.
  14364. + *                Not fully supported by all chipset types,
  14365. + *                and quite likely to cause trouble with
  14366. + *                older/odd IDE drives.
  14367. + *
  14368. + * "idebus=xx"        : inform IDE driver of VESA/PCI bus speed in Mhz,
  14369. + *                where "xx" is between 20 and 66 inclusive,
  14370. + *                used when tuning chipset PIO modes.
  14371. + *                For PCI bus, 25 is correct for a P75 system,
  14372. + *                30 is correct for P90,P120,P180 systems,
  14373. + *                and 33 is used for P100,P133,P166 systems.
  14374. + *                If in doubt, use idebus=33 for PCI.
  14375. + *                As for VLB, it is safest to not specify it.
  14376. + *
  14377. + * "idex=noprobe"    : do not attempt to access/use this interface
  14378. + * "idex=base"        : probe for an interface at the addr specified,
  14379. + *                where "base" is usually 0x1f0 or 0x170
  14380. + *                and "ctl" is assumed to be "base"+0x206
  14381. + * "idex=base,ctl"    : specify both base and ctl
  14382. + * "idex=base,ctl,irq"    : specify base, ctl, and irq number
  14383. + * "idex=autotune"    : driver will attempt to tune interface speed
  14384. + *                to the fastest PIO mode supported,
  14385. + *                for all drives on this interface.
  14386. + *                Not fully supported by all chipset types,
  14387. + *                and quite likely to cause trouble with
  14388. + *                older/odd IDE drives.
  14389. + * "idex=noautotune"    : driver will NOT attempt to tune interface speed
  14390. + *                This is the default for most chipsets,
  14391. + *                except the cmd640.
  14392. + * "idex=serialize"    : do not overlap operations on idex and ide(x^1)
  14393. + *
  14394. + * The following are valid ONLY on ide0,
  14395. + * and the defaults for the base,ctl ports must not be altered.
  14396. + *
  14397. + * "ide0=dtc2278"    : probe/support DTC2278 interface
  14398. + * "ide0=ht6560b"    : probe/support HT6560B interface
  14399. + * "ide0=cmd640_vlb"    : *REQUIRED* for VLB cards with the CMD640 chip
  14400. + *              (not for PCI -- automatically detected)
  14401. + * "ide0=qd6580"    : probe/support qd6580 interface
  14402. + * "ide0=ali14xx"    : probe/support ali14xx chipsets (ALI M1439, M1443, M1445)
  14403. + * "ide0=umc8672"    : probe/support umc8672 chipsets
  14404. + */
  14405. +void ide_setup (char *s)
  14406. +{
  14407. +    int i, vals[3];
  14408. +    ide_hwif_t *hwif;
  14409. +    ide_drive_t *drive;
  14410. +    unsigned int hw, unit;
  14411. +    const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1);
  14412. +    const char max_hwif  = '0' + (MAX_HWIFS - 1);
  14413. +
  14414. +    printk("ide_setup: %s", s);
  14415. +    init_ide_data ();
  14416. +
  14417. +    /*
  14418. +     * Look for drive options:  "hdx="
  14419. +     */
  14420. +    if (s[0] == 'h' && s[1] == 'd' && s[2] >= 'a' && s[2] <= max_drive) {
  14421. +        const char *hd_words[] = {"none", "noprobe", "nowerr", "cdrom",
  14422. +                "serialize", "autotune", "noautotune", NULL};
  14423. +        unit = s[2] - 'a';
  14424. +        hw   = unit / MAX_DRIVES;
  14425. +        unit = unit % MAX_DRIVES;
  14426. +        hwif = &ide_hwifs[hw];
  14427. +        drive = &hwif->drives[unit];
  14428. +        switch (match_parm(&s[3], hd_words, vals, 3)) {
  14429. +            case -1: /* "none" */
  14430. +                drive->nobios = 1;  /* drop into "noprobe" */
  14431. +            case -2: /* "noprobe" */
  14432. +                drive->noprobe = 1;
  14433. +                goto done;
  14434. +            case -3: /* "nowerr" */
  14435. +                drive->bad_wstat = BAD_R_STAT;
  14436. +                hwif->noprobe = 0;
  14437. +                goto done;
  14438. +            case -4: /* "cdrom" */
  14439. +                drive->present = 1;
  14440. +                drive->media = ide_cdrom;
  14441. +                hwif->noprobe = 0;
  14442. +                goto done;
  14443. +            case -5: /* "serialize" */
  14444. +                printk(" -- USE \"ide%d=serialize\" INSTEAD", hw);
  14445. +                goto do_serialize;
  14446. +            case -6: /* "autotune" */
  14447. +                drive->autotune = 1;
  14448. +                goto done;
  14449. +            case -7: /* "noautotune" */
  14450. +                drive->autotune = 2;
  14451. +                goto done;
  14452. +            case 3: /* cyl,head,sect */
  14453. +                drive->media    = ide_disk;
  14454. +                drive->cyl    = drive->bios_cyl  = vals[0];
  14455. +                drive->head    = drive->bios_head = vals[1];
  14456. +                drive->sect    = drive->bios_sect = vals[2];
  14457. +                drive->present    = 1;
  14458. +                drive->forced_geom = 1;
  14459. +                hwif->noprobe = 0;
  14460. +                goto done;
  14461. +            default:
  14462. +                goto bad_option;
  14463. +        }
  14464. +    }
  14465. +
  14466. +    if (s[0] != 'i' || s[1] != 'd' || s[2] != 'e')
  14467. +        goto bad_option;
  14468. +    /*
  14469. +     * Look for bus speed option:  "idebus="
  14470. +     */
  14471. +    if (s[3] == 'b' && s[4] == 'u' && s[5] == 's') {
  14472. +        if (match_parm(&s[6], NULL, vals, 1) != 1)
  14473. +            goto bad_option;
  14474. +        if (vals[0] >= 20 && vals[0] <= 66)
  14475. +            idebus_parameter = vals[0];
  14476. +        else
  14477. +            printk(" -- BAD BUS SPEED! Expected value from 20 to 66");
  14478. +        goto done;
  14479. +    }
  14480. +    /*
  14481. +     * Look for interface options:  "idex="
  14482. +     */
  14483. +    if (s[3] >= '0' && s[3] <= max_hwif) {
  14484. +        /*
  14485. +         * Be VERY CAREFUL changing this: note hardcoded indexes below
  14486. +         */
  14487. +        const char *ide_words[] = {"noprobe", "serialize", "autotune", "noautotune",
  14488. +            "qd6580", "ht6560b", "cmd640_vlb", "dtc2278", "umc8672", "ali14xx", "dc4030", NULL};
  14489. +        hw = s[3] - '0';
  14490. +        hwif = &ide_hwifs[hw];
  14491. +        i = match_parm(&s[4], ide_words, vals, 3);
  14492. +
  14493. +        /*
  14494. +         * Cryptic check to ensure chipset not already set for hwif:
  14495. +         */
  14496. +        if (i > 0 || i <= -5) {
  14497. +            if (hwif->chipset != ide_unknown)
  14498. +                goto bad_option;
  14499. +            if (i <= -5) {
  14500. +                if (ide_hwifs[1].chipset != ide_unknown)
  14501. +                    goto bad_option;
  14502. +                /*
  14503. +                 * Interface keywords work only for ide0:
  14504. +                 */
  14505. +                if (hw != 0)
  14506. +                    goto bad_hwif;
  14507. +            }
  14508. +        }
  14509. +
  14510. +        switch (i) {
  14511. +#ifdef CONFIG_BLK_DEV_PROMISE
  14512. +            case -11: /* "dc4030" */
  14513. +            {
  14514. +                setup_dc4030(hwif);
  14515. +                goto done;
  14516. +            }
  14517. +#endif /* CONFIG_BLK_DEV_PROMISE */
  14518. +            case -4: /* "noautotune" */
  14519. +                hwif->drives[0].autotune = 2;
  14520. +                hwif->drives[1].autotune = 2;
  14521. +                goto done;
  14522. +            case -3: /* "autotune" */
  14523. +                hwif->drives[0].autotune = 1;
  14524. +                hwif->drives[1].autotune = 1;
  14525. +                goto done;
  14526. +            case -2: /* "serialize" */
  14527. +            do_serialize:
  14528. +                ide_hwifs[hw].serialized = 1;   /* serialize */
  14529. +                ide_hwifs[hw^1].serialized = 1; /* with mate */
  14530. +                goto done;
  14531. +
  14532. +            case -1: /* "noprobe" */
  14533. +                hwif->noprobe = 1;
  14534. +                goto done;
  14535. +
  14536. +            case 1:    /* base */
  14537. +                vals[1] = vals[0] + 0x206; /* default ctl */
  14538. +            case 2: /* base,ctl */
  14539. +                vals[2] = 0;    /* default irq = probe for it */
  14540. +            case 3: /* base,ctl,irq */
  14541. +                hwif->io.io_base  = vals[0];
  14542. +                hwif->io.ctl_port = vals[1];
  14543. +                hwif->io.io_size  = 1;
  14544. +                hwif->irq      = vals[2];
  14545. +                hwif->noprobe  = 0;
  14546. +                hwif->chipset  = ide_generic;
  14547. +                goto done;
  14548. +
  14549. +            case 0: goto bad_option;
  14550. +            default:
  14551. +                printk(" -- SUPPORT NOT CONFIGURED IN THIS KERNEL\n");
  14552. +                return;
  14553. +        }
  14554. +    }
  14555. +bad_option:
  14556. +    printk(" -- BAD OPTION\n");
  14557. +    return;
  14558. +bad_hwif:
  14559. +    printk("-- NOT SUPPORTED ON ide%d", hw);
  14560. +done:
  14561. +    printk("\n");
  14562. +}
  14563. +
  14564. +/*
  14565. + * This routine is called from the partition-table code in genhd.c
  14566. + * to "convert" a drive to a logical geometry with fewer than 1024 cyls.
  14567. + *
  14568. + * The second parameter, "xparm", determines exactly how the translation 
  14569. + * will be handled:
  14570. + *         0 = convert to CHS with fewer than 1024 cyls
  14571. + *            using the same method as Ontrack DiskManager.
  14572. + *         1 = same as "0", plus offset everything by 63 sectors.
  14573. + *        -1 = similar to "0", plus redirect sector 0 to sector 1.
  14574. + *        >1 = convert to a CHS geometry with "xparm" heads.
  14575. + *
  14576. + * Returns 0 if the translation was not possible, if the device was not 
  14577. + * an IDE disk drive, or if a geometry was "forced" on the commandline.
  14578. + * Returns 1 if the geometry translation was successful.
  14579. + */
  14580. +int ide_xlate_1024 (kdev_t i_rdev, int xparm, const char *msg)
  14581. +{
  14582. +    ide_drive_t *drive;
  14583. +    static const byte head_vals[] = {4, 8, 16, 32, 64, 128, 255, 0};
  14584. +    const byte *heads = head_vals;
  14585. +    unsigned long tracks;
  14586. +
  14587. +    if ((drive = get_info_ptr(i_rdev)) == NULL || drive->forced_geom)
  14588. +        return 0;
  14589. +
  14590. +    if (xparm > 1 && xparm <= drive->bios_head && drive->bios_sect == 63)
  14591. +        return 0;        /* we already have a translation */
  14592. +
  14593. +    printk("%s ", msg);
  14594. +
  14595. +    if (drive->id) {
  14596. +        drive->cyl  = drive->id->cyls;
  14597. +        drive->head = drive->id->heads;
  14598. +        drive->sect = drive->id->sectors;
  14599. +    }
  14600. +    drive->bios_cyl  = drive->cyl;
  14601. +    drive->bios_head = drive->head;
  14602. +    drive->bios_sect = drive->sect;
  14603. +    drive->special.b.set_geometry = 1;
  14604. +
  14605. +    tracks = drive->bios_cyl * drive->bios_head * drive->bios_sect / 63;
  14606. +    drive->bios_sect = 63;
  14607. +    if (xparm > 1) {
  14608. +        drive->bios_head = xparm;
  14609. +        drive->bios_cyl = tracks / drive->bios_head;
  14610. +    } else {
  14611. +        while (drive->bios_cyl >= 1024) {
  14612. +            drive->bios_head = *heads;
  14613. +            drive->bios_cyl = tracks / drive->bios_head;
  14614. +            if (0 == *++heads)
  14615. +                break;
  14616. +        }
  14617. +#if FAKE_FDISK_FOR_EZDRIVE
  14618. +        if (xparm == -1) {
  14619. +            drive->remap_0_to_1 = 1;
  14620. +            msg = "0->1";
  14621. +        } else
  14622. +#endif /* FAKE_FDISK_FOR_EZDRIVE */
  14623. +        if (xparm == 1) {
  14624. +            drive->sect0 = 63;
  14625. +            drive->bios_cyl = (tracks - 1) / drive->bios_head;
  14626. +            msg = "+63";
  14627. +        }
  14628. +        printk("[remap %s] ", msg);
  14629. +    }
  14630. +    drive->part[0].nr_sects = current_capacity(drive);
  14631. +    printk("[%d/%d/%d]", drive->bios_cyl, drive->bios_head, drive->bios_sect);
  14632. +    return 1;
  14633. +}
  14634. +
  14635. +#if MAX_HWIFS > 1
  14636. +/*
  14637. + * save_match() is used to simplify logic in init_irq() below.
  14638. + *
  14639. + * A loophole here is that we may not know about a particular
  14640. + * hwif's irq until after that hwif is actually probed/initialized..
  14641. + * This could be a problem for the case where an hwif is on a
  14642. + * dual interface that requires serialization (eg. cmd640) and another
  14643. + * hwif using one of the same irqs is initialized beforehand.
  14644. + *
  14645. + * This routine detects and reports such situations, but does not fix them.
  14646. + */
  14647. +static void save_match (ide_hwif_t *hwif, ide_hwif_t *new, ide_hwif_t **match)
  14648. +{
  14649. +    ide_hwif_t *m = *match;
  14650. +
  14651. +    if (m && m->hwgroup && m->hwgroup != new->hwgroup) {
  14652. +        if (!new->hwgroup)
  14653. +            return;
  14654. +        printk("%s: potential irq problem with %s and %s\n", hwif->name, new->name, m->name);
  14655. +    }
  14656. +    if (!m || m->irq != hwif->irq) /* don't undo a prior perfect match */
  14657. +        *match = new;
  14658. +}
  14659. +#endif /* MAX_HWIFS > 1 */
  14660. +
  14661. +/*
  14662. + * This routine sets up the irq for an ide interface, and creates a new
  14663. + * hwgroup for the irq/hwif if none was previously assigned.
  14664. + *
  14665. + * Much of the code is for correctly detecting/handling irq sharing
  14666. + * and irq serialization situations.  This is somewhat complex because
  14667. + * it handles static as well as dynamic (PCMCIA) IDE interfaces.
  14668. + *
  14669. + * The SA_INTERRUPT in sa_flags means ide_intr() is always entered with
  14670. + * interrupts completely disabled.  This can be bad for interrupt latency,
  14671. + * but anything else has led to problems on some machines.  We re-enable
  14672. + * interrupts as much as we can safely do in most places.
  14673. + */
  14674. +static int init_irq (ide_hwif_t *hwif)
  14675. +{
  14676. +    unsigned long flags;
  14677. +#if MAX_HWIFS > 1
  14678. +    unsigned int index;
  14679. +#endif /* MAX_HWIFS > 1 */
  14680. +    ide_hwgroup_t *hwgroup;
  14681. +    ide_hwif_t *match = NULL;
  14682. +
  14683. +    save_flags(flags);
  14684. +    cli();
  14685. +
  14686. +    hwif->hwgroup = NULL;
  14687. +#if MAX_HWIFS > 1
  14688. +    /*
  14689. +     * Group up with any other hwifs that share our irq(s).
  14690. +     */
  14691. +    for (index = 0; index < MAX_HWIFS; index++) {
  14692. +        ide_hwif_t *h = &ide_hwifs[index];
  14693. +        if (h->hwgroup) {  /* scan only initialized hwif's */
  14694. +            if (hwif->irq == h->irq) {
  14695. +                hwif->sharing_irq = h->sharing_irq = 1;
  14696. +                save_match(hwif, h, &match);
  14697. +            }
  14698. +            if (hwif->serialized) {
  14699. +                ide_hwif_t *mate = &ide_hwifs[hwif->index^1];
  14700. +                if (index == mate->index || h->irq == mate->irq)
  14701. +                    save_match(hwif, h, &match);
  14702. +            }
  14703. +            if (h->serialized) {
  14704. +                ide_hwif_t *mate = &ide_hwifs[h->index^1];
  14705. +                if (hwif->irq == mate->irq)
  14706. +                    save_match(hwif, h, &match);
  14707. +            }
  14708. +        }
  14709. +    }
  14710. +#endif /* MAX_HWIFS > 1 */
  14711. +    /*
  14712. +     * If we are still without a hwgroup, then form a new one
  14713. +     */
  14714. +    if (match) {
  14715. +        hwgroup = match->hwgroup;
  14716. +    } else {
  14717. +        hwgroup = kmalloc(sizeof(ide_hwgroup_t), GFP_KERNEL);
  14718. +        hwgroup->hwif      = hwgroup->next_hwif = hwif->next = hwif;
  14719. +        hwgroup->rq      = NULL;
  14720. +        hwgroup->handler = NULL;
  14721. +        if (hwif->drives[0].present)
  14722. +            hwgroup->drive = &hwif->drives[0];
  14723. +        else
  14724. +            hwgroup->drive = &hwif->drives[1];
  14725. +        hwgroup->poll_timeout = 0;
  14726. +        init_timer(&hwgroup->timer);
  14727. +        hwgroup->timer.function = &timer_expiry;
  14728. +        hwgroup->timer.data = (unsigned long) hwgroup;
  14729. +    }
  14730. +
  14731. +    /*
  14732. +     * Allocate the irq, if not already obtained for another hwif
  14733. +     */
  14734. +    if (!match || match->irq != hwif->irq) {
  14735. +        if (request_irq(hwif->irq, ide_intr, SA_INTERRUPT, hwif->name, hwgroup)) {
  14736. +            if (!match)
  14737. +                kfree(hwgroup);
  14738. +            restore_flags(flags);
  14739. +            return 1;
  14740. +        }
  14741. +    }
  14742. +
  14743. +    /*
  14744. +     * Everything is okay, so link us into the hwgroup
  14745. +     */
  14746. +    hwif->hwgroup = hwgroup;
  14747. +    hwif->next = hwgroup->hwif->next;
  14748. +    hwgroup->hwif->next = hwif;
  14749. +
  14750. +    restore_flags(flags);    /* safe now that hwif->hwgroup is set up */
  14751. +
  14752. +    printk("%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
  14753. +        hwif->io.io_base, hwif->io.io_base+7, hwif->io.ctl_port, hwif->irq);
  14754. +    if (match)
  14755. +        printk(" (%sed with %s)", hwif->sharing_irq ? "shar" : "serializ", match->name);
  14756. +    printk("\n");
  14757. +    return 0;
  14758. +}
  14759. +
  14760. +static struct file_operations ide_fops = {
  14761. +    NULL,            /* lseek - default */
  14762. +    block_read,        /* read - general block-dev read */
  14763. +    block_write,        /* write - general block-dev write */
  14764. +    NULL,            /* readdir - bad */
  14765. +    NULL,            /* select */
  14766. +    ide_ioctl,        /* ioctl */
  14767. +    NULL,            /* mmap */
  14768. +    ide_open,        /* open */
  14769. +    ide_release,        /* release */
  14770. +    block_fsync        /* fsync */
  14771. +    ,NULL,            /* fasync */
  14772. +    ide_check_media_change,    /* check_media_change */
  14773. +    revalidate_disk        /* revalidate */
  14774. +};
  14775. +
  14776. +/*
  14777. + * ide_init_pci() finds/initializes "known" PCI IDE interfaces
  14778. + *
  14779. + * This routine should ideally be using pcibios_find_class() to find
  14780. + * all IDE interfaces, but that function causes some systems to "go weird".
  14781. + */
  14782. +static void probe_for_hwifs (void)
  14783. +{
  14784. +}
  14785. +
  14786. +static int hwif_init (int h)
  14787. +{
  14788. +    ide_hwif_t *hwif = &ide_hwifs[h];
  14789. +    void (*rfn)(void);
  14790. +    
  14791. +    if (!hwif->present)
  14792. +        return 0;
  14793. +    if (!hwif->irq) {
  14794. +        if (!(hwif->irq = default_irqs[h])) {
  14795. +            printk("%s: DISABLED, NO IRQ\n", hwif->name);
  14796. +            return (hwif->present = 0);
  14797. +        }
  14798. +    }
  14799. +#ifdef CONFIG_BLK_DEV_HD
  14800. +    if (hwif->irq == HD_IRQ && hwif->io_base != HD_DATA) {
  14801. +        printk("%s: CANNOT SHARE IRQ WITH OLD HARDDISK DRIVER (hd.c)\n", hwif->name);
  14802. +        return (hwif->present = 0);
  14803. +    }
  14804. +#endif /* CONFIG_BLK_DEV_HD */
  14805. +    
  14806. +    hwif->present = 0; /* we set it back to 1 if all is ok below */
  14807. +    switch (hwif->major) {
  14808. +    case IDE0_MAJOR: rfn = &do_ide0_request; break;
  14809. +#if MAX_HWIFS > 1
  14810. +    case IDE1_MAJOR: rfn = &do_ide1_request; break;
  14811. +#endif
  14812. +#if MAX_HWIFS > 2
  14813. +    case IDE2_MAJOR: rfn = &do_ide2_request; break;
  14814. +#endif
  14815. +#if MAX_HWIFS > 3
  14816. +    case IDE3_MAJOR: rfn = &do_ide3_request; break;
  14817. +#endif
  14818. +    default:
  14819. +        printk("%s: request_fn NOT DEFINED\n", hwif->name);
  14820. +        return (hwif->present = 0);
  14821. +    }
  14822. +    if (register_blkdev (hwif->major, hwif->name, &ide_fops)) {
  14823. +        printk("%s: UNABLE TO GET MAJOR NUMBER %d\n", hwif->name, hwif->major);
  14824. +    } else if (init_irq (hwif)) {
  14825. +        printk("%s: UNABLE TO GET IRQ %d\n", hwif->name, hwif->irq);
  14826. +        (void) unregister_blkdev (hwif->major, hwif->name);
  14827. +    } else {
  14828. +        init_gendisk(hwif);
  14829. +        blk_dev[hwif->major].request_fn = rfn;
  14830. +        read_ahead[hwif->major] = 8;    /* (4kB) */
  14831. +        hwif->present = 1;    /* success */
  14832. +    }
  14833. +    return hwif->present;
  14834. +}
  14835. +
  14836. +/*
  14837. + * This is gets invoked once during initialization, to set *everything* up
  14838. + */
  14839. +int ide_init (void)
  14840. +{
  14841. +    int index;
  14842. +
  14843. +    init_ide_data ();
  14844. +    /*
  14845. +     * Probe for special "known" interface chipsets
  14846. +     */
  14847. +    probe_for_hwifs ();
  14848. +
  14849. +    /*
  14850. +     * Probe for drives in the usual way.. CMOS/BIOS, then poke at ports
  14851. +     */
  14852. +    for (index = 0; index < MAX_HWIFS; ++index)
  14853. +        probe_hwif (&ide_hwifs[index]);
  14854. +    for (index = 0; index < MAX_HWIFS; ++index)
  14855. +        hwif_init (index);
  14856. +
  14857. +#ifdef CONFIG_BLK_DEV_IDETAPE
  14858. +    idetape_register_chrdev();    /* Register character device interface to the ide tape */
  14859. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  14860. +    
  14861. +    return 0;
  14862. +}
  14863. +
  14864. +#ifdef CONFIG_BLK_DEV_IDE_PCMCIA
  14865. +int ide_register(int io_base, int ctl_port, int irq)
  14866. +{
  14867. +    int index, i, rc = -1;
  14868. +    ide_hwif_t *hwif;
  14869. +    ide_drive_t *drive;
  14870. +    unsigned long flags;
  14871. +
  14872. +    save_flags(flags);
  14873. +    cli();
  14874. +    for (index = 0; index < MAX_HWIFS; ++index) {
  14875. +        hwif = &ide_hwifs[index];
  14876. +        if (hwif->present) {
  14877. +            if (hwif->io_base == io_base || hwif->ctl_port == ctl_port)
  14878. +                break; /* this ide port already exists */
  14879. +        } else {
  14880. +            hwif->io_base = io_base;
  14881. +            hwif->ctl_port = ctl_port;
  14882. +            hwif->irq = irq;
  14883. +            hwif->noprobe = 0;
  14884. +            probe_hwif(hwif);
  14885. +            if (!hwif_init(index))
  14886. +                break;
  14887. +            for (i = 0; i < hwif->gd->nr_real; i++) {
  14888. +                drive = &hwif->drives[i];
  14889. +                revalidate_disk(MKDEV(hwif->major, i<<PARTN_BITS));
  14890. +#ifdef CONFIG_BLK_DEV_IDECD
  14891. +                if (drive->present && drive->media == ide_cdrom)
  14892. +                    ide_cdrom_setup(drive);
  14893. +#endif /* CONFIG_BLK_DEV_IDECD */
  14894. +            }
  14895. +            rc = index;
  14896. +            break;
  14897. +        }
  14898. +    }
  14899. +    restore_flags(flags);
  14900. +    return rc;
  14901. +}
  14902. +
  14903. +void ide_unregister (unsigned int index)
  14904. +{
  14905. +    struct gendisk *gd, **gdp;
  14906. +    ide_hwif_t *hwif, *g;
  14907. +    ide_hwgroup_t *hwgroup;
  14908. +    int irq_count = 0;
  14909. +    unsigned long flags;
  14910. +
  14911. +    if (index >= MAX_HWIFS)
  14912. +        return;
  14913. +    save_flags(flags);
  14914. +    cli();
  14915. +    hwif = &ide_hwifs[index];
  14916. +    if (!hwif->present || hwif->drives[0].busy || hwif->drives[1].busy) {
  14917. +        restore_flags(flags);
  14918. +        return;
  14919. +    }
  14920. +    hwif->present = 0;
  14921. +    hwgroup = hwif->hwgroup;
  14922. +
  14923. +    /*
  14924. +     * free the irq if we were the only hwif using it
  14925. +     */
  14926. +    g = hwgroup->hwif;
  14927. +    do {
  14928. +        if (g->irq == hwif->irq)
  14929. +            ++irq_count;
  14930. +        g = g->next;
  14931. +    } while (g != hwgroup->hwif);
  14932. +    if (irq_count == 1)
  14933. +        free_irq(hwif->irq, hwgroup);
  14934. +
  14935. +    /*
  14936. +     * Note that we only release the standard ports,
  14937. +     * and do not even try to handle any extra ports
  14938. +     * allocated for weird IDE interface chipsets.
  14939. +     */
  14940. +    release_region(hwif->io_base, 8);
  14941. +    release_region(hwif->ctl_port, 1);
  14942. +
  14943. +    /*
  14944. +     * Remove us from the hwgroup, and free
  14945. +     * the hwgroup if we were the only member
  14946. +     */
  14947. +    while (hwgroup->hwif->next != hwif)
  14948. +        hwgroup->hwif = hwgroup->hwif->next;
  14949. +    hwgroup->hwif->next = hwif->next;
  14950. +    if (hwgroup->hwif == hwif)
  14951. +        hwgroup->hwif = hwif->next;
  14952. +    if (hwgroup->next_hwif == hwif)
  14953. +        hwgroup->next_hwif = hwif->next;
  14954. +    if (hwgroup->hwif == hwif)
  14955. +        kfree(hwgroup);
  14956. +
  14957. +    /*
  14958. +     * Remove us from the kernel's knowledge
  14959. +     */
  14960. +    unregister_blkdev(hwif->major, hwif->name);
  14961. +    kfree(blksize_size[hwif->major]);
  14962. +    blk_dev[hwif->major].request_fn = NULL;
  14963. +    blksize_size[hwif->major] = NULL;
  14964. +    for (gdp = &gendisk_head; *gdp; gdp = &((*gdp)->next))
  14965. +        if (*gdp == hwif->gd)
  14966. +            break;
  14967. +    if (*gdp == NULL)
  14968. +        printk("gd not in disk chain!\n");
  14969. +    else {
  14970. +        gd = *gdp; *gdp = gd->next;
  14971. +        kfree(gd->sizes);
  14972. +        kfree(gd->part);
  14973. +        kfree(gd);
  14974. +    }
  14975. +    init_hwif_data (index);    /* restore hwif data to pristine status */
  14976. +    restore_flags(flags);
  14977. +}
  14978. +#endif /* CONFIG_BLK_DEV_IDE_PCMCIA */
  14979. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/ide.h linux/arch/arm/drivers/block/ide.h
  14980. --- linux.orig/arch/arm/drivers/block/ide.h    Thu Jan  1 01:00:00 1970
  14981. +++ linux/arch/arm/drivers/block/ide.h    Sat Sep  7 10:26:07 1996
  14982. @@ -0,0 +1,678 @@
  14983. +/*
  14984. + *  linux/drivers/block/ide.h
  14985. + *
  14986. + *  Copyright (C) 1994, 1995  Linus Torvalds & authors
  14987. + */
  14988. +
  14989. +#include <linux/config.h>
  14990. +
  14991. +/*
  14992. + * This is the multiple IDE interface driver, as evolved from hd.c.  
  14993. + * It supports up to four IDE interfaces, on one or more IRQs (usually 14 & 15).
  14994. + * There can be up to two drives per interface, as per the ATA-2 spec.
  14995. + *
  14996. + * Primary i/f:    ide0: major=3;  (hda)         minor=0; (hdb)         minor=64
  14997. + * Secondary i/f:  ide1: major=22; (hdc or hd1a) minor=0; (hdd or hd1b) minor=64
  14998. + * Tertiary i/f:   ide2: major=33; (hde)         minor=0; (hdf)         minor=64
  14999. + * Quaternary i/f: ide3: major=34; (hdg)         minor=0; (hdh)         minor=64
  15000. + */
  15001. +
  15002. +/******************************************************************************
  15003. + * IDE driver configuration options (play with these as desired):
  15004. + * 
  15005. + * REALLY_SLOW_IO can be defined in ide.c and ide-cd.c, if necessary
  15006. + */
  15007. +#undef REALLY_FAST_IO            /* define if ide ports are perfect */
  15008. +#define INITIAL_MULT_COUNT    0    /* off=0; on=2,4,8,16,32, etc.. */
  15009. +
  15010. +#ifndef DISK_RECOVERY_TIME        /* off=0; on=access_delay_time */
  15011. +#define DISK_RECOVERY_TIME    0    /*  for hardware that needs it */
  15012. +#endif
  15013. +#ifndef OK_TO_RESET_CONTROLLER        /* 1 needed for good error recovery */
  15014. +#define OK_TO_RESET_CONTROLLER    1    /* 0 for use with AH2372A/B interface */
  15015. +#endif
  15016. +#ifndef FAKE_FDISK_FOR_EZDRIVE        /* 1 to help linux fdisk with EZDRIVE */
  15017. +#define FAKE_FDISK_FOR_EZDRIVE     1    /* 0 to reduce kernel size */
  15018. +#endif
  15019. +#ifndef FANCY_STATUS_DUMPS        /* 1 for human-readable drive errors */
  15020. +#define FANCY_STATUS_DUMPS    1    /* 0 to reduce kernel size */
  15021. +#endif
  15022. +
  15023. +#if defined(CONFIG_BLK_DEV_IDECD) || defined(CONFIG_BLK_DEV_IDETAPE)
  15024. +#define CONFIG_BLK_DEV_IDEATAPI 1
  15025. +#endif
  15026. +
  15027. +/*
  15028. + * IDE_DRIVE_CMD is used to implement many features of the hdparm utility
  15029. + */
  15030. +#define IDE_DRIVE_CMD        99    /* (magic) undef to reduce kernel size*/
  15031. +
  15032. +/*
  15033. + *  "No user-serviceable parts" beyond this point  :)
  15034. + *****************************************************************************/
  15035. +
  15036. +typedef unsigned char    byte;    /* used everywhere */
  15037. +
  15038. +/*
  15039. + * Probably not wise to fiddle with these
  15040. + */
  15041. +#define ERROR_MAX    8    /* Max read/write errors per sector */
  15042. +#define ERROR_RESET    3    /* Reset controller every 4th retry */
  15043. +#define ERROR_RECAL    1    /* Recalibrate every 2nd retry */
  15044. +
  15045. +/*
  15046. + * Ensure that various configuration flags have compatible settings
  15047. + */
  15048. +#ifdef REALLY_SLOW_IO
  15049. +#undef REALLY_FAST_IO
  15050. +#endif
  15051. +
  15052. +/*
  15053. + * Definitions for accessing IDE controller registers
  15054. + */
  15055. +
  15056. +#define HWIF(drive)        ((ide_hwif_t *)((drive)->hwif))
  15057. +#define HWGROUP(drive)        ((ide_hwgroup_t *)(HWIF(drive)->hwgroup))
  15058. +
  15059. +#define IDE_DATA_OFFSET        (0)
  15060. +#define IDE_ERROR_OFFSET    (1)
  15061. +#define IDE_NSECTOR_OFFSET    (2)
  15062. +#define IDE_SECTOR_OFFSET    (3)
  15063. +#define IDE_LCYL_OFFSET        (4)
  15064. +#define IDE_HCYL_OFFSET        (5)
  15065. +#define IDE_SELECT_OFFSET    (6)
  15066. +#define IDE_STATUS_OFFSET    (7)
  15067. +#define IDE_FEATURE_OFFSET    IDE_ERROR_OFFSET
  15068. +#define IDE_COMMAND_OFFSET    IDE_STATUS_OFFSET
  15069. +
  15070. +#define IDE_DATA_REG        (HWIF(drive)->io.io_base+HWIF(drive)->io.io_size*IDE_DATA_OFFSET)
  15071. +#define IDE_ERROR_REG        (HWIF(drive)->io.io_base+HWIF(drive)->io.io_size*IDE_ERROR_OFFSET)
  15072. +#define IDE_NSECTOR_REG        (HWIF(drive)->io.io_base+HWIF(drive)->io.io_size*IDE_NSECTOR_OFFSET)
  15073. +#define IDE_SECTOR_REG        (HWIF(drive)->io.io_base+HWIF(drive)->io.io_size*IDE_SECTOR_OFFSET)
  15074. +#define IDE_LCYL_REG        (HWIF(drive)->io.io_base+HWIF(drive)->io.io_size*IDE_LCYL_OFFSET)
  15075. +#define IDE_HCYL_REG        (HWIF(drive)->io.io_base+HWIF(drive)->io.io_size*IDE_HCYL_OFFSET)
  15076. +#define IDE_SELECT_REG        (HWIF(drive)->io.io_base+HWIF(drive)->io.io_size*IDE_SELECT_OFFSET)
  15077. +#define IDE_STATUS_REG        (HWIF(drive)->io.io_base+HWIF(drive)->io.io_size*IDE_STATUS_OFFSET)
  15078. +#define IDE_CONTROL_REG        (HWIF(drive)->io.ctl_port)
  15079. +#define IDE_FEATURE_REG        IDE_ERROR_REG
  15080. +#define IDE_COMMAND_REG        IDE_STATUS_REG
  15081. +#define IDE_ALTSTATUS_REG    IDE_CONTROL_REG
  15082. +
  15083. +#ifdef REALLY_FAST_IO
  15084. +#define OUT_BYTE(b,p)        outb((b),(p))
  15085. +#define IN_BYTE(p)        (byte)inb(p)
  15086. +#else
  15087. +#define OUT_BYTE(b,p)        outb_p((b),(p))
  15088. +#define IN_BYTE(p)        (byte)inb_p(p)
  15089. +#endif /* REALLY_FAST_IO */
  15090. +
  15091. +#define GET_ERR()        IN_BYTE(IDE_ERROR_REG)
  15092. +#define GET_STAT()        IN_BYTE(IDE_STATUS_REG)
  15093. +#define OK_STAT(stat,good,bad)    (((stat)&((good)|(bad)))==(good))
  15094. +#define BAD_R_STAT        (BUSY_STAT   | ERR_STAT)
  15095. +#define BAD_W_STAT        (BAD_R_STAT  | WRERR_STAT)
  15096. +#define BAD_STAT        (BAD_R_STAT  | DRQ_STAT)
  15097. +#define DRIVE_READY        (READY_STAT  | SEEK_STAT)
  15098. +#define DATA_READY        (DRIVE_READY | DRQ_STAT)
  15099. +
  15100. +/*
  15101. + * Some more useful definitions
  15102. + */
  15103. +#define IDE_MAJOR_NAME    "ide"    /* the same for all i/f; see also genhd.c */
  15104. +#define MAJOR_NAME    IDE_MAJOR_NAME
  15105. +#define PARTN_BITS    6    /* number of minor dev bits for partitions */
  15106. +#define PARTN_MASK    ((1<<PARTN_BITS)-1)    /* a useful bit mask */
  15107. +#define MAX_DRIVES    2    /* per interface; 2 assumed by lots of code */
  15108. +#ifndef MAX_HWIFS
  15109. +#define MAX_HWIFS    4    /* an arbitrary, but realistic limit */
  15110. +#endif
  15111. +#define SECTOR_WORDS    (512 / 4)    /* number of 32bit words per sector */
  15112. +
  15113. +/*
  15114. + * Timeouts for various operations:
  15115. + */
  15116. +#define WAIT_DRQ    (5*HZ/100)    /* 50msec - spec allows up to 20ms */
  15117. +#ifdef CONFIG_APM
  15118. +#define WAIT_READY    (5*HZ)        /* 5sec - some laptops are very slow */
  15119. +#else
  15120. +#define WAIT_READY    (3*HZ/100)    /* 30msec - should be instantaneous */
  15121. +#endif /* CONFIG_APM */
  15122. +#define WAIT_PIDENTIFY    (1*HZ)    /* 1sec   - should be less than 3ms (?) */
  15123. +#define WAIT_WORSTCASE    (30*HZ)    /* 30sec  - worst case when spinning up */
  15124. +#define WAIT_CMD    (10*HZ)    /* 10sec  - maximum wait for an IRQ to happen */
  15125. +
  15126. +#define SELECT_DRIVE(hwif,drive)  OUT_BYTE((drive)->select.all, hwif->io.io_base+hwif->io.io_size * IDE_SELECT_OFFSET);
  15127. +
  15128. +#ifdef CONFIG_BLK_DEV_IDETAPE
  15129. +#include "ide-tape.h"
  15130. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  15131. +
  15132. +#ifdef CONFIG_BLK_DEV_IDECD
  15133. +
  15134. +struct atapi_request_sense {
  15135. +    unsigned char error_code : 7;
  15136. +    unsigned char valid      : 1;
  15137. +    byte reserved1;
  15138. +    unsigned char sense_key  : 4;
  15139. +    unsigned char reserved2  : 1;
  15140. +    unsigned char ili        : 1;
  15141. +    unsigned char reserved3  : 2;
  15142. +    byte info[4];
  15143. +    byte sense_len;
  15144. +    byte command_info[4];
  15145. +    byte asc;
  15146. +    byte ascq;
  15147. +    byte fru;
  15148. +    byte sense_key_specific[3];
  15149. +};
  15150. +
  15151. +struct packet_command {
  15152. +    char *buffer;
  15153. +    int buflen;
  15154. +    int stat;
  15155. +    struct atapi_request_sense *sense_data;
  15156. +    unsigned char c[12];
  15157. +};
  15158. +
  15159. +
  15160. +/* Structure of a MSF cdrom address. */
  15161. +struct atapi_msf {
  15162. +    byte reserved;
  15163. +    byte minute;
  15164. +    byte second;
  15165. +    byte frame;
  15166. +};
  15167. +
  15168. +
  15169. +/* Space to hold the disk TOC. */
  15170. +
  15171. +#define MAX_TRACKS 99
  15172. +struct atapi_toc_header {
  15173. +    unsigned short toc_length;
  15174. +    byte first_track;
  15175. +    byte last_track;
  15176. +};
  15177. +
  15178. +struct atapi_toc_entry {
  15179. +    byte reserved1;
  15180. +    unsigned control : 4;
  15181. +    unsigned adr     : 4;
  15182. +    byte track;
  15183. +    byte reserved2;
  15184. +    union {
  15185. +        unsigned lba;
  15186. +        struct atapi_msf msf;
  15187. +    } addr;
  15188. +};
  15189. +
  15190. +struct atapi_toc {
  15191. +    int    last_session_lba;
  15192. +    int    xa_flag;
  15193. +    unsigned capacity;
  15194. +    struct atapi_toc_header hdr;
  15195. +    struct atapi_toc_entry  ent[MAX_TRACKS+1];
  15196. +      /* One extra for the leadout. */
  15197. +};
  15198. +
  15199. +
  15200. +/* This structure is annoyingly close to, but not identical with,
  15201. +   the cdrom_subchnl structure from cdrom.h. */
  15202. +struct atapi_cdrom_subchnl 
  15203. +{
  15204. +    u_char  acdsc_reserved;
  15205. +    u_char  acdsc_audiostatus;
  15206. +    u_short acdsc_length;
  15207. +    u_char  acdsc_format;
  15208. +
  15209. +    u_char  acdsc_adr:    4;
  15210. +    u_char  acdsc_ctrl:    4;
  15211. +    u_char  acdsc_trk;
  15212. +    u_char  acdsc_ind;
  15213. +    union {
  15214. +        struct atapi_msf msf;
  15215. +        int    lba;
  15216. +    } acdsc_absaddr;
  15217. +    union {
  15218. +        struct atapi_msf msf;
  15219. +        int    lba;
  15220. +    } acdsc_reladdr;
  15221. +};
  15222. +
  15223. +
  15224. +/* Extra per-device info for cdrom drives. */
  15225. +struct cdrom_info {
  15226. +
  15227. +    /* Buffer for table of contents.  NULL if we haven't allocated
  15228. +       a TOC buffer for this device yet. */
  15229. +
  15230. +    struct atapi_toc *toc;
  15231. +
  15232. +    /* Sector buffer.  If a read request wants only the first part
  15233. +       of a cdrom block, we cache the rest of the block here,
  15234. +       in the expectation that that data is going to be wanted soon.
  15235. +       SECTOR_BUFFERED is the number of the first buffered sector,
  15236. +       and NSECTORS_BUFFERED is the number of sectors in the buffer.
  15237. +       Before the buffer is allocated, we should have
  15238. +       SECTOR_BUFFER == NULL and NSECTORS_BUFFERED == 0. */
  15239. +
  15240. +    unsigned long sector_buffered;
  15241. +    unsigned long nsectors_buffered;
  15242. +    char *sector_buffer;
  15243. +
  15244. +    /* The result of the last successful request sense command
  15245. +       on this device. */
  15246. +    struct atapi_request_sense sense_data;
  15247. +};
  15248. +
  15249. +#endif /* CONFIG_BLK_DEV_IDECD */
  15250. +
  15251. +/*
  15252. + * Now for the data we need to maintain per-drive:  ide_drive_t
  15253. + */
  15254. +
  15255. +typedef enum {ide_disk, ide_cdrom, ide_tape} ide_media_t;
  15256. +
  15257. +typedef union {
  15258. +    unsigned all            : 8;    /* all of the bits together */
  15259. +    struct {
  15260. +        unsigned set_geometry    : 1;    /* respecify drive geometry */
  15261. +        unsigned recalibrate    : 1;    /* seek to cyl 0      */
  15262. +        unsigned set_multmode    : 1;    /* set multmode count */
  15263. +        unsigned set_tune    : 1;    /* tune interface for drive */
  15264. +        unsigned reserved    : 4;    /* unused */
  15265. +        } b;
  15266. +    } special_t;
  15267. +
  15268. +typedef union {
  15269. +    unsigned all            : 8;    /* all of the bits together */
  15270. +    struct {
  15271. +        unsigned head        : 4;    /* always zeros here */
  15272. +        unsigned unit        : 1;    /* drive select number, 0 or 1 */
  15273. +        unsigned bit5        : 1;    /* always 1 */
  15274. +        unsigned lba        : 1;    /* using LBA instead of CHS */
  15275. +        unsigned bit7        : 1;    /* always 1 */
  15276. +    } b;
  15277. +    } select_t;
  15278. +
  15279. +typedef struct ide_drive_s {
  15280. +    special_t    special;    /* special action flags */
  15281. +    unsigned present    : 1;    /* drive is physically present */
  15282. +    unsigned noprobe     : 1;    /* from:  hdx=noprobe */
  15283. +    unsigned keep_settings  : 1;    /* restore settings after drive reset */
  15284. +    unsigned busy        : 1;    /* currently doing revalidate_disk() */
  15285. +    unsigned removable    : 1;    /* 1 if need to do check_media_change */
  15286. +    unsigned using_dma    : 1;    /* disk is using dma for read/write */
  15287. +    unsigned forced_geom    : 1;    /* 1 if hdx=c,h,s was given at boot */
  15288. +    unsigned unmask        : 1;    /* flag: okay to unmask other irqs */
  15289. +    unsigned no_unmask    : 1;    /* disallow setting unmask bit */
  15290. +    unsigned no_io_32bit    : 1;    /* disallow enabling 32bit I/O */
  15291. +    unsigned nobios        : 1;    /* flag: do not probe bios for drive */
  15292. +    unsigned autotune    : 2;    /* 1=autotune, 2=noautotune, 0=default */
  15293. +#if FAKE_FDISK_FOR_EZDRIVE
  15294. +    unsigned remap_0_to_1    : 1;    /* flag: partitioned with ezdrive */
  15295. +#endif /* FAKE_FDISK_FOR_EZDRIVE */
  15296. +    ide_media_t    media;        /* disk, cdrom, tape */
  15297. +    select_t    select;        /* basic drive/head select reg value */
  15298. +    byte        ctl;        /* "normal" value for IDE_CONTROL_REG */
  15299. +    byte        ready_stat;    /* min status value for drive ready */
  15300. +    byte        mult_count;    /* current multiple sector setting */
  15301. +    byte         mult_req;    /* requested multiple sector setting */
  15302. +    byte        tune_req;    /* requested drive pio setting */
  15303. +    byte        io_32bit;    /* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
  15304. +    byte        bad_wstat;    /* used for ignoring WRERR_STAT */
  15305. +    byte        sect0;        /* offset of first sector for DM6:DDO */
  15306. +    byte         usage;        /* current "open()" count for drive */
  15307. +    byte         head;        /* "real" number of heads */
  15308. +    byte        sect;        /* "real" sectors per track */
  15309. +    byte        bios_head;    /* BIOS/fdisk/LILO number of heads */
  15310. +    byte        bios_sect;    /* BIOS/fdisk/LILO sectors per track */
  15311. +    unsigned short    bios_cyl;    /* BIOS/fdisk/LILO number of cyls */
  15312. +    unsigned short    cyl;        /* "real" number of cyls */
  15313. +    void          *hwif;    /* actually (ide_hwif_t *) */
  15314. +    struct wait_queue *wqueue;    /* used to wait for drive in open() */
  15315. +    struct hd_driveid *id;        /* drive model identification info */
  15316. +    struct hd_struct  *part;    /* drive partition table */
  15317. +    char        name[4];    /* drive name, such as "hda" */
  15318. +#ifdef CONFIG_BLK_DEV_IDECD
  15319. +    struct cdrom_info cdrom_info;    /* for ide-cd.c */
  15320. +#endif /* CONFIG_BLK_DEV_IDECD */
  15321. +#ifdef CONFIG_BLK_DEV_IDETAPE
  15322. +    idetape_tape_t    tape;        /* for ide-tape.c */
  15323. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  15324. +    } ide_drive_t;
  15325. +
  15326. +typedef struct hwreg_s {
  15327. +    unsigned long    io_base;
  15328. +    unsigned long    io_size;    /* 1 = normal, 16 = ICS ide */
  15329. +    unsigned long    ctl_port;
  15330. +    } hwreg_t;
  15331. +/*
  15332. + * An ide_dmaproc_t() initiates/aborts DMA read/write operations on a drive.
  15333. + *
  15334. + * The caller is assumed to have selected the drive and programmed the drive's
  15335. + * sector address using CHS or LBA.  All that remains is to prepare for DMA
  15336. + * and then issue the actual read/write DMA/PIO command to the drive.
  15337. + *
  15338. + * Returns 0 if all went well.
  15339. + * Returns 1 if DMA read/write could not be started, in which case the caller
  15340. + * should either try again later, or revert to PIO for the current request.
  15341. + */
  15342. +typedef enum {    ide_dma_read = 0,    ide_dma_write = 1,
  15343. +        ide_dma_abort = 2,    ide_dma_check = 3,
  15344. +        ide_dma_status_bad = 4,    ide_dma_transferred = 5,
  15345. +        ide_dma_begin = 6 }
  15346. +    ide_dma_action_t;
  15347. +
  15348. +typedef int (ide_dmaproc_t)(ide_dma_action_t, ide_drive_t *);
  15349. +
  15350. +
  15351. +/*
  15352. + * An ide_tuneproc_t() is used to set the speed of an IDE interface
  15353. + * to a particular PIO mode.  The "byte" parameter is used
  15354. + * to select the PIO mode by number (0,1,2,3,4,5), and a value of 255
  15355. + * indicates that the interface driver should "auto-tune" the PIO mode
  15356. + * according to the drive capabilities in drive->id;
  15357. + *
  15358. + * Not all interface types support tuning, and not all of those
  15359. + * support all possible PIO settings.  They may silently ignore
  15360. + * or round values as they see fit.
  15361. + */
  15362. +typedef void (ide_tuneproc_t)(ide_drive_t *, byte);
  15363. +
  15364. +/*
  15365. + * This is used to provide HT6560B & PROMISE interface support.
  15366. + */
  15367. +typedef void (ide_selectproc_t) (ide_drive_t *);
  15368. +
  15369. +/*
  15370. + * hwif_chipset_t is used to keep track of the specific hardware
  15371. + * chipset used by each IDE interface, if known.
  15372. + */
  15373. +typedef enum {    ide_unknown,    ide_generic,    ide_triton,
  15374. +        ide_cmd640,    ide_dtc2278,    ide_ali14xx,
  15375. +        ide_qd6580,    ide_umc8672,    ide_ht6560b,
  15376. +        ide_promise }
  15377. +    hwif_chipset_t;
  15378. +
  15379. +typedef struct hwif_s {
  15380. +    struct hwif_s    *next;        /* for linked-list in ide_hwgroup_t */
  15381. +    void        *hwgroup;    /* actually (ide_hwgroup_t *) */
  15382. +    hwreg_t        io;
  15383. +    ide_drive_t    drives[MAX_DRIVES];    /* drive info */
  15384. +    struct gendisk    *gd;        /* gendisk structure */
  15385. +    ide_tuneproc_t    *tuneproc;    /* routine to tune PIO mode for drives */
  15386. +#if defined(CONFIG_BLK_DEV_HT6560B) || defined(CONFIG_BLK_DEV_PROMISE)
  15387. +    ide_selectproc_t *selectproc;    /* tweaks hardware to select drive */
  15388. +#endif
  15389. +    ide_dmaproc_t    *dmaproc;    /* dma read/write/abort routine */
  15390. +    unsigned long    *dmatable;    /* dma physical region descriptor table */
  15391. +    unsigned short    dma_base;    /* base addr for dma ports (triton) */
  15392. +    byte        irq;        /* our irq number */
  15393. +    byte        major;        /* our major number */
  15394. +    char         name[5];    /* name of interface, eg. "ide0" */
  15395. +    byte        index;        /* 0 for ide0; 1 for ide1; ... */
  15396. +    hwif_chipset_t    chipset;    /* sub-module for tuning.. */
  15397. +    unsigned    noprobe    : 1;    /* don't probe for this interface */
  15398. +    unsigned    present    : 1;    /* this interface exists */
  15399. +    unsigned    serialized : 1;    /* serialized operation with mate hwif */
  15400. +    unsigned    sharing_irq: 1;    /* 1 = sharing irq with another hwif */
  15401. +#ifdef CONFIG_BLK_DEV_PROMISE
  15402. +    unsigned    is_promise2: 1;    /* 2nd i/f on promise DC4030 */
  15403. +#endif /* CONFIG_BLK_DEV_PROMISE */
  15404. +#if (DISK_RECOVERY_TIME > 0)
  15405. +    unsigned long    last_time;    /* time when previous rq was done */
  15406. +#endif
  15407. +#ifdef CONFIG_BLK_DEV_IDECD
  15408. +    struct request request_sense_request;    /* from ide-cd.c */
  15409. +    struct packet_command request_sense_pc;    /* from ide-cd.c */
  15410. +#endif /* CONFIG_BLK_DEV_IDECD */
  15411. +#ifdef CONFIG_BLK_DEV_IDETAPE
  15412. +    ide_drive_t    *tape_drive;    /* Pointer to the tape on this interface */
  15413. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  15414. +    } ide_hwif_t;
  15415. +
  15416. +/*
  15417. + *  internal ide interrupt handler type
  15418. + */
  15419. +typedef void (ide_handler_t)(ide_drive_t *);
  15420. +
  15421. +typedef struct hwgroup_s {
  15422. +    ide_handler_t        *handler;/* irq handler, if active */
  15423. +    ide_drive_t        *drive;    /* current drive */
  15424. +    ide_hwif_t        *hwif;    /* ptr to current hwif in linked-list */
  15425. +    ide_hwif_t        *next_hwif; /* next selected hwif (for tape) */
  15426. +    struct request        *rq;    /* current request */
  15427. +    struct timer_list    timer;    /* failsafe timer */
  15428. +    struct request        wrq;    /* local copy of current write rq */
  15429. +    unsigned long        poll_timeout;    /* timeout value during long polls */
  15430. +    } ide_hwgroup_t;
  15431. +
  15432. +/*
  15433. + * ide_hwifs[] is the master data structure used to keep track
  15434. + * of just about everything in ide.c.  Whenever possible, routines
  15435. + * should be using pointers to a drive (ide_drive_t *) or
  15436. + * pointers to a hwif (ide_hwif_t *), rather than indexing this
  15437. + * structure directly (the allocation/layout may change!).
  15438. + *
  15439. + */
  15440. +#ifndef _IDE_C
  15441. +extern    ide_hwif_t    ide_hwifs[];        /* master data repository */
  15442. +#endif
  15443. +
  15444. +/*
  15445. + * One final include file, which references some of the data/defns from above
  15446. + */
  15447. +#define IDE_DRIVER    /* "parameter" for blk.h */
  15448. +#include <linux/blk.h>
  15449. +
  15450. +#if (DISK_RECOVERY_TIME > 0)
  15451. +void ide_set_recovery_timer (ide_hwif_t *);
  15452. +#define SET_RECOVERY_TIMER(drive) ide_set_recovery_timer (drive)
  15453. +#else
  15454. +#define SET_RECOVERY_TIMER(drive)
  15455. +#endif
  15456. +
  15457. +/*
  15458. + * This is used for (nearly) all data transfers from the IDE interface
  15459. + */
  15460. +void ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount);
  15461. +
  15462. +/*
  15463. + * This is used for (nearly) all data transfers to the IDE interface
  15464. + */
  15465. +void ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount);
  15466. +
  15467. +/*
  15468. + * This is used on exit from the driver, to designate the next irq handler
  15469. + * and also to start the safety timer.
  15470. + */
  15471. +void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout);
  15472. +
  15473. +/*
  15474. + * Error reporting, in human readable form (luxurious, but a memory hog).
  15475. + */
  15476. +byte ide_dump_status (ide_drive_t *drive, const char *msg, byte stat);
  15477. +
  15478. +/*
  15479. + * ide_error() takes action based on the error returned by the controller.
  15480. + * The calling function must return afterwards, to restart the request.
  15481. + */
  15482. +void ide_error (ide_drive_t *drive, const char *msg, byte stat);
  15483. +
  15484. +/*
  15485. + * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
  15486. + * removing leading/trailing blanks and compressing internal blanks.
  15487. + * It is primarily used to tidy up the model name/number fields as
  15488. + * returned by the WIN_[P]IDENTIFY commands.
  15489. + */
  15490. +void ide_fixstring (byte *s, const int bytecount, const int byteswap);
  15491. +
  15492. +/*
  15493. + * This routine busy-waits for the drive status to be not "busy".
  15494. + * It then checks the status for all of the "good" bits and none
  15495. + * of the "bad" bits, and if all is okay it returns 0.  All other
  15496. + * cases return 1 after invoking ide_error() -- caller should return.
  15497. + *
  15498. + */
  15499. +int ide_wait_stat (ide_drive_t *drive, byte good, byte bad, unsigned long timeout);
  15500. +
  15501. +/*
  15502. + * This routine is called from the partition-table code in genhd.c
  15503. + * to "convert" a drive to a logical geometry with fewer than 1024 cyls.
  15504. + *
  15505. + * The second parameter, "xparm", determines exactly how the translation
  15506. + * will be handled:
  15507. + *         0 = convert to CHS with fewer than 1024 cyls
  15508. + *            using the same method as Ontrack DiskManager.
  15509. + *         1 = same as "0", plus offset everything by 63 sectors.
  15510. + *        -1 = similar to "0", plus redirect sector 0 to sector 1.
  15511. + *        >1 = convert to a CHS geometry with "xparm" heads.
  15512. + *
  15513. + * Returns 0 if the translation was not possible, if the device was not
  15514. + * an IDE disk drive, or if a geometry was "forced" on the commandline.
  15515. + * Returns 1 if the geometry translation was successful.
  15516. + */
  15517. +int ide_xlate_1024 (kdev_t, int, const char *);
  15518. +
  15519. +/*
  15520. + * Start a reset operation for an IDE interface.
  15521. + * The caller should return immediately after invoking this.
  15522. + */
  15523. +void ide_do_reset (ide_drive_t *);
  15524. +
  15525. +/*
  15526. + * This function is intended to be used prior to invoking ide_do_drive_cmd().
  15527. + */
  15528. +void ide_init_drive_cmd (struct request *rq);
  15529. +
  15530. +/*
  15531. + * "action" parameter type for ide_do_drive_cmd() below.
  15532. + */
  15533. +typedef enum
  15534. +    {ide_wait,    /* insert rq at end of list, and wait for it */
  15535. +     ide_next,    /* insert rq immediately after current request */
  15536. +     ide_preempt,    /* insert rq in front of current request */
  15537. +     ide_end}    /* insert rq at end of list, but don't wait for it */
  15538. + ide_action_t;
  15539. +
  15540. +/*
  15541. + * This function issues a special IDE device request
  15542. + * onto the request queue.
  15543. + *
  15544. + * If action is ide_wait, then then rq is queued at the end of
  15545. + * the request queue, and the function sleeps until it has been
  15546. + * processed.  This is for use when invoked from an ioctl handler.
  15547. + *
  15548. + * If action is ide_preempt, then the rq is queued at the head of
  15549. + * the request queue, displacing the currently-being-processed
  15550. + * request and this function returns immediately without waiting
  15551. + * for the new rq to be completed.  This is VERY DANGEROUS, and is
  15552. + * intended for careful use by the ATAPI tape/cdrom driver code.
  15553. + *
  15554. + * If action is ide_next, then the rq is queued immediately after
  15555. + * the currently-being-processed-request (if any), and the function
  15556. + * returns without waiting for the new rq to be completed.  As above,
  15557. + * This is VERY DANGEROUS, and is intended for careful use by the
  15558. + * ATAPI tape/cdrom driver code.
  15559. + *
  15560. + * If action is ide_end, then the rq is queued at the end of the
  15561. + * request queue, and the function returns immediately without waiting
  15562. + * for the new rq to be completed. This is again intended for careful
  15563. + * use by the ATAPI tape/cdrom driver code. (Currently used by ide-tape.c,
  15564. + * when operating in the pipelined operation mode).
  15565. + */
  15566. +int ide_do_drive_cmd (ide_drive_t *drive, struct request *rq, ide_action_t action);
  15567. +
  15568. +/*
  15569. + * Clean up after success/failure of an explicit drive cmd.
  15570. + * stat/err are used only when (HWGROUP(drive)->rq->cmd == IDE_DRIVE_CMD).
  15571. + */
  15572. +void ide_end_drive_cmd (ide_drive_t *drive, byte stat, byte err);
  15573. +
  15574. +/*
  15575. + * ide_system_bus_speed() returns what we think is the system VESA/PCI
  15576. + * bus speed (in Mhz).  This is used for calculating interface PIO timings.
  15577. + * The default is 40 for known PCI systems, 50 otherwise.
  15578. + * The "idebus=xx" parameter can be used to override this value.
  15579. + */
  15580. +int ide_system_bus_speed (void);
  15581. +
  15582. +/*
  15583. + * ide_multwrite() transfers a block of up to mcount sectors of data
  15584. + * to a drive as part of a disk multwrite operation.
  15585. + */
  15586. +void ide_multwrite (ide_drive_t *drive, unsigned int mcount);
  15587. +
  15588. +#ifdef CONFIG_BLK_DEV_IDECD
  15589. +/*
  15590. + * These are routines in ide-cd.c invoked from ide.c
  15591. + */
  15592. +void ide_do_rw_cdrom (ide_drive_t *, unsigned long);
  15593. +int ide_cdrom_ioctl (ide_drive_t *, struct inode *, struct file *, unsigned int, unsigned long);
  15594. +int ide_cdrom_check_media_change (ide_drive_t *);
  15595. +int ide_cdrom_open (struct inode *, struct file *, ide_drive_t *);
  15596. +void ide_cdrom_release (struct inode *, struct file *, ide_drive_t *);
  15597. +void ide_cdrom_setup (ide_drive_t *);
  15598. +#endif /* CONFIG_BLK_DEV_IDECD */
  15599. +
  15600. +#ifdef CONFIG_BLK_DEV_IDETAPE
  15601. +
  15602. +/*
  15603. + *    Functions in ide-tape.c which are invoked from ide.c:
  15604. + */
  15605. +
  15606. +/*
  15607. + *    idetape_identify_device is called during device probing stage to
  15608. + *    probe for an ide atapi tape drive and to initialize global variables
  15609. + *    in ide-tape.c which provide the link between the character device
  15610. + *    and the corresponding block device.
  15611. + *
  15612. + *    Returns 1 if an ide tape was detected and is supported.
  15613. + *    Returns 0 otherwise.
  15614. + */
  15615. +
  15616. +int idetape_identify_device (ide_drive_t *drive,struct hd_driveid *id);
  15617. +
  15618. +/*
  15619. + *    idetape_setup is called a bit later than idetape_identify_device,
  15620. + *    during the search for disk partitions, to initialize various tape
  15621. + *    state variables in ide_drive_t *drive.
  15622. + */
  15623. +
  15624. +void idetape_setup (ide_drive_t *drive);
  15625. +
  15626. +/*
  15627. + *    idetape_do_request is our request function. It is called by ide.c
  15628. + *    to process a new request.
  15629. + */
  15630. +
  15631. +void idetape_do_request (ide_drive_t *drive, struct request *rq, unsigned long block);
  15632. +
  15633. +/*
  15634. + *    idetape_end_request is used to finish servicing a request, and to
  15635. + *    insert a pending pipeline request into the main device queue.
  15636. + */
  15637. +
  15638. +void idetape_end_request (byte uptodate, ide_hwgroup_t *hwgroup);
  15639. +
  15640. +/*
  15641. + *    Block device interface functions.
  15642. + */
  15643. +
  15644. +int idetape_blkdev_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file,
  15645. +            unsigned int cmd, unsigned long arg);
  15646. +int idetape_blkdev_open (struct inode *inode, struct file *filp, ide_drive_t *drive);
  15647. +void idetape_blkdev_release (struct inode *inode, struct file *filp, ide_drive_t *drive);
  15648. +
  15649. +/*
  15650. + *    idetape_register_chrdev initializes the character device interface to
  15651. + *    the ide tape drive.
  15652. + */
  15653. +
  15654. +void idetape_register_chrdev (void);
  15655. +
  15656. +#endif /* CONFIG_BLK_DEV_IDETAPE */
  15657. +
  15658. +#ifdef CONFIG_BLK_DEV_TRITON
  15659. +void ide_init_triton (byte, byte);
  15660. +#endif /* CONFIG_BLK_DEV_TRITON */
  15661. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/ll_rw_blk.c linux/arch/arm/drivers/block/ll_rw_blk.c
  15662. --- linux.orig/arch/arm/drivers/block/ll_rw_blk.c    Thu Jan  1 01:00:00 1970
  15663. +++ linux/arch/arm/drivers/block/ll_rw_blk.c    Sat Aug 17 23:24:17 1996
  15664. @@ -0,0 +1,651 @@
  15665. +/*
  15666. + *  linux/drivers/block/ll_rw_blk.c
  15667. + *
  15668. + * Copyright (C) 1991, 1992 Linus Torvalds
  15669. + * Copyright (C) 1994,      Karl Keyte: Added support for disk statistics
  15670. + */
  15671. +
  15672. +/*
  15673. + * This handles all read/write requests to block devices
  15674. + */
  15675. +#include <linux/sched.h>
  15676. +#include <linux/kernel.h>
  15677. +#include <linux/kernel_stat.h>
  15678. +#include <linux/errno.h>
  15679. +#include <linux/string.h>
  15680. +#include <linux/config.h>
  15681. +#include <linux/locks.h>
  15682. +#include <linux/mm.h>
  15683. +
  15684. +#include <asm/system.h>
  15685. +#include <asm/io.h>
  15686. +#include "blk.h"
  15687. +
  15688. +extern int adfsimg_map (kdev_t *rdev, unsigned long *rsector, unsigned long size);
  15689. +
  15690. +/*
  15691. + * The request-struct contains all necessary data
  15692. + * to load a nr of sectors into memory
  15693. + */
  15694. +static struct request all_requests[NR_REQUEST];
  15695. +
  15696. +/*
  15697. + * The "disk" task queue is used to start the actual requests
  15698. + * after a plug
  15699. + */
  15700. +DECLARE_TASK_QUEUE(tq_disk);
  15701. +
  15702. +/* 
  15703. + * used to wait on when there are no free requests
  15704. + */
  15705. +struct wait_queue * wait_for_request;
  15706. +
  15707. +/* This specifies how many sectors to read ahead on the disk.  */
  15708. +
  15709. +int read_ahead[MAX_BLKDEV];
  15710. +
  15711. +/* blk_dev_struct is:
  15712. + *    *request_fn
  15713. + *    *current_request
  15714. + */
  15715. +struct blk_dev_struct blk_dev[MAX_BLKDEV]; /* initialized by blk_dev_init() */
  15716. +
  15717. +/*
  15718. + * blk_size contains the size of all block-devices in units of 1024 byte
  15719. + * sectors:
  15720. + *
  15721. + * blk_size[MAJOR][MINOR]
  15722. + *
  15723. + * if (!blk_size[MAJOR]) then no minor size checking is done.
  15724. + */
  15725. +int * blk_size[MAX_BLKDEV];
  15726. +
  15727. +/*
  15728. + * blksize_size contains the size of all block-devices:
  15729. + *
  15730. + * blksize_size[MAJOR][MINOR]
  15731. + *
  15732. + * if (!blksize_size[MAJOR]) then 1024 bytes is assumed.
  15733. + */
  15734. +int * blksize_size[MAX_BLKDEV];
  15735. +
  15736. +/*
  15737. + * hardsect_size contains the size of the hardware sector of a device.
  15738. + *
  15739. + * hardsect_size[MAJOR][MINOR]
  15740. + *
  15741. + * if (!hardsect_size[MAJOR])
  15742. + *        then 512 bytes is assumed.
  15743. + * else
  15744. + *        sector_size is hardsect_size[MAJOR][MINOR]
  15745. + * This is currently set by some scsi device and read by the msdos fs driver
  15746. + * This might be a some uses later.
  15747. + */
  15748. +int * hardsect_size[MAX_BLKDEV];
  15749. +
  15750. +/*
  15751. + * remove the plug and let it rip..
  15752. + */
  15753. +void unplug_device(void * data)
  15754. +{
  15755. +    struct blk_dev_struct * dev = (struct blk_dev_struct *) data;
  15756. +    unsigned long flags;
  15757. +
  15758. +    save_flags_cli(flags);
  15759. +    if (dev->current_request == &dev->plug) {
  15760. +        struct request * next = dev->plug.next;
  15761. +        dev->current_request = next;
  15762. +        if (next) {
  15763. +            dev->plug.next = NULL;
  15764. +            (dev->request_fn)();
  15765. +        }
  15766. +    }
  15767. +    restore_flags(flags);
  15768. +}
  15769. +
  15770. +/*
  15771. + * "plug" the device if there are no outstanding requests: this will
  15772. + * force the transfer to start only after we have put all the requests
  15773. + * on the list.
  15774. + *
  15775. + * This is called with interrupts off and no requests on the queue.
  15776. + */
  15777. +static inline void plug_device(struct blk_dev_struct * dev)
  15778. +{
  15779. +    dev->current_request = &dev->plug;
  15780. +    queue_task_irq_off(&dev->plug_tq, &tq_disk);
  15781. +}
  15782. +
  15783. +/*
  15784. + * look for a free request in the first N entries.
  15785. + * NOTE: interrupts must be disabled on the way in, and will still
  15786. + *       be disabled on the way out.
  15787. + */
  15788. +static inline struct request * get_request(int n, kdev_t dev)
  15789. +{
  15790. +    static struct request *prev_found = NULL, *prev_limit = NULL;
  15791. +    register struct request *req, *limit;
  15792. +
  15793. +    if (n <= 0)
  15794. +        panic("get_request(%d): impossible!\n", n);
  15795. +
  15796. +    limit = all_requests + n;
  15797. +    if (limit != prev_limit) {
  15798. +        prev_limit = limit;
  15799. +        prev_found = all_requests;
  15800. +    }
  15801. +    req = prev_found;
  15802. +    for (;;) {
  15803. +        req = ((req > all_requests) ? req : limit) - 1;
  15804. +        if (req->rq_status == RQ_INACTIVE)
  15805. +            break;
  15806. +        if (req == prev_found)
  15807. +            return NULL;
  15808. +    }
  15809. +    prev_found = req;
  15810. +    req->rq_status = RQ_ACTIVE;
  15811. +    req->rq_dev = dev;
  15812. +    return req;
  15813. +}
  15814. +
  15815. +/*
  15816. + * wait until a free request in the first N entries is available.
  15817. + */
  15818. +static struct request * __get_request_wait(int n, kdev_t dev)
  15819. +{
  15820. +    register struct request *req;
  15821. +    struct wait_queue wait = { current, NULL };
  15822. +
  15823. +    add_wait_queue(&wait_for_request, &wait);
  15824. +    for (;;) {
  15825. +        current->state = TASK_UNINTERRUPTIBLE;
  15826. +        cli();
  15827. +        req = get_request(n, dev);
  15828. +        sti();
  15829. +        if (req)
  15830. +            break;
  15831. +        run_task_queue(&tq_disk);
  15832. +        schedule();
  15833. +    }
  15834. +    remove_wait_queue(&wait_for_request, &wait);
  15835. +    current->state = TASK_RUNNING;
  15836. +    return req;
  15837. +}
  15838. +
  15839. +static inline struct request * get_request_wait(int n, kdev_t dev)
  15840. +{
  15841. +    register struct request *req;
  15842. +
  15843. +    cli();
  15844. +    req = get_request(n, dev);
  15845. +    sti();
  15846. +    if (req)
  15847. +        return req;
  15848. +    return __get_request_wait(n, dev);
  15849. +}
  15850. +
  15851. +/* RO fail safe mechanism */
  15852. +
  15853. +static long ro_bits[MAX_BLKDEV][8];
  15854. +
  15855. +int is_read_only(kdev_t dev)
  15856. +{
  15857. +    int minor,major;
  15858. +
  15859. +    major = MAJOR(dev);
  15860. +    minor = MINOR(dev);
  15861. +    if (major < 0 || major >= MAX_BLKDEV) return 0;
  15862. +    return ro_bits[major][minor >> 5] & (1 << (minor & 31));
  15863. +}
  15864. +
  15865. +void set_device_ro(kdev_t dev,int flag)
  15866. +{
  15867. +    int minor,major;
  15868. +
  15869. +    major = MAJOR(dev);
  15870. +    minor = MINOR(dev);
  15871. +    if (major < 0 || major >= MAX_BLKDEV) return;
  15872. +    if (flag) ro_bits[major][minor >> 5] |= 1 << (minor & 31);
  15873. +    else ro_bits[major][minor >> 5] &= ~(1 << (minor & 31));
  15874. +}
  15875. +
  15876. +static inline void drive_stat_acct(int cmd, unsigned long nr_sectors,
  15877. +                    short disk_index)
  15878. +{
  15879. +    kstat.dk_drive[disk_index]++;
  15880. +    if (cmd == READ) {
  15881. +        kstat.dk_drive_rio[disk_index]++;
  15882. +        kstat.dk_drive_rblk[disk_index] += nr_sectors;
  15883. +    } else if (cmd == WRITE) {
  15884. +        kstat.dk_drive_wio[disk_index]++;
  15885. +        kstat.dk_drive_wblk[disk_index] += nr_sectors;
  15886. +    } else
  15887. +        printk(KERN_ERR "drive_stat_acct: cmd not R/W?\n");
  15888. +}
  15889. +
  15890. +/*
  15891. + * add-request adds a request to the linked list.
  15892. + * It disables interrupts so that it can muck with the
  15893. + * request-lists in peace.
  15894. + *
  15895. + * By this point, req->cmd is always either READ/WRITE, never READA/WRITEA,
  15896. + * which is important for drive_stat_acct() above.
  15897. + */
  15898. +
  15899. +void add_request(struct blk_dev_struct * dev, struct request * req)
  15900. +{
  15901. +    struct request * tmp;
  15902. +    short         disk_index;
  15903. +
  15904. +    switch (MAJOR(req->rq_dev)) {
  15905. +        case SCSI_DISK_MAJOR:
  15906. +            disk_index = (MINOR(req->rq_dev) & 0x0070) >> 4;
  15907. +            if (disk_index < 4)
  15908. +                drive_stat_acct(req->cmd, req->nr_sectors, disk_index);
  15909. +            break;
  15910. +        case IDE0_MAJOR:    /* same as HD_MAJOR */
  15911. +        case XT_DISK_MAJOR:
  15912. +            disk_index = (MINOR(req->rq_dev) & 0x0040) >> 6;
  15913. +            drive_stat_acct(req->cmd, req->nr_sectors, disk_index);
  15914. +            break;
  15915. +        case IDE1_MAJOR:
  15916. +            disk_index = ((MINOR(req->rq_dev) & 0x0040) >> 6) + 2;
  15917. +            drive_stat_acct(req->cmd, req->nr_sectors, disk_index);
  15918. +        default:
  15919. +            break;
  15920. +    }
  15921. +
  15922. +    req->next = NULL;
  15923. +    cli();
  15924. +    if (req->bh)
  15925. +        mark_buffer_clean(req->bh);
  15926. +    if (!(tmp = dev->current_request)) {
  15927. +        dev->current_request = req;
  15928. +        (dev->request_fn)();
  15929. +        sti();
  15930. +        return;
  15931. +    }
  15932. +    for ( ; tmp->next ; tmp = tmp->next) {
  15933. +        if ((IN_ORDER(tmp,req) ||
  15934. +            !IN_ORDER(tmp,tmp->next)) &&
  15935. +            IN_ORDER(req,tmp->next))
  15936. +            break;
  15937. +    }
  15938. +    req->next = tmp->next;
  15939. +    tmp->next = req;
  15940. +
  15941. +/* for SCSI devices, call request_fn unconditionally */
  15942. +    if (scsi_blk_major(MAJOR(req->rq_dev)))
  15943. +        (dev->request_fn)();
  15944. +
  15945. +    sti();
  15946. +}
  15947. +
  15948. +static void make_request(int major,int rw, struct buffer_head * bh)
  15949. +{
  15950. +    unsigned int sector, count;
  15951. +    struct request * req;
  15952. +    int rw_ahead, max_req;
  15953. +
  15954. +    count = bh->b_size >> 9;
  15955. +    sector = bh->b_rsector;
  15956. +
  15957. +    /* Uhhuh.. Nasty dead-lock possible here.. */
  15958. +    if (buffer_locked(bh))
  15959. +        return;
  15960. +    /* Maybe the above fixes it, and maybe it doesn't boot. Life is interesting */
  15961. +
  15962. +    lock_buffer(bh);
  15963. +
  15964. +    if (blk_size[major])
  15965. +        if (blk_size[major][MINOR(bh->b_rdev)] < (sector + count)>>1) {
  15966. +            bh->b_state &= (1 << BH_Lock) | (1 << BH_FreeOnIO);
  15967. +            /* This may well happen - the kernel calls bread()
  15968. +               without checking the size of the device, e.g.,
  15969. +               when mounting a device. */
  15970. +            printk(KERN_INFO
  15971. +                "attempt to access beyond end of device\n");
  15972. +            printk(KERN_INFO "%s: rw=%d, want=%d, limit=%d\n",
  15973. +                kdevname(bh->b_rdev), rw,
  15974. +                (sector + count)>>1,
  15975. +                blk_size[major][MINOR(bh->b_rdev)]);
  15976. +            unlock_buffer(bh);
  15977. +            return;
  15978. +        }
  15979. +
  15980. +    rw_ahead = 0;    /* normal case; gets changed below for READA/WRITEA */
  15981. +    switch (rw) {
  15982. +        case READA:
  15983. +            rw_ahead = 1;
  15984. +            rw = READ;    /* drop into READ */
  15985. +        case READ:
  15986. +            if (buffer_uptodate(bh)) {
  15987. +                unlock_buffer(bh); /* Hmmph! Already have it */
  15988. +                return;
  15989. +            }
  15990. +            kstat.pgpgin++;
  15991. +            max_req = NR_REQUEST;    /* reads take precedence */
  15992. +            break;
  15993. +        case WRITEA:
  15994. +            rw_ahead = 1;
  15995. +            rw = WRITE;    /* drop into WRITE */
  15996. +        case WRITE:
  15997. +            if (!buffer_dirty(bh)) {
  15998. +                unlock_buffer(bh); /* Hmmph! Nothing to write */
  15999. +                return;
  16000. +            }
  16001. +            /* We don't allow the write-requests to fill up the
  16002. +             * queue completely:  we want some room for reads,
  16003. +             * as they take precedence. The last third of the
  16004. +             * requests are only for reads.
  16005. +             */
  16006. +            kstat.pgpgout++;
  16007. +            max_req = (NR_REQUEST * 2) / 3;
  16008. +            break;
  16009. +        default:
  16010. +            printk(KERN_ERR "make_request: bad block dev cmd,"
  16011. +                " must be R/W/RA/WA\n");
  16012. +            unlock_buffer(bh);
  16013. +            return;
  16014. +    }
  16015. +    /* look for a free request. */
  16016. +    if (major == ADFSIMG_MAJOR)
  16017. +        max_req = (max_req * 2) / 3;
  16018. +    /*
  16019. +     * Try to coalesce the new request with old requests
  16020. +     */
  16021. +    cli();
  16022. +    req = blk_dev[major].current_request;
  16023. +    if (!req) {
  16024. +        /* MD and loop can't handle plugging without deadlocking */
  16025. +        if (major != MD_MAJOR && major != LOOP_MAJOR && major != ADFSIMG_MAJOR)
  16026. +            plug_device(blk_dev + major);
  16027. +    } else switch (major) {
  16028. +         case IDE0_MAJOR:    /* same as HD_MAJOR */
  16029. +         case IDE1_MAJOR:
  16030. +         case FLOPPY_MAJOR:
  16031. +         case IDE2_MAJOR:
  16032. +         case IDE3_MAJOR:
  16033. +         case XT_DISK_MAJOR:
  16034. +         case ADFSIMG_MAJOR:
  16035. +        /*
  16036. +         * The scsi disk and cdrom drivers completely remove the request
  16037. +         * from the queue when they start processing an entry.  For this
  16038. +         * reason it is safe to continue to add links to the top entry for
  16039. +         * those devices.
  16040. +         *
  16041. +         * All other drivers need to jump over the first entry, as that
  16042. +         * entry may be busy being processed and we thus can't change it.
  16043. +         */
  16044. +        req = req->next;
  16045. +        if (!req)
  16046. +            break;
  16047. +        /* fall through */
  16048. +
  16049. +         case SCSI_DISK_MAJOR:
  16050. +         case SCSI_CDROM_MAJOR:
  16051. +
  16052. +        do {
  16053. +            if (req->sem)
  16054. +                continue;
  16055. +            if (req->cmd != rw)
  16056. +                continue;
  16057. +            if (req->nr_sectors >= 244)
  16058. +                continue;
  16059. +            if (req->rq_dev != bh->b_rdev)
  16060. +                continue;
  16061. +            /* Can we add it to the end of this request? */
  16062. +            if (req->sector + req->nr_sectors == sector) {
  16063. +                req->bhtail->b_reqnext = bh;
  16064. +                req->bhtail = bh;
  16065. +            /* or to the beginning? */
  16066. +            } else if (req->sector - count == sector) {
  16067. +                bh->b_reqnext = req->bh;
  16068. +                req->bh = bh;
  16069. +                req->buffer = bh->b_data;
  16070. +                req->current_nr_sectors = count;
  16071. +                req->sector = sector;
  16072. +            } else
  16073. +                continue;
  16074. +
  16075. +            req->nr_sectors += count;
  16076. +            mark_buffer_clean(bh);
  16077. +                sti();
  16078. +                return;
  16079. +        } while ((req = req->next) != NULL);
  16080. +    }
  16081. +
  16082. +/* find an unused request. */
  16083. +    req = get_request(max_req, bh->b_rdev);
  16084. +    sti();
  16085. +
  16086. +/* if no request available: if rw_ahead, forget it; otherwise try again blocking.. */
  16087. +    if (!req) {
  16088. +        if (rw_ahead) {
  16089. +            unlock_buffer(bh);
  16090. +            return;
  16091. +        }
  16092. +        req = __get_request_wait(max_req, bh->b_rdev);
  16093. +    }
  16094. +
  16095. +/* fill up the request-info, and add it to the queue */
  16096. +    req->cmd = rw;
  16097. +    req->errors = 0;
  16098. +    req->sector = sector;
  16099. +    req->nr_sectors = count;
  16100. +    req->current_nr_sectors = count;
  16101. +    req->buffer = bh->b_data;
  16102. +    req->sem = NULL;
  16103. +    req->bh = bh;
  16104. +    req->bhtail = bh;
  16105. +    req->next = NULL;
  16106. +    add_request(major+blk_dev,req);
  16107. +}
  16108. +
  16109. +/* This function can be used to request a number of buffers from a block
  16110. +   device. Currently the only restriction is that all buffers must belong to
  16111. +   the same device */
  16112. +
  16113. +void ll_rw_block(int rw, int nr, struct buffer_head * bh[])
  16114. +{
  16115. +    unsigned int major;
  16116. +    int correct_size;
  16117. +    struct blk_dev_struct * dev;
  16118. +    int i;
  16119. +
  16120. +    /* Make sure that the first block contains something reasonable */
  16121. +    while (!*bh) {
  16122. +        bh++;
  16123. +        if (--nr <= 0)
  16124. +            return;
  16125. +    }
  16126. +
  16127. +    dev = NULL;
  16128. +    if ((major = MAJOR(bh[0]->b_dev)) < MAX_BLKDEV)
  16129. +        dev = blk_dev + major;
  16130. +    if (!dev || !dev->request_fn) {
  16131. +        printk(KERN_ERR
  16132. +    "ll_rw_block: Trying to read nonexistent block-device %s (%ld)\n",
  16133. +        kdevname(bh[0]->b_dev), bh[0]->b_blocknr);
  16134. +        goto sorry;
  16135. +    }
  16136. +
  16137. +    /* Determine correct block size for this device.  */
  16138. +    correct_size = BLOCK_SIZE;
  16139. +    if (blksize_size[major]) {
  16140. +        i = blksize_size[major][MINOR(bh[0]->b_dev)];
  16141. +        if (i)
  16142. +            correct_size = i;
  16143. +    }
  16144. +
  16145. +    /* Verify requested block sizes.  */
  16146. +    for (i = 0; i < nr; i++) {
  16147. +        if (bh[i] && bh[i]->b_size != correct_size) {
  16148. +            printk(KERN_NOTICE "ll_rw_block: device %s: "
  16149. +                   "only %d-char blocks implemented (%lu)\n",
  16150. +                   kdevname(bh[0]->b_dev),
  16151. +                   correct_size, bh[i]->b_size);
  16152. +            goto sorry;
  16153. +        }
  16154. +
  16155. +        /* Md remaps blocks now */
  16156. +        bh[i]->b_rdev = bh[i]->b_dev;
  16157. +        bh[i]->b_rsector=bh[i]->b_blocknr*(bh[i]->b_size >> 9);
  16158. +#ifdef CONFIG_BLK_DEV_MD
  16159. +        if (major==MD_MAJOR &&
  16160. +            md_map (MINOR(bh[i]->b_dev), &bh[i]->b_rdev,
  16161. +                &bh[i]->b_rsector, bh[i]->b_size >> 9)) {
  16162. +            printk (KERN_ERR
  16163. +                "Bad md_map in ll_rw_block\n");
  16164. +            goto sorry;
  16165. +        }
  16166. +#endif
  16167. +    }
  16168. +
  16169. +    if ((rw == WRITE || rw == WRITEA) && is_read_only(bh[0]->b_dev)) {
  16170. +        printk(KERN_NOTICE "Can't write to read-only device %s\n",
  16171. +               kdevname(bh[0]->b_dev));
  16172. +        goto sorry;
  16173. +    }
  16174. +
  16175. +    for (i = 0; i < nr; i++) {
  16176. +        if (bh[i]) {
  16177. +            set_bit(BH_Req, &bh[i]->b_state);
  16178. +
  16179. +            make_request(MAJOR(bh[i]->b_rdev), rw, bh[i]);
  16180. +        }
  16181. +    }
  16182. +    return;
  16183. +
  16184. +      sorry:
  16185. +    for (i = 0; i < nr; i++) {
  16186. +        if (bh[i]) {
  16187. +            clear_bit(BH_Dirty, &bh[i]->b_state);
  16188. +            clear_bit(BH_Uptodate, &bh[i]->b_state);
  16189. +        }
  16190. +    }
  16191. +    return;
  16192. +}
  16193. +
  16194. +void ll_rw_swap_file(int rw, kdev_t dev, unsigned int *b, int nb, char *buf)
  16195. +{
  16196. +    int i, j;
  16197. +    int buffersize;
  16198. +    unsigned long rsector;
  16199. +    kdev_t rdev;
  16200. +    struct request * req[8];
  16201. +    unsigned int major = MAJOR(dev);
  16202. +    struct semaphore sem = MUTEX_LOCKED;
  16203. +
  16204. +    if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  16205. +        printk(KERN_NOTICE "ll_rw_swap_file: trying to swap to"
  16206. +                    " nonexistent block-device\n");
  16207. +        return;
  16208. +    }
  16209. +    switch (rw) {
  16210. +        case READ:
  16211. +            break;
  16212. +        case WRITE:
  16213. +            if (is_read_only(dev)) {
  16214. +                printk(KERN_NOTICE
  16215. +                    "Can't swap to read-only device %s\n",
  16216. +                    kdevname(dev));
  16217. +                return;
  16218. +            }
  16219. +            break;
  16220. +        default:
  16221. +            panic("ll_rw_swap: bad block dev cmd, must be R/W");
  16222. +    }
  16223. +    buffersize = PAGE_SIZE / nb;
  16224. +
  16225. +    for (j=0, i=0; i<nb;)
  16226. +    {
  16227. +        for (; j < 8 && i < nb; j++, i++, buf += buffersize)
  16228. +        {
  16229. +            rdev = dev;
  16230. +            rsector = (b[i] * buffersize) >> 9;
  16231. +#ifdef CONFIG_BLK_DEV_MD
  16232. +            if (major==MD_MAJOR &&
  16233. +                md_map (MINOR(dev), &rdev,
  16234. +                &rsector, buffersize >> 9)) {
  16235. +                printk (KERN_ERR
  16236. +                    "Bad md_map in ll_rw_swap_file\n");
  16237. +                return;
  16238. +            }
  16239. +#endif
  16240. +            if (j == 0) {
  16241. +                req[j] = get_request_wait(NR_REQUEST, rdev);
  16242. +            } else {
  16243. +                cli();
  16244. +                req[j] = get_request(NR_REQUEST, rdev);
  16245. +                sti();
  16246. +                if (req[j] == NULL)
  16247. +                    break;
  16248. +            }
  16249. +            req[j]->cmd = rw;
  16250. +            req[j]->errors = 0;
  16251. +            req[j]->sector = rsector;
  16252. +            req[j]->nr_sectors = buffersize >> 9;
  16253. +            req[j]->current_nr_sectors = buffersize >> 9;
  16254. +            req[j]->buffer = buf;
  16255. +            req[j]->sem = &sem;
  16256. +            req[j]->bh = NULL;
  16257. +            req[j]->next = NULL;
  16258. +            add_request(MAJOR(rdev)+blk_dev,req[j]);
  16259. +        }
  16260. +        run_task_queue(&tq_disk);
  16261. +        while (j > 0) {
  16262. +            j--;
  16263. +            down(&sem);
  16264. +        }
  16265. +    }
  16266. +}
  16267. +
  16268. +int blk_dev_init(void)
  16269. +{
  16270. +    struct request * req;
  16271. +    struct blk_dev_struct *dev;
  16272. +
  16273. +    for (dev = blk_dev + MAX_BLKDEV; dev-- != blk_dev;) {
  16274. +        dev->request_fn      = NULL;
  16275. +        dev->current_request = NULL;
  16276. +        dev->plug.rq_status  = RQ_INACTIVE;
  16277. +        dev->plug.cmd        = -1;
  16278. +        dev->plug.next       = NULL;
  16279. +        dev->plug_tq.routine = &unplug_device;
  16280. +        dev->plug_tq.data    = dev;
  16281. +    }
  16282. +
  16283. +    req = all_requests + NR_REQUEST;
  16284. +    while (--req >= all_requests) {
  16285. +        req->rq_status = RQ_INACTIVE;
  16286. +        req->next = NULL;
  16287. +    }
  16288. +    memset(ro_bits,0,sizeof(ro_bits));
  16289. +#ifdef CONFIG_BLK_DEV_RAM
  16290. +    rd_init();
  16291. +#endif
  16292. +#ifdef CONFIG_BLK_DEV_LOOP
  16293. +    loop_init();
  16294. +#endif
  16295. +#ifdef CONFIG_BLK_DEV_IDE
  16296. +    ide_init();        /* this MUST precede hd_init */
  16297. +#endif
  16298. +#ifdef CONFIG_BLK_DEV_HD
  16299. +    hd_init();
  16300. +#endif
  16301. +#ifdef CONFIG_BLK_DEV_XD
  16302. +    xd_init();
  16303. +#endif
  16304. +#ifdef CONFIG_BLK_DEV_FD
  16305. +    floppy_init();
  16306. +#else
  16307. +#ifndef CONFIG_ARCH_ARC
  16308. +    outb_p(0xc, 0x3f2);
  16309. +#endif
  16310. +#endif
  16311. +#ifdef CONFIG_BLK_DEV_MD
  16312. +    md_init();
  16313. +#endif CONFIG_BLK_DEV_MD
  16314. +    return 0;
  16315. +}
  16316. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/mfm.S linux/arch/arm/drivers/block/mfm.S
  16317. --- linux.orig/arch/arm/drivers/block/mfm.S    Thu Jan  1 01:00:00 1970
  16318. +++ linux/arch/arm/drivers/block/mfm.S    Sat Sep  7 21:09:58 1996
  16319. @@ -0,0 +1,159 @@
  16320. +@ Read/Write DMA code for the ST506/MFM hard drive controllers on the A400
  16321. +@   motherboard on ST506 podules.
  16322. +@ (c) David Alan Gilbert (gilbertd@cs.man.ac.uk) 1996
  16323. +
  16324. +#include <asm/assembler.h>
  16325. + 
  16326. +_hdc63463_irqdata:
  16327. +@ Controller base address
  16328. +  .global _hdc63463_baseaddress
  16329. +_hdc63463_baseaddress:
  16330. +  .word 0
  16331. +
  16332. +  .global _hdc63463_irqpolladdress
  16333. +_hdc63463_irqpolladdress:
  16334. +  .word 0
  16335. + 
  16336. +  .global _hdc63463_irqpollmask
  16337. +_hdc63463_irqpollmask:
  16338. +  .word 0
  16339. +
  16340. +@ where to read/write data  from the kernel data space
  16341. +  .global _hdc63463_dataptr
  16342. +_hdc63463_dataptr:
  16343. +  .word 0
  16344. +
  16345. +@ Number of bytes left to transfer
  16346. +  .global _hdc63463_dataleft
  16347. +_hdc63463_dataleft:
  16348. +  .word 0
  16349. +
  16350. +@ -------------------------------------------------------------------------
  16351. +@ hdc63463_writedma: DMA from host to controller
  16352. +@  internal reg usage: r0=hdc base address, r1=irq poll address, r2=poll mask
  16353. +@                      r3=data ptr, r4=data left, r5,r6=temporary
  16354. +  .global _hdc63463_writedma
  16355. +_hdc63463_writedma:
  16356. +  stmfd sp!,{r4-r7}
  16357. +  adr r5,_hdc63463_irqdata
  16358. +  ldmia r5,{r0,r1,r2,r3,r4}
  16359. +
  16360. +
  16361. +writedma_again:
  16362. +
  16363. +  @ test number of remaining bytes to transfer
  16364. +  cmp r4,#0
  16365. +  beq writedma_end
  16366. +  bmi writedma_end
  16367. +
  16368. +  @ Check the hdc is interrupting
  16369. +  ldrb r5,[r1,#0]
  16370. +  tst r5,r2
  16371. +  beq writedma_end
  16372. +
  16373. +  @ Transfer a block of upto 256 bytes
  16374. +  cmp r4,#256
  16375. +  movlt r7,r4
  16376. +  movge r7,#256
  16377. +
  16378. +  @ Check the hdc is still busy and command has not ended and no errors
  16379. +  ldr r5,[r0,#32]     @ Status reg - 16 bit - its the top few bits which are status
  16380. +  tst r5,#0x3c00        @ Test for things which should be off
  16381. +  bne writedma_end
  16382. +  and r5,r5,#0x8000        @ This is test for things which should be on: Busy
  16383. +  cmp r5,#0x8000
  16384. +  bne writedma_end 
  16385. +
  16386. +  @ Bytes remaining at end
  16387. +  sub r4,r4,r7
  16388. +
  16389. +  @ HDC Write register location
  16390. +  add r0,r0,#32+8
  16391. +
  16392. +writedma_loop:
  16393. +  @ OK - pretty sure we should be doing this
  16394. +
  16395. +  ldr r5,[r3],#4          @ Get a word to be written
  16396. +  @ get bottom half to be sent first
  16397. +  mov r6,r5,lsl#16        @ Separate the first 2 bytes
  16398. +  orr r2,r6,r6,lsr #16    @ Duplicate them in the bottom half of the word
  16399. +  @ now the top half
  16400. +  mov r6,r5,lsr#16        @ Get 2nd 2 bytes
  16401. +  orr r6,r6,r6,lsl#16     @ Duplicate
  16402. +  @str r6,[r0]       @ to hdc
  16403. +  stmia r0,{r2,r6}
  16404. +  subs r7,r7,#4           @ Dec. number of bytes left
  16405. +  bne writedma_loop
  16406. +
  16407. +  @ If we were too slow we had better go through again - DAG - took out with new interrupt routine
  16408. +  @ sub r0,r0,#32+8
  16409. +  @ adr r2,_hdc63463_irqdata
  16410. +  @ ldr r2,[r2,#8]
  16411. +  @ b writedma_again
  16412. +
  16413. +writedma_end:
  16414. +  adr r5,_hdc63463_irqdata+12
  16415. +  stmia r5,{r3,r4}
  16416. +  ldmfd sp!,{r4-r7}
  16417. +  RETINSTR(mov,pc,lr)
  16418. +
  16419. +@ -------------------------------------------------------------------------
  16420. +@ hdc63463_readdma: DMA from controller to host
  16421. +@  internal reg usage: r0=hdc base address, r1=irq poll address, r2=poll mask
  16422. +@                      r3=data ptr, r4=data left, r5,r6=temporary
  16423. +  .global _hdc63463_readdma
  16424. +_hdc63463_readdma:
  16425. +  stmfd sp!,{r4-r7}
  16426. +  adr r5,_hdc63463_irqdata
  16427. +  ldmia r5,{r0,r1,r2,r3,r4}
  16428. +
  16429. +readdma_again:
  16430. +  @ test number of remaining bytes to transfer
  16431. +  cmp r4,#0
  16432. +  beq readdma_end
  16433. +  bmi readdma_end
  16434. +
  16435. +  @ Check the hdc is interrupting
  16436. +  ldrb r5,[r1,#0]
  16437. +  tst r5,r2
  16438. +  beq readdma_end
  16439. +
  16440. +  @ Check the hdc is still busy and command has not ended and no errors
  16441. +  ldr r5,[r0,#32]     @ Status reg - 16 bit - its the top few bits which are status
  16442. +  tst r5,#0x3c00      @ Test for things which should be off
  16443. +  bne readdma_end
  16444. +  and r5,r5,#0x8000        @ This is test for things which should be on: Busy
  16445. +  cmp r5,#0x8000
  16446. +  bne readdma_end 
  16447. +
  16448. +  @ Transfer a block of upto 256 bytes
  16449. +  cmp r4,#256
  16450. +  movlt r7,r4
  16451. +  movge r7,#256
  16452. +
  16453. +  @ Bytes remaining at end
  16454. +  sub r4,r4,r7
  16455. +
  16456. +  @ Set a pointer to the data register in the HDC
  16457. +  add r0,r0,#8
  16458. +readdma_loop:
  16459. +  @ OK - pretty sure we should be doing this
  16460. +  ldmia r0,{r5,r6}
  16461. +  mov r5,r5,lsl#16
  16462. +  mov r6,r6,lsl#16
  16463. +  orr r6,r6,r5,lsr #16
  16464. +  str r6,[r3],#4
  16465. +  subs r7,r7,#4        @ Decrement bytes to go
  16466. +  bne readdma_loop
  16467. +
  16468. +  @ Try reading multiple blocks - if this was fast enough then I dont think
  16469. +  @ this should help - NO taken out DAG - new interrupt handler has
  16470. +  @ non-consecutive memory blocks
  16471. +  @ sub r0,r0,#8
  16472. +  @ b readdma_again
  16473. +
  16474. +readdma_end:
  16475. +  adr r5,_hdc63463_irqdata+12
  16476. +  stmia r5,{r3,r4}
  16477. +  ldmfd sp!,{r4-r7}
  16478. +  RETINSTR(mov,pc,lr)
  16479. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/block/mfmhd.c linux/arch/arm/drivers/block/mfmhd.c
  16480. --- linux.orig/arch/arm/drivers/block/mfmhd.c    Thu Jan  1 01:00:00 1970
  16481. +++ linux/arch/arm/drivers/block/mfmhd.c    Sat Sep  7 21:09:09 1996
  16482. @@ -0,0 +1,1379 @@
  16483. +/*
  16484. + * linux/arch/arm/drivers/block/mfmhd.c
  16485. + *
  16486. + * Copyright (C) 1995, 1996 Russell King, Dave Alan Gilbert (gilbertd@cs.man.ac.uk)
  16487. + *
  16488. + * MFM hard drive code [experimental]
  16489. + */
  16490. +
  16491. +/*
  16492. + * Change list:
  16493. + *
  16494. + *  3/2/96:DAG: Started a change list :-)
  16495. + *              Set the hardsect_size pointers up since we are running 256 byte
  16496. + *                sectors
  16497. + *              Added DMA code, put it into the rw_intr
  16498. + *              Moved RCAL out of generic interrupt code - don't want to do it
  16499. + *                while DMA'ing - its now in individual handlers.
  16500. + *              Took interrupt handlers off task queue lists and called
  16501. + *                directly - not sure of implications.
  16502. + *
  16503. + * 18/2/96:DAG: Well its reading OK I think, well enough for image file code
  16504. + *              to find the image file; but now I've discovered that I actually
  16505. + *              have to put some code in for image files.
  16506. + *
  16507. + *              Added stuff for image files; seems to work, but I've not
  16508. + *              got a multisegment image file (I don't think!).
  16509. + *              Put in a hack (yep a real hack) for multiple cylinder reads.
  16510. + *              Not convinced its working.
  16511. + *
  16512. + *  5/4/96:DAG: Added asm/hardware.h and use IOC_ macros
  16513. + *              Rewrote dma code in mfm.S (again!) - now takes a word at a time
  16514. + *              from main RAM for speed; still doesn't feel speedy!
  16515. + *
  16516. + * 20/4/96:DAG: After rewriting mfm.S a heck of a lot of times and speeding
  16517. + *              things up, I've finally figured out why its so damn slow.
  16518. + *              Linux is only reading a block at a time, and so you never
  16519. + *              get more than 1K per disc revoloution ~=60K/second.
  16520. + *
  16521. + * 27/4/96:DAG: On Russell's advice I change ll_rw_blk.c to ask it to
  16522. + *              join adjacent blocks together. Everything falls flat on its
  16523. + *              face.
  16524. + *              Four hours of debugging later; I hadn't realised that
  16525. + *              ll_rw_blk would be so generous as to join blocks whose
  16526. + *              results aren't going into consecutive buffers.
  16527. + * 
  16528. + *              OK; severe rehacking of mfm_rw_interrupt; now end_request's
  16529. + *              as soon as its DMA'd each request.  Odd thing is that
  16530. + *              we are sometimes getting interrupts where we are not transferring
  16531. + *              any data; why? Is that what happens when you miss? I doubt
  16532. + *              it; are we too fast? No - its just at command ends. Got 240K/s
  16533. + *              better than before, but RiscOS hits 480K/s
  16534. + *
  16535. + * 25/6/96:RMK: Fixed init code to allow the MFM podule to work.  Increased the
  16536. + *              number of errors for my Miniscribe drive (8425).
  16537. + *
  16538. + * 30/6/96:DAG: Russell suggested that a check drive 0 might turn the LEDs off
  16539. + *              - so in request_done just before it clears Busy it sends a
  16540. + *              check drive 0 - and the LEDs go off!!!!
  16541. + *
  16542. + *              Added test for mainboard controller. - Removes need for separate
  16543. + *              define.
  16544. + *
  16545. + * 13/7/96:DAG: Changed hardware sectore size to 512 in attempt to make
  16546. + *              IM drivers work.
  16547. + * 21/7/96:DAG: Took out old image file stuff (accessing it now produces an IO
  16548. + *              error.)
  16549. + *
  16550. + * 17/8/96:DAG: Ran through indent -kr -i8; evil - all my nice 2 character indents
  16551. + *              gone :-( Hand modified afterwards.
  16552. + *        Took out last remains of the older image map system.
  16553. + */
  16554. +
  16555. +#ifdef MODULE
  16556. +#include <linux/module.h>
  16557. +#include <linux/version.h>
  16558. +#endif
  16559. +
  16560. +#include <linux/config.h>
  16561. +#include <linux/sched.h>
  16562. +#include <linux/fs.h>
  16563. +#include <linux/interrupt.h>
  16564. +#include <linux/kernel.h>
  16565. +#include <linux/timer.h>
  16566. +#include <linux/tqueue.h>
  16567. +#include <linux/mm.h>
  16568. +
  16569. +#include <linux/errno.h>
  16570. +#include <linux/genhd.h>
  16571. +#include <linux/major.h>
  16572. +#include <linux/xd.h>
  16573. +
  16574. +#include <asm/system.h>
  16575. +#include <asm/io.h>
  16576. +#include <asm/irq-no.h>
  16577. +#include <asm/segment.h>
  16578. +#include <asm/delay.h>
  16579. +#include <asm/dma.h>
  16580. +#include <asm/hardware.h>
  16581. +
  16582. +#include <asm/ecard.h>
  16583. +
  16584. +static int lastspecifieddrive;
  16585. +static unsigned Busy;
  16586. +
  16587. +static unsigned int PartFragRead;    /* The number of sectors which have been read
  16588. +                       during a partial read split over two
  16589. +                       cylinders.  If 0 it means a partial
  16590. +                       read did not occur. */
  16591. +
  16592. +static unsigned int PartFragRead_RestartBlock;    /* Where to restart on a split access */
  16593. +static unsigned int PartFragRead_SectorsLeft;    /* Where to restart on a split access */
  16594. +
  16595. +static int Sectors256LeftInCurrent;    /* i.e. 256 byte sectors left in current */
  16596. +static int SectorsLeftInRequest;    /* i.e. blocks left in the thing mfm_request was called for */
  16597. +static int Copy_Sector;        /* The 256 byte sector we are currently at - fragments need to know 
  16598. +                   where to take over */
  16599. +static char *Copy_buffer;
  16600. +#define MFM_DISK_MAJOR    13
  16601. +#undef  XT_DISK_MAJOR
  16602. +#define XT_DISK_MAJOR    -1
  16603. +#define MAJOR_NR    MFM_DISK_MAJOR
  16604. +#include "blk.h"
  16605. +
  16606. +XD_INFO mfm_info[XD_MAXDRIVES];
  16607. +
  16608. +/*#define DEBUG */
  16609. +
  16610. +#define MFM_COMMAND (mfm_addr + 0)
  16611. +#define MFM_DATAOUT (mfm_addr + 1)
  16612. +#define MFM_STATUS  (mfm_addr + 8)
  16613. +#define MFM_DATAIN  (mfm_addr + 9)
  16614. +
  16615. +static void mfm_geninit(struct gendisk *dev);
  16616. +static int mfm_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long arg);
  16617. +static int mfm_open(struct inode *inode, struct file *file);
  16618. +static void mfm_release(struct inode *inode, struct file *file);
  16619. +static void mfm_interrupt_handler(int, struct pt_regs *);
  16620. +static void mfm_seek(void);
  16621. +static void mfm_unexpected_interrupt(void);
  16622. +static void mfm_rerequest(void);
  16623. +static void mfm_request(void);
  16624. +static int mfm_reread_partitions(int dev);
  16625. +static void mfm_specify(void);
  16626. +
  16627. +static void issue_request(int dev, unsigned int block, unsigned int nsect,
  16628. +              struct request *req);
  16629. +#define mfm_init xd_init
  16630. +#define mfm_setup xd_setup
  16631. +
  16632. +static struct hd_struct mfm[XD_MAXDRIVES << 6];
  16633. +static int mfm_sizes[XD_MAXDRIVES << 6], mfm_access[XD_MAXDRIVES] =
  16634. +{0, 0};
  16635. +static int mfm_blocksizes[XD_MAXDRIVES << 6];
  16636. +static unsigned char mfm_valid[XD_MAXDRIVES] =
  16637. +{-1,};
  16638. +static struct wait_queue *mfm_wait_open = NULL;
  16639. +
  16640. +static int mfm_irq;        /* Interrupt number */
  16641. +static int mfm_addr;        /* Controller address */
  16642. +static unsigned char *mfm_IRQPollLoc;    /* Address to read for IRQ information */
  16643. +static char mfm_IRQMask;    /* AND with *mfm_IRQPollLoc to find if there is an interrupt */
  16644. +static int mfm_drives = 0;    /* drives available */
  16645. +static int mfm_status = 0;    /* interrupt status */
  16646. +static int *errors;
  16647. +
  16648. +static struct rawcmd {
  16649. +    unsigned int flags;
  16650. +    unsigned int dev;
  16651. +    unsigned int cylinder;
  16652. +    unsigned int head;
  16653. +    unsigned int sector;
  16654. +    unsigned int cmdtype;
  16655. +    unsigned int cmdcode;
  16656. +    unsigned char cmddata[16];
  16657. +    unsigned int cmdlen;
  16658. +} raw_cmd;
  16659. +
  16660. +#define NEED_SEEK 1
  16661. +unsigned char result[16];
  16662. +unsigned char resultlen;
  16663. +
  16664. +static struct cont {
  16665. +    void (*interrupt) (void);    /* interrupt handler */
  16666. +    void (*error) (void);    /* error handler */
  16667. +    void (*redo) (void);    /* redo handler */
  16668. +    void (*done) (int st);    /* done handler */
  16669. +} *cont = NULL;
  16670. +
  16671. +static struct drvparam {
  16672. +    int cylinder;
  16673. +    unsigned int nocylinders;
  16674. +    unsigned int lowcurrentcylinder;
  16675. +    unsigned int precompcylinder;
  16676. +    unsigned char noheads;
  16677. +    unsigned char nosectors;
  16678. +    struct {
  16679. +        char recal;
  16680. +        char report;
  16681. +        char abort;
  16682. +    } errors;
  16683. +} mfm_drive_param[8] = {
  16684. +    { -1, 616, 616, 129, 4, 32, { 0, 0, 4 } },
  16685. +    { -1, 616, 616, 129, 4, 32, { 0, 0, 4 } },
  16686. +    { -1, 616, 616, 129, 4, 32, { 0, 0, 4 } },
  16687. +    { -1, 616, 616, 129, 4, 32, { 0, 0, 4 } },
  16688. +    { -1, 616, 616, 129, 4, 32, { 0, 0, 4 } },
  16689. +    { -1, 616, 616, 129, 4, 32, { 0, 0, 4 } },
  16690. +    { -1, 616, 616, 129, 4, 32, { 0, 0, 4 } },
  16691. +    { -1, 616, 616, 129, 4, 32, { 0, 0, 4 } }
  16692. +};
  16693. +
  16694. +#define MFM_DRV_PARAM mfm_drive_param[raw_cmd.dev]
  16695. +
  16696. +struct tq_struct mfm_tq =
  16697. +{0, 0, (void (*)(void *)) mfm_unexpected_interrupt, 0};
  16698. +
  16699. +#define NO_TRACK -1
  16700. +#define NEED_1_RECAL -2
  16701. +#define NEED_2_RECAL -3
  16702. +
  16703. +int mfm_sectsizes[256];        /* We have to do this because we don't have 512 byte sectors */
  16704. +
  16705. +/* Stuff from the assembly routines */
  16706. +extern unsigned int hdc63463_baseaddress;    /* Controller base address */
  16707. +extern unsigned int hdc63463_irqpolladdress;    /* Address to read to test for int */
  16708. +extern unsigned int hdc63463_irqpollmask;    /* Mask for irq register */
  16709. +extern unsigned int hdc63463_dataptr;    /* Pointer to kernel data space to DMA */
  16710. +extern int hdc63463_dataleft;    /* Number of bytes left to transfer */
  16711. +
  16712. +#if 0
  16713. +extern int number_mfm_drives;    /* in setup.c */
  16714. +#else
  16715. +int number_mfm_drives = 1;
  16716. +#endif
  16717. +/* ------------------------------------------------------------------------------------------ */
  16718. +/*
  16719. + * From the HD63463 data sheet from Hitachi Ltd.
  16720. + */
  16721. +
  16722. +#define CMD_ABT        0xF0    /* Abort */
  16723. +#define CMD_SPC        0xE8    /* Specify */
  16724. +#define CMD_TST        0xE0    /* Test */
  16725. +#define CMD_RCLB    0xC8    /* Recalibrate */
  16726. +#define CMD_SEK        0xC0    /* Seek */
  16727. +#define CMD_WFS        0xAB    /* Write Format Skew */
  16728. +#define CMD_WFM        0xA3    /* Write Format */
  16729. +#define CMD_MTB        0x90    /* Memory to buffer */
  16730. +#define CMD_CMPD    0x88    /* Compare data */
  16731. +#define CMD_WD        0x87    /* Write data */
  16732. +#define CMD_RED        0x70    /* Read erroneous data */
  16733. +#define CMD_RIS        0x68    /* Read ID skew */
  16734. +#define CMD_FID        0x61    /* Find ID */
  16735. +#define CMD_RID        0x60    /* Read ID */
  16736. +#define CMD_BTM        0x50    /* Buffer to memory */
  16737. +#define CMD_CKD        0x48    /* Check data */
  16738. +#define CMD_RD        0x40    /* Read data */
  16739. +#define CMD_OPBW    0x38    /* Open buffer write */
  16740. +#define CMD_OPBR    0x30    /* Open buffer read */
  16741. +#define CMD_CKV        0x28    /* Check drive */
  16742. +#define CMD_CKE        0x20    /* Check ECC */
  16743. +#define CMD_POD        0x18    /* Polling disable */
  16744. +#define CMD_POL        0x10    /* Polling enable */
  16745. +#define CMD_RCAL    0x08    /* Recall */
  16746. +
  16747. +#define STAT_BSY    0x8000    /* Busy */
  16748. +#define STAT_CPR    0x4000    /* Command Parameter Rejection */
  16749. +#define STAT_CED    0x2000    /* Command end */
  16750. +#define STAT_SED    0x1000    /* Seek end */
  16751. +#define STAT_DER    0x0800    /* Drive error */
  16752. +#define STAT_ABN    0x0400    /* Abnormal end */
  16753. +#define STAT_POL    0x0200    /* Polling */
  16754. +
  16755. +/* ------------------------------------------------------------------------------------------ */
  16756. +#ifdef DEBUG
  16757. +static void console_printf(const char *fmt,...)
  16758. +{
  16759. +    static char buffer[2048];    /* Arbitary! */
  16760. +    extern void console_print(const char *);
  16761. +    va_list ap;
  16762. +    int flags;
  16763. +
  16764. +    save_flags(flags);
  16765. +    cli();
  16766. +
  16767. +    va_start(ap, fmt);
  16768. +
  16769. +    vsprintf(buffer, fmt, ap);
  16770. +
  16771. +    console_print(buffer);
  16772. +
  16773. +    va_end(fmt);
  16774. +
  16775. +    restore_flags(flags);
  16776. +};    /* console_printf */
  16777. +#endif
  16778. +
  16779. +/* ------------------------------------------------------------------------------------------ */
  16780. +
  16781. +static struct gendisk mfm_gendisk =
  16782. +{
  16783. +    MAJOR_NR,        /* Major number */
  16784. +    "mfm",            /* Major name */
  16785. +    6,            /* Bits to shift to get real from partition */
  16786. +    1 << 6,            /* Number of partitions per real */
  16787. +    XD_MAXDRIVES,        /* maximum number of real */
  16788. +    mfm_geninit,        /* init function */
  16789. +    mfm,            /* hd struct */
  16790. +    mfm_sizes,        /* block sizes */
  16791. +    0,            /* number */
  16792. +    (void *) mfm_info,    /* internal */
  16793. +    NULL            /* next */
  16794. +};
  16795. +
  16796. +static struct file_operations mfm_fops =
  16797. +{
  16798. +    NULL,            /* lseek - default */
  16799. +    block_read,        /* read - general block-dev read */
  16800. +    block_write,        /* write - general block-dev write */
  16801. +    NULL,            /* readdir - bad */
  16802. +    NULL,            /* select */
  16803. +    mfm_ioctl,        /* ioctl */
  16804. +    NULL,            /* mmap */
  16805. +    mfm_open,        /* open */
  16806. +    mfm_release,        /* release */
  16807. +    block_fsync        /* fsync */
  16808. +};
  16809. +
  16810. +static struct expansion_card *ecs;
  16811. +static const int mfm_prods[] = {0x000b};
  16812. +static const int mfm_manus[] = {0x0000};
  16813. +
  16814. +/* See if there is a controller at the address presently set in mfm_addr */
  16815. +static int CheckController(void)
  16816. +{
  16817. +    int result;
  16818. +
  16819. +    /* Send any command */
  16820. +    outw(CMD_SEK, MFM_COMMAND);
  16821. +
  16822. +    /* experimentation shows that at least BSY or CPR should be on if
  16823. +       the controller exists. On my 310 this returns 0 */
  16824. +    result = (inw(MFM_STATUS) & 0xc000) != 0;
  16825. +
  16826. +    /* If we did find it we have got to clean up */
  16827. +    if (result) {
  16828. +        /* Wait until the busy flag disappears */
  16829. +        while (inw(MFM_STATUS) & STAT_BSY);
  16830. +
  16831. +        outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  16832. +    }
  16833. +    return result;
  16834. +};                /* CheckController */
  16835. +
  16836. +
  16837. +int mfm_init(void)
  16838. +{
  16839. +    unsigned int i;
  16840. +    /* DAG */
  16841. +    mfm_irq = IRQ_HARDDISK;
  16842. +    mfm_addr = (0x32d0000 >> 2);    /* Motherboard HDC address  - thats medium (as RiscOS)
  16843. +                       used to be slow */
  16844. +    mfm_IRQPollLoc = &(IOC_IRQSTATB);    /* was  ioc+0x2 */
  16845. +    mfm_IRQMask = 0x08;    /* IL3 pin */
  16846. +    printk("mfm: Looking for onboard controller.....\n");
  16847. +    if (!CheckController()) {
  16848. +        printk("mfm: Hmm - no onboard controller - lets try podules....\n");
  16849. +        ecs = ecard_find(0, sizeof(mfm_prods), mfm_prods, mfm_manus);
  16850. +        if (!ecs)
  16851. +            return -1;
  16852. +
  16853. +        mfm_irq = ecs->irq;
  16854. +        mfm_addr = ((int) ecard_address(ecs->slot_no, ECARD_IOC, ECARD_MEDIUM) + 0x2000) >> 2;
  16855. +        mfm_IRQMask = 0x08;
  16856. +        mfm_IRQPollLoc = (unsigned char *) ((int) ecard_address(ecs->slot_no, ECARD_IOC, ECARD_MEDIUM) + 0x3000);
  16857. +
  16858. +        ecard_claim(ecs);
  16859. +    };
  16860. +
  16861. +    /* Stuff for the assembler routines to get to */
  16862. +    hdc63463_baseaddress = (unsigned int) (mfm_addr << 2);
  16863. +    hdc63463_irqpolladdress = (int) mfm_IRQPollLoc;
  16864. +    hdc63463_irqpollmask = mfm_IRQMask;
  16865. +
  16866. +    printk("mfm: controller found at address %X, interrupt %d\n", mfm_addr << 2, mfm_irq);
  16867. +
  16868. +    if (register_blkdev(MAJOR_NR, "mfm", &mfm_fops)) {
  16869. +        printk("mfm_init: unable to get major number %d\n", MAJOR_NR);
  16870. +        return -1;
  16871. +    }
  16872. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  16873. +    read_ahead[MAJOR_NR] = 8;    /* 8 sector (4kB?) read ahread */
  16874. +
  16875. +    /* This stops MSDOS trying to mount it - but ll_rw_blk has tons of >>9
  16876. +       presuming 512 byte sectors - its upto us to fix it! */
  16877. +    hardsect_size[MAJOR_NR] = mfm_sectsizes;
  16878. +
  16879. +    /* OK - well actually I'm going to leave it at 512 - this lets the
  16880. +       adfs image drivers work */
  16881. +    for (i = 0; i < 256; i++)
  16882. +        mfm_sectsizes[i] = 512;
  16883. +
  16884. +#ifndef MODULE
  16885. +    mfm_gendisk.next = gendisk_head;
  16886. +    gendisk_head = &mfm_gendisk;
  16887. +#endif
  16888. +
  16889. +    Busy = 0;
  16890. +    lastspecifieddrive = -1;
  16891. +
  16892. +    return 0;
  16893. +}
  16894. +
  16895. +/* DAG: Gets called by the genhd code to set up the number of sectors etc. */
  16896. +void xd_set_geometry(int dev, unsigned char secsptrack, unsigned char heads,
  16897. +             unsigned long discsize, unsigned int secsize)
  16898. +{
  16899. +    dev = MINOR(dev);
  16900. +    /* The HD version checks to see if the number of cylinders are unset */
  16901. +    /* and then causes them to be set... */
  16902. +    /* Need to set up the precomp etc. */
  16903. +    if (mfm_info[dev >> 6].cylinders == 1) {
  16904. +        mfm_info[dev >> 6].sectors = secsptrack;
  16905. +        mfm_info[dev >> 6].heads = heads;
  16906. +        mfm_info[dev >> 6].cylinders = discsize / (secsptrack * heads * secsize);
  16907. +
  16908. +        mfm_drive_param[dev >> 6].nosectors = secsptrack;
  16909. +        mfm_drive_param[dev >> 6].noheads = heads;
  16910. +        mfm_drive_param[dev >> 6].nocylinders = discsize / (secsptrack * heads * secsize);
  16911. +
  16912. +        printk("mfm%c: %d cylinders, %d heads, %d sectors secsize=%d (%ld total blocks)\n", 'a' + (dev >> 6),
  16913. +               mfm_info[dev >> 6].cylinders, heads, secsptrack, secsize, discsize);
  16914. +
  16915. +        /* Should probably do a specify command here.... */
  16916. +        if ((heads < 1) || (mfm_drive_param[dev >> 6].nocylinders > 1024)) {
  16917. +            printk("mfm%c: Insane disc shape! Setting to 512/4/32\n",'a' + (dev >> 6));
  16918. +
  16919. +            /* These values are fairly arbitary, but are there so that if your
  16920. +            lucky you can pick apart your disc to find out what is going on -
  16921. +            I reckon these figures won't hurt MOST drives */
  16922. +            mfm_info[dev >> 6].sectors = 32;
  16923. +            mfm_info[dev >> 6].heads = 4;
  16924. +            mfm_info[dev >> 6].cylinders = 512;
  16925. +
  16926. +            mfm_drive_param[dev >> 6].nosectors = 32;
  16927. +            mfm_drive_param[dev >> 6].noheads = 4;
  16928. +            mfm_drive_param[dev >> 6].nocylinders = 512;
  16929. +        };
  16930. +        mfm_specify();
  16931. +    };
  16932. +
  16933. +    mfm[dev].start_sect = 0;
  16934. +    /* This is 512 byte sectors - I want 256 but where does this get set for image files? */
  16935. +    mfm[dev].nr_sects = (discsize / secsize) / 2;    
  16936. +
  16937. +}
  16938. +
  16939. +static int mfm_initdrives(void)
  16940. +{
  16941. +    mfm_info[0].heads = 4;
  16942. +    mfm_info[0].cylinders = 1;    /* its going to have to figure it out from the drive */
  16943. +    mfm_info[0].sectors = 32;
  16944. +    mfm_info[0].control = 0;
  16945. +    mfm_info[1].heads = 4;
  16946. +    mfm_info[1].cylinders = 1;    /* its going to have to figure it out from the drive */
  16947. +    mfm_info[1].sectors = 32;
  16948. +    mfm_info[1].control = 0;
  16949. +    if (number_mfm_drives > XD_MAXDRIVES) {
  16950. +        number_mfm_drives = XD_MAXDRIVES;
  16951. +        printk("No. of ADFS MFM drives is greater than XD_MAXDRIVES - you can't have that many!\n");
  16952. +    };
  16953. +    return number_mfm_drives;
  16954. +}
  16955. +
  16956. +static void mfm_geninit(struct gendisk *dev)
  16957. +{
  16958. +    int i;
  16959. +
  16960. +    mfm_drives = mfm_initdrives();
  16961. +    printk("mfm: detected %d hard drive%s\n", mfm_drives, mfm_drives == 1 ? "" : "s");
  16962. +    for (i = 0; i < mfm_drives; i++)
  16963. +        printk("mfm%d: heads = %d, cylinders = %d, sectors = %d\n", i,
  16964. +               mfm_info[i].heads, mfm_info[i].cylinders, mfm_info[i].sectors);
  16965. +
  16966. +    if (request_irq(mfm_irq, mfm_interrupt_handler, SA_INTERRUPT, "MFM harddisk"))
  16967. +        printk("mfm: unable to get IRQ%d\n", mfm_irq);
  16968. +
  16969. +    if (mfm_addr != (0x32d0000 >> 2))
  16970. +        outw(0x80, mfm_addr + (0x1000 >> 2));    /* Required to enable IRQs from MFM podule */
  16971. +
  16972. +    for (i = 0; i < mfm_drives; i++) {
  16973. +        mfm[i << 6].nr_sects = mfm_info[i].heads * mfm_info[i].cylinders *
  16974. +            mfm_info[i].sectors;
  16975. +        mfm[i << 6].start_sect = 0;
  16976. +        mfm_valid[i] = 1;
  16977. +    }
  16978. +    mfm_gendisk.nr_real = mfm_drives;
  16979. +
  16980. +    for (i = 0; i < (XD_MAXDRIVES << 6); i++)
  16981. +        mfm_blocksizes[i] = 1024;    /* Can't increase this - if you do all hell breaks loose */
  16982. +    blksize_size[MAJOR_NR] = mfm_blocksizes;
  16983. +}
  16984. +
  16985. +static int mfm_open(struct inode *inode, struct file *file)
  16986. +{
  16987. +    int dev = DEVICE_NR(MINOR(inode->i_rdev));
  16988. +
  16989. +    if ((dev) < mfm_drives) {
  16990. +        while (!mfm_valid[dev])
  16991. +            sleep_on(&mfm_wait_open);
  16992. +
  16993. +        mfm_access[dev]++;
  16994. +
  16995. +        return (0);
  16996. +    } else
  16997. +        return (-ENODEV);
  16998. +}
  16999. +
  17000. +static int mfm_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long arg)
  17001. +{
  17002. +    XD_GEOMETRY *geometry = (XD_GEOMETRY *) arg;
  17003. +    int dev = DEVICE_NR(MINOR(inode->i_rdev)), err;
  17004. +
  17005. +    if (inode && (dev < mfm_drives))
  17006. +        switch (cmd) {
  17007. +        case HDIO_GETGEO:
  17008. +            if (arg) {
  17009. +                if ((err = verify_area(VERIFY_WRITE, geometry, sizeof(*geometry))))
  17010. +                    return (err);
  17011. +                put_fs_byte(mfm_info[dev].heads, (char *) &geometry->heads);
  17012. +                put_fs_byte(mfm_info[dev].sectors, (char *) &geometry->sectors);
  17013. +                put_fs_word(mfm_info[dev].cylinders, (short *) &geometry->cylinders);
  17014. +                put_fs_long(mfm[MINOR(inode->i_rdev)].start_sect, (long *) &geometry->start);
  17015. +
  17016. +                return (0);
  17017. +            }
  17018. +            break;
  17019. +        case BLKRASET:
  17020. +            if (!suser())
  17021. +                return -EACCES;
  17022. +            if (!inode->i_rdev)
  17023. +                return -EINVAL;
  17024. +            if (arg > 0xff)
  17025. +                return -EINVAL;
  17026. +            read_ahead[MAJOR(inode->i_rdev)] = arg;
  17027. +            return 0;
  17028. +        case BLKGETSIZE:
  17029. +            if (arg) {
  17030. +                if ((err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long))))
  17031. +                     return (err);
  17032. +                put_fs_long(mfm[MINOR(inode->i_rdev)].nr_sects, (long *) arg);
  17033. +
  17034. +                return (0);
  17035. +            }
  17036. +            break;
  17037. +        case BLKFLSBUF:
  17038. +            if (!suser())
  17039. +                return -EACCES;
  17040. +            if (!inode->i_rdev)
  17041. +                return -EINVAL;
  17042. +            fsync_dev(inode->i_rdev);
  17043. +            invalidate_buffers(inode->i_rdev);
  17044. +            return 0;
  17045. +
  17046. +        case BLKRRPART:
  17047. +            return (mfm_reread_partitions(inode->i_rdev));
  17048. +            RO_IOCTLS(inode->i_rdev, arg);
  17049. +        }
  17050. +    return (-EINVAL);
  17051. +}
  17052. +
  17053. +static void mfm_release(struct inode *inode, struct file *file)
  17054. +{
  17055. +    int dev = DEVICE_NR(MINOR(inode->i_rdev));
  17056. +
  17057. +    if (dev < mfm_drives) {
  17058. +        sync_dev(dev);
  17059. +        mfm_access[dev]--;
  17060. +    }
  17061. +}
  17062. +
  17063. +static int mfm_reread_partitions(int dev)
  17064. +{
  17065. +    int target = DEVICE_NR(MINOR(dev)), start = target << mfm_gendisk.minor_shift,
  17066. +     partition;
  17067. +
  17068. +    cli();
  17069. +
  17070. +    mfm_valid[target] = (mfm_access[target] != 1);
  17071. +
  17072. +    sti();
  17073. +
  17074. +    if (mfm_valid[target])
  17075. +        return -EBUSY;
  17076. +
  17077. +    for (partition = mfm_gendisk.max_p - 1; partition >= 0; partition--) {
  17078. +        sync_dev(MAJOR_NR << 8 | start | partition);
  17079. +        invalidate_inodes(MAJOR_NR << 8 | start | partition);
  17080. +        invalidate_buffers(MAJOR_NR << 8 | start | partition);
  17081. +        mfm_gendisk.part[start + partition].start_sect = 0;
  17082. +        mfm_gendisk.part[start + partition].nr_sects = 0;
  17083. +    };
  17084. +
  17085. +    mfm_gendisk.part[start].nr_sects = mfm_info[target].heads *
  17086. +        mfm_info[target].cylinders * mfm_info[target].sectors;
  17087. +    resetup_one_dev(&mfm_gendisk, target);
  17088. +
  17089. +    mfm_valid[target] = 1;
  17090. +    wake_up(&mfm_wait_open);
  17091. +
  17092. +    return 0;
  17093. +}
  17094. +
  17095. +static void print_status(void)
  17096. +{
  17097. +    char *error;
  17098. +    static char *errors[] = {
  17099. +         "no error",
  17100. +     "command aborted",
  17101. +     "invalid command",
  17102. +     "parameter error",
  17103. +     "not initialised",
  17104. +     "rejected TEST",
  17105. +     "no useld",
  17106. +     "write fault",
  17107. +     "not ready",
  17108. +     "no scp",
  17109. +     "in seek",
  17110. +     "invalid NCA",
  17111. +     "invalid step rate",
  17112. +     "seek error",
  17113. +     "over run",
  17114. +     "invalid PHA",
  17115. +     "data field EEC error",
  17116. +     "data field CRC error",
  17117. +     "error corrected",
  17118. +     "data field fatal error",
  17119. +     "no data am",
  17120. +     "not hit",
  17121. +     "ID field CRC error",
  17122. +     "time over",
  17123. +     "no ID am",
  17124. +     "not writable"
  17125. +    };
  17126. +    if (result[1] < 0x65)
  17127. +        error = errors[result[1] >> 2];
  17128. +    else
  17129. +        error = "unknown";
  17130. +    printk("(");
  17131. +    if (mfm_status & STAT_BSY) printk("BSY ");
  17132. +    if (mfm_status & STAT_CPR) printk("CPR ");
  17133. +    if (mfm_status & STAT_CED) printk("CED ");
  17134. +    if (mfm_status & STAT_SED) printk("SED ");
  17135. +    if (mfm_status & STAT_DER) printk("DER ");
  17136. +    if (mfm_status & STAT_ABN) printk("ABN ");
  17137. +    if (mfm_status & STAT_POL) printk("POL ");
  17138. +    printk(") SSB = %X (%s)\n", result[1], error);
  17139. +
  17140. +}
  17141. +
  17142. +/* ------------------------------------------------------------------------------------- */
  17143. +
  17144. +static void issue_command(int command, unsigned char *cmdb, int len)
  17145. +{
  17146. +    int status;
  17147. +#ifdef DEBUG
  17148. +    int i;
  17149. +    console_printf("issue_command: %02X: ", command);
  17150. +    for (i = 0; i < len; i++)
  17151. +        console_printf("%02X ", cmdb[i]);
  17152. +    console_printf("\n");
  17153. +#endif
  17154. +
  17155. +    do {
  17156. +        status = inw(MFM_STATUS);
  17157. +    } while (status & (STAT_BSY | STAT_POL));
  17158. +#ifdef DEBUG
  17159. +    console_printf("issue_command: status after pol/bsy loop: %02X:\n ", status >> 8);
  17160. +#endif
  17161. +    if (status & (STAT_CPR | STAT_CED | STAT_SED | STAT_DER | STAT_ABN)) {
  17162. +        outw(CMD_RCAL, MFM_COMMAND);
  17163. +        while (inw(MFM_STATUS) & STAT_BSY);
  17164. +    }
  17165. +    status = inw(MFM_STATUS);
  17166. +#ifdef DEBUG
  17167. +    console_printf("issue_command: status before parameter issue: %02X:\n ", status >> 8);
  17168. +#endif
  17169. +    while (len > 0) {
  17170. +        outw(cmdb[1] | (cmdb[0] << 8), MFM_DATAOUT);
  17171. +        len -= 2;
  17172. +        cmdb += 2;
  17173. +    }
  17174. +    status = inw(MFM_STATUS);
  17175. +#ifdef DEBUG
  17176. +    console_printf("issue_command: status before command issue: %02X:\n ", status >> 8);
  17177. +#endif
  17178. +    outw(command, MFM_COMMAND);
  17179. +    status = inw(MFM_STATUS);
  17180. +#ifdef DEBUG
  17181. +    console_printf("issue_command: status immediatly after command issue: %02X:\n ", status >> 8);
  17182. +#endif
  17183. +}
  17184. +
  17185. +static void wait_for_completion(void)
  17186. +{
  17187. +    while ((mfm_status = inw(MFM_STATUS)) & STAT_BSY);
  17188. +}
  17189. +
  17190. +/* ------------------------------------------------------------------------------------- */
  17191. +
  17192. +static void mfm_rw_intr(void)
  17193. +{
  17194. +    int old_status;        /* Holds status on entry, we read to see if the command just finished */
  17195. +#ifdef DEBUG
  17196. +    console_printf("mfm_rw_intr...dataleft=%d\n", hdc63463_dataleft);
  17197. +    print_status();
  17198. +#endif
  17199. +
  17200. +    if (mfm_status & (STAT_DER | STAT_ABN)) {
  17201. +        /* Something has gone wrong - lets try that again */
  17202. +        outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  17203. +        if (cont) {
  17204. +#ifdef DEBUG
  17205. +            console_printf("mfm_rw_intr: DER/ABN err\n");
  17206. +#endif
  17207. +            cont->error();
  17208. +            cont->redo();
  17209. +        };
  17210. +        return;
  17211. +    };
  17212. +
  17213. +    /* OK so what ever happend its not an error, now I reckon we are left between
  17214. +       a choice of command end or some data which is ready to be collected */
  17215. +    /* I think we have to transfer data while the interrupt line is on and its
  17216. +       not any other type of interrupt */
  17217. +    if (CURRENT->cmd == WRITE) {
  17218. +        extern void hdc63463_writedma(void);
  17219. +        if ((hdc63463_dataleft <= 0) && (!(mfm_status & STAT_CED))) {
  17220. +            printk("mfm_rw_intr: Apparent DMA write request when no more to DMA\n");
  17221. +            if (cont) {
  17222. +                cont->error();
  17223. +                cont->redo();
  17224. +            };
  17225. +            return;
  17226. +        };
  17227. +        hdc63463_writedma();
  17228. +    } else {
  17229. +        extern void hdc63463_readdma(void);
  17230. +        if ((hdc63463_dataleft <= 0) && (!(mfm_status & STAT_CED))) {
  17231. +            printk("mfm_rw_intr: Apparent DMA read request when no more to DMA\n");
  17232. +            if (cont) {
  17233. +                cont->error();
  17234. +                cont->redo();
  17235. +            };
  17236. +            return;
  17237. +        };
  17238. +#ifdef DEBUG
  17239. +        console_printf("Going to try read dma..............status=0x%x, buffer=%p\n", mfm_status, hdc63463_dataptr);
  17240. +#endif
  17241. +        hdc63463_readdma();
  17242. +    };            /* Read */
  17243. +
  17244. +    if (hdc63463_dataptr != ((unsigned int) Copy_buffer + 256)) {
  17245. +        /* If we didn't actually manage to get any data on this interrupt - but why? We got the interrupt */
  17246. +        /* Ah - well looking at the status its just when we get command end; so no problem */
  17247. +        /*console_printf("mfm: dataptr mismatch. dataptr=0x%08x Copy_buffer+256=0x%08p\n",
  17248. +           hdc63463_dataptr,Copy_buffer+256);
  17249. +           print_status(); */
  17250. +    } else {
  17251. +        Sectors256LeftInCurrent--;
  17252. +        Copy_buffer += 256;
  17253. +        Copy_Sector++;
  17254. +
  17255. +        /* We have come to the end of this request */
  17256. +        if (!Sectors256LeftInCurrent) {
  17257. +#ifdef DEBUG
  17258. +            console_printf("mfm: end_request for CURRENT=0x%p CURRENT(sector=%d current_nr_sectors=%d nr_sectors=%d)\n",
  17259. +                       CURRENT, CURRENT->sector, CURRENT->current_nr_sectors, CURRENT->nr_sectors);
  17260. +#endif
  17261. +
  17262. +            CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
  17263. +            CURRENT->sector += CURRENT->current_nr_sectors;
  17264. +            SectorsLeftInRequest -= CURRENT->current_nr_sectors;
  17265. +
  17266. +            end_request(1);
  17267. +            if (SectorsLeftInRequest) {
  17268. +                hdc63463_dataptr = (unsigned int) CURRENT->buffer;
  17269. +                Copy_buffer = CURRENT->buffer;
  17270. +                Sectors256LeftInCurrent = CURRENT->current_nr_sectors * 2;
  17271. +                errors = &(CURRENT->errors);
  17272. +                /* These should match the present calculations of the next logical sector
  17273. +                   on the device
  17274. +                   Copy_Sector=CURRENT->sector*2; */
  17275. +
  17276. +                if (Copy_Sector != CURRENT->sector * 2)
  17277. +#ifdef DEBUG
  17278. +                    console_printf("mfm: Copy_Sector mismatch. Copy_Sector=%d CURRENT->sector*2=%d\n",
  17279. +                    Copy_Sector, CURRENT->sector * 2);
  17280. +#else
  17281. +                    printk("mfm: Copy_Sector mismatch! Eek!\n");
  17282. +#endif
  17283. +            };    /* CURRENT */
  17284. +        };    /* Sectors256LeftInCurrent */
  17285. +    };
  17286. +
  17287. +    old_status = mfm_status;
  17288. +    mfm_status = inw(MFM_STATUS);
  17289. +    if (mfm_status & (STAT_DER | STAT_ABN)) {
  17290. +        /* Something has gone wrong - lets try that again */
  17291. +        if (cont) {
  17292. +#ifdef DEBUG
  17293. +            console_printf("mfm_rw_intr: DER/ABN error\n");
  17294. +#endif
  17295. +            cont->error();
  17296. +            cont->redo();
  17297. +        };
  17298. +        return;
  17299. +    };
  17300. +
  17301. +    /* If this code wasn't entered due to command_end but there is
  17302. +       now a command end we must read the command results out. If it was
  17303. +       entered like this then mfm_interrupt_handler would have done the
  17304. +       job. */
  17305. +    if ((!((old_status & (STAT_CPR | STAT_BSY)) == STAT_CPR)) &&
  17306. +        ((mfm_status & (STAT_CPR | STAT_BSY)) == STAT_CPR)) {
  17307. +        int len = 0;
  17308. +        while (len < 16) {
  17309. +            int in;
  17310. +            in = inw(MFM_DATAIN);
  17311. +            result[len++] = in >> 8;
  17312. +            result[len++] = in;
  17313. +        };
  17314. +    };            /* Result read */
  17315. +
  17316. +    /*console_printf ("mfm_rw_intr nearexit [%02X]\n", (unsigned int)*mfm_IRQPollLoc); */
  17317. +
  17318. +    /* If end of command move on */
  17319. +    if (mfm_status & (STAT_CED)) {
  17320. +        outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  17321. +        /* End of command - trigger the next command */
  17322. +        if (cont) {
  17323. +            cont->done(1);
  17324. +        }
  17325. +#ifdef DEBUG
  17326. +        console_printf("mfm_rw_intr: returned from cont->done\n");
  17327. +#endif
  17328. +    } else {
  17329. +        /* Its going to generate another interrupt */
  17330. +        SET_INTR(mfm_rw_intr);
  17331. +    };
  17332. +}
  17333. +
  17334. +static void mfm_setup_rw(void)
  17335. +{
  17336. +#ifdef DEBUG
  17337. +    console_printf("setting up for rw...\n");
  17338. +#endif
  17339. +#if 1
  17340. +    SET_INTR(mfm_rw_intr);
  17341. +    issue_command(raw_cmd.cmdcode, raw_cmd.cmddata, raw_cmd.cmdlen);
  17342. +#else
  17343. +    if (cont) {
  17344. +        cont->done(0);
  17345. +        cont->redo();
  17346. +    }
  17347. +#endif
  17348. +}
  17349. +
  17350. +static void mfm_recal_intr(void)
  17351. +{
  17352. +#ifdef DEBUG
  17353. +    console_printf("recal intr - status = ");
  17354. +    print_status();
  17355. +#endif
  17356. +    outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  17357. +    if (mfm_status & (STAT_DER | STAT_ABN)) {
  17358. +        printk("recal failed\n");
  17359. +        MFM_DRV_PARAM.cylinder = NEED_2_RECAL;
  17360. +        if (cont) {
  17361. +            cont->error();
  17362. +            cont->redo();
  17363. +        }
  17364. +        return;
  17365. +    }
  17366. +    /* Thats seek end - we are finished */
  17367. +    if (mfm_status & STAT_SED) {
  17368. +        issue_command(CMD_POD, NULL, 0);
  17369. +        MFM_DRV_PARAM.cylinder = 0;
  17370. +        mfm_seek();
  17371. +        return;
  17372. +    }
  17373. +    /* Command end without seek end (see data sheet p.20) for parallel seek
  17374. +       - we have to send a POL command to wait for the seek */
  17375. +    if (mfm_status & STAT_CED) {
  17376. +        SET_INTR(mfm_recal_intr);
  17377. +        issue_command(CMD_POL, NULL, 0);
  17378. +        return;
  17379. +    }
  17380. +    printk("recal: unknown status\n");
  17381. +}
  17382. +
  17383. +static void mfm_seek_intr(void)
  17384. +{
  17385. +#ifdef DEBUG
  17386. +    console_printf("seek intr - status = ");
  17387. +    print_status();
  17388. +#endif
  17389. +    outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  17390. +    if (mfm_status & (STAT_DER | STAT_ABN)) {
  17391. +        printk("seek failed\n");
  17392. +        MFM_DRV_PARAM.cylinder = NEED_2_RECAL;
  17393. +        if (cont) {
  17394. +            cont->error();
  17395. +            cont->redo();
  17396. +        }
  17397. +        return;
  17398. +    }
  17399. +    if (mfm_status & STAT_SED) {
  17400. +        issue_command(CMD_POD, NULL, 0);
  17401. +        MFM_DRV_PARAM.cylinder = raw_cmd.cylinder;
  17402. +        mfm_seek();
  17403. +        return;
  17404. +    }
  17405. +    if (mfm_status & STAT_CED) {
  17406. +        SET_INTR(mfm_seek_intr);
  17407. +        issue_command(CMD_POL, NULL, 0);
  17408. +        return;
  17409. +    }
  17410. +    printk("seek: unknown status\n");
  17411. +}
  17412. +
  17413. +static void mfm_specify(void)
  17414. +{
  17415. +    /* IDEA2 seems to work better - its what RiscOS sets my
  17416. +       disc to - on its SECOND call to specify! */
  17417. +#define IDEA2
  17418. +    unsigned char cmdb[16];
  17419. +#ifdef DEBUG
  17420. +    console_printf("specify...dev=%d lastspecified=%d\n", raw_cmd.dev, lastspecifieddrive);
  17421. +#endif
  17422. +    cmdb[0] = 0x1F;        /* OM0 - !SECT,!MOD,!DIF,PADP,ECD,CRCP,CRCI,ACOR */
  17423. +    cmdb[1] = 0xC3;        /* OM1 - DTM,BRST,!CEDM,!SEDM,!DERM,0,AMEX,PSK */
  17424. +#ifndef IDEA2
  17425. +    cmdb[2] = 0x16;        /* OM2 - SL - step pulse low */
  17426. +#else
  17427. +    cmdb[2] = 0;        /* OM2 - SL - step pulse low */
  17428. +#endif
  17429. +    cmdb[3] = (number_mfm_drives == 1) ? 0x02 : 0x06;    /* 1 or 2 drives */
  17430. +    cmdb[4] = 0xFC | ((MFM_DRV_PARAM.nocylinders - 1) >> 8);    /* RW time over/high part of number of cylinders */
  17431. +    cmdb[5] = MFM_DRV_PARAM.nocylinders - 1;    /* low part of number of cylinders */
  17432. +    cmdb[6] = MFM_DRV_PARAM.noheads - 1;    /* Number of heads */
  17433. +    cmdb[7] = MFM_DRV_PARAM.nosectors - 1;    /* Number of sectors */
  17434. +#ifndef IDEA2
  17435. +    cmdb[8] = 0xA9;        /* Step pulse high=21, Record Length=001 (256 bytes) */
  17436. +#else
  17437. +    cmdb[8] = 0x21;        /* Step pulse high=4, Record Length=001 (256 bytes) */
  17438. +#endif
  17439. +    cmdb[9] = 0x0A;        /* gap length 1 */
  17440. +    cmdb[10] = 0x0D;    /* gap length 2 */
  17441. +    cmdb[11] = 0x0C;    /* gap length 3 */
  17442. +    /* DAG: Note my data sheet shows precomp and low current the other way around */
  17443. +    cmdb[12] = (MFM_DRV_PARAM.precompcylinder - 1) >> 8;    /* pre comp cylinder */
  17444. +    cmdb[13] = MFM_DRV_PARAM.precompcylinder - 1;
  17445. +    cmdb[14] = (MFM_DRV_PARAM.lowcurrentcylinder - 1) >> 8;        /* Low current cylinder */
  17446. +    cmdb[15] = MFM_DRV_PARAM.lowcurrentcylinder - 1;
  17447. +
  17448. +    issue_command(CMD_SPC, cmdb, 16);
  17449. +    /* Ensure that we will do another specify if we move to the other drive */
  17450. +    lastspecifieddrive = raw_cmd.dev;
  17451. +    wait_for_completion();
  17452. +}
  17453. +
  17454. +static void mfm_seek(void)
  17455. +{
  17456. +    unsigned char cmdb[4];
  17457. +#ifdef DEBUG
  17458. +    console_printf("seeking...\n");
  17459. +#endif
  17460. +    if (MFM_DRV_PARAM.cylinder < 0) {
  17461. +        SET_INTR(mfm_recal_intr);
  17462. +#ifdef DEBUG
  17463. +        console_printf("mfm_seek: about to call specify\n");
  17464. +#endif
  17465. +        mfm_specify();    /* DAG added this */
  17466. +
  17467. +        cmdb[0] = raw_cmd.dev + 1;
  17468. +        cmdb[1] = 0;    /*raw_cmd.head; */
  17469. +
  17470. +        issue_command(CMD_RCLB, cmdb, 2);
  17471. +        return;
  17472. +    }
  17473. +    /*mfm_specify(); *//* DAG took this out */
  17474. +    if (MFM_DRV_PARAM.cylinder != raw_cmd.cylinder) {
  17475. +        cmdb[0] = raw_cmd.dev + 1;
  17476. +        cmdb[1] = 0;    /* raw_cmd.head; DAG: My data sheet says this should be 0 */
  17477. +        cmdb[2] = raw_cmd.cylinder >> 8;
  17478. +        cmdb[3] = raw_cmd.cylinder;
  17479. +
  17480. +        SET_INTR(mfm_seek_intr);
  17481. +        issue_command(CMD_SEK, cmdb, 4);
  17482. +    } else
  17483. +        mfm_setup_rw();
  17484. +}
  17485. +
  17486. +static void mfm_initialise(void)
  17487. +{
  17488. +#ifdef DEBUG
  17489. +    console_printf("init...\n");
  17490. +#endif
  17491. +    if (raw_cmd.flags & NEED_SEEK)
  17492. +        mfm_seek();
  17493. +    else
  17494. +        mfm_setup_rw();
  17495. +}
  17496. +
  17497. +/* ------------------------------------------------------------------------------------- */
  17498. +
  17499. +static void request_done(int uptodate)
  17500. +{
  17501. +#ifdef DEBUG
  17502. +    console_printf("mfm:request_done\n");
  17503. +#endif
  17504. +    if (uptodate) {
  17505. +        unsigned char block[2] = {0, 0};
  17506. +
  17507. +        /* Apparently worked - lets check bytes left to DMA */
  17508. +        if (hdc63463_dataleft != (PartFragRead_SectorsLeft * 256)) {
  17509. +            printk("mfm: request_done - dataleft=%d - should be %d - Eek!\n", hdc63463_dataleft, PartFragRead_SectorsLeft * 256);
  17510. +            end_request(0);
  17511. +            Busy = 0;
  17512. +        };
  17513. +        /* Potentially this means that we've done; but we might be doing
  17514. +           a partial access, (over two cylinders) or we may have a number
  17515. +           of fragments in an image file.  First lets deal with partial accesss
  17516. +         */
  17517. +        if (PartFragRead) {
  17518. +            /* Yep - a partial access */
  17519. +
  17520. +            /* and issue the remainder */
  17521. +            issue_request(MINOR(CURRENT->rq_dev), PartFragRead_RestartBlock, PartFragRead_SectorsLeft, CURRENT);
  17522. +            return;
  17523. +        };
  17524. +
  17525. +        /* ah well - perhaps there is another fragment to go */
  17526. +
  17527. +        /* Increment pointers/counts to start of next fragment */
  17528. +        if (SectorsLeftInRequest > 0) printk("mfm: SectorsLeftInRequest>0 - Eek! Shouldn't happen!\n");
  17529. +
  17530. +        /* No - its the end of the line */
  17531. +        /* end_request's should have happened at the end of sector DMAs */
  17532. +        /* Turns Drive LEDs off - may slow it down? */
  17533. +        issue_command(CMD_CKV, block, 2);
  17534. +
  17535. +        Busy = 0;
  17536. +#ifdef DEBUG
  17537. +        console_printf("request_done: About to mfm_request\n");
  17538. +#endif
  17539. +        /* Next one please */
  17540. +        mfm_request();    /* Moved from mfm_rw_intr */
  17541. +#ifdef DEBUG
  17542. +        console_printf("request_done: returned from mfm_request\n");
  17543. +#endif
  17544. +    } else {
  17545. +        end_request(0);
  17546. +        Busy = 0;
  17547. +    }
  17548. +}
  17549. +
  17550. +static void error_handler(void)
  17551. +{
  17552. +    int i;
  17553. +    printk("error detected... status = ");
  17554. +    print_status();
  17555. +    (*errors)++;
  17556. +    if (*errors > MFM_DRV_PARAM.errors.abort)
  17557. +        cont->done(0);
  17558. +    if (*errors > MFM_DRV_PARAM.errors.recal)
  17559. +        MFM_DRV_PARAM.cylinder = NEED_2_RECAL;
  17560. +}
  17561. +
  17562. +static void rw_interrupt(void)
  17563. +{
  17564. +    printk("rw_interrupt\n");
  17565. +}
  17566. +
  17567. +static struct cont rw_cont =
  17568. +{
  17569. +    rw_interrupt,
  17570. +    error_handler,
  17571. +    mfm_rerequest,
  17572. +    request_done
  17573. +};
  17574. +
  17575. +/*
  17576. + * Actually gets round to issuing the request - note everything at this
  17577. + * point is in 256 byte sectors not Linux 512 byte blocks
  17578. + */
  17579. +static void issue_request(int dev, unsigned int block, unsigned int nsect,
  17580. +              struct request *req)
  17581. +{
  17582. +    int track, start_head, start_sector;
  17583. +    int sectors_to_next_cyl;
  17584. +
  17585. +    dev >>= 6;
  17586. +
  17587. +    track = block / mfm_info[dev].sectors;
  17588. +    start_sector = block % mfm_info[dev].sectors;
  17589. +    start_head = track % mfm_info[dev].heads;
  17590. +
  17591. +    /* First get the number of whole tracks which are free before the next
  17592. +       track */
  17593. +    sectors_to_next_cyl = (mfm_info[dev].heads - (start_head + 1)) * mfm_info[dev].sectors;
  17594. +    /* Then add in the number of sectors left on this track */
  17595. +    sectors_to_next_cyl += (mfm_info[dev].sectors - start_sector);
  17596. +
  17597. +#ifdef DEBUG
  17598. +    console_printf("issue_request: mfm_info[dev].sectors=%d track=%d\n", mfm_info[dev].sectors, track);
  17599. +#endif
  17600. +
  17601. +    raw_cmd.flags = NEED_SEEK;
  17602. +    raw_cmd.dev = dev;
  17603. +    raw_cmd.sector = start_sector;
  17604. +    raw_cmd.head = start_head;
  17605. +    raw_cmd.cylinder = track / mfm_info[dev].heads;
  17606. +    raw_cmd.cmdtype = CURRENT->cmd;
  17607. +    raw_cmd.cmdcode = CURRENT->cmd == WRITE ? CMD_WD : CMD_RD;
  17608. +    raw_cmd.cmddata[0] = dev + 1;    /* DAG: +1 to get US */
  17609. +    raw_cmd.cmddata[1] = raw_cmd.head;
  17610. +    raw_cmd.cmddata[2] = raw_cmd.cylinder >> 8;
  17611. +    raw_cmd.cmddata[3] = raw_cmd.cylinder;
  17612. +    raw_cmd.cmddata[4] = raw_cmd.head;
  17613. +    raw_cmd.cmddata[5] = raw_cmd.sector;
  17614. +
  17615. +    /* Was == and worked - how the heck??? */
  17616. +    if (lastspecifieddrive != raw_cmd.dev) {
  17617. +        mfm_specify();
  17618. +    };
  17619. +
  17620. +    if (nsect <= sectors_to_next_cyl) {
  17621. +        raw_cmd.cmddata[6] = nsect >> 8;
  17622. +        raw_cmd.cmddata[7] = nsect;
  17623. +        PartFragRead = 0;    /* All in one */
  17624. +        PartFragRead_SectorsLeft = 0;    /* Must set this - used in DMA calcs */
  17625. +    } else {
  17626. +        raw_cmd.cmddata[6] = sectors_to_next_cyl >> 8;
  17627. +        raw_cmd.cmddata[7] = sectors_to_next_cyl;
  17628. +        PartFragRead = sectors_to_next_cyl;    /* only do this many this time */
  17629. +        PartFragRead_RestartBlock = block + sectors_to_next_cyl;    /* Where to restart from */
  17630. +        PartFragRead_SectorsLeft = nsect - sectors_to_next_cyl;
  17631. +    };
  17632. +    raw_cmd.cmdlen = 8;
  17633. +
  17634. +    /* Setup DMA pointers */
  17635. +    hdc63463_dataptr = (unsigned int) Copy_buffer;
  17636. +    hdc63463_dataleft = nsect * 256;    /* Better way? */
  17637. +
  17638. +
  17639. +#ifdef DEBUG
  17640. +    console_printf("mfm%c: %sing: CHS=%d/%d/%d, sectors=%d, buffer=0x%08lx (%p)\n",
  17641. +         raw_cmd.dev + 'a', (CURRENT->cmd == READ) ? "read" : "writ",
  17642. +               raw_cmd.cylinder,
  17643. +               raw_cmd.head,
  17644. +        raw_cmd.sector, nsect, (unsigned long) Copy_buffer, CURRENT);
  17645. +#endif
  17646. +    cont = &rw_cont;
  17647. +    errors = &(CURRENT->errors);
  17648. +    mfm_tq.routine = (void (*)(void *)) mfm_initialise;
  17649. +    queue_task(&mfm_tq, &tq_immediate);
  17650. +    mark_bh(IMMEDIATE_BH);
  17651. +};                /* issue_request */
  17652. +
  17653. +static void mfm_rerequest(void)
  17654. +{
  17655. +    /* Called when an error has just happened - need to trick mfm_request
  17656. +       into thinking we weren't busy */
  17657. +    /* Turn off ints - mfm_request expects no interrupts anyway */
  17658. +#ifdef DEBUG
  17659. +    console_printf("mfm_rerequest\n");
  17660. +#endif
  17661. +    cli();
  17662. +    Busy = 0;
  17663. +    mfm_request();
  17664. +};
  17665. +
  17666. +static void mfm_request(void)
  17667. +{
  17668. +    unsigned int dev, block, nsect;
  17669. +
  17670. +#ifdef DEBUG
  17671. +    console_printf("mfm_request CURRENT=%p Busy=%d\n", CURRENT, Busy);
  17672. +#endif
  17673. +    if (!CURRENT) {
  17674. +#ifdef DEBUG
  17675. +        console_printf("mfm_request: Exited due to NULL Current 1\n");
  17676. +#endif
  17677. +        return;
  17678. +    };
  17679. +    if (CURRENT->rq_status == RQ_INACTIVE) {
  17680. +        /* Hmm - seems to be happening a lot on 1.3.45 */
  17681. +        /*console_printf("mfm_request: Exited due to INACTIVE Current\n"); */
  17682. +        return;
  17683. +    };
  17684. +
  17685. +    /* If we are still processing then return; we will get called again */
  17686. +    if (Busy) {
  17687. +        /* Again seems to be common in 1.3.45 */
  17688. +        /*console_printf("mfm_request: Exiting due to busy\n"); */
  17689. +        return;
  17690. +    };
  17691. +    Busy = 1;
  17692. +#if 0
  17693. +    if (CURRENT && CURRENT->rq_dev < 0) {
  17694. +        console_printf("mfm_request: exit due to (CURRENT && CURRENT->rq_dev < 0)\n");
  17695. +        Busy = 0;
  17696. +        return;
  17697. +    };
  17698. +#endif
  17699. +
  17700. +    while (1) {
  17701. +#ifdef DEBUG
  17702. +        console_printf("mfm_request: loop start\n");
  17703. +#endif
  17704. +        /* DAG: I wonder if there wshould be a store flags here? */
  17705. +        sti();
  17706. +
  17707. +#ifdef DEBUG
  17708. +        console_printf("mfm_request: before INIT_REQUEST\n");
  17709. +#endif
  17710. +        if (!CURRENT) {
  17711. +            printk("mfm_request: Exiting due to !CURRENT (pre)\n");
  17712. +            Busy = 0;
  17713. +            return;
  17714. +        };
  17715. +
  17716. +        INIT_REQUEST;
  17717. +
  17718. +        /* DAG: Should this be here - e.g. if we run out of valid requests */
  17719. +        if (!CURRENT) {
  17720. +            printk("mfm_request: Exiting due to !CURRENT (post)\n");
  17721. +            Busy = 0;
  17722. +            return;
  17723. +        };
  17724. +
  17725. +#ifdef DEBUG
  17726. +        console_printf("mfm_request:                 before arg extraction\n");
  17727. +#endif
  17728. +        dev = MINOR(CURRENT->rq_dev);
  17729. +        Copy_buffer = CURRENT->buffer;
  17730. +
  17731. +        block = CURRENT->sector;
  17732. +        nsect = CURRENT->nr_sectors;
  17733. +        SectorsLeftInRequest = nsect;
  17734. +        Sectors256LeftInCurrent = CURRENT->current_nr_sectors * 2;
  17735. +        Copy_buffer = CURRENT->buffer;
  17736. +        Copy_Sector = CURRENT->sector * 2;
  17737. +
  17738. +#ifdef DEBUG
  17739. +        /*if ((dev>>6)==1) */ console_printf("mfm_request:                                raw vals: dev=%d (block=512 bytes) block=%d nblocks=%d\n", dev, block, nsect);
  17740. +#endif
  17741. +
  17742. +        /* DAG: Linux doesn't cope with this - even though it has an array telling
  17743. +           it the hardware block size - silly */
  17744. +        block *= 2;    /* Now in 256 byte sectors */
  17745. +        nsect *= 2;    /* Ditto */
  17746. +
  17747. +        if (dev >= (mfm_drives << 6) ||
  17748. +            block >= (mfm[dev].nr_sects * 2) || ((block + nsect) > (mfm[dev].nr_sects * 2))) {
  17749. +            printk("mfm: oops dev=0x%04x mfm_drives=%d block=%d mfm[dev].nr_sects=%ld nsect=%d\n",
  17750. +            dev, mfm_drives, block, mfm[dev].nr_sects, nsect);
  17751. +            if (dev >= (mfm_drives << 6))
  17752. +                printk("mfm: bad minor number: device=0x%04x\n", CURRENT->rq_dev);
  17753. +            else
  17754. +                printk("mfm%c: bad access: block=%d, count=%d\n", (dev >> 6) + 'a',
  17755. +                       block, nsect);
  17756. +            printk("mfm: continue 1\n");
  17757. +            end_request(0);
  17758. +            Busy = 0;
  17759. +            continue;
  17760. +        }
  17761. +        block += mfm[dev].start_sect;
  17762. +
  17763. +        if (dev & 0x3f) {
  17764. +            printk("mfm: Accessing old image file - not allowed!\n");
  17765. +            end_request(0);
  17766. +            Busy = 0;
  17767. +            continue;
  17768. +        }
  17769. +#ifdef DEBUG
  17770. +        console_printf("mfm_request: block after offset=%d\n", block);
  17771. +#endif
  17772. +
  17773. +        if (CURRENT->cmd != READ && CURRENT->cmd != WRITE) {
  17774. +            printk("unknown mfm-command %d\n", CURRENT->cmd);
  17775. +            end_request(0);
  17776. +            Busy = 0;
  17777. +            printk("mfm: continue 4\n");
  17778. +            continue;
  17779. +        }
  17780. +        issue_request(dev, block, nsect, CURRENT);
  17781. +
  17782. +        break;
  17783. +    }
  17784. +#ifdef DEBUG
  17785. +    console_printf("mfm_request: Dropping out bottom\n");
  17786. +#endif
  17787. +}
  17788. +
  17789. +static void do_mfm_request(void)
  17790. +{
  17791. +#ifdef DEBUG
  17792. +    console_printf("do_mfm_request: about to mfm_request\n");
  17793. +#endif
  17794. +    mfm_request();
  17795. +}
  17796. +
  17797. +static void mfm_unexpected_interrupt(void)
  17798. +{
  17799. +    printk("mfm: unexpected interrupt - status = ");
  17800. +    print_status();
  17801. +    while (1);
  17802. +}
  17803. +
  17804. +static void mfm_interrupt_handler(int unused, struct pt_regs *regs)
  17805. +{
  17806. +    int i;
  17807. +    void (*handler) (void) = DEVICE_INTR;
  17808. +
  17809. +#ifdef DEBUG
  17810. +    console_printf("mfm_interrupt_handler (handler=0x%p)\n", handler);
  17811. +#endif
  17812. +    CLEAR_INTR;
  17813. +    mfm_status = inw(MFM_STATUS);
  17814. +
  17815. +    /* If CPR (Command Parameter Reject) and not busy it means that the command
  17816. +       has some return message to give us */
  17817. +    if ((mfm_status & (STAT_CPR | STAT_BSY)) == STAT_CPR) {
  17818. +        int len = 0;
  17819. +        while (len < 16) {
  17820. +            int in;
  17821. +            in = inw(MFM_DATAIN);
  17822. +            result[len++] = in >> 8;
  17823. +            result[len++] = in;
  17824. +        }
  17825. +    }
  17826. +    if (!handler) {
  17827. +        outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  17828. +        mfm_unexpected_interrupt();
  17829. +        return;
  17830. +    }
  17831. +    handler();
  17832. +}
  17833. +
  17834. +/* DAG: Called presumably to accept command line parameters */
  17835. +/* Ignore for the moment! */
  17836. +void mfm_setup(char *str, int *ints)
  17837. +{
  17838. +    return;
  17839. +}
  17840. +
  17841. +#ifdef MODULE
  17842. +
  17843. +int init_module(void)
  17844. +{
  17845. +    mfm_init();
  17846. +    mfm_geninit(&mfm_gendisk);
  17847. +    return 0;
  17848. +}
  17849. +
  17850. +void cleanup_module(void)
  17851. +{
  17852. +    if (ecs) {
  17853. +        if (mfm_addr != (0x32d0000 >> 2))
  17854. +            outw(0, mfm_addr + (0x1000 >> 2));    /* Required to enable IRQs from MFM podule */
  17855. +        free_irq(mfm_irq);
  17856. +        unregister_blkdev(MAJOR_NR, "mfm");
  17857. +        ecard_release(ecs);
  17858. +    }
  17859. +}
  17860. +
  17861. +#endif
  17862. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/Config.in linux/arch/arm/drivers/char/Config.in
  17863. --- linux.orig/arch/arm/drivers/char/Config.in    Thu Jan  1 01:00:00 1970
  17864. +++ linux/arch/arm/drivers/char/Config.in    Tue Jul 30 17:45:42 1996
  17865. @@ -0,0 +1,29 @@
  17866. +#
  17867. +# Character device configuration
  17868. +#
  17869. +mainmenu_option next_comment
  17870. +comment 'Character devices'
  17871. +
  17872. +bool 'Echo console messages on /dev/ttyS0' CONFIG_SERIAL_ECHO
  17873. +tristate 'Standard/generic serial support' CONFIG_SERIAL
  17874. +if [ $CONFIG_SERIAL != 'n' ]; then
  17875. +  tristate 'Atomwide serial port support' CONFIG_ATOMWIDE_SERIAL
  17876. +  tristate 'Dual serial port support' CONFIG_DUALSP_SERIAL
  17877. +fi
  17878. +tristate 'Parallel printer support' CONFIG_PRINTER
  17879. +
  17880. +bool 'Mouse support' CONFIG_MOUSE
  17881. +if [ "$CONFIG_MOUSE" = "y" ]; then
  17882. +  tristate 'Keyboard mouse (pre-RiscPC)' CONFIG_KBDMOUSE
  17883. +fi
  17884. +
  17885. +bool 'Support for user misc device modules' CONFIG_UMISC
  17886. +
  17887. +bool 'Watchdog Timer Support'   CONFIG_WATCHDOG
  17888. +if [ "$CONFIG_WATCHDOG" != "n" ]; then
  17889. +  bool '   Disable watchdog shutdown on close' CONFIG_WATCHDOG_NOWAYOUT
  17890. +  define_bool CONFIG_SOFT_WATCHDOG y
  17891. +fi
  17892. +#bool 'Enhanced Real Time Clock Support' CONFIG_RTC
  17893. +endmenu
  17894. +
  17895. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/Makefile linux/arch/arm/drivers/char/Makefile
  17896. --- linux.orig/arch/arm/drivers/char/Makefile    Thu Jan  1 01:00:00 1970
  17897. +++ linux/arch/arm/drivers/char/Makefile    Tue Jul 30 17:39:37 1996
  17898. @@ -0,0 +1,149 @@
  17899. +#
  17900. +# Makefile for the kernel character device drivers.
  17901. +#
  17902. +# Note! Dependencies are done automagically by 'make dep', which also
  17903. +# removes any old dependencies. DON'T put your own dependencies here
  17904. +# unless it's something special (ie not a .c file).
  17905. +#
  17906. +# Note 2! The CFLAGS definitions are now inherited from the
  17907. +# parent makes..
  17908. +#
  17909. +
  17910. +#
  17911. +# This file contains the font map for the default font
  17912. +#
  17913. +
  17914. +FONTMAPFILE = cp437.uni
  17915. +
  17916. +# Links to make
  17917. +
  17918. +LK = conmakehash.c consolemap.c consolemap.h cp437.uni \
  17919. +     kbd_kern.h lp.c random.c tty_ioctl.c softdog.c
  17920. +
  17921. +all: links first_rule
  17922. +
  17923. +L_TARGET := char.a
  17924. +M_OBJS   :=
  17925. +L_OBJS   := tty_io.o n_tty.o console.o keyboard.o \
  17926. +        tty_ioctl.o pty.o vt.o mem.o vc_screen.o random.o \
  17927. +        defkeymap.o consolemap.o selection.o
  17928. +
  17929. +# architecture options
  17930. +ifeq ($(MACHINE),a5k)
  17931. +  ifeq ($(CONFIG_SERIAL),y)
  17932. +    SL=y
  17933. +  else
  17934. +    ifeq ($(CONFIG_SERIAL),m)
  17935. +      SM=m
  17936. +    endif
  17937. +  endif
  17938. +else
  17939. +  ifeq ($(MACHINE),arc)
  17940. +    ifeq ($(CONFIG_SERIAL),y)
  17941. +      LX_OBJS += serial6850.o
  17942. +    else
  17943. +      ifeq ($(CONFIG_SERIAL),m)
  17944. +        LX_OBJS += serial6850.o
  17945. +      endif
  17946. +    endif
  17947. +  endif
  17948. +endif
  17949. +
  17950. +# Common dependencies
  17951. +
  17952. +ifeq ($(CONFIG_ATOMWIDE_SERIAL),y)
  17953. +  L_OBJS += serial-atomwide.o
  17954. +  SL=y
  17955. +else
  17956. +  ifeq ($(CONFIG_ATOMWIDE_SERIAL),m)
  17957. +    M_OBJS += serial-atomwide.o
  17958. +    SM=m
  17959. +  endif
  17960. +endif
  17961. +
  17962. +ifeq ($(CONFIG_DUALSP_SERIAL),y)
  17963. +  L_OBJS += serial-dualsp.o
  17964. +  SL=y
  17965. +else
  17966. +  ifeq ($(CONFIG_DUALSP_SERIAL),m)
  17967. +    M_OBJS += serial-dualsp.o
  17968. +    SM=m
  17969. +  endif
  17970. +endif
  17971. +
  17972. +ifdef SL
  17973. +  L_OBJS += serial.o
  17974. +else
  17975. +  ifdef SM
  17976. +    M_OBJS += serial.o
  17977. +  endif
  17978. +endif
  17979. +
  17980. +ifeq ($(CONFIG_PRINTER),y)
  17981. +  L_OBJS += lp.o
  17982. +else
  17983. +  ifeq ($(CONFIG_PRINTER),m)
  17984. +    M_OBJS += lp.o
  17985. +  endif
  17986. +endif
  17987. +
  17988. +ifeq ($(CONFIG_UMISC),y)
  17989. +# To support third-party modules, msic.c must reside in the kernel
  17990. +M = y
  17991. +endif
  17992. +
  17993. +ifeq ($(CONFIG_KBDMOUSE),y)
  17994. +  M = y
  17995. +  L_OBJS += kbdmouse.o
  17996. +else
  17997. +  ifeq ($(CONFIG_KBDMOUSE),m)
  17998. +    MM = m
  17999. +    M_OBJS += kbdmouse.o
  18000. +  endif
  18001. +endif
  18002. +
  18003. +ifeq ($(CONFIG_SOFT_WATCHDOG),y)
  18004. +M = y
  18005. +L_OBJS += softdog.o
  18006. +else
  18007. +  ifeq ($(CONFIG_SOFT_WATCHDOG),m)
  18008. +  M_OBJS += softdog.o
  18009. +  MM = m
  18010. +  endif
  18011. +endif
  18012. +
  18013. +ifdef M
  18014. +  L_OBJS += misc.o
  18015. +else
  18016. +  ifdef MM
  18017. +    M_OBJS += misc.o
  18018. +  endif
  18019. +endif
  18020. +
  18021. +include $(TOPDIR)/Rules.make
  18022. +
  18023. +fastdep: links uni_hash.tbl
  18024. +
  18025. +conmakehash: conmakehash.c
  18026. +    $(HOSTCC) -o conmakehash conmakehash.c
  18027. +
  18028. +uni_hash.tbl: $(FONTMAPFILE) conmakehash
  18029. +    ./conmakehash $(FONTMAPFILE) > uni_hash.tbl
  18030. +
  18031. +.PHONY: links
  18032. +links:
  18033. +    -@for f in $(LK); do \
  18034. +        if [ ! -e $$f ]; then \
  18035. +            echo "ln -s ../../../../drivers/char/$$f .";\
  18036. +            ln -s ../../../../drivers/char/$$f .; \
  18037. +        fi \
  18038. +    done
  18039. +
  18040. +mrproper:
  18041. +    -@for f in $(LK); do \
  18042. +        if [ -L $$f ]; then \
  18043. +            echo $(RM) $$f; \
  18044. +            $(RM) $$f; \
  18045. +        fi; \
  18046. +    done
  18047. +    $(RM) conmakehash
  18048. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/console/font.h linux/arch/arm/drivers/char/console/font.h
  18049. --- linux.orig/arch/arm/drivers/char/console/font.h    Thu Jan  1 01:00:00 1970
  18050. +++ linux/arch/arm/drivers/char/console/font.h    Sat Apr 20 14:37:42 1996
  18051. @@ -0,0 +1,102 @@
  18052. +/*
  18053. + * Font definition
  18054. + */
  18055. +const unsigned char cmap_80[][8]= {
  18056. +    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*   */
  18057. +    {0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x00}, /* ! */
  18058. +    {0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00}, /* " */
  18059. +    {0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36, 0x00}, /* # */
  18060. +    {0x0C, 0x3F, 0x68, 0x3E, 0x0B, 0x7E, 0x18, 0x00}, /* $ */
  18061. +    {0x60, 0x66, 0x0C, 0x18, 0x30, 0x66, 0x06, 0x00}, /* % */
  18062. +    {0x38, 0x6C, 0x6C, 0x38, 0x6D, 0x66, 0x3B, 0x00}, /* & */
  18063. +    {0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, /* ' */
  18064. +    {0x0C, 0x18, 0x30, 0x30, 0x30, 0x18, 0x0C, 0x00}, /* ( */
  18065. +    {0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x18, 0x30, 0x00}, /* ) */
  18066. +    {0x00, 0x18, 0x7E, 0x3C, 0x7E, 0x18, 0x00, 0x00}, /* * */
  18067. +    {0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00}, /* + */
  18068. +    {0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30}, /* , */
  18069. +    {0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00}, /* - */
  18070. +    {0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00}, /* . */
  18071. +    {0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00, 0x00}, /* / */
  18072. +    {0x3C, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x3C, 0x00}, /* 0 */
  18073. +    {0x18, 0x38, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00}, /* 1 */
  18074. +    {0x3C, 0x66, 0x06, 0x0C, 0x18, 0x30, 0x7E, 0x00}, /* 2 */
  18075. +    {0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C, 0x00}, /* 3 */
  18076. +    {0x0C, 0x1C, 0x3C, 0x6C, 0x7E, 0x0C, 0x0C, 0x00}, /* 4 */
  18077. +    {0x7E, 0x60, 0x7C, 0x06, 0x06, 0x66, 0x3C, 0x00}, /* 5 */
  18078. +    {0x1C, 0x30, 0x60, 0x7C, 0x66, 0x66, 0x3C, 0x00}, /* 6 */
  18079. +    {0x7E, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00}, /* 7 */
  18080. +    {0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00}, /* 8 */
  18081. +    {0x3C, 0x66, 0x66, 0x3E, 0x06, 0x0C, 0x38, 0x00}, /* 9 */
  18082. +    {0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00}, /* : */
  18083. +    {0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30}, /* ; */
  18084. +    {0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x00}, /* < */
  18085. +    {0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00}, /* = */ 
  18086. +    {0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x00}, /* > */
  18087. +    {0x3C, 0x66, 0x0C, 0x18, 0x18, 0x00, 0x18, 0x00}, /* ? */
  18088. +    {0x3C, 0x66, 0x6E, 0x6A, 0x6E, 0x60, 0x3C, 0x00}, /* @ */
  18089. +    {0x3C, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00}, /* A */
  18090. +    {0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x7C, 0x00}, /* B */
  18091. +    {0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x00}, /* C */
  18092. +    {0x78, 0x6C, 0x66, 0x66, 0x66, 0x6C, 0x78, 0x00}, /* D */
  18093. +    {0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E, 0x00}, /* E */
  18094. +    {0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x60, 0x00}, /* F */
  18095. +    {0x3C, 0x66, 0x60, 0x6E, 0x66, 0x66, 0x3C, 0x00}, /* G */
  18096. +    {0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00}, /* H */
  18097. +    {0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00}, /* I */
  18098. +    {0x3E, 0x0C, 0x0C, 0x0C, 0x0C, 0x6C, 0x38, 0x00}, /* J */
  18099. +    {0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66, 0x00}, /* K */
  18100. +    {0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7E, 0x00}, /* L */
  18101. +    {0x63, 0x77, 0x7F, 0x6B, 0x6B, 0x63, 0x63, 0x00}, /* M */
  18102. +    {0x66, 0x66, 0x76, 0x7E, 0x6E, 0x66, 0x66, 0x00}, /* N */
  18103. +    {0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00}, /* O */
  18104. +    {0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x60, 0x00}, /* P */
  18105. +    {0x3C, 0x66, 0x66, 0x66, 0x6A, 0x6C, 0x36, 0x00}, /* Q */
  18106. +    {0x7C, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0x66, 0x00}, /* R */
  18107. +    {0x3C, 0x66, 0x60, 0x3C, 0x06, 0x66, 0x3C, 0x00}, /* S */
  18108. +    {0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00}, /* T */
  18109. +    {0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00}, /* U */
  18110. +    {0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00}, /* V */
  18111. +    {0x63, 0x63, 0x6B, 0x6B, 0x7F, 0x77, 0x63, 0x00}, /* W */
  18112. +    {0x66, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x66, 0x00}, /* X */
  18113. +    {0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x00}, /* Y */
  18114. +    {0x7E, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x7E, 0x00}, /* Z */
  18115. +    {0x7C, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7C, 0x00}, /* [ */
  18116. +    {0x00, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x00}, /* \ */
  18117. +    {0x3E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x3E, 0x00}, /* ] */
  18118. +    {0x3C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* ^ */
  18119. +    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF}, /* _ */
  18120. +    {0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* ` */
  18121. +    {0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x3E, 0x00}, /* a */
  18122. +    {0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x7C, 0x00}, /* b */
  18123. +    {0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x00}, /* c */
  18124. +    {0x06, 0x06, 0x3E, 0x66, 0x66, 0x66, 0x3E, 0x00}, /* d */
  18125. +    {0x00, 0x00, 0x3C, 0x66, 0x7E, 0x60, 0x3C, 0x00}, /* e */
  18126. +    {0x1C, 0x30, 0x30, 0x7C, 0x30, 0x30, 0x30, 0x00}, /* f */
  18127. +    {0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x3C}, /* g */
  18128. +    {0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x00}, /* h */
  18129. +    {0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00}, /* i */
  18130. +    {0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x70}, /* j */
  18131. +    {0x60, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0x00}, /* k */
  18132. +    {0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00}, /* l */
  18133. +    {0x00, 0x00, 0x36, 0x7F, 0x6B, 0x6B, 0x63, 0x00}, /* m */
  18134. +    {0x00, 0x00, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x00}, /* n */
  18135. +    {0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00}, /* o */
  18136. +    {0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60}, /* p */
  18137. +    {0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x07}, /* q */
  18138. +    {0x00, 0x00, 0x6C, 0x76, 0x60, 0x60, 0x60, 0x00}, /* r */
  18139. +    {0x00, 0x00, 0x3E, 0x60, 0x3C, 0x06, 0x7C, 0x00}, /* s */
  18140. +    {0x30, 0x30, 0x7C, 0x30, 0x30, 0x30, 0x1C, 0x00}, /* t */
  18141. +    {0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3E, 0x00}, /* u */
  18142. +    {0x00, 0x00, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00}, /* v */
  18143. +    {0x00, 0x00, 0x63, 0x6B, 0x6B, 0x7F, 0x36, 0x00}, /* w */
  18144. +    {0x00, 0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x00}, /* x */
  18145. +    {0x00, 0x00, 0x66, 0x66, 0x66, 0x3E, 0x06, 0x3C}, /* y */
  18146. +    {0x00, 0x00, 0x7E, 0x0C, 0x18, 0x30, 0x7E, 0x00}, /* z */
  18147. +    {0x0C, 0x18, 0x18, 0x70, 0x18, 0x18, 0x0C, 0x00}, /* { */
  18148. +    {0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00}, /* | */
  18149. +    {0x30, 0x18, 0x18, 0x0E, 0x18, 0x18, 0x30, 0x00}, /* } */
  18150. +    {0x31, 0x6B, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00}, /* ~ */
  18151. +    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}  /*  */
  18152. +};
  18153. +
  18154. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/console/serialecho.c linux/arch/arm/drivers/char/console/serialecho.c
  18155. --- linux.orig/arch/arm/drivers/char/console/serialecho.c    Thu Jan  1 01:00:00 1970
  18156. +++ linux/arch/arm/drivers/char/console/serialecho.c    Fri May 10 13:34:51 1996
  18157. @@ -0,0 +1,116 @@
  18158. +/*
  18159. + * linux/arch/arm/drivers/char/serialecho.c
  18160. + *
  18161. + * Serial echoing for kernel console messages.
  18162. + */
  18163. +#if defined (CONFIG_ARCH_A5K) || defined (CONFIG_ARCH_RPC)
  18164. +
  18165. +#include <linux/serial_reg.h>
  18166. +
  18167. +extern int serial_echo_init (int base);
  18168. +extern int serial_echo_print (const char *s);
  18169. +
  18170. +/*
  18171. + * this defines the address for the port to which printk echoing is done
  18172. + *  when CONFIG_SERIAL_ECHO is defined
  18173. + */
  18174. +#define SERIAL_ECHO_PORT    0x3f8    /* internal serial port */
  18175. +
  18176. +static int serial_echo_port = 0;
  18177. +
  18178. +#define serial_echo_outb(v,a) outb((v),(a)+serial_echo_port)
  18179. +#define serial_echo_inb(a)    inb((a)+serial_echo_port)
  18180. +
  18181. +#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
  18182. +
  18183. +/* wait for the transmitter & holding register to empty */
  18184. +#define WAIT_FOR_XMITR \
  18185. + do { \
  18186. +    lsr = serial_echo_inb (UART_LSR); \
  18187. + } while ((lsr & BOTH_EMPTY) != BOTH_EMPTY)
  18188. +
  18189. +/*
  18190. + * These two functions abstract the actual communications with the
  18191. + * debug port.  This is so we can change the underlying communications
  18192. + * mechanism without modifying the rest of the code.
  18193. + */
  18194. +int serial_echo_print (const char *s)
  18195. +{
  18196. +    int lsr, ier;
  18197. +    int i;
  18198. +
  18199. +    if (!serial_echo_port)
  18200. +    return;
  18201. +
  18202. +    /*
  18203. +     * First save the IER then disable interrupts
  18204. +     */
  18205. +    ier = serial_echo_inb (UART_IER);
  18206. +    serial_echo_outb (0x00, UART_IER);
  18207. +
  18208. +    /*
  18209. +     * Now do each character
  18210. +     */
  18211. +    for (i = 0; *s; i++, s++) {
  18212. +    WAIT_FOR_XMITR;
  18213. +
  18214. +    /* send the character out. */
  18215. +    serial_echo_outb (*s, UART_TX);
  18216. +
  18217. +    /* if a LF, also do CR... */
  18218. +    if (*s == 10) {
  18219. +        WAIT_FOR_XMITR;
  18220. +        serial_echo_outb (13, UART_TX);
  18221. +    }
  18222. +    }
  18223. +
  18224. +    /*
  18225. +     * Finally, wait for transmitter & holding register to empty
  18226. +     *  and restore the IER.
  18227. +     */
  18228. +    WAIT_FOR_XMITR;
  18229. +    serial_echo_outb (ier, UART_IER);
  18230. +
  18231. +    return 0;
  18232. +}
  18233. +
  18234. +int serial_echo_init (int base)
  18235. +{
  18236. +    int comstat, hi, lo;
  18237. +
  18238. +    if (base != 0x3f8) {
  18239. +    serial_echo_port = 0;
  18240. +    return 0;
  18241. +    } else
  18242. +    serial_echo_port = base;
  18243. +
  18244. +    /*
  18245. +     * Read the Divisor Latch
  18246. +     */
  18247. +    comstat = serial_echo_inb (UART_LCR);
  18248. +    serial_echo_outb (comstat | UART_LCR_DLAB, UART_LCR);
  18249. +    hi = serial_echo_inb (UART_DLM);
  18250. +    lo = serial_echo_outb (UART_DLL);
  18251. +    serial_echo_outb (comstat);
  18252. +
  18253. +    /*
  18254. +     * now do a hardwired init
  18255. +     */
  18256. +    serial_echo_outb (0x03, UART_LCR); /* No parity, 8 bits, 1 stop */
  18257. +    serial_echo_outb (0x83, UART_LCR); /* Access divisor latch */
  18258. +    serial_echo_outb (0x00, UART_DLM); /* 9600 baud */
  18259. +    serial_echo_outb (0x0c, UART_DLL); /* Done with divisor */
  18260. +
  18261. +    /*
  18262. +     * Prior to disabling interrupts, read the LSR and RBR
  18263. +     * registers
  18264. +     */
  18265. +    comstat = serial_echo_inb (UART_LSR); /* COM? LSR */
  18266. +    comstat = serial_echo_inb (UART_RX);  /* COM? RBR */
  18267. +    serial_echo_outb (0x00, UART_IER);    /* Disable all interrupts */
  18268. +
  18269. +    return 0;
  18270. +}
  18271. +
  18272. +#endif
  18273. +
  18274. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/console.c linux/arch/arm/drivers/char/console.c
  18275. --- linux.orig/arch/arm/drivers/char/console.c    Thu Jan  1 01:00:00 1970
  18276. +++ linux/arch/arm/drivers/char/console.c    Fri Sep  6 21:11:28 1996
  18277. @@ -0,0 +1,2339 @@
  18278. +/*
  18279. + * linux/arch/arm/drivers/char/console.c
  18280. + *
  18281. + * Modifications (C) 1995, 1996 Russell King
  18282. + */
  18283. +
  18284. +/*
  18285. + * This module exports the console io functions:
  18286. + *
  18287. + *  'int           vcd_init (struct vt *vt, int kmallocok, unsigned long *kmem)'
  18288. + *  'unsigned long vcd_pre_init (unsigned long kmem, struct vt *vt)'
  18289. + *  'void          vcd_disallocate (struct vt *vt)'
  18290. + *  'int           vcd_resize (unsigned long lines, unsigned long cols)'
  18291. + *  'void          vcd_blankscreen (int nopowersave)'
  18292. + *  'void          vcd_unblankscreen (void)'
  18293. + *  'void          vcd_savestate (const struct vt *vt, int blanked)'
  18294. + *  'void          vcd_restorestate (const struct vt *vt)'
  18295. + *  'void          vcd_setup_graphics (const struct vt *vt)'
  18296. + *  'int           vcd_write (const struct vt *vt, int from_user, const unsigned char *buf, int count)'
  18297. + *  'int           vcd_ioctl (const struct vt *vt, int cmd, unsigned long arg)'
  18298. + *
  18299. + *
  18300. + *    'int vc_allocate(unsigned int console)'
  18301. + *    'int vc_cons_allocated (unsigned int console)'
  18302. + *    'int vc_resize(unsigned long lines,unsigned long cols)'
  18303. + *    'void vc_disallocate(unsigned int currcons)'
  18304. + *
  18305. + *    'unsigned long con_init(unsigned long)'
  18306. + * S    'int con_open(struct tty_struct *tty,struct file *filp)'
  18307. + * S    'void con_write(struct tty_struct *tty)'
  18308. + * S    'void console_print(const char *b)'
  18309. + *    'void update_screen(int new_console)'
  18310. + *
  18311. + *    'void blank_screen(void)'
  18312. + *    'void unblank_screen(void)'
  18313. + *    'void scrollback(int lines)'            *
  18314. + *    'void scrollfront(int lines)'            *
  18315. + *    'int do_screendump(int arg)'
  18316. + *
  18317. + *    'int con_get_font(char *)'
  18318. + *    'int con_set_font(char *)'
  18319. + *    'int con_get_trans(char *)'
  18320. + *    'int con_set_trans(char *)'
  18321. + *
  18322. + *    'int mouse_reporting(void)'
  18323. + */
  18324. +
  18325. +#define BLANK 0x0020
  18326. +/* A bitmap for codes <32. A bit of 1 indicates that the code
  18327. + * corresponding to that bit number invokes a special action
  18328. + * (such as cursor movement) and should not be displayed as a
  18329. + * glyph unless the disp_ctrl mode is explicitly enabled.
  18330. + */
  18331. +#define CTRL_ACTION 0x0d00ff81
  18332. +#define CTRL_ALWAYS 0x0800f501  /* Cannot be overriden by disp_ctrl */
  18333. + 
  18334. +#include <linux/config.h>
  18335. +#include <linux/sched.h>
  18336. +#include <linux/timer.h>
  18337. +#include <linux/interrupt.h>
  18338. +#include <linux/tty.h>
  18339. +#include <linux/tty_flip.h>
  18340. +#include <linux/kernel.h>
  18341. +#include <linux/errno.h>
  18342. +#include <linux/kd.h>
  18343. +#include <linux/major.h>
  18344. +#include <linux/mm.h>
  18345. +#include <linux/malloc.h>
  18346. +
  18347. +#include <asm/segment.h>
  18348. +#include <asm/irq-no.h>
  18349. +
  18350. +#define DEBUG
  18351. +
  18352. +#include "kbd_kern.h"
  18353. +#include "consolemap.h"
  18354. +#include "vt_kern.h"
  18355. +#include "selection.h"
  18356. +
  18357. +#define set_kbd(x) set_vc_kbd_mode (vt->kbd, x)
  18358. +#define clr_kbd(x) clr_vc_kbd_mode (vt->kbd, x)
  18359. +#define is_kbd(x)  vc_kbd_mode (vt->kbd, x)
  18360. +
  18361. +#define decarm        VC_REPEAT
  18362. +#define decckm        VC_CKMODE
  18363. +#define kbdapplic    VC_APPLIC
  18364. +#define lnm        VC_CRLF
  18365. +
  18366. +/*
  18367. + * this is what the terminal answers to a ESC-Z or csi0c query.
  18368. + */
  18369. +#define VT100ID "\033[?1;2c"
  18370. +#define VT102ID "\033[?6c"
  18371. +
  18372. +extern int setup_arm_irq(int, struct irqaction *);
  18373. +
  18374. +int bytes_per_char_h, bytes_per_char_v, video_num_columns;
  18375. +
  18376. +/*
  18377. + * routines to load custom translation table, EGA/VGA font and
  18378. + * VGA colour palette from console.c
  18379. + */
  18380. +extern int con_set_trans_old(unsigned char * table);
  18381. +extern int con_get_trans_old(unsigned char * table);
  18382. +extern int con_set_trans_new(unsigned short * table);
  18383. +extern int con_get_trans_new(unsigned short * table);
  18384. +extern void con_clear_unimap(struct unimapinit *ui);
  18385. +extern int con_set_unimap(ushort ct, struct unipair *list);
  18386. +extern int con_get_unimap(ushort ct, ushort *uct, struct unipair *list);
  18387. +extern void con_set_default_unimap(void);
  18388. +extern int con_set_font(char * fontmap);
  18389. +extern int con_get_font(char * fontmap);
  18390. +
  18391. +
  18392. +/* ARM Extensions */
  18393. +extern void ll_write_char(unsigned long ps, unsigned long chinfo);
  18394. +extern void memc_write (int reg, int val);
  18395. +extern void vidc_write (int reg, int val);
  18396. +extern void memsetl (void *ptr, unsigned long word, int length);
  18397. +extern void map_screen_mem (unsigned long vid_base, int remap);
  18398. +static void ll_erase (const struct vt * const vt, unsigned char sx, unsigned char sy,
  18399. +            unsigned char cx, unsigned char cy);
  18400. +
  18401. +#include <linux/ctype.h>
  18402. +
  18403. +#ifndef MIN
  18404. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  18405. +#endif
  18406. +
  18407. +static void gotoxy (const struct vt * const vt, int new_x, int new_y);
  18408. +static inline void set_cursor (const struct vt * const vt);
  18409. +extern void reset_vc(const struct vt * const vt);
  18410. +extern void register_console(void (*proc)(const char *));
  18411. +extern void compute_shiftstate(void);
  18412. +extern void con_reset_palette (const struct vt * const vt);
  18413. +extern void con_set_palette (const struct vt * const vt);
  18414. +
  18415. +static int can_do_color = 1;
  18416. +static int printable;                /* Is console ready for printing? */
  18417. +
  18418. +#define console_charmask 0xff
  18419. +#ifndef console_charmask
  18420. +static unsigned short console_charmask = 0x0ff;
  18421. +#endif
  18422. +
  18423. +#include "console/font.h"
  18424. +
  18425. +static const unsigned long palette_1[] = {
  18426. +    0x1000,        /* Black   */
  18427. +    0x1fff,        /* White   */
  18428. +    0x1000,        /* Black   */
  18429. +    0x1000,        /* Black   */
  18430. +    0x1000,        /* Black   */
  18431. +    0x1000,        /* Black   */
  18432. +    0x1000,        /* Black   */
  18433. +    0x1000,        /* Black   */
  18434. +    0x1000,        /* Black   */
  18435. +    0x1000,        /* Black   */
  18436. +    0x1000,        /* Black   */
  18437. +    0x1000,        /* Black   */
  18438. +    0x1000,        /* Black   */
  18439. +    0x1000,        /* Black   */
  18440. +    0x1000,        /* Black   */
  18441. +    0x1000,        /* Black   */
  18442. +    0x1000,        /* Black   */
  18443. +    0x1000,        /* Black   */
  18444. +    0x1000,        /* Black   */
  18445. +    0x1000        /* Black   */
  18446. +};
  18447. +
  18448. +static const unsigned long palette_4[] = {
  18449. +    0x1000,        /* Black   */
  18450. +    0x100c,        /* Red     */
  18451. +    0x10c0,        /* Green   */
  18452. +    0x10cc,        /* Yellow  */
  18453. +    0x1c00,        /* Blue    */
  18454. +    0x1c0c,        /* Magenta */
  18455. +    0x1cc0,        /* Cyan    */
  18456. +    0x1ccc,        /* White   */
  18457. +    0x1000,
  18458. +    0x100f,
  18459. +    0x10f0,
  18460. +    0x10ff,
  18461. +    0x1f00,
  18462. +    0x1f0F,
  18463. +    0x1ff0,
  18464. +    0x1fff,
  18465. +    0x1000,        /* Black   */
  18466. +    0x1000,        /* Black   */
  18467. +    0x1000
  18468. +};
  18469. +
  18470. +static const unsigned long palette_8[] = {
  18471. +    0x1000,
  18472. +    0x1111,
  18473. +    0x1222,
  18474. +    0x1333,
  18475. +    0x1400,
  18476. +    0x1511,
  18477. +    0x1622,
  18478. +    0x1733,
  18479. +    0x1004,
  18480. +    0x1115,
  18481. +    0x1226,
  18482. +    0x1337,
  18483. +    0x1404,
  18484. +    0x1515,
  18485. +    0x1626,
  18486. +    0x1737,
  18487. +    0x1000,        /* Black   */
  18488. +    0x1000,        /* Black   */
  18489. +    0x1000
  18490. +};
  18491. +
  18492. +static const unsigned long *default_palette_entries = palette_4;
  18493. +
  18494. +static const unsigned char color_1[] = {0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 };
  18495. +static const unsigned char color_4[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 };
  18496. +static const unsigned char color_8[] = {0x00, 0x18, 0x60, 0x78, 0x84, 0x9C, 0xE4, 0xFC,
  18497. +                    0x00, 0x1B, 0x63, 0x7B, 0x87, 0x9F, 0xE7, 0xFF};
  18498. +static const unsigned char *color_table = color_4;
  18499. +
  18500. +/*===================================================================================*/
  18501. +
  18502. +#ifdef CONFIG_SERIAL_ECHO
  18503. +#include "console/serialecho.c"
  18504. +#endif
  18505. +
  18506. +#ifdef DEBUG
  18507. +static int vcd_validate (struct con_struct *vcd, const char *msg)
  18508. +{
  18509. +    unsigned long old_origin, old_pos, w = 0;
  18510. +
  18511. +    old_origin = vcd->screen.origin;
  18512. +    if (vcd->screen.origin < 0x01f80000 || vcd->screen.origin > 0x02000000) {
  18513. +    vcd->screen.origin = 0x02000000;
  18514. +    w = 1;
  18515. +    }
  18516. +    old_pos = vcd->screen.pos;
  18517. +    if (vcd->screen.pos < 0x01f80000 || vcd->screen.pos > 0x02080000) {
  18518. +    vcd->screen.pos = 0x02000000;
  18519. +    w = 1;
  18520. +    }
  18521. +    if (w)
  18522. +    printk ("*** CONSOLE ERROR: %s: (%p): origin = %08lX pos = %08lX ***\n", msg, vcd, old_origin, old_pos);
  18523. +    return w;
  18524. +}
  18525. +#endif
  18526. +
  18527. +void no_scroll(char *str, int *ints)
  18528. +{
  18529. +}
  18530. +
  18531. +static unsigned long __real_origin;
  18532. +static unsigned long __origin;        /* Offset of currently displayed screen */
  18533. +
  18534. +static void __set_origin(unsigned long offset)
  18535. +{
  18536. +    unsigned long flags;
  18537. +
  18538. +    clear_selection ();
  18539. +
  18540. +    save_flags_cli (flags);
  18541. +    __origin = offset;
  18542. +
  18543. +    memc_write(0, offset >> 2);
  18544. +    memc_write(1, 0);
  18545. +    memc_write(2, vtdata.screen.memmask >> 2);
  18546. +    restore_flags(flags);
  18547. +}
  18548. +
  18549. +void scrollback(int lines)
  18550. +{
  18551. +}
  18552. +
  18553. +void scrollfront(int lines)
  18554. +{
  18555. +}
  18556. +
  18557. +static void set_origin (const struct vt * const vt)
  18558. +{
  18559. +    if (vtdata.fgconsole != vt || vt->vtd->vc_mode == KD_GRAPHICS)
  18560. +    return;
  18561. +    __real_origin = vt->vcd->screen.origin - vtdata.screen.memstart;
  18562. +    if (__real_origin > vtdata.screen.memmask)
  18563. +    __real_origin -= vtdata.screen.memmask + 1;
  18564. +    __set_origin(__real_origin);
  18565. +}
  18566. +
  18567. +/* -------------------------------------------------------------------------------
  18568. + * Cursor
  18569. + * ------------------------------------------------------------------------------- */
  18570. +
  18571. +static char cursor_on = 0;
  18572. +static unsigned long cp;
  18573. +
  18574. +static void put_cursor(char on_off,unsigned long newcp)
  18575. +{
  18576. +    static char con;
  18577. +    unsigned long cp_p = cp;
  18578. +    int c = vtdata.screen.bytespercharh == 8 ? color_table[15] : 0x11 * color_table[15];
  18579. +    int i;
  18580. +
  18581. +    if (vtdata.fgconsole->vtd->vc_mode == KD_GRAPHICS)
  18582. +    return;
  18583. +
  18584. +    cp = newcp;
  18585. +
  18586. +    if (con != on_off) {
  18587. +    if (cp_p != -1)
  18588. +        for (i = 0; i < vtdata.screen.bytespercharh; i++)
  18589. +        ((unsigned char*)cp_p)[i]^=c;
  18590. +    con = on_off;
  18591. +    }
  18592. +}
  18593. +
  18594. +static void vsync_irq(int irq, void *dev_id, struct pt_regs *regs)
  18595. +{
  18596. +    static char cursor_flash;
  18597. +
  18598. +    if(++cursor_flash==16) {
  18599. +    cursor_flash=0;
  18600. +    cursor_on = cursor_on ? 0 : 1;
  18601. +    if (vtdata.fgconsole->vcd->screen.cursoron > 0)
  18602. +        put_cursor(cursor_on,cp);
  18603. +    }
  18604. +}
  18605. +
  18606. +static void hide_cursor(void)
  18607. +{
  18608. +    put_cursor (0, -1);
  18609. +}
  18610. +
  18611. +static void set_cursor (const struct vt * const vt)
  18612. +{
  18613. +    unsigned long flags;
  18614. +
  18615. +    if (vt != vtdata.fgconsole || vt->vtd->vc_mode == KD_GRAPHICS)
  18616. +    return;
  18617. +
  18618. +    if(__real_origin != __origin)
  18619. +    __set_origin (__real_origin);
  18620. +
  18621. +    save_flags_cli (flags);
  18622. +    if (vt->vcd->deccm) {
  18623. +#ifdef DEBUG
  18624. +        vcd_validate (vt->vcd, "set_cursor");
  18625. +#endif
  18626. +    cp = vt->vcd->screen.pos + vtdata.numcolumns *
  18627. +            vtdata.screen.bytespercharh * (vtdata.screen.bytespercharv - 1);
  18628. +    } else
  18629. +    hide_cursor();
  18630. +    restore_flags(flags);
  18631. +}
  18632. +
  18633. +static void vcd_removecursors (const struct vt *vt)
  18634. +{
  18635. +    unsigned long flags;
  18636. +
  18637. +    save_flags_cli (flags);
  18638. +
  18639. +    if (--vt->vcd->screen.cursoron == 0 && vtdata.fgconsole == vt)
  18640. +    put_cursor (0, cp);
  18641. +
  18642. +    restore_flags (flags);
  18643. +}
  18644. +
  18645. +static void vcd_restorecursors(const struct vt *vt)
  18646. +{
  18647. +    unsigned long flags;
  18648. +
  18649. +    save_flags_cli (flags);
  18650. +
  18651. +    if (++vt->vcd->screen.cursoron == 1 && cursor_on && vtdata.fgconsole == vt)
  18652. +    put_cursor (1, cp);
  18653. +
  18654. +    restore_flags (flags);
  18655. +}
  18656. +
  18657. +/* -----------------------------------------------------------------------------------------
  18658. + * VC stuff
  18659. + * ----------------------------------------------------------------------------------------- */
  18660. +/*
  18661. + * gotoxy() must verify all boundaries, because the arguments
  18662. + * might also be negative. If a given position is out of
  18663. + * bounds, the cursor is placed at the nearest margin.
  18664. + */
  18665. +static void gotoxy (const struct vt * const vt, int new_x, int new_y)
  18666. +{
  18667. +    struct con_struct *vcd = vt->vcd;
  18668. +    int min_y, max_y;
  18669. +
  18670. +    if (new_x < 0)
  18671. +    vcd->curstate.x = 0;
  18672. +    else
  18673. +    if (new_x >= vtdata.numcolumns)
  18674. +    vcd->curstate.x = vtdata.numcolumns - 1;
  18675. +    else
  18676. +    vcd->curstate.x = new_x;
  18677. +
  18678. +    if (vcd->decom) {
  18679. +    new_y += vcd->top;
  18680. +    min_y = vcd->top;
  18681. +    max_y = vcd->bottom;
  18682. +    } else {
  18683. +    min_y = 0;
  18684. +    max_y = vtdata.numrows;
  18685. +    }
  18686. +
  18687. +    if (new_y < min_y)
  18688. +    vcd->curstate.y = min_y;
  18689. +    else if (new_y >= max_y)
  18690. +    vcd->curstate.y = max_y - 1;
  18691. +    else
  18692. +    vcd->curstate.y = new_y;
  18693. +
  18694. +    vcd->screen.pos = vcd->screen.origin +
  18695. +            vcd->curstate.y * vtdata.screen.sizerow +
  18696. +            vcd->curstate.x * vtdata.screen.bytespercharh;
  18697. +    vcd->buffer.pos = vcd->curstate.y * vtdata.buffer.sizerow +
  18698. +                vcd->curstate.x;
  18699. +    vcd->need_wrap = 0;
  18700. +#ifdef DEBUG
  18701. +    vcd_validate (vcd, "gotoxy");
  18702. +#endif
  18703. +}
  18704. +
  18705. +/* for absolute user moves, when decom is set */
  18706. +static void gotoxay (const struct vt * const vt, int new_x, int new_y)
  18707. +{
  18708. +    gotoxy(vt, new_x, vt->vcd->decom ? (vt->vcd->top+new_y) : new_y);
  18709. +}
  18710. +
  18711. +/* --------------------------------------------------------------------------------
  18712. + * Screen scrolling
  18713. + * -------------------------------------------------------------------------------- */
  18714. +
  18715. +static void scrollup (const struct vt * const vt, unsigned int t, unsigned int b, unsigned int l)
  18716. +{
  18717. +    struct con_struct *vcd = vt->vcd;
  18718. +    int old_top, new_top, old_end, new_end, displayed;
  18719. +
  18720. +    if (b > vtdata.numrows || t >= b || l == 0)
  18721. +    return;
  18722. +
  18723. +    displayed = vtdata.fgconsole == vt;
  18724. +
  18725. +    if (t == 0 && b == vtdata.numrows && displayed) {
  18726. +    /*
  18727. +     * we can hardware scroll...
  18728. +     */
  18729. +    memsetl ((void *)(vcd->screen.origin + vtdata.screen.sizerow * vtdata.numrows),
  18730. +        vcd->cached_backcolwrd, l * vtdata.screen.sizerow);
  18731. +
  18732. +    vcd->screen.pos -= vcd->screen.origin;
  18733. +    vcd->screen.origin += l * vtdata.screen.sizerow;
  18734. +    if (vcd->screen.origin >= vtdata.screen.memend)
  18735. +        vcd->screen.origin = vcd->screen.origin - vtdata.screen.memend + vtdata.screen.memstart;
  18736. +    vcd->screen.pos += vcd->screen.origin;
  18737. +    set_origin (vt);
  18738. +    displayed = 0;
  18739. +    }
  18740. +    
  18741. +    old_top = t;
  18742. +    new_top = old_top + l;
  18743. +    old_end = b - l;
  18744. +    new_end = b;
  18745. +
  18746. +    if (new_top < new_end) { /* we have something to move */
  18747. +    memmove (vcd->buffer.buffer + old_top * vtdata.buffer.sizerow,
  18748. +         vcd->buffer.buffer + new_top * vtdata.buffer.sizerow,
  18749. +         (new_end - new_top) * vtdata.buffer.sizerow * 4);
  18750. +
  18751. +    if (displayed)
  18752. +        memmove ((void *)(vcd->screen.origin + old_top * vtdata.screen.sizerow),
  18753. +             (void *)(vcd->screen.origin + new_top * vtdata.screen.sizerow),
  18754. +             (new_end - new_top) * vtdata.screen.sizerow);
  18755. +    }
  18756. +
  18757. +    if (old_end < new_end) {
  18758. +    if (old_end < old_top)
  18759. +        old_end = old_top;
  18760. +    memsetl (vcd->buffer.buffer + old_end * vtdata.buffer.sizerow,
  18761. +            vcd->combined_state | 32, (new_end - old_end) * vtdata.buffer.sizerow * 4);
  18762. +
  18763. +    if (displayed)
  18764. +        memsetl ((void *)(vcd->screen.origin + old_end * vtdata.screen.sizerow),
  18765. +            vcd->cached_backcolwrd, (new_end - old_end) * vtdata.screen.sizerow);
  18766. +    }
  18767. +}
  18768. +
  18769. +static void scrolldown (const struct vt * const vt, unsigned int t, unsigned int b, unsigned int l)
  18770. +{
  18771. +    struct con_struct *vcd = vt->vcd;
  18772. +    int old_top, new_top, old_end, new_end, displayed;
  18773. +
  18774. +    if (b > vtdata.numrows || t >= b)
  18775. +    return;
  18776. +
  18777. +    displayed = vtdata.fgconsole == vt;
  18778. +
  18779. +    if (t == 0 && b == vtdata.numrows && displayed) {
  18780. +    /*
  18781. +     * we can hardware scroll...
  18782. +     */
  18783. +    vcd->screen.pos -= vcd->screen.origin;
  18784. +    vcd->screen.origin -= l * vtdata.screen.sizerow;
  18785. +    if (vcd->screen.origin < vtdata.screen.memstart)
  18786. +        vcd->screen.origin = vcd->screen.origin - vtdata.screen.memstart + vtdata.screen.memend;
  18787. +    vcd->screen.pos += vcd->screen.origin;
  18788. +    memsetl ((void *)vcd->screen.origin, vcd->cached_backcolwrd, l * vtdata.screen.sizerow);
  18789. +    set_origin (vt);
  18790. +    displayed = 0;
  18791. +    }
  18792. +
  18793. +    new_top = t;
  18794. +    old_top = new_top + l;
  18795. +    new_end = b - l;
  18796. +    old_end = b;
  18797. +
  18798. +    if (new_top < new_end) { /* we have something to move */
  18799. +    memmove (vcd->buffer.buffer + old_top * vtdata.buffer.sizerow,
  18800. +         vcd->buffer.buffer + new_top * vtdata.buffer.sizerow,
  18801. +         (new_end - new_top) * vtdata.buffer.sizerow * 4);
  18802. +
  18803. +    if (displayed)
  18804. +        memmove ((void *)(vcd->screen.origin + old_top * vtdata.screen.sizerow),
  18805. +             (void *)(vcd->screen.origin + new_top * vtdata.screen.sizerow),
  18806. +             (new_end - new_top) * vtdata.screen.sizerow);
  18807. +    }
  18808. +
  18809. +    if (new_top < old_top) { /* we have something to clear */
  18810. +    if (old_top > old_end)
  18811. +        old_top = old_end;
  18812. +    memsetl (vcd->buffer.buffer + new_top * vtdata.buffer.sizerow,
  18813. +            vcd->combined_state | 32, (old_top - new_top) * vtdata.buffer.sizerow * 4);
  18814. +
  18815. +    if (displayed)
  18816. +        memsetl ((void *)(vcd->screen.origin + new_top * vtdata.screen.sizerow),
  18817. +                vcd->cached_backcolwrd, (old_top - new_top) * vtdata.screen.sizerow);
  18818. +    }
  18819. +}
  18820. +
  18821. +static void csi_J (const struct vt * const vt, int vpar)
  18822. +{
  18823. +    unsigned char endx, endy;
  18824. +    unsigned char startx, starty;
  18825. +
  18826. +    switch (vpar) {
  18827. +    case 0: /* erase from cursor to bottom of screen (including char at (x, y) */
  18828. +    startx = vt->vcd->curstate.x;
  18829. +    starty = vt->vcd->curstate.y;
  18830. +    endx   = vtdata.numcolumns - 1;
  18831. +    endy   = vtdata.numrows - 1;
  18832. +    break;
  18833. +    case 1: /* erase from top of screen to cursor (including char at (x, y) */
  18834. +    startx = 0;
  18835. +    starty = 0;
  18836. +    endx   = vt->vcd->curstate.x;
  18837. +    endy   = vt->vcd->curstate.y;
  18838. +    break;
  18839. +    case 2: /* erase entire screen */
  18840. +    startx = 0;
  18841. +    starty = 0;
  18842. +    endx   = vtdata.numcolumns - 1;
  18843. +    endy   = vtdata.numrows - 1;
  18844. +#if TODO
  18845. +    origin = video_mem_base;
  18846. +    set_origin (currcons);
  18847. +    gotoxy (currcons, x, y);
  18848. +#endif
  18849. +    break;
  18850. +    default:
  18851. +    return;
  18852. +    }
  18853. +    ll_erase (vt, startx, starty, endx, endy);
  18854. +    /*vt->vcd->need_wrap = 0; why? We don't move the cursor... */
  18855. +}
  18856. +
  18857. +static void csi_K (const struct vt * const vt, int vpar)
  18858. +{
  18859. +    unsigned char endx;
  18860. +    unsigned char startx;
  18861. +
  18862. +    switch(vpar) {
  18863. +    case 0: /* erase from cursor to end of line */
  18864. +    startx = vt->vcd->curstate.x;
  18865. +    endx   = vtdata.numcolumns - 1;
  18866. +    break;
  18867. +    case 1: /* erase from beginning of line to cursor */
  18868. +    startx = 0;
  18869. +    endx   = vt->vcd->curstate.x;
  18870. +    break;
  18871. +    case 2: /* erase entire line */
  18872. +    startx = 0;
  18873. +    endx   = vtdata.numcolumns - 1;
  18874. +    break;
  18875. +    default:
  18876. +    return;
  18877. +    }
  18878. +    ll_erase (vt, startx, vt->vcd->curstate.y, endx, vt->vcd->curstate.y);
  18879. +    /*vt->vcd->need_wrap = 0; why? We don't move the cursor... */
  18880. +}
  18881. +
  18882. +static void csi_X (const struct vt * const vt, int vpar) /* erase the following vpar positions */
  18883. +{                             /* not vt100? */
  18884. +    unsigned char countx, county;
  18885. +    unsigned char startx, starty;
  18886. +
  18887. +    if (!vpar)
  18888. +    vpar++;
  18889. +
  18890. +    startx = vt->vcd->curstate.x;
  18891. +    starty = vt->vcd->curstate.y;
  18892. +    countx = 0;
  18893. +    county = 0;
  18894. +#if TODO
  18895. +    ll_erase(currcons,startx,starty,countx,county);
  18896. +#endif
  18897. +    /*vt->vcd->need_wrap = 0; why? We don't move the cursor... */
  18898. +}
  18899. +
  18900. +static void update_attr (const struct vt * const vt)
  18901. +{
  18902. +    vt->vcd->combined_state = (vt->vcd->curstate.flags << 24) |
  18903. +                  (vt->vcd->curstate.backcol << 16) |
  18904. +                  (vt->vcd->curstate.forecol << 8);
  18905. +    switch (vtdata.screen.bitsperpix) {
  18906. +    case 1:
  18907. +    vt->vcd->cached_backcolwrd = 0;
  18908. +    break;
  18909. +    default:
  18910. +    case 4:
  18911. +    vt->vcd->cached_backcolwrd = 0x11111111 * vt->vcd->curstate.backcol;
  18912. +    break;
  18913. +    case 8:
  18914. +    vt->vcd->cached_backcolwrd = 0x01010101 * vt->vcd->curstate.backcol;
  18915. +    break;
  18916. +    }
  18917. +}
  18918. +
  18919. +static void default_attr (const struct vt * const vt)
  18920. +{
  18921. +    vt->vcd->curstate.flags &= ~(FLG_INVERSE|FLG_FLASH|FLG_UNDERLINE|FLG_ITALIC|FLG_BOLD);
  18922. +    vt->vcd->curstate.forecol = vt->vcd->def_forecol;
  18923. +    vt->vcd->curstate.backcol = vt->vcd->def_backcol;
  18924. +}
  18925. +
  18926. +static int csi_m (const struct vt * const vt)
  18927. +{
  18928. +    struct con_struct *vcd = vt->vcd;
  18929. +    int i;
  18930. +
  18931. +    for (i = 0; i <= vcd->npar; i++) {
  18932. +    switch (vcd->par[i]) {
  18933. +    case 0:
  18934. +        default_attr (vt);
  18935. +        break;
  18936. +    case 1:
  18937. +        vcd->curstate.flags |= FLG_BOLD;
  18938. +        break;    /* Bold */
  18939. +    case 2:
  18940. +        vcd->curstate.flags &= ~FLG_BOLD;
  18941. +        break;    /* Feint */
  18942. +    case 3:
  18943. +        vcd->curstate.flags |= FLG_ITALIC;
  18944. +        break;    /* Italic */
  18945. +    case 4:
  18946. +        vcd->curstate.flags |= FLG_UNDERLINE;
  18947. +        break;    /* Underline */
  18948. +    case 5:
  18949. +    case 6:
  18950. +        vcd->curstate.flags |= FLG_FLASH;
  18951. +        break;    /* Flash */
  18952. +    case 7:
  18953. +        vcd->curstate.flags |= FLG_INVERSE;
  18954. +        break;    /* Inverse chars */
  18955. +
  18956. +    case 10:
  18957. +        /* ANSI X3.64-1979 (SCO-ish?)
  18958. +         * Select primary font, don't display
  18959. +         * control chars if defined, don't set
  18960. +         * bit 8 on output.
  18961. +         */
  18962. +        vcd->translate = set_translate(vcd->curstate.flags & FLG_CHRSET
  18963. +                ? vcd->curstate.G1_charset
  18964. +                : vcd->curstate.G0_charset);
  18965. +        vcd->disp_ctrl = 0;
  18966. +        vcd->toggle_meta = 0;
  18967. +        return 1;
  18968. +    case 11:
  18969. +        /* ANSI X3.64-1979 (SCO-ish?)
  18970. +         * Select first alternate font, let's
  18971. +         * chars < 32 be displayed as ROM chars.
  18972. +         */
  18973. +        vcd->translate = set_translate(IBMPC_MAP);
  18974. +        vcd->disp_ctrl = 1;
  18975. +        vcd->toggle_meta = 0;
  18976. +        return 1;
  18977. +    case 12:
  18978. +        /* ANSI X3.64-1979 (SCO-ish?)
  18979. +         * Select second alternate font, toggle
  18980. +         * high bit before displaying as ROM char.
  18981. +         */
  18982. +        vcd->translate = set_translate(IBMPC_MAP);
  18983. +        vcd->disp_ctrl = 1;
  18984. +        vcd->toggle_meta = 1;
  18985. +        return 1;
  18986. +    case 21:
  18987. +    case 22:
  18988. +        vcd->curstate.flags &= ~FLG_BOLD;
  18989. +        break;
  18990. +    case 24:
  18991. +        vcd->curstate.flags &= ~FLG_UNDERLINE;
  18992. +        break;
  18993. +    case 25:
  18994. +        vcd->curstate.flags &= ~FLG_FLASH;
  18995. +        break;
  18996. +    case 27:
  18997. +        vcd->curstate.flags &= ~FLG_INVERSE;
  18998. +        break;
  18999. +    case 30:
  19000. +    case 31:
  19001. +    case 32:
  19002. +    case 33:
  19003. +    case 34:
  19004. +    case 35:
  19005. +    case 36:
  19006. +    case 37:
  19007. +        vcd->curstate.forecol = color_table[vcd->par[i]-30];
  19008. +        break;                        /* Foreground colour */
  19009. +    case 38:
  19010. +        vcd->curstate.forecol = vcd->def_forecol;
  19011. +        vcd->curstate.flags &= ~FLG_UNDERLINE;
  19012. +        break;
  19013. +    case 39:
  19014. +        vcd->curstate.forecol = vcd->def_forecol;
  19015. +        vcd->curstate.flags &= ~FLG_UNDERLINE;
  19016. +        break;                        /* Default foreground colour */
  19017. +    case 40:
  19018. +    case 41:
  19019. +    case 42:
  19020. +    case 43:
  19021. +    case 44:
  19022. +    case 45:
  19023. +    case 46:
  19024. +    case 47:
  19025. +        vcd->curstate.backcol = color_table[vcd->par[i]-40];
  19026. +        break;                        /* Background colour */
  19027. +    case 49:
  19028. +        vcd->curstate.backcol = vcd->def_backcol;
  19029. +        break;                        /* Default background colour */
  19030. +    }
  19031. +    }
  19032. +    update_attr (vt);
  19033. +    return 0;
  19034. +}
  19035. +
  19036. +static void respond_string (char *p, struct tty_struct *tty)
  19037. +{
  19038. +    while (*p)
  19039. +    tty_insert_flip_char (tty, *p++, 0);
  19040. +    tty_schedule_flip (tty);
  19041. +}
  19042. +
  19043. +static void cursor_report (const struct vt *vt)
  19044. +{
  19045. +    char buf[40];
  19046. +
  19047. +    sprintf (buf, "\033[%d;%dR", vt->vcd->curstate.y + (vt->vcd->decom ? vt->vcd->top + 1 : 1),
  19048. +                     vt->vcd->curstate.x + 1);
  19049. +    respond_string (buf, *vt->tty);
  19050. +}
  19051. +
  19052. +static void status_report (struct tty_struct *tty)
  19053. +{
  19054. +    respond_string ("\033[0n", tty);
  19055. +}
  19056. +
  19057. +static void respond_ID (struct tty_struct *tty)
  19058. +{
  19059. +    respond_string(VT102ID, tty);
  19060. +}
  19061. +
  19062. +void mouse_report (struct tty_struct *tty, int butt, int mrx, int mry)
  19063. +{
  19064. +    char buf[8];
  19065. +
  19066. +    sprintf (buf,"\033[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
  19067. +    (char)('!'+mry));
  19068. +    respond_string(buf, tty);
  19069. +}
  19070. +
  19071. +/* invoked by ioctl(TIOCLINUX) */
  19072. +int mouse_reporting (void)
  19073. +{
  19074. +    return vtdata.fgconsole->vcd->report_mouse;
  19075. +}
  19076. +
  19077. +static inline unsigned long *bufferpos (const struct vt * const vt, int offset)
  19078. +{
  19079. +    return vt->vcd->buffer.buffer + offset;
  19080. +}
  19081. +
  19082. +static inline unsigned long screenpos (const struct vt * const vt, int offset)
  19083. +{
  19084. +    int hx, hy;
  19085. +
  19086. +    hx = offset % vtdata.numcolumns;
  19087. +    hy = offset / vtdata.numcolumns;
  19088. +    return vt->vcd->screen.origin + hy * vtdata.screen.sizerow + hx * vtdata.screen.bytespercharh;
  19089. +}
  19090. +
  19091. +void invert_screen (const struct vt * const vt, int offset, int count)
  19092. +{
  19093. +    int i;
  19094. +    unsigned long *buffer = vt->vcd->buffer.buffer + offset;
  19095. +    unsigned long p, pp;
  19096. +
  19097. +    for (i = 0; i <= count; i++)
  19098. +    buffer[i] ^= FLG_INVERSE << 24;
  19099. +
  19100. +    if (vt == vtdata.fgconsole) {
  19101. +    int hx, hy, hex, hey;
  19102. +
  19103. +    hx = offset % vtdata.numcolumns;
  19104. +    hy = offset / vtdata.numcolumns;
  19105. +    hex = (offset + count) % vtdata.numcolumns;
  19106. +    hey = (offset + count) / vtdata.numcolumns;
  19107. +
  19108. +    p = vt->vcd->screen.origin + hy * vtdata.screen.sizerow;
  19109. +    for (;hy <= hey; hy ++) {
  19110. +        pp = p + hx * vtdata.screen.bytespercharh;
  19111. +        for (; hx < ((hy == hey) ? hex + 1 : vtdata.numcolumns); hx ++) {
  19112. +        ll_write_char (pp, *buffer++);
  19113. +        pp += vtdata.screen.bytespercharh;
  19114. +        }
  19115. +        hx = 0;
  19116. +        p += vtdata.screen.sizerow;
  19117. +    }    
  19118. +    }
  19119. +}
  19120. +
  19121. +void complement_pos (const struct vt * const vt, int offset)
  19122. +{
  19123. +    static unsigned long p = 0;
  19124. +    static unsigned long old = 0;
  19125. +    unsigned long complement = 0;
  19126. +
  19127. +    switch (vtdata.screen.bitsperpix) {
  19128. +    case 4:
  19129. +    complement = 0x00070700;
  19130. +    break;
  19131. +    case 8:
  19132. +    complement = 0x00fcfc00;
  19133. +    break;
  19134. +    }
  19135. +
  19136. +    if (p)
  19137. +    ll_write_char (p, old);
  19138. +    if (offset == -1)
  19139. +    p = 0;
  19140. +    else {
  19141. +    p = screenpos (vt, offset);
  19142. +    old = vt->vcd->buffer.buffer[offset];
  19143. +    ll_write_char (p, old ^ complement);
  19144. +    }
  19145. +}
  19146. +
  19147. +unsigned long screen_word (const struct vt * const vt, int offset)
  19148. +{
  19149. +    return *bufferpos (vt, offset);
  19150. +}
  19151. +
  19152. +int scrw2glyph (unsigned long scr_word)
  19153. +{
  19154. +    return scr_word & 255;
  19155. +}
  19156. +
  19157. +unsigned long *screen_pos (const struct vt * const vt, int offset)
  19158. +{
  19159. +    return bufferpos (vt, offset);
  19160. +}
  19161. +
  19162. +void getconsxy (const struct vt * const vt, char *p)
  19163. +{
  19164. +    p[0] = vt->vcd->curstate.x;
  19165. +    p[1] = vt->vcd->curstate.y;
  19166. +}
  19167. +
  19168. +void putconsxy (const struct vt * const vt, char *p)
  19169. +{
  19170. +    gotoxy (vt, p[0], p[1]);
  19171. +    set_cursor (vt);
  19172. +}
  19173. +
  19174. +static void set_mode (const struct vt * const vt, int on_off)
  19175. +{
  19176. +    struct con_struct *vcd = vt->vcd;
  19177. +    int i;
  19178. +
  19179. +    for (i = 0; i <= vcd->npar; i++)
  19180. +    if (vcd->ques)
  19181. +        switch(vcd->par[i]) {    /* DEC private modes set/reset */
  19182. +        case 1:            /* Cursor keys send ^[Ox/^[[x */
  19183. +        if (on_off)
  19184. +            set_kbd(decckm);
  19185. +        else
  19186. +            clr_kbd(decckm);
  19187. +        break;
  19188. +        case 3:         /* 80/132 mode switch unimplemented */
  19189. +        vcd->deccolm = on_off;
  19190. +        csi_J (vt, 2);
  19191. +        gotoxy (vt, 0, 0);
  19192. +        break;
  19193. +        case 5:        /* Inverted screen on/off */
  19194. +        if (vcd->decscnm != on_off) {
  19195. +            vcd->decscnm = on_off;
  19196. +            invert_screen (vt, 0, vtdata.screen.totsize);
  19197. +            update_attr (vt);
  19198. +        }
  19199. +        break;
  19200. +        case 6:        /* Origin relative/absolute */
  19201. +        vcd->decom = on_off;
  19202. +        gotoxay (vt, 0, 0);
  19203. +        break;
  19204. +        case 7:        /* Autowrap on/off */
  19205. +        vcd->decawm = on_off;
  19206. +        break;
  19207. +        case 8:        /* Autorepeat on/off */
  19208. +        if (on_off)
  19209. +            set_kbd(decarm);
  19210. +        else
  19211. +            clr_kbd(decarm);
  19212. +        break;
  19213. +        case 9:
  19214. +        vcd->report_mouse = on_off ? 1 : 0;
  19215. +        break;
  19216. +        case 25:        /* Cursor on/off */
  19217. +        vcd->deccm = on_off;
  19218. +        set_cursor (vt);
  19219. +        break;
  19220. +        case 1000:
  19221. +        vcd->report_mouse = on_off ? 2 : 0;
  19222. +        break;
  19223. +        }
  19224. +    else
  19225. +        switch(vcd->par[i]) {    /* ANSI modes set/reset */
  19226. +        case 3:            /* Monitor (display ctrls) */
  19227. +        vcd->disp_ctrl = on_off;
  19228. +        break;
  19229. +        case 4:            /* Insert mode on/off */
  19230. +        vcd->decim = on_off;
  19231. +        break;
  19232. +        case 20:            /* Lf, Enter = CrLf/Lf */
  19233. +        if (on_off)
  19234. +            set_kbd(lnm);
  19235. +        else
  19236. +            clr_kbd(lnm);
  19237. +        break;
  19238. +        }
  19239. +}
  19240. +
  19241. +static void setterm_command (const struct vt * const vt)
  19242. +{
  19243. +    switch (vt->vcd->par[0]) {
  19244. +    case 1: /* Set colour for underline mode (implemented as an underline) */
  19245. +    break;
  19246. +    case 2: /* set colour for half intensity mode (implemented as half) */
  19247. +    break;
  19248. +    case 8:
  19249. +    vt->vcd->def_forecol = vt->vcd->curstate.forecol;
  19250. +    vt->vcd->def_backcol = vt->vcd->curstate.backcol;
  19251. +    break;
  19252. +    case 9:
  19253. +    vtdata.screen.blankinterval = ((vt->vcd->par[1] < 60) ? vt->vcd->par[1] : 60) * 60 * HZ;
  19254. +    vt_pokeblankedconsole ();
  19255. +    break;
  19256. +    }
  19257. +}
  19258. +
  19259. +static void insert_char (const struct vt * const vt)
  19260. +{
  19261. +    register unsigned char *c,*cc;
  19262. +    register unsigned int row;
  19263. +    register int mcol, bpr, n = 1;
  19264. +
  19265. +    /*
  19266. +     * Should really convert this to memmoves...
  19267. +     */
  19268. +    if (vtdata.fgconsole == vt) {
  19269. +    c = (unsigned char *)vt->vcd->screen.pos;
  19270. +    cc = (unsigned char *)c + vtdata.screen.bytespercharh * n;
  19271. +    mcol = (vtdata.numcolumns - vt->vcd->curstate.x - n) * vtdata.screen.bytespercharh - 1;
  19272. +    bpr = vtdata.numcolumns * vtdata.screen.bytespercharh;
  19273. +
  19274. +    for (row = vtdata.screen.bytespercharv; row > 0; row --) {
  19275. +        register int col;
  19276. +        for(col = mcol; col >= 0; col--)
  19277. +        cc[col] = c[col];
  19278. +        for (col = n * vtdata.screen.bytespercharh - 1; col >= 0; col --)
  19279. +        c[col] = 0x11 * vt->vcd->curstate.backcol;
  19280. +        c += bpr;
  19281. +        cc += bpr;
  19282. +    }
  19283. +    }
  19284. +
  19285. +    if (vt->vcd->curstate.x < vtdata.numcolumns - n)
  19286. +    memmove ((void *)vt->vcd->buffer.buffer + (vt->vcd->curstate.y * vtdata.numcolumns + vt->vcd->curstate.x + n),
  19287. +         (void *)vt->vcd->buffer.buffer + (vt->vcd->curstate.y * vtdata.numcolumns + vt->vcd->curstate.x),
  19288. +         (vtdata.numcolumns - vt->vcd->curstate.x - n) * 4);
  19289. +    memsetl ((void *)vt->vcd->buffer.buffer + (vt->vcd->curstate.y * vtdata.numcolumns + vt->vcd->curstate.x),
  19290. +        vt->vcd->combined_state | 32, n * 4);
  19291. +}
  19292. +
  19293. +static inline void insert_line (const struct vt * const vt, int n)
  19294. +{
  19295. +    scrolldown (vt, vt->vcd->curstate.y, vt->vcd->bottom, n);
  19296. +/*  vt->vcd->need_wrap = 0; why? We haven't moved the cursor. */
  19297. +}
  19298. +
  19299. +static void delete_char (const struct vt * const vt)
  19300. +{
  19301. +    register unsigned char *c, *cc;
  19302. +    register unsigned int  row;
  19303. +    register int mcol, bpr, n = 1;
  19304. +
  19305. +    /*
  19306. +     * Should really convert this to memmoves...
  19307. +     */
  19308. +    if (vtdata.fgconsole == vt) {
  19309. +    c = (unsigned char *)vt->vcd->screen.pos;
  19310. +    cc = (unsigned char *)c + vtdata.screen.bytespercharh * n;
  19311. +    mcol = vtdata.screen.bytespercharh * (vtdata.numcolumns - vt->vcd->curstate.x - n);
  19312. +    bpr = vtdata.numcolumns * vtdata.screen.bytespercharh;
  19313. +
  19314. +    for (row = vtdata.screen.bytespercharv; row > 0; row --) {
  19315. +        register int col;
  19316. +        
  19317. +        for (col = 0; col < mcol; col++)
  19318. +        c[col] = cc[col];
  19319. +        for (; col < mcol + n * vtdata.screen.bytespercharh - 1; col ++)
  19320. +        c[col] = 0x11 * vt->vcd->curstate.backcol;
  19321. +        c += bpr;
  19322. +        cc += bpr;
  19323. +    }
  19324. +    }
  19325. +
  19326. +    if (vt->vcd->curstate.x != vtdata.numcolumns - 1)
  19327. +    memmove ((void *)vt->vcd->buffer.buffer + (vt->vcd->curstate.y * vtdata.numcolumns + vt->vcd->curstate.x),
  19328. +         (void *)vt->vcd->buffer.buffer + (vt->vcd->curstate.y * vtdata.numcolumns + vt->vcd->curstate.x + n),
  19329. +         (vtdata.numcolumns - vt->vcd->curstate.x - n) * 4);
  19330. +    memsetl ((void *)vt->vcd->buffer.buffer + ((vt->vcd->curstate.y + 1) * vtdata.numcolumns - n),
  19331. +            vt->vcd->combined_state | 32, n * 4);
  19332. +}
  19333. +
  19334. +static void delete_line (const struct vt * const vt, int n)
  19335. +{
  19336. +    scrollup (vt, vt->vcd->curstate.y, vt->vcd->bottom, n);
  19337. +/*  vt->vcd->need_wrap = 0; why? we haven't moved the cursor. */
  19338. +}
  19339. +
  19340. +static void csi_at (const struct vt * const vt, int nr)
  19341. +{
  19342. +    if (nr > vtdata.numcolumns - vt->vcd->curstate.x)
  19343. +    nr = vtdata.numcolumns - vt->vcd->curstate.x;
  19344. +    else
  19345. +    if (!nr)
  19346. +    nr = 1;
  19347. +    while (nr--)
  19348. +    insert_char (vt);
  19349. +}
  19350. +
  19351. +static void csi_L (const struct vt * const vt, int nr)
  19352. +{
  19353. +    if (nr > vtdata.numrows - vt->vcd->curstate.y)
  19354. +    nr = vtdata.numrows - vt->vcd->curstate.y;
  19355. +    else
  19356. +    if (!nr)
  19357. +    nr = 1;
  19358. +    insert_line (vt, nr);
  19359. +}
  19360. +
  19361. +static void csi_P (const struct vt * const vt, int nr)
  19362. +{
  19363. +    if (nr > vtdata.numcolumns)
  19364. +    nr = vtdata.numcolumns;
  19365. +    else
  19366. +    if (!nr)
  19367. +    nr = 1;
  19368. +    while (nr--)
  19369. +    delete_char (vt);
  19370. +}
  19371. +
  19372. +static void csi_M (const struct vt * const vt, int nr)
  19373. +{
  19374. +    if (nr > vtdata.numrows)
  19375. +    nr = vtdata.numrows;
  19376. +    else
  19377. +    if (!nr)
  19378. +    nr = 1;
  19379. +    delete_line (vt, nr);
  19380. +}
  19381. +
  19382. +enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
  19383. +    EShash, ESsetG0, ESsetG1, ESpercent, ESignore, ESnonstd,
  19384. +    ESpalette };
  19385. +
  19386. +static void reset_terminal (const struct vt * const vt, int initialising)
  19387. +{
  19388. +    struct con_struct *vcd;
  19389. +
  19390. +    vcd = vt->vcd;
  19391. +
  19392. +    vcd->top            = 0;
  19393. +    vcd->bottom            = vtdata.numrows;
  19394. +    vcd->state            = ESnormal;
  19395. +    vcd->ques            = 0;
  19396. +    vcd->translate        = set_translate (LAT1_MAP);
  19397. +    vcd->curstate.G0_charset    = LAT1_MAP;
  19398. +    vcd->curstate.G1_charset    = GRAF_MAP;
  19399. +    vcd->curstate.flags        = 0;
  19400. +    vcd->need_wrap        = 0;
  19401. +    vcd->report_mouse        = 0;
  19402. +    vcd->utf            = 0;
  19403. +    vcd->utf_count        = 0;
  19404. +    vcd->disp_ctrl        = 0;
  19405. +    vcd->toggle_meta        = 0;
  19406. +    vcd->decscnm        = 0;
  19407. +    vcd->decom            = 0;
  19408. +    vcd->decawm            = 1;
  19409. +    vcd->deccm            = 1;
  19410. +    vcd->decim            = 0;
  19411. +    vcd->curstate.forecol    = color_table[7];
  19412. +    vcd->curstate.backcol    = color_table[0];
  19413. +    vcd->def_forecol        = color_table[7];
  19414. +    vcd->def_backcol        = color_table[0];
  19415. +    vcd->tab_stop[0]        = 0x01010100;
  19416. +    vcd->tab_stop[1]        =
  19417. +    vcd->tab_stop[2]        =
  19418. +    vcd->tab_stop[3]        =
  19419. +    vcd->tab_stop[4]        = 0x01010101;
  19420. +
  19421. +    set_kbd (decarm);
  19422. +    clr_kbd (decckm);
  19423. +    clr_kbd(kbdapplic);
  19424. +    clr_kbd(lnm);
  19425. +
  19426. +    vt->kbd->lockstate        = 0;
  19427. +    vt->kbd->ledmode        = LED_SHOW_FLAGS;
  19428. +    vt->kbd->ledflagstate    = vt->kbd->default_ledflagstate;
  19429. +    if (!initialising)
  19430. +    set_leds ();
  19431. +
  19432. +    if (vcd->screen.palette_entries) {
  19433. +    kfree (vcd->screen.palette_entries);
  19434. +    vcd->screen.palette_entries = 0;
  19435. +    }
  19436. +
  19437. +    gotoxy (vt, 0, 0);
  19438. +    vcd->savedstate = vcd->curstate;
  19439. +    update_attr (vt);
  19440. +
  19441. +    if (!initialising)
  19442. +    csi_J (vt, 2);
  19443. +}
  19444. +
  19445. +void console_print(const char *b)
  19446. +{
  19447. +    static int printing = 0;
  19448. +    struct vt *vt = vtdata.fgconsole;
  19449. +    struct con_struct * const vcd = vt->vcd;
  19450. +    unsigned long character, bufpos;
  19451. +    unsigned char c;
  19452. +
  19453. +#ifdef DEBUG
  19454. +    vcd_validate (vcd, "console_print entry");
  19455. +#endif
  19456. +
  19457. +    if (!printable || printing || vt->vtd->vc_mode == KD_GRAPHICS)
  19458. +    return;  /* console not yet initialized */
  19459. +    printing = 1;
  19460. +
  19461. +    if (!vt_allocated(vtdata.fgconsole)) {
  19462. +    /* impossible */
  19463. +      printk ("console_print: tty %d not allocated ??\n", vtdata.fgconsole->num);
  19464. +      printing = 0;
  19465. +      return;
  19466. +    }
  19467. +
  19468. +#ifdef CONFIG_SERIAL_ECHO
  19469. +    serial_echo_print (b);
  19470. +#endif
  19471. +
  19472. +    vcd_removecursors (vt);
  19473. +    bufpos = vcd->buffer.pos;
  19474. +
  19475. +    while ((c = *b++) != 0) {
  19476. +    if (c == 10 || c == 13 || vcd->need_wrap) {
  19477. +        vcd->screen.pos -= vcd->curstate.x * vtdata.screen.bytespercharh;
  19478. +        bufpos -= vcd->curstate.x;
  19479. +
  19480. +        vcd->need_wrap = vcd->curstate.x = 0;
  19481. +
  19482. +        if (vcd->curstate.y + 1 == vcd->bottom)
  19483. +        scrollup (vt, vt->vcd->top, vt->vcd->bottom, 1);
  19484. +        else
  19485. +        if (vcd->curstate.y < vtdata.numrows - 1) {
  19486. +        vcd->curstate.y ++;
  19487. +        vcd->screen.pos += vtdata.screen.sizerow;
  19488. +        bufpos += vtdata.buffer.sizerow;
  19489. +        }
  19490. +        if (c == 10 || c == 13)
  19491. +        continue;
  19492. +    }
  19493. +
  19494. +    vcd->buffer.buffer[bufpos] = character = vcd->combined_state | (c & 255);
  19495. +    ll_write_char (vcd->screen.pos, character);
  19496. +
  19497. +    if (vcd->curstate.x == vtdata.numcolumns - 1) {
  19498. +        vcd->need_wrap = 1;
  19499. +        continue;
  19500. +    }
  19501. +    vcd->curstate.x++;
  19502. +    vcd->screen.pos += vtdata.screen.bytespercharh;
  19503. +    bufpos ++;
  19504. +    }
  19505. +    vcd->buffer.pos = bufpos;
  19506. +    set_cursor (vt);
  19507. +    vcd_restorecursors (vt);
  19508. +
  19509. +    vt_pokeblankedconsole ();
  19510. +    printing = 0;
  19511. +#ifdef DEBUG
  19512. +    vcd_validate (vt->vcd, "console_print exit");
  19513. +#endif
  19514. +}
  19515. +#if 0
  19516. +static void con_setsize (unsigned long rows, unsigned long cols)
  19517. +{
  19518. +    vtdata.numcolumns     = cols;
  19519. +    vtdata.numrows        = rows;
  19520. +    vtdata.screen.sizerow = cols * vtdata.screen.bytespercharh * vtdata.screen.bytespercharv;
  19521. +    vtdata.screen.totsize = vtdata.screen.sizerow * rows;
  19522. +    vtdata.buffer.sizerow = cols;
  19523. +    vtdata.buffer.totsize = vtdata.buffer.sizerow * rows;
  19524. +}
  19525. +#endif
  19526. +
  19527. +void update_scrmem (const struct vt * const vt, int start, int length)
  19528. +{
  19529. +    unsigned long p, pp, sx, sy, ex, ey;
  19530. +    unsigned long *buffer;
  19531. +
  19532. +    sy = start / vtdata.numcolumns;
  19533. +    sx = start % vtdata.numcolumns;
  19534. +    length += start;
  19535. +    ey = length / vtdata.numcolumns;
  19536. +    ex = length % vtdata.numcolumns;
  19537. +
  19538. +    if (ey > vtdata.numrows)
  19539. +    ey = vtdata.numrows;
  19540. +
  19541. +    p = vt->vcd->screen.origin + sy * vtdata.screen.sizerow;
  19542. +    buffer = vt->vcd->buffer.buffer + start;
  19543. +
  19544. +    if (ey > sy) {
  19545. +    for (; sy < ey; sy++) {
  19546. +        pp = p + sx * vtdata.screen.bytespercharh;
  19547. +        for (; sx < vtdata.numcolumns; sx++) {
  19548. +        ll_write_char (pp, *buffer);
  19549. +        pp += vtdata.screen.bytespercharh;
  19550. +        buffer ++;
  19551. +        }
  19552. +        p += vtdata.screen.sizerow;
  19553. +        sx = 0;
  19554. +    }
  19555. +    }
  19556. +
  19557. +    if (ey == sy && ex) {
  19558. +    for (; sx < ex; sx++) {
  19559. +        ll_write_char (p, *buffer);
  19560. +        p += vtdata.screen.bytespercharh;
  19561. +        buffer ++;
  19562. +    }
  19563. +    }
  19564. +}
  19565. +
  19566. +void set_scrmem (const struct vt * const vt, long offset)
  19567. +{
  19568. +    unsigned long p, pp, my, by;
  19569. +    unsigned long *buffer;
  19570. +    int i;
  19571. +
  19572. +    p = vt->vcd->screen.origin;
  19573. +    buffer = vt->vcd->buffer.buffer;
  19574. +
  19575. +    by = vtdata.screen.sizerow;
  19576. +    for (my = vtdata.numrows; my > 0; my--) {
  19577. +    int mx, bx = vtdata.screen.bytespercharh;
  19578. +    pp = p;
  19579. +    mx = vtdata.numcolumns;
  19580. +    while (mx > 8) {
  19581. +        mx -= 8;
  19582. +        ll_write_char (pp, *buffer++); pp += bx;
  19583. +        ll_write_char (pp, *buffer++); pp += bx;
  19584. +        ll_write_char (pp, *buffer++); pp += bx;
  19585. +        ll_write_char (pp, *buffer++); pp += bx;
  19586. +        ll_write_char (pp, *buffer++); pp += bx;
  19587. +        ll_write_char (pp, *buffer++); pp += bx;
  19588. +        ll_write_char (pp, *buffer++); pp += bx;
  19589. +        ll_write_char (pp, *buffer++); pp += bx;
  19590. +    }
  19591. +    while (mx > 0) {
  19592. +        mx -= 1;
  19593. +        ll_write_char (pp, *buffer++); pp += bx;
  19594. +    }
  19595. +    p += by;
  19596. +    }
  19597. +    pp = vt->vcd->screen.origin + ((vtdata.screen.totsize + 0x7FFF) & PAGE_MASK);
  19598. +    while (p < pp) {
  19599. +    *(unsigned long *)p = 0;
  19600. +    p += 4;
  19601. +    }
  19602. +    if (!vt->vcd->screen.palette_entries || vt->vtd->vc_mode != KD_GRAPHICS)
  19603. +    for (i = 0; i < 17; i++)
  19604. +        vidc_write(i << 2, default_palette_entries[i]);
  19605. +    else
  19606. +    for (i = 0; i < 17; i++)
  19607. +        vidc_write(i << 2, vt->vcd->screen.palette_entries[i] & 0x1fff);
  19608. +}
  19609. +
  19610. +/*
  19611. + * PIO_FONT support
  19612. + */
  19613. +int con_set_font (char *arg)
  19614. +{
  19615. +    return -EINVAL;
  19616. +}
  19617. +
  19618. +int con_get_font (char *arg)
  19619. +{
  19620. +    return -EINVAL;
  19621. +}
  19622. +
  19623. +void con_reset_palette (const struct vt * const vt)
  19624. +{
  19625. +}
  19626. +
  19627. +void con_set_palette (const struct vt * const vt)
  19628. +{
  19629. +    int i;
  19630. +    if (vt->vtd->vc_mode == KD_GRAPHICS && vt->vcd->screen.palette_entries)
  19631. +    for (i = 0; i < 17; i++)
  19632. +        vidc_write (i << 2, vt->vcd->screen.palette_entries[i] & 0x1fff);
  19633. +    else
  19634. +    for (i = 0; i < 17; i++)
  19635. +        vidc_write (i << 2, default_palette_entries[i]);
  19636. +}
  19637. +
  19638. +/* == arm specific console code ============================================================== */
  19639. +
  19640. +int do_screendump(int arg)
  19641. +{
  19642. +    char *buf = (char *)arg;
  19643. +    int l;
  19644. +    if (!suser())
  19645. +    return -EPERM;
  19646. +    l = verify_area (VERIFY_WRITE, buf, 2);
  19647. +    if (l)
  19648. +    return l;
  19649. +    return -ENOSYS;
  19650. +}
  19651. +
  19652. +static void ll_erase (const struct vt *vt, unsigned char sx, unsigned char sy,
  19653. +                      unsigned char ex, unsigned char ey)
  19654. +{
  19655. +    int displayed;
  19656. +
  19657. +    displayed = vt == vtdata.fgconsole;
  19658. +    ex += 1;
  19659. +
  19660. +    if (sx != 0) {
  19661. +    /* erase to end of line */
  19662. +    int c, i;
  19663. +    if (sy == ey)
  19664. +        c = ex - sx;
  19665. +    else
  19666. +        c = vtdata.numcolumns - sx;
  19667. +
  19668. +    if (sx + c > vtdata.numcolumns + 1)
  19669. +        c = vtdata.numcolumns - sx;
  19670. +
  19671. +    memsetl (vt->vcd->buffer.buffer + (sx + sy * vtdata.buffer.sizerow),
  19672. +        vt->vcd->combined_state | 32, 4 * c);
  19673. +
  19674. +    if (displayed)
  19675. +        for (i = vtdata.screen.bytespercharv - 1; i >= 0; i --)
  19676. +        memset ((void *)(vt->vcd->screen.origin + sx * vtdata.screen.bytespercharh +
  19677. +            sy * vtdata.screen.sizerow + i * vtdata.numcolumns *
  19678. +            vtdata.screen.bytespercharh), vt->vcd->cached_backcolwrd,
  19679. +            c * vtdata.screen.bytespercharh);
  19680. +    sy ++;
  19681. +    }
  19682. +    if (sy < ey || (sy == ey && ex == vtdata.numcolumns - 1)) {
  19683. +    /* erase all lines from sy to ey (not inclusive) */
  19684. +    int c;
  19685. +
  19686. +    c = ey - sy;
  19687. +    if (c == 0)
  19688. +        c ++;
  19689. +
  19690. +    memsetl (vt->vcd->buffer.buffer + sy * vtdata.buffer.sizerow,
  19691. +        vt->vcd->combined_state | 32, 4 * c * vtdata.buffer.sizerow);
  19692. +
  19693. +    if (displayed)
  19694. +        memset ((void *)(vt->vcd->screen.origin + sy * vtdata.screen.sizerow),
  19695. +        vt->vcd->cached_backcolwrd, c * vtdata.screen.sizerow);
  19696. +    sy += c;
  19697. +    }
  19698. +    if (sy == ey) {
  19699. +    int i;
  19700. +
  19701. +    memsetl (vt->vcd->buffer.buffer + sy * vtdata.buffer.sizerow,
  19702. +        vt->vcd->combined_state | 32, 4 * ex);
  19703. +
  19704. +    if (displayed)
  19705. +        for (i = vtdata.screen.bytespercharv - 1; i >= 0; i--)
  19706. +        memset ((void *)(vt->vcd->screen.origin + sy * vtdata.screen.sizerow + i *
  19707. +                vtdata.numcolumns * vtdata.screen.bytespercharh),
  19708. +            vt->vcd->cached_backcolwrd, ex * vtdata.screen.bytespercharh);
  19709. +    }
  19710. +}
  19711. +
  19712. +/*===============================================================================================*/
  19713. +
  19714. +static int vcd_write_utf (struct con_struct *vcd, int c)
  19715. +{
  19716. +    /* Combine UTF-8 into Unicode */
  19717. +    /* Incomplete characters silently ignored */
  19718. +    if (c < 0x80) {
  19719. +    vcd->utf_count = 0;
  19720. +    return c;
  19721. +    }
  19722. +
  19723. +    if (vcd->utf_count > 0 && (c & 0xc0) == 0x80) {
  19724. +    vcd->utf_char = (vcd->utf_char << 6) | (c & 0x3f);
  19725. +    if (--vcd->utf_count == 0)
  19726. +        return vcd->utf_char;
  19727. +    else
  19728. +        return -1;
  19729. +    } else {
  19730. +    unsigned int count, chr;
  19731. +    if ((c & 0xe0) == 0xc0) {
  19732. +        count = 1;
  19733. +        chr = (c & 0x1f);
  19734. +    } else if ((c & 0xf0) == 0xe0) {
  19735. +        count = 2;
  19736. +        chr = (c & 0x0f);
  19737. +    } else if ((c & 0xf8) == 0xf0) {
  19738. +        count = 3;
  19739. +        chr = (c & 0x07);
  19740. +    } else if ((c & 0xfc) == 0xf8) {
  19741. +        count = 4;
  19742. +        chr = (c & 0x03);
  19743. +    } else if ((c & 0xfe) == 0xfc) {
  19744. +        count = 5;
  19745. +        chr = (c & 0x01);
  19746. +    } else {
  19747. +        count = 0;
  19748. +        chr = 0;
  19749. +    }
  19750. +    vcd->utf_count = count;
  19751. +    vcd->utf_char = chr;
  19752. +    return -1;
  19753. +    }
  19754. +}
  19755. +
  19756. +static void vcd_write_char (const struct vt * const vt, unsigned int c)
  19757. +{
  19758. +    struct con_struct * const vcd = vt->vcd;
  19759. +    unsigned long character, bufpos;
  19760. +
  19761. +    if (c & ~console_charmask)
  19762. +    return;
  19763. +
  19764. +    bufpos = vcd->buffer.pos;
  19765. +
  19766. +    if (vcd->need_wrap) {
  19767. +    vcd->screen.pos -= vcd->curstate.x * vtdata.screen.bytespercharh;
  19768. +    bufpos -= vcd->curstate.x;
  19769. +
  19770. +    vcd->need_wrap = vcd->curstate.x = 0;
  19771. +
  19772. +    if (vcd->curstate.y + 1 == vcd->bottom)
  19773. +        scrollup (vt, vt->vcd->top, vt->vcd->bottom, 1);
  19774. +    else
  19775. +    if (vcd->curstate.y + 1 < vtdata.numrows) {
  19776. +        vcd->curstate.y ++;
  19777. +        vcd->screen.pos += vtdata.screen.sizerow;
  19778. +        bufpos += vtdata.buffer.sizerow;
  19779. +    }
  19780. +    }
  19781. +
  19782. +    if (vcd->decim)
  19783. +    insert_char (vt);
  19784. +
  19785. +    /*
  19786. +     * write character to buffer and screen
  19787. +     */
  19788. +    vcd->buffer.buffer[bufpos] = character = vcd->combined_state | (c & 255);
  19789. +
  19790. +    if (vtdata.fgconsole == vt)
  19791. +    ll_write_char (vcd->screen.pos, character);
  19792. +
  19793. +    if (vcd->curstate.x + 1 == vtdata.numcolumns)
  19794. +    vcd->need_wrap = vcd->decawm;
  19795. +    else {
  19796. +    vcd->curstate.x ++;
  19797. +    vcd->screen.pos += vtdata.screen.bytespercharh;
  19798. +    bufpos += 1;
  19799. +    }
  19800. +    vcd->buffer.pos = bufpos;
  19801. +}
  19802. +
  19803. +static int vcd_write_ctrl (const struct vt *vt, unsigned int c)
  19804. +{
  19805. +    struct con_struct *vcd = vt->vcd;
  19806. +    /*
  19807. +     *  Control characters can be used in the _middle_
  19808. +     *  of an escape sequence.
  19809. +     */
  19810. +    switch(c) {
  19811. +    case 7:
  19812. +    vt_mksound (0x637, 72, HZ/8);
  19813. +    return 0;
  19814. +    case 8:
  19815. +    if (vcd->need_wrap)
  19816. +        vcd->need_wrap = 0;
  19817. +    else
  19818. +    if (vcd->curstate.x) {
  19819. +        vcd->curstate.x --;
  19820. +        vcd->screen.pos -= vtdata.screen.bytespercharh;
  19821. +        vcd->buffer.pos -= 1;
  19822. +        vcd->need_wrap = 0;
  19823. +    }
  19824. +    return 0;
  19825. +    case 9:
  19826. +    vcd->screen.pos -= vcd->curstate.x * vtdata.screen.bytespercharh;
  19827. +    vcd->buffer.pos -= vcd->curstate.x;
  19828. +    while (vcd->curstate.x < vtdata.numcolumns - 1) {
  19829. +        vcd->curstate.x++;
  19830. +        if (vcd->tab_stop[vcd->curstate.x >> 5] & (1 << (vcd->curstate.x & 31)))
  19831. +        break;
  19832. +    }
  19833. +    vcd->screen.pos += vcd->curstate.x * vtdata.screen.bytespercharh;
  19834. +    vcd->buffer.pos += vcd->curstate.x;
  19835. +    return 0;
  19836. +    case 10:
  19837. +    case 11:
  19838. +    case 12:
  19839. +    if (vcd->curstate.y + 1 == vcd->bottom)
  19840. +        scrollup (vt, vt->vcd->top, vt->vcd->bottom, 1);
  19841. +    else
  19842. +    if (vcd->curstate.y < vtdata.numrows - 1) {
  19843. +        vcd->curstate.y ++;
  19844. +        vcd->screen.pos += vtdata.screen.sizerow;
  19845. +        vcd->buffer.pos += vtdata.buffer.sizerow;
  19846. +    }
  19847. +    vcd->need_wrap = 0;
  19848. +    if (!is_kbd(lnm))
  19849. +        return 0;
  19850. +    case 13:
  19851. +    vcd->screen.pos -= vcd->curstate.x * vtdata.screen.bytespercharh;
  19852. +    vcd->buffer.pos -= vcd->curstate.x;
  19853. +    vcd->curstate.x = vcd->need_wrap = 0;
  19854. +    return 0;
  19855. +    case 14:
  19856. +    vcd->curstate.flags |= FLG_CHRSET;
  19857. +    vcd->disp_ctrl = 1;
  19858. +    vcd->translate = set_translate(vcd->curstate.G1_charset);
  19859. +    return 1;
  19860. +    case 15:
  19861. +    vcd->curstate.flags &= ~FLG_CHRSET;
  19862. +    vcd->disp_ctrl = 0;
  19863. +    vcd->translate = set_translate(vcd->curstate.G0_charset);
  19864. +    return 1;
  19865. +    case 24:
  19866. +    case 26:
  19867. +    vcd->state = ESnormal;
  19868. +    return 0;
  19869. +    case 27:
  19870. +    vcd->state = ESesc;
  19871. +    return 0;
  19872. +    case 127:
  19873. +    /* ignored */
  19874. +    return 0;
  19875. +    case 128+27:
  19876. +    vcd->state = ESsquare;
  19877. +    return 0;
  19878. +    }
  19879. +
  19880. +    switch(vcd->state) {
  19881. +    case ESesc:
  19882. +    vcd->state = ESnormal;
  19883. +    switch (c) {
  19884. +    case '[':
  19885. +        vcd->state = ESsquare;
  19886. +        return 0;
  19887. +    case '%':
  19888. +        vcd->state = ESpercent;
  19889. +        return 0;
  19890. +    case 'E':
  19891. +        vcd->screen.pos -= vcd->curstate.x * vtdata.screen.bytespercharh;
  19892. +        vcd->buffer.pos -= vcd->curstate.x;
  19893. +        vcd->curstate.x = vcd->need_wrap = 0;
  19894. +    case 'D':
  19895. +        if (vcd->curstate.y + 1 == vcd->bottom)
  19896. +        scrollup (vt, vt->vcd->top, vt->vcd->bottom, 1);
  19897. +        else
  19898. +        if (vcd->curstate.y < vtdata.numrows - 1) {
  19899. +        vcd->curstate.y ++;
  19900. +        vcd->screen.pos += vtdata.screen.sizerow;
  19901. +        vcd->buffer.pos += vtdata.buffer.sizerow;
  19902. +        }
  19903. +        /* vcd->need_wrap = 0; why should we reset this when the x position is the same? */
  19904. +        return 0;
  19905. +    case 'M':
  19906. +        if (vcd->curstate.y == vcd->top)
  19907. +        scrolldown (vt, vt->vcd->top, vt->vcd->bottom, 1);
  19908. +        else
  19909. +        if (vcd->curstate.y > 0) {
  19910. +        vcd->curstate.y --;
  19911. +        vcd->screen.pos -= vtdata.screen.sizerow;
  19912. +        vcd->buffer.pos -= vtdata.buffer.sizerow;
  19913. +        }
  19914. +        /* vcd->need_wrap = 0; why should we reset this when the x position is the same? */
  19915. +        return 0;
  19916. +    case 'H':
  19917. +        vcd->tab_stop[vcd->curstate.x >> 5] |= (1 << (vcd->curstate.x & 31));
  19918. +        return 0;
  19919. +    case 'Z':
  19920. +        respond_ID (*vt->tty);
  19921. +        return 0;
  19922. +    case '7':
  19923. +        vcd->savedstate = vcd->curstate;
  19924. +        return 0;
  19925. +    case '8':
  19926. +        vcd->curstate = vcd->savedstate;
  19927. +        update_attr (vt);
  19928. +        return 1;
  19929. +    case '(':
  19930. +        vcd->state = ESsetG0;
  19931. +        return 0;
  19932. +    case ')':
  19933. +        vcd->state = ESsetG1;
  19934. +        return 0;
  19935. +    case '#':
  19936. +        vcd->state = EShash;
  19937. +        return 0;
  19938. +    case 'c':
  19939. +        reset_terminal (vt, 0);
  19940. +        return 0;
  19941. +    case '>': /* Numeric keypad */
  19942. +        clr_kbd (kbdapplic);
  19943. +        return 0;
  19944. +    case '=': /* Appl. keypad */
  19945. +        set_kbd (kbdapplic);
  19946. +        return 0;
  19947. +    }
  19948. +    return 0;
  19949. +    case ESnonstd:
  19950. +    vcd->state = ESnormal;
  19951. +    switch (c) {
  19952. +    case 'P': /* palette escape sequence */
  19953. +        for (vcd->npar = 0; vcd->npar < NPAR; vcd->npar++)
  19954. +        vcd->par[vcd->npar] = 0;
  19955. +        vcd->npar = 0 ;
  19956. +        vcd->state = ESpalette;
  19957. +        return 0;
  19958. +    case 'R': /* reset palette */
  19959. +        con_reset_palette (vt);
  19960. +    default:
  19961. +        return 0;
  19962. +    }
  19963. +    case ESpalette:
  19964. +    if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')) {
  19965. +        vcd->par[vcd->npar++] = (c > '9' ? (c & 0xDF) - 'A' + 10 : c - '0');
  19966. +        if (vcd->npar == 7) {
  19967. +#if TODO
  19968. +        int i = par[0]*3, j = 1;
  19969. +        palette[i] = 16*par[j++];
  19970. +        palette[i++] += par[j++];
  19971. +        palette[i] = 16*par[j++];
  19972. +        palette[i++] += par[j++];
  19973. +        palette[i] = 16*par[j++];
  19974. +        palette[i++] += par[j];
  19975. +#endif
  19976. +        con_set_palette (vt);
  19977. +        vcd->state = ESnormal;
  19978. +        }
  19979. +    } else
  19980. +        vcd->state = ESnormal;
  19981. +    return 0;
  19982. +    case ESsquare:
  19983. +    for (vcd->npar = 0; vcd->npar < NPAR; vcd->npar++)
  19984. +        vcd->par[vcd->npar] = 0;
  19985. +    vcd->npar = 0;
  19986. +    vcd->state = ESgetpars;
  19987. +    if (c == '[') { /* Function key */
  19988. +        vcd->state = ESfunckey;
  19989. +        return 0;
  19990. +    }
  19991. +
  19992. +    vcd->ques = (c == '?');
  19993. +    if (vcd->ques)
  19994. +        return 0;
  19995. +    case ESgetpars:
  19996. +    if (c == ';' && vcd->npar < NPAR - 1) {
  19997. +        vcd->npar ++;
  19998. +        return 0;
  19999. +    } else
  20000. +    if (c >= '0' && c <= '9') {
  20001. +        vcd->par[vcd->npar] = vcd->par[vcd->npar] * 10 + c - '0';
  20002. +        return 0;
  20003. +    } else
  20004. +        vcd->state = ESgotpars;
  20005. +    case ESgotpars:
  20006. +    vcd->state=ESnormal;
  20007. +    switch (c) {
  20008. +    case 'h':
  20009. +        set_mode(vt, 1);
  20010. +        return 0;
  20011. +    case 'l':
  20012. +        set_mode(vt, 0);
  20013. +        return 0;
  20014. +    case 'n':
  20015. +        if (!vcd->ques) {
  20016. +        if (vcd->par[0] == 5)
  20017. +            status_report (*vt->tty);
  20018. +        else
  20019. +        if (vcd->par[0] == 6)
  20020. +            cursor_report (vt);
  20021. +        }
  20022. +        return 0;
  20023. +    }
  20024. +    if (vcd->ques) {
  20025. +        vcd->ques = 0;
  20026. +        return 0;
  20027. +    }
  20028. +    switch(c) {
  20029. +    case 'G':
  20030. +    case '`':
  20031. +        if (vcd->par[0])
  20032. +        vcd->par[0]--;
  20033. +        gotoxy (vt, vcd->par[0], vcd->curstate.y);
  20034. +        return 0;
  20035. +    case 'A':
  20036. +        if (!vcd->par[0])
  20037. +        vcd->par[0]++;
  20038. +        gotoxy (vt, vcd->curstate.x, vcd->curstate.y - vcd->par[0]);
  20039. +        return 0;
  20040. +    case 'B':
  20041. +    case 'e':
  20042. +        if (!vcd->par[0])
  20043. +        vcd->par[0]++;
  20044. +        gotoxy (vt, vcd->curstate.x, vcd->curstate.y + vcd->par[0]);
  20045. +        return 0;
  20046. +    case 'C':
  20047. +    case 'a':
  20048. +        if (!vcd->par[0])
  20049. +        vcd->par[0]++;
  20050. +        gotoxy (vt, vcd->curstate.x + vcd->par[0], vcd->curstate.y);
  20051. +        return 0;
  20052. +    case 'D':
  20053. +        if (!vcd->par[0])
  20054. +        vcd->par[0]++;
  20055. +        gotoxy (vt, vcd->curstate.x - vcd->par[0], vcd->curstate.y);
  20056. +        return 0;
  20057. +    case 'E':
  20058. +        if (!vcd->par[0])
  20059. +        vcd->par[0]++;
  20060. +        gotoxy (vt, 0, vcd->curstate.y + vcd->par[0]);
  20061. +        return 0;
  20062. +    case 'F':
  20063. +        if (!vcd->par[0])
  20064. +        vcd->par[0]++;
  20065. +        gotoxy (vt, 0, vcd->curstate.y - vcd->par[0]);
  20066. +        return 0;
  20067. +    case 'd':
  20068. +        if (vcd->par[0])
  20069. +        vcd->par[0]--;
  20070. +        gotoxay (vt, vcd->curstate.x, vcd->par[0]);
  20071. +        return 0;
  20072. +    case 'H':
  20073. +    case 'f':
  20074. +        if (vcd->par[0])
  20075. +        vcd->par[0]--;
  20076. +        if (vcd->par[1])
  20077. +        vcd->par[1]--;
  20078. +        gotoxay (vt, vcd->par[1], vcd->par[0]);
  20079. +        return 0;
  20080. +    case 'J':
  20081. +        csi_J (vt, vcd->par[0]);
  20082. +        return 0;
  20083. +    case 'K':
  20084. +        csi_K (vt, vcd->par[0]);
  20085. +        return 0;
  20086. +    case 'L':
  20087. +        csi_L (vt, vcd->par[0]);
  20088. +        return 0;
  20089. +    case 'M':
  20090. +        csi_M (vt, vcd->par[0]);
  20091. +        return 0;
  20092. +    case 'P':
  20093. +        csi_P (vt, vcd->par[0]);
  20094. +        return 0;
  20095. +    case 'c':
  20096. +        if (!vcd->par[0])
  20097. +        respond_ID(*vt->tty);
  20098. +        return 0;
  20099. +    case 'g':
  20100. +        if (!vcd->par[0])
  20101. +        vcd->tab_stop[vcd->curstate.x >> 5] &= ~(1 << (vcd->curstate.x & 31));
  20102. +        else
  20103. +        if (vcd->par[0] == 3) {
  20104. +        vcd->tab_stop[0] =
  20105. +        vcd->tab_stop[1] =
  20106. +        vcd->tab_stop[2] =
  20107. +        vcd->tab_stop[3] =
  20108. +        vcd->tab_stop[4] = 0;
  20109. +        }
  20110. +        return 0;
  20111. +    case 'm':
  20112. +        return csi_m (vt);
  20113. +    case 'q': /* DECLL - but only 3 leds */
  20114. +        /* map 0,1,2,3 to 0,1,2,4 */
  20115. +        if (vcd->par[0] < 4)
  20116. +          setledstate(vt->kbd, (vcd->par[0] < 3 ? vcd->par[0] : 4));
  20117. +        return 0;
  20118. +    case 'r':
  20119. +        if (!vcd->par[0])
  20120. +        vcd->par[0]++;
  20121. +        if (!vcd->par[1])
  20122. +        vcd->par[1] = vtdata.numrows;
  20123. +        if (vcd->par[0] < vcd->par[1] && vcd->par[1] <= vtdata.numrows) {
  20124. +        vcd->top = vcd->par[0] - 1;
  20125. +        vcd->bottom = vcd->par[1];
  20126. +        gotoxay (vt, 0, 0);
  20127. +        }
  20128. +        return 0;
  20129. +    case 's':
  20130. +        vcd->savedstate = vcd->curstate;
  20131. +        return 0;
  20132. +    case 'u':
  20133. +        vcd->curstate = vcd->savedstate;
  20134. +        update_attr (vt);
  20135. +        return 1;
  20136. +    case 'X':
  20137. +        csi_X (vt, vcd->par[0]);
  20138. +        return 0;
  20139. +    case '@':
  20140. +        csi_at (vt, vcd->par[0]);
  20141. +        return 0;
  20142. +    case ']': /* setterm functions */
  20143. +        setterm_command (vt);
  20144. +        return 0;
  20145. +    }
  20146. +    return 0;
  20147. +    case ESpercent:
  20148. +    vcd->state = ESnormal;
  20149. +    switch (c) {
  20150. +    case '@': /* defined in ISO 2022 */
  20151. +        vcd->utf = 0;
  20152. +        return 0;
  20153. +    case 'G': /* prelim official escape code */
  20154. +    case '8': /* retained for compatibility */
  20155. +        vcd->utf = 1;
  20156. +        return 0;
  20157. +    }
  20158. +    return 0;
  20159. +    case ESfunckey:
  20160. +    vcd->state = ESnormal;
  20161. +    return 0;
  20162. +    case EShash:
  20163. +    vcd->state = ESnormal;
  20164. +    if (c == '8') {
  20165. +        /* DEC screen alignment test. kludge :-) */
  20166. +    }
  20167. +    return 0;
  20168. +    case ESsetG0:
  20169. +    vcd->state = ESnormal;
  20170. +    if (c == '0')
  20171. +        vcd->curstate.G0_charset = GRAF_MAP;
  20172. +    else
  20173. +    if (c == 'B')
  20174. +        vcd->curstate.G0_charset = LAT1_MAP;
  20175. +    else
  20176. +    if (c == 'U')
  20177. +        vcd->curstate.G0_charset = IBMPC_MAP;
  20178. +    else
  20179. +    if (c == 'K')
  20180. +        vcd->curstate.G0_charset = USER_MAP;
  20181. +    if ((vcd->curstate.flags & FLG_CHRSET) == 0) {
  20182. +        vcd->translate = set_translate(vcd->curstate.G0_charset);
  20183. +        return 1;
  20184. +    }
  20185. +    return 0;
  20186. +    case ESsetG1:
  20187. +    vcd->state = ESnormal;
  20188. +    if (c == '0')
  20189. +        vcd->curstate.G1_charset = GRAF_MAP;
  20190. +    else
  20191. +    if (c == 'B')
  20192. +        vcd->curstate.G1_charset = LAT1_MAP;
  20193. +    else
  20194. +    if (c == 'U')
  20195. +        vcd->curstate.G1_charset = IBMPC_MAP;
  20196. +    else
  20197. +    if (c == 'K')
  20198. +        vcd->curstate.G1_charset = USER_MAP;
  20199. +    if (vcd->curstate.flags & FLG_CHRSET) {
  20200. +        vcd->translate = set_translate(vcd->curstate.G1_charset);
  20201. +        return 1;
  20202. +    }
  20203. +    return 0;
  20204. +    default:
  20205. +    vcd->state = ESnormal;
  20206. +    }
  20207. +    return 0;
  20208. +}
  20209. +
  20210. +/*===============================================================================================*/
  20211. +
  20212. +int vcd_init (struct vt *vt, int kmallocok, unsigned long *kmem)
  20213. +{
  20214. +    memset (vt->vcd, 0, sizeof (*vt->vcd));
  20215. +    
  20216. +    vt->vcd->screen.origin    = vtdata.screen.memstart;
  20217. +    if (kmallocok) {
  20218. +    vt->vcd->buffer.buffer    = kmalloc (vtdata.buffer.totsize * sizeof (unsigned long), GFP_KERNEL);
  20219. +    if (!vt->vcd->buffer.buffer)
  20220. +        return -ENOMEM;
  20221. +    vt->vcd->buffer.kmalloced = 1;
  20222. +    } else {
  20223. +    vt->vcd->buffer.buffer    = (unsigned long *) *kmem;
  20224. +    *kmem += vtdata.buffer.totsize * sizeof (unsigned long);
  20225. +    }
  20226. +
  20227. +    vt->vtd->paste_wait        = NULL;
  20228. +    vt->vcd->screen.cursoron    = (kmem ? 1 : 0);
  20229. +    vt->vcd->screen.palette_entries = NULL;
  20230. +    reset_terminal (vt, (kmem ? 1 : 0));
  20231. +
  20232. +    return 0;
  20233. +}
  20234. +
  20235. +static struct irqaction vsyncirq = { vsync_irq, 0, 0, "vsync", NULL, NULL };
  20236. +    
  20237. +unsigned long vcd_pre_init (unsigned long kmem, struct vt *vt)
  20238. +{
  20239. +    int colours, i;
  20240. +
  20241. +    /* Use ORIG_VIDEO_MODE */
  20242. +    vtdata.screen.bytespercharh = bytes_per_char_h;
  20243. +    vtdata.screen.bytespercharv = bytes_per_char_v;
  20244. +    video_num_columns = vtdata.numcolumns;
  20245. +    vtdata.screen.sizerow  = (vtdata.numcolumns *
  20246. +                vtdata.screen.bytespercharh * vtdata.screen.bytespercharv);
  20247. +    vtdata.screen.totsize  = vtdata.screen.sizerow * vtdata.numrows;
  20248. +    vtdata.screen.memmask  = (vtdata.screen.totsize - 1) | (PAGE_SIZE-1);
  20249. +    vtdata.screen.memend   = 0x02000000;
  20250. +    vtdata.screen.memstart = vtdata.screen.memend - vtdata.screen.memmask - 1;
  20251. +    vtdata.buffer.sizerow  = vtdata.numcolumns;
  20252. +    vtdata.buffer.totsize  = vtdata.numcolumns * vtdata.numrows;
  20253. +
  20254. +    map_screen_mem (vtdata.screen.memstart, 1);
  20255. +
  20256. +    switch (vtdata.screen.bytespercharh) {
  20257. +    case 1:
  20258. +    default_palette_entries = palette_1;
  20259. +    color_table = color_1;
  20260. +    can_do_color = 0;
  20261. +    vtdata.screen.bitsperpix = 1;
  20262. +    colours = 1;
  20263. +    break;
  20264. +    default:
  20265. +    case 4:
  20266. +    default_palette_entries = palette_4;
  20267. +    color_table = color_4;
  20268. +    can_do_color = 1;
  20269. +    vtdata.screen.bitsperpix = 4;
  20270. +    colours = 16;
  20271. +    break;
  20272. +    case 8:
  20273. +    default_palette_entries = palette_8;
  20274. +    color_table = color_8;
  20275. +    can_do_color = 1;
  20276. +    vtdata.screen.bitsperpix = 8;
  20277. +    colours = 256;
  20278. +    break;
  20279. +    }
  20280. +
  20281. +    for (i = 0; i < 17; i++)
  20282. +    vidc_write (i << 2, default_palette_entries[i]);
  20283. +
  20284. +    vcd_init (vt, 0, &kmem);
  20285. +
  20286. +    vt->vcd->screen.cursoron = 1;
  20287. +
  20288. +    set_origin (vt);
  20289. +
  20290. +    gotoxy (vt, ORIG_X, ORIG_Y);
  20291. +    csi_J (vt, 0);
  20292. +    printable = 1;
  20293. +
  20294. +#ifdef CONFIG_SERIAL_ECHO
  20295. +    serial_echo_init (SERIAL_ECHO_PORT);
  20296. +#endif
  20297. +
  20298. +    printk ("Console: %s %s %dx%dx%d, %d virtual console%s (max %d)\n",
  20299. +    can_do_color ? "colour" : "mono",
  20300. +    "A-series",
  20301. +      vtdata.numcolumns,
  20302. +      vtdata.numrows,
  20303. +      colours,
  20304. +      MIN_NR_CONSOLES,
  20305. +      (MIN_NR_CONSOLES == 1) ? "":"s",
  20306. +      MAX_NR_CONSOLES);
  20307. +
  20308. +    register_console (console_print);
  20309. +
  20310. +    if (setup_arm_irq(IRQ_VSYNCPULSE, &vsyncirq))
  20311. +    panic ("Unable to get VSYNC irq for console\n");
  20312. +
  20313. +    return kmem;
  20314. +}
  20315. +
  20316. +void vcd_disallocate (struct vt *vt)
  20317. +{
  20318. +    if (vt->vcd && vt->vcd->buffer.kmalloced) {
  20319. +    kfree (vt->vcd->buffer.buffer);
  20320. +    vt->vcd->buffer.buffer = NULL;
  20321. +    vt->vcd->buffer.kmalloced = 0;
  20322. +    }
  20323. +}
  20324. +
  20325. +int vcd_resize(unsigned long lines, unsigned long cols)
  20326. +{/* TODO */
  20327. +    return -ENOMEM;
  20328. +}
  20329. +
  20330. +void vcd_blankscreen(int nopowersave)
  20331. +{
  20332. +    int i;
  20333. +
  20334. +    /* DISABLE VIDEO */
  20335. +    for (i = 0; i < 17; i++)
  20336. +    vidc_write(i<<2, 0);
  20337. +}
  20338. +
  20339. +void vcd_unblankscreen (void)
  20340. +{
  20341. +    int i;
  20342. +    if (!vtdata.fgconsole->vcd->screen.palette_entries ||
  20343. +        vtdata.fgconsole->vtd->vc_mode != KD_GRAPHICS)
  20344. +    for(i=0; i<17; i++)
  20345. +        vidc_write(i<<2, default_palette_entries[i]);
  20346. +    else
  20347. +    for(i=0; i<17; i++)
  20348. +        vidc_write(i<<2, vtdata.fgconsole->vcd->screen.palette_entries[i] & 0x1fff);
  20349. +}
  20350. +
  20351. +static unsigned long old_origin;
  20352. +
  20353. +void vcd_savestate (const struct vt *vt, int blanked)
  20354. +{
  20355. +    clear_selection ();
  20356. +    vcd_removecursors (vt);
  20357. +
  20358. +    old_origin = vt->vcd->screen.origin;
  20359. +
  20360. +    if (blanked)
  20361. +    vtdata.blanked = NULL;
  20362. +#ifdef DEBUG
  20363. +    vcd_validate (vt->vcd, "vcd_savestate");
  20364. +#endif
  20365. +}
  20366. +
  20367. +void vcd_restorestate (const struct vt *vt)
  20368. +{
  20369. +    int text_mode;
  20370. +#ifdef DEBUG
  20371. +    unsigned long o_orig, o_pos;
  20372. +#endif
  20373. +    /*
  20374. +     * Reset the origin on this VT to be the same as the previous.
  20375. +     * This way we don't get any jumps when we change VT's.
  20376. +     */
  20377. +    text_mode = vt->vtd->vc_mode == KD_TEXT ? 1 : 0;
  20378. +#ifdef DEBUG
  20379. +    o_orig = vt->vcd->screen.origin;
  20380. +    o_pos = vt->vcd->screen.pos;
  20381. +#endif
  20382. +    vt->vcd->screen.pos -= vt->vcd->screen.origin;
  20383. +    if (text_mode) {
  20384. +    vt->vcd->screen.origin = old_origin;
  20385. +    set_scrmem (vt, 0);
  20386. +    } else
  20387. +    vt->vcd->screen.origin = 0x02000000;
  20388. +    vt->vcd->screen.pos += vt->vcd->screen.origin;
  20389. +#ifdef DEBUG
  20390. +    if (vcd_validate (vt->vcd, "vcd_restorestate")) {
  20391. +    printk ("old_origin = %08lX; old_pos = %08lX; new_origin = %08lX\n", o_orig, o_pos, old_origin);
  20392. +    }
  20393. +#endif
  20394. +    set_origin (vt);
  20395. +    set_cursor (vt);
  20396. +    if (text_mode)
  20397. +    vcd_restorecursors (vt);
  20398. +    set_leds ();
  20399. +}
  20400. +
  20401. +void vcd_setup_graphics (const struct vt *vt)
  20402. +{
  20403. +    clear_selection ();
  20404. +    vcd_removecursors (vt);
  20405. +
  20406. +    __real_origin = 0;
  20407. +    __set_origin (0);
  20408. +}
  20409. +
  20410. +int vcd_write (const struct vt *vt, int from_user, const unsigned char *buf, int count)
  20411. +{
  20412. +    int strt_count = count;
  20413. +    unsigned short *cached_trans;
  20414. +    unsigned int cached_ctrls;
  20415. +    register struct con_struct *vcd;
  20416. +
  20417. +    if (from_user && get_fs () == KERNEL_DS)
  20418. +    from_user = 0;
  20419. +
  20420. +    vcd = vt->vcd;
  20421. +
  20422. +#ifdef DEBUG
  20423. +    vcd_validate (vcd, "vcd_write entry");
  20424. +#endif
  20425. +
  20426. +    vcd_removecursors (vt);
  20427. +    if (vt == vtdata.select.vt)
  20428. +    clear_selection();
  20429. +
  20430. +    disable_bh (KEYBOARD_BH);
  20431. +recache:
  20432. +    cached_ctrls = vcd->disp_ctrl ? CTRL_ALWAYS : CTRL_ACTION;
  20433. +    cached_trans = vcd->translate + (vcd->toggle_meta ? 0x80 : 0);
  20434. +
  20435. +    while (!(*vt->tty)->stopped && count) {
  20436. +    int tc, c;
  20437. +    __asm__("teq    %3, #0
  20438. +    ldreqb    %0, [%1], #1
  20439. +    ldrnebt    %0, [%1], #1" : "=r" (c), "=&r" (buf) : "1" (buf), "r" (from_user));
  20440. +    count --;
  20441. +
  20442. +    if (vcd->utf) {
  20443. +        if ((tc = vcd_write_utf (vcd, c)) < 0)
  20444. +        continue;
  20445. +        c = tc;
  20446. +    } else
  20447. +        tc = cached_trans[c];
  20448. +
  20449. +    if (vcd->state == ESnormal && tc && (c != 127 || vcd->disp_ctrl)) {
  20450. +        if (c >= 32 || (!vcd->utf && !(cached_ctrls & (1 << c)))) { /* ok */
  20451. +        tc = conv_uni_to_pc (tc);
  20452. +        if (tc + 4 == 0)
  20453. +            tc = conv_uni_to_pc (0xfffd);
  20454. +        else
  20455. +        if (tc + 3 == 0)
  20456. +            tc = c;
  20457. +
  20458. +        vcd_write_char (vt, tc);
  20459. +        continue;
  20460. +        }
  20461. +    }
  20462. +
  20463. +    if (vcd_write_ctrl (vt, c))
  20464. +        goto recache;
  20465. +    else
  20466. +        continue;
  20467. +    }
  20468. +    if (vt->vtd->vc_mode != KD_GRAPHICS)
  20469. +    set_cursor (vt);
  20470. +    enable_bh(KEYBOARD_BH);
  20471. +    vcd_restorecursors (vt);
  20472. +#ifdef DEBUG
  20473. +    vcd_validate (vcd, "vcd_write exit");
  20474. +#endif
  20475. +    return strt_count - count;
  20476. +}
  20477. +
  20478. +int vcd_ioctl (const struct vt *vt, int cmd, unsigned long arg)
  20479. +{
  20480. +    int i;
  20481. +    switch (cmd) {
  20482. +    case VT_GETPALETTE: {
  20483. +    unsigned long pix, num, *val;
  20484. +        
  20485. +    i = verify_area (VERIFY_READ, (void *)arg, 12);
  20486. +    if (i)
  20487. +        return i;
  20488. +    pix = get_user ((unsigned long *)arg);
  20489. +    num = get_user ((unsigned long *)(arg + 4));
  20490. +    val = (unsigned long *) get_user ((unsigned long *)(arg + 8));
  20491. +
  20492. +    if (pix > 18 || pix + num > 19 || num < 1)
  20493. +        return -EINVAL;
  20494. +
  20495. +    i = verify_area (VERIFY_WRITE, val, num * sizeof (unsigned long));
  20496. +    if (i)
  20497. +        return i;
  20498. +
  20499. +    if (vt->vcd->screen.palette_entries)
  20500. +        for (i = pix; i < pix + num; i++)
  20501. +        *val++ = vt->vcd->screen.palette_entries[i] & 0x1fff;
  20502. +    else
  20503. +        for (i = pix; i < pix + num; i++)
  20504. +        *val++ = default_palette_entries[i] & 0x1fff;
  20505. +    return 0;
  20506. +        }
  20507. +    case VT_SETPALETTE: {
  20508. +    unsigned long pix, num, *val;
  20509. +
  20510. +    i = verify_area (VERIFY_READ, (void *)arg, 12);
  20511. +    if (i)
  20512. +        return i;
  20513. +
  20514. +    pix = get_user ((unsigned long *)arg);
  20515. +    num = get_user ((unsigned long *)(arg + 4));
  20516. +    val = (unsigned long *) get_user ((unsigned long *)(arg + 8));
  20517. +
  20518. +    if (pix > 18 || pix + num > 19 || num < 1)
  20519. +        return -EINVAL;
  20520. +
  20521. +    i = verify_area (VERIFY_READ, val, num * sizeof (unsigned long));
  20522. +    if (i)
  20523. +        return i;
  20524. +
  20525. +    if (!vt->vcd->screen.palette_entries) {
  20526. +        vt->vcd->screen.palette_entries = kmalloc (sizeof (unsigned long) * 19, GFP_KERNEL);
  20527. +        if (!vt->vcd->screen.palette_entries)
  20528. +        return -ENOMEM;
  20529. +        for (i = 0; i < 19; i++)
  20530. +        vt->vcd->screen.palette_entries[i] = default_palette_entries[i];
  20531. +    }
  20532. +
  20533. +    for (i = pix; i < pix + num; i++) {
  20534. +        vt->vcd->screen.palette_entries[i] = *val++;
  20535. +        vidc_write (i << 2, vt->vcd->screen.palette_entries[i] & 0x1fff);
  20536. +    }
  20537. +    return 0;
  20538. +    }
  20539. +
  20540. +    case PIO_FONT:
  20541. +    if (vt->vtd->vc_mode != KD_TEXT)
  20542. +        return -EINVAL;
  20543. +    return con_set_font((char *)arg);
  20544. +    /* con_set_font() defined in console.c */
  20545. +
  20546. +    case GIO_FONT:
  20547. +    if (vt->vtd->vc_mode != KD_TEXT)
  20548. +        return -EINVAL;
  20549. +    return con_get_font((char *)arg);
  20550. +    /* con_get_font() defined in console.c */
  20551. +
  20552. +    case PIO_SCRNMAP:
  20553. +    return con_set_trans_old ((char *)arg);
  20554. +
  20555. +    case GIO_SCRNMAP:
  20556. +    return con_get_trans_old((char *)arg);
  20557. +
  20558. +    case PIO_UNISCRNMAP:
  20559. +    return con_set_trans_new((short *)arg);
  20560. +
  20561. +    case GIO_UNISCRNMAP:
  20562. +    return con_get_trans_new((short *)arg);
  20563. +
  20564. +    case PIO_UNIMAPCLR: {
  20565. +    struct unimapinit ui;
  20566. +
  20567. +    i = verify_area(VERIFY_READ, (void *)arg, sizeof(struct unimapinit));
  20568. +    if (i)
  20569. +        return i;
  20570. +    memcpy_fromfs(&ui, (void *)arg, sizeof(struct unimapinit));
  20571. +    con_clear_unimap(&ui);
  20572. +    return 0;
  20573. +    }
  20574. +
  20575. +    case PIO_UNIMAP: {
  20576. +    i = verify_area(VERIFY_READ, (void *)arg, sizeof(struct unimapdesc));
  20577. +    if (i == 0) {
  20578. +        struct unimapdesc *ud;
  20579. +        u_short ct;
  20580. +        struct unipair *list;
  20581. +
  20582. +        ud = (struct unimapdesc *) arg;
  20583. +        ct = get_fs_word(&ud->entry_ct);
  20584. +        list = (struct unipair *) get_fs_long(&ud->entries);
  20585. +
  20586. +        i = verify_area(VERIFY_READ, (void *) list,
  20587. +            ct*sizeof(struct unipair));
  20588. +        if (!i)
  20589. +        return con_set_unimap(ct, list);
  20590. +    }
  20591. +    return i;
  20592. +    }
  20593. +
  20594. +    case GIO_UNIMAP: {
  20595. +    i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct unimapdesc));
  20596. +    if (i == 0) {
  20597. +        struct unimapdesc *ud;
  20598. +        u_short ct;
  20599. +        struct unipair *list;
  20600. +
  20601. +        ud = (struct unimapdesc *) arg;
  20602. +        ct = get_fs_word(&ud->entry_ct);
  20603. +        list = (struct unipair *) get_fs_long(&ud->entries);
  20604. +        if (ct)
  20605. +        i = verify_area(VERIFY_WRITE, (void *) list,
  20606. +            ct*sizeof(struct unipair));
  20607. +        if (!i)
  20608. +        return con_get_unimap(ct, &(ud->entry_ct), list);
  20609. +    }
  20610. +    return i;
  20611. +    }
  20612. +
  20613. +    default:
  20614. +    return -ENOIOCTLCMD;
  20615. +    }
  20616. +}
  20617. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/cp437.uni linux/arch/arm/drivers/char/cp437.uni
  20618. --- linux.orig/arch/arm/drivers/char/cp437.uni    Thu Jan  1 01:00:00 1970
  20619. +++ linux/arch/arm/drivers/char/cp437.uni    Thu Jul 18 22:32:15 1996
  20620. @@ -0,0 +1,291 @@
  20621. +#
  20622. +# Unicode table for IBM Codepage 437.  Note that there are many more
  20623. +# substitutions that could be conceived (for example, thick-line
  20624. +# graphs probably should be replaced with double-line ones, accented
  20625. +# Latin characters should replaced with their nonaccented versions,
  20626. +# and some upper case Greek characters could be replaced by Latin), however,
  20627. +# I have limited myself to the Unicodes used by the kernel ISO 8859-1,
  20628. +# DEC VT, and IBM CP 437 tables.
  20629. +#
  20630. +# --------------------------------
  20631. +#
  20632. +# Basic IBM dingbats, some of which will never have a purpose clear
  20633. +# to mankind
  20634. +#
  20635. +0x00    U+0000
  20636. +0x01    U+263a
  20637. +0x02    U+263b
  20638. +0x03    U+2665
  20639. +0x04    U+2666 U+25c6
  20640. +0x05    U+2663
  20641. +0x06    U+2660
  20642. +0x07    U+2022
  20643. +0x08    U+25d8
  20644. +0x09    U+25cb
  20645. +0x0a    U+25d9
  20646. +0x0b    U+2642
  20647. +0x0c    U+2640
  20648. +0x0d    U+266a
  20649. +0x0e    U+266b
  20650. +0x0f    U+263c
  20651. +0x10    U+25b6 U+25ba
  20652. +0x11    U+25c0 U+25c4
  20653. +0x12    U+2195
  20654. +0x13    U+203c
  20655. +0x14    U+00b6
  20656. +0x15    U+00a7
  20657. +0x16    U+25ac
  20658. +0x17    U+21a8
  20659. +0x18    U+2191
  20660. +0x19    U+2193
  20661. +0x1a    U+2192
  20662. +0x1b    U+2190
  20663. +0x1c    U+221f
  20664. +0x1d    U+2194
  20665. +0x1e    U+25b2
  20666. +0x1f    U+25bc
  20667. +#
  20668. +# The ASCII range is identity-mapped, but some of the characters also
  20669. +# have to act as substitutes, especially the upper-case characters.
  20670. +#
  20671. +0x20    U+0020
  20672. +0x21    U+0021
  20673. +0x22    U+0022 U+00a8
  20674. +0x23    U+0023
  20675. +0x24    U+0024
  20676. +0x25    U+0025
  20677. +0x26    U+0026
  20678. +0x27    U+0027
  20679. +0x28    U+0028
  20680. +0x29    U+0029
  20681. +0x2a    U+002a
  20682. +0x2b    U+002b
  20683. +0x2c    U+002c U+00b8
  20684. +0x2d    U+002d U+00ad
  20685. +0x2e    U+002e
  20686. +0x2f    U+002f
  20687. +0x30    U+0030
  20688. +0x31    U+0031
  20689. +0x32    U+0032
  20690. +0x33    U+0033
  20691. +0x34    U+0034
  20692. +0x35    U+0035
  20693. +0x36    U+0036
  20694. +0x37    U+0037
  20695. +0x38    U+0038
  20696. +0x39    U+0039
  20697. +0x3a    U+003a
  20698. +0x3b    U+003b
  20699. +0x3c    U+003c
  20700. +0x3d    U+003d
  20701. +0x3e    U+003e
  20702. +0x3f    U+003f
  20703. +0x40    U+0040
  20704. +0x41    U+0041 U+00c0 U+00c1 U+00c2 U+00c3
  20705. +0x42    U+0042
  20706. +0x43    U+0043 U+00a9
  20707. +0x44    U+0044
  20708. +0x45    U+0045 U+00c8 U+00ca U+00cb
  20709. +0x46    U+0046
  20710. +0x47    U+0047
  20711. +0x48    U+0048
  20712. +0x49    U+0049 U+00cc U+00cd U+00ce U+00cf
  20713. +0x4a    U+004a
  20714. +0x4b    U+004b U+212a
  20715. +0x4c    U+004c
  20716. +0x4d    U+004d
  20717. +0x4e    U+004e
  20718. +0x4f    U+004f U+00d2 U+00d3 U+00d4 U+00d5
  20719. +0x50    U+0050
  20720. +0x51    U+0051
  20721. +0x52    U+0052 U+00ae
  20722. +0x53    U+0053
  20723. +0x54    U+0054
  20724. +0x55    U+0055 U+00d9 U+00da U+00db
  20725. +0x56    U+0056
  20726. +0x57    U+0057
  20727. +0x58    U+0058
  20728. +0x59    U+0059 U+00dd
  20729. +0x5a    U+005a
  20730. +0x5b    U+005b
  20731. +0x5c    U+005c
  20732. +0x5d    U+005d
  20733. +0x5e    U+005e
  20734. +0x5f    U+005f U+f804
  20735. +0x60    U+0060
  20736. +0x61    U+0061 U+00e3
  20737. +0x62    U+0062
  20738. +0x63    U+0063
  20739. +0x64    U+0064
  20740. +0x65    U+0065
  20741. +0x66    U+0066
  20742. +0x67    U+0067
  20743. +0x68    U+0068
  20744. +0x69    U+0069
  20745. +0x6a    U+006a
  20746. +0x6b    U+006b
  20747. +0x6c    U+006c
  20748. +0x6d    U+006d
  20749. +0x6e    U+006e
  20750. +0x6f    U+006f U+00f5
  20751. +0x70    U+0070
  20752. +0x71    U+0071
  20753. +0x72    U+0072
  20754. +0x73    U+0073
  20755. +0x74    U+0074
  20756. +0x75    U+0075
  20757. +0x76    U+0076
  20758. +0x77    U+0077
  20759. +0x78    U+0078 U+00d7
  20760. +0x79    U+0079 U+00fd
  20761. +0x7a    U+007a
  20762. +0x7b    U+007b
  20763. +0x7c    U+007c U+00a5
  20764. +0x7d    U+007d
  20765. +0x7e    U+007e
  20766. +#
  20767. +# Okay, what on Earth is this one supposed to be used for?
  20768. +#
  20769. +0x7f    U+2302
  20770. +#
  20771. +# Non-English characters, mostly lower case letters...
  20772. +#
  20773. +0x80    U+00c7
  20774. +0x81    U+00fc
  20775. +0x82    U+00e9
  20776. +0x83    U+00e2
  20777. +0x84    U+00e4
  20778. +0x85    U+00e0
  20779. +0x86    U+00e5
  20780. +0x87    U+00e7
  20781. +0x88    U+00ea
  20782. +0x89    U+00eb
  20783. +0x8a    U+00e8
  20784. +0x8b    U+00ef
  20785. +0x8c    U+00ee
  20786. +0x8d    U+00ec
  20787. +0x8e    U+00c4
  20788. +0x8f    U+00c5 U+212b
  20789. +0x90    U+00c9
  20790. +0x91    U+00e6
  20791. +0x92    U+00c6
  20792. +0x93    U+00f4
  20793. +0x94    U+00f6
  20794. +0x95    U+00f2
  20795. +0x96    U+00fb
  20796. +0x97    U+00f9
  20797. +0x98    U+00ff
  20798. +0x99    U+00d6
  20799. +0x9a    U+00dc
  20800. +0x9b    U+00a2
  20801. +0x9c    U+00a3
  20802. +0x9d    U+00a5
  20803. +0x9e    U+20a7
  20804. +0x9f    U+0192
  20805. +0xa0    U+00e1
  20806. +0xa1    U+00ed
  20807. +0xa2    U+00f3
  20808. +0xa3    U+00fa
  20809. +0xa4    U+00f1
  20810. +0xa5    U+00d1
  20811. +0xa6    U+00aa
  20812. +0xa7    U+00ba
  20813. +0xa8    U+00bf
  20814. +0xa9    U+2310
  20815. +0xaa    U+00ac
  20816. +0xab    U+00bd
  20817. +0xac    U+00bc
  20818. +0xad    U+00a1
  20819. +0xae    U+00ab
  20820. +0xaf    U+00bb
  20821. +#
  20822. +# Block graphics
  20823. +#
  20824. +0xb0    U+2591
  20825. +0xb1    U+2592
  20826. +0xb2    U+2593
  20827. +0xb3    U+2502
  20828. +0xb4    U+2524
  20829. +0xb5    U+2561
  20830. +0xb6    U+2562
  20831. +0xb7    U+2556
  20832. +0xb8    U+2555
  20833. +0xb9    U+2563
  20834. +0xba    U+2551
  20835. +0xbb    U+2557
  20836. +0xbc    U+255d
  20837. +0xbd    U+255c
  20838. +0xbe    U+255b
  20839. +0xbf    U+2510
  20840. +0xc0    U+2514
  20841. +0xc1    U+2534
  20842. +0xc2    U+252c
  20843. +0xc3    U+251c
  20844. +0xc4    U+2500
  20845. +0xc5    U+253c
  20846. +0xc6    U+255e
  20847. +0xc7    U+255f
  20848. +0xc8    U+255a
  20849. +0xc9    U+2554
  20850. +0xca    U+2569
  20851. +0xcb    U+2566
  20852. +0xcc    U+2560
  20853. +0xcd    U+2550
  20854. +0xce    U+256c
  20855. +0xcf    U+2567
  20856. +0xd0    U+2568
  20857. +0xd1    U+2564
  20858. +0xd2    U+2565
  20859. +0xd3    U+2559
  20860. +0xd4    U+2558
  20861. +0xd5    U+2552
  20862. +0xd6    U+2553
  20863. +0xd7    U+256b
  20864. +0xd8    U+256a
  20865. +0xd9    U+2518
  20866. +0xda    U+250c
  20867. +0xdb    U+2588
  20868. +0xdc    U+2584
  20869. +0xdd    U+258c
  20870. +0xde    U+2590
  20871. +0xdf    U+2580
  20872. +#
  20873. +# Greek letters and mathematical symbols
  20874. +#
  20875. +0xe0    U+03b1
  20876. +0xe1    U+03b2 U+00df
  20877. +0xe2    U+0393
  20878. +0xe3    U+03c0
  20879. +0xe4    U+03a3
  20880. +0xe5    U+03c3
  20881. +0xe6    U+00b5 U+03bc
  20882. +0xe7    U+03c4
  20883. +0xe8    U+03a6 U+00d8
  20884. +0xe9    U+0398
  20885. +0xea    U+03a9 U+2126
  20886. +0xeb    U+03b4
  20887. +0xec    U+221e
  20888. +0xed    U+03c6 U+00f8
  20889. +0xee    U+03b5
  20890. +0xef    U+2229
  20891. +0xf0    U+2261
  20892. +0xf1    U+00b1
  20893. +0xf2    U+2265
  20894. +0xf3    U+2264
  20895. +0xf4    U+2320
  20896. +0xf5    U+2321
  20897. +0xf6    U+00f7
  20898. +0xf7    U+2248
  20899. +0xf8    U+00b0
  20900. +0xf9    U+2219
  20901. +0xfa    U+00b7
  20902. +0xfb    U+221a
  20903. +0xfc    U+207f
  20904. +0xfd    U+00b2
  20905. +#
  20906. +# Square bullet, non-spacing blank
  20907. +# Mapping U+fffd to the square bullet means it is the substitution
  20908. +# character
  20909. +# 
  20910. +0xfe    U+25a0 U+fffd
  20911. +0xff    U+00a0
  20912. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/defkeymap.c linux/arch/arm/drivers/char/defkeymap.c
  20913. --- linux.orig/arch/arm/drivers/char/defkeymap.c    Thu Jan  1 01:00:00 1970
  20914. +++ linux/arch/arm/drivers/char/defkeymap.c    Sun Mar  3 12:31:45 1996
  20915. @@ -0,0 +1,337 @@
  20916. +/*
  20917. + * linux/arch/arm/drivers/char/defkeymap.c
  20918. + *
  20919. + * Copyright (C) 1995, 1996 Russell King
  20920. + */
  20921. +
  20922. +#include <linux/types.h>
  20923. +#include <linux/keyboard.h>
  20924. +#include <linux/kd.h>
  20925. +
  20926. +/* Normal (maps 1:1 with no processing) */
  20927. +#define KTn    0xF0
  20928. +/* Function keys */
  20929. +#define KTf    0xF1
  20930. +/* Special (Performs special house-keeping funcs) */
  20931. +#define KTs    0xF2
  20932. +#define KIGNORE        K(KTs, 0)    /* Ignore */
  20933. +#define KENTER        K(KTs, 1)    /* Enter */
  20934. +#define KREGS        K(KTs, 2)    /* Regs */
  20935. +#define KMEM        K(KTs, 3)    /* Mem */
  20936. +#define KSTAT        K(KTs, 4)    /* State */
  20937. +#define KINTR        K(KTs, 5)    /* Intr */
  20938. +#define Ksl    6    /* Last console */
  20939. +#define KCAPSLK        K(KTs, 7)    /* Caps lock */
  20940. +#define KNUMLK        K(KTs, 8)    /* Num-lock */
  20941. +#define KSCRLLK        K(KTs, 9)    /* Scroll-lock */
  20942. +#define KSCRLFOR    K(KTs,10)    /* Scroll forward */
  20943. +#define KSCRLBAK    K(KTs,11)    /* Scroll back */
  20944. +#define KREBOOT        K(KTs,12)    /* Reboot */
  20945. +#define KCAPSON        K(KTs,13)    /* Caps on */
  20946. +#define KCOMPOSE    K(KTs,14)    /* Compose */
  20947. +#define KSAK        K(KTs,15)    /* SAK */
  20948. +#define CONS_DEC    K(KTs,16)    /* Dec console */
  20949. +#define CONS_INC    K(KTs,17)    /* Incr console */
  20950. +#define KFLOPPY        K(KTs,18)    /* Floppy */
  20951. +/* Key pad (0-9 = digits, 10=+, 11=-, 12=*, 13=/, 14=enter, 16=., 17=# */
  20952. +#define KTp    0xF3
  20953. +#define KPAD_0        K(KTp, 0 )
  20954. +#define KPAD_1      K(KTp, 1 )
  20955. +#define KPAD_2        K(KTp, 2 )
  20956. +#define KPAD_3        K(KTp, 3 )
  20957. +#define KPAD_4        K(KTp, 4 )
  20958. +#define KPAD_5        K(KTp, 5 )
  20959. +#define KPAD_6        K(KTp, 6 )
  20960. +#define KPAD_7        K(KTp, 7 )
  20961. +#define KPAD_8        K(KTp, 8 )
  20962. +#define KPAD_9        K(KTp, 9 )
  20963. +#define KPAD_PL        K(KTp,10 )
  20964. +#define KPAD_MI        K(KTp,11 )
  20965. +#define KPAD_ML        K(KTp,12 )
  20966. +#define KPAD_DV        K(KTp,13 )
  20967. +#define KPAD_EN        K(KTp,14 )
  20968. +#define KPAD_DT        K(KTp,16 )
  20969. +#define KPAD_HS        K(KTp,18 )
  20970. +/* Console switching */
  20971. +#define KCn    0xF5
  20972. +/* Cursor */
  20973. +#define KTc    0xF6
  20974. +#define Kcd    0    /* Cursor down */
  20975. +#define Kcl    1    /* Cursor left */
  20976. +#define Kcr    2    /* Cursor right */
  20977. +#define Kcu    3    /* Cursor up */
  20978. +/* Shift/alt modifiers etc */
  20979. +#define KMd    0xF7
  20980. +#define KSHIFT        K(KMd, 0 )
  20981. +#define KALTGR        K(KMd, 1 )
  20982. +#define KCTRL        K(KMd, 2 )
  20983. +#define KALT        K(KMd, 3 )
  20984. +/* Meta */
  20985. +#define KMt    0xF8
  20986. +#define KAs    0xF9
  20987. +#define KPADA_0        K(KAs, 0 )
  20988. +#define KPADA_1        K(KAs, 1 )
  20989. +#define KPADA_2        K(KAs, 2 )
  20990. +#define KPADA_3        K(KAs, 3 )
  20991. +#define KPADA_4        K(KAs, 4 )
  20992. +#define KPADA_5        K(KAs, 5 )
  20993. +#define KPADA_6        K(KAs, 6 )
  20994. +#define KPADA_7        K(KAs, 7 )
  20995. +#define KPADA_8        K(KAs, 8 )
  20996. +#define KPADA_9        K(KAs, 9 )
  20997. +#define KPADB_0        K(KAs,10 )
  20998. +#define KPADB_1        K(KAs,11 )
  20999. +#define KPADB_2        K(KAs,12 )
  21000. +#define KPADB_3        K(KAs,13 )
  21001. +#define KPADB_4        K(KAs,14 )
  21002. +#define KPADB_5        K(KAs,15 )
  21003. +#define KPADB_6        K(KAs,16 )
  21004. +#define KPADB_7        K(KAs,17 )
  21005. +#define KPADB_8        K(KAs,18 )
  21006. +#define KPADB_9        K(KAs,19 )
  21007. +/* Locking keys */
  21008. +#define KLk    0xFA
  21009. +/* Letters */
  21010. +#define KTl    0xFB
  21011. +
  21012. +u_short plain_map[]=
  21013. +{
  21014. +  K(KTn, 27),K(KTf,  0),K(KTf,  1),K(KTf,  2 ),K(KTf,  3),K(KTf,  4),K(KTf,  5 ),K(KTf,  6),
  21015. +  K(KTf,  7),K(KTf,  8),K(KTf,  9),K(KTf, 10 ),K(KTf, 11),KIGNORE   ,KSCRLLK    ,KINTR     ,
  21016. +  K(KTn,'`'),K(KTn,'1'),K(KTn,'2'),K(KTn,'3' ),K(KTn,'4'),K(KTn,'5'),K(KTn,'6' ),K(KTn,'7'),
  21017. +  K(KTn,'8'),K(KTn,'9'),K(KTn,'0'),K(KTn,'-' ),K(KTn,'='),K(KTn,'£'),K(KTn,127 ),K(KTf,21 ),
  21018. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,K(KTn,  9 ),K(KTl,'q'),
  21019. +  K(KTl,'w'),K(KTl,'e'),K(KTl,'r'),K(KTl,'t' ),K(KTl,'y'),K(KTl,'u'),K(KTl,'i' ),K(KTl,'o'),
  21020. +  K(KTl,'p'),K(KTn,'['),K(KTn,']'),K(KTn,'\\'),K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
  21021. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTl,'a'),K(KTl,'s'),K(KTl,'d' ),K(KTl,'f'),
  21022. +  K(KTl,'g'),K(KTl,'h'),K(KTl,'j'),K(KTl,'k' ),K(KTl,'l'),K(KTn,';'),K(KTn,'\''),KENTER    ,
  21023. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTl,'z' ),K(KTl,'x'),
  21024. +  K(KTl,'c'),K(KTl,'v'),K(KTl,'b'),K(KTl,'n' ),K(KTl,'m'),K(KTn,','),K(KTn,'.' ),K(KTn,'/'),
  21025. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn,' '),
  21026. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   
  21027. +};
  21028. +
  21029. +u_short shift_map[]=
  21030. +{
  21031. +  K(KTn, 27),K(KTf, 10),K(KTf, 11),K(KTf, 12 ),K(KTf, 13),K(KTf, 14),K(KTf, 15 ),K(KTf, 16),
  21032. +  K(KTf, 17),K(KTf, 18),K(KTf, 19),K(KTf, 20 ),K(KTf, 21),KIGNORE   ,KMEM       ,KINTR     ,
  21033. +  K(KTn,'~'),K(KTn,'!'),K(KTn,'@'),K(KTn,'#' ),K(KTn,'$'),K(KTn,'%'),K(KTn,'^' ),K(KTn,'&'),
  21034. +  K(KTn,'*'),K(KTn,'('),K(KTn,')'),K(KTn,'_' ),K(KTn,'+'),K(KTn,'¤'),K(KTn,127 ),K(KTf,21 ),
  21035. +  K(KTf,20 ),KSCRLBAK  ,KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,K(KTn,  9 ),K(KTl,'Q'),
  21036. +  K(KTl,'W'),K(KTl,'E'),K(KTl,'R'),K(KTl,'T' ),K(KTl,'Y'),K(KTl,'U'),K(KTl,'I' ),K(KTl,'O'),
  21037. +  K(KTl,'P'),K(KTn,'{'),K(KTn,'}'),K(KTn,'|' ),K(KTf,22 ),K(KTf,23 ),KSCRLFOR   ,KPAD_7    ,
  21038. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTl,'A'),K(KTl,'S'),K(KTl,'D' ),K(KTl,'F'),
  21039. +  K(KTl,'G'),K(KTl,'H'),K(KTl,'J'),K(KTl,'K' ),K(KTl,'L'),K(KTn,':'),K(KTn,'"' ),KENTER    ,
  21040. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTl,'Z' ),K(KTl,'X'),
  21041. +  K(KTl,'C'),K(KTl,'V'),K(KTl,'B'),K(KTl,'N' ),K(KTl,'M'),K(KTn,'<'),K(KTn,'>' ),K(KTn,'?'),
  21042. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn,' '),
  21043. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   
  21044. +};
  21045. +
  21046. +u_short altgr_map[]=
  21047. +{
  21048. +  KIGNORE   ,K(KCn,12 ),K(KCn,13 ),K(KCn,14  ),K(KCn,15 ),K(KCn,16 ),K(KCn,17  ),K(KCn, 18),
  21049. +  K(KCn, 19),K(KCn,20 ),K(KCn,21 ),K(KCn,22  ),K(KCn,23 ),KIGNORE   ,KREGS      ,KINTR     ,
  21050. +  KIGNORE   ,KIGNORE   ,K(KTn,'@'),KIGNORE    ,K(KTn,'$'),KIGNORE   ,KIGNORE    ,K(KTn,'{'),
  21051. +  K(KTn,'['),K(KTn,']'),K(KTn,'}'),K(KTn,'\\'),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
  21052. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KTl,'q'),
  21053. +  K(KTl,'w'),K(KTl,'e'),K(KTl,'r'),K(KTl,'t' ),K(KTl,'y'),K(KTl,'u'),K(KTl,'i' ),K(KTl,'o'),
  21054. +  K(KTl,'p'),KIGNORE   ,K(KTn,'~'),KIGNORE    ,K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPADB_7   ,
  21055. +  KPADB_8   ,KPADB_9   ,KPAD_MI   ,KCTRL      ,K(KAs,20 ),K(KTl,'s'),K(KAs,23  ),K(KAs,25 ),
  21056. +  K(KTl,'g'),K(KTl,'h'),K(KTl,'j'),K(KTl,'k' ),K(KTl,'l'),KIGNORE   ,KIGNORE    ,KENTER    ,
  21057. +  KPADB_4   ,KPADB_5   ,KPADB_6   ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTl,'z' ),K(KTl,'x'),
  21058. +  K(KAs,22 ),K(KTl,'v'),K(KTl,21 ),K(KTl,'n' ),K(KTl,'m'),KIGNORE   ,KIGNORE    ,KIGNORE   ,
  21059. +  KSHIFT    ,K(KTc,Kcu),KPADB_1   ,KPADB_2    ,KPADB_3   ,KCAPSLK   ,KALT       ,KIGNORE   ,
  21060. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPADB_0   ,KPAD_DT    ,KPAD_EN
  21061. +};
  21062. +
  21063. +u_short ctrl_map[]=
  21064. +{
  21065. +  KIGNORE   ,K(KTf,  0),K(KTf,  1),K(KTf,  2 ),K(KTf,  3),K(KTf,  4),K(KTf, 5  ),K(KTf,  6),
  21066. +  K(KTf,  7),K(KTf,  8),K(KTf,  9),K(KTf, 10 ),K(KTf, 11),KIGNORE   ,KSTAT      ,KINTR     ,
  21067. +  KIGNORE   ,K(KTn, 1 ),K(KTn, 2 ),K(KTn, 3  ),K(KTn, 4 ),K(KTn, 5 ),K(KTn, 6  ),K(KTn, 7 ),
  21068. +  K(KTn, 8 ),K(KTn, 9 ),K(KTn, 0 ),K(KTn,31  ),KIGNORE   ,KIGNORE   ,K(KTn, 8  ),K(KTf,21 ),
  21069. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KTn,17 ),
  21070. +  K(KTn,23 ),K(KTn, 5 ),K(KTn,18 ),K(KTn,20  ),K(KTn,25 ),K(KTn,21 ),K(KTn, 9  ),K(KTn,15 ),
  21071. +  K(KTn,16 ),K(KTn,27 ),K(KTn,29 ),K(KTn,28  ),K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
  21072. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTn, 1 ),K(KTn,19 ),K(KTn, 4  ),K(KTn, 6 ),
  21073. +  K(KTn, 7 ),K(KTn, 8 ),K(KTn,10 ),K(KTn,11  ),K(KTn,12 ),KIGNORE   ,K(KTn, 7  ),KENTER    ,
  21074. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTn,26  ),K(KTn,24 ),
  21075. +  K(KTn, 3 ),K(KTn,22 ),K(KTn, 2 ),K(KTn,14  ),K(KTn,13 ),KIGNORE   ,KCOMPOSE   ,K(KTn,127),
  21076. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn, 0 ),
  21077. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   
  21078. +};
  21079. +
  21080. +u_short shift_ctrl_map[]=
  21081. +{
  21082. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
  21083. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KFLOPPY    ,KINTR     ,
  21084. +  KIGNORE   ,KIGNORE   ,K(KTn, 0 ),KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
  21085. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,K(KTn,31  ),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
  21086. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KTn,17 ),
  21087. +  K(KTn,23 ),K(KTn, 5 ),K(KTn,18 ),K(KTn,20  ),K(KTn,25 ),K(KTn,21 ),K(KTn, 9  ),K(KTn,15 ),
  21088. +  K(KTn,16 ),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
  21089. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTn, 1 ),K(KTn,19 ),K(KTn, 4  ),K(KTn, 6 ),
  21090. +  K(KTn, 7 ),K(KTn, 8 ),K(KTn,10 ),K(KTn,11  ),K(KTn,12 ),KIGNORE   ,K(KTn, 7  ),KENTER    ,
  21091. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTn,26  ),K(KTn,24 ),
  21092. +  K(KTn, 3 ),K(KTn,22 ),K(KTn, 2 ),K(KTn,14  ),K(KTn,13 ),KIGNORE   ,KIGNORE    ,KIGNORE   ,
  21093. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn, 0 ),
  21094. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   
  21095. +};
  21096. +
  21097. +u_short alt_map[]=
  21098. +{
  21099. +  K(KMt,27 ),K(KCn, 0 ),K(KCn, 1 ),K(KCn, 2  ),K(KCn, 3 ),K(KCn, 4 ),K(KCn, 5  ),K(KCn, 6 ),
  21100. +  K(KCn, 7 ),K(KCn, 8 ),K(KCn, 9 ),K(KCn,10  ),K(KCn,11 ),KIGNORE   ,KSCRLLK    ,KINTR     ,
  21101. +  K(KMt,'`'),K(KMt,'1'),K(KMt,'2'),K(KMt,'3' ),K(KMt,'4'),K(KMt,'5'),K(KMt,'6' ),K(KMt,'7'),
  21102. +  K(KMt,'8'),K(KMt,'9'),K(KMt,'0'),K(KMt,'-' ),K(KMt,'='),K(KMt,'£'),K(KMt,127 ),K(KTf,21 ),
  21103. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,K(KMt, 9  ),K(KMt,'q'),
  21104. +  K(KMt,'w'),K(KMt,'e'),K(KMt,'r'),K(KMt,'t' ),K(KMt,'y'),K(KMt,'u'),K(KMt,'i' ),K(KMt,'o'),
  21105. +  K(KMt,'p'),K(KMt,'['),K(KMt,']'),K(KMt,'\\'),K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPADA_7   ,
  21106. +  KPADA_8   ,KPADA_9   ,KPAD_MI   ,KCTRL      ,K(KMt,'a'),K(KMt,'s'),K(KMt,'d' ),K(KMt,'f'),
  21107. +  K(KMt,'g'),K(KMt,'h'),K(KMt,'j'),K(KMt,'k' ),K(KMt,'l'),K(KMt,';'),K(KMt,'\''),K(KMt,13 ),
  21108. +  KPADA_4   ,KPADA_5   ,KPADA_6   ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KMt,'z' ),K(KMt,'x'),
  21109. +  K(KMt,'c'),K(KMt,'v'),K(KMt,'b'),K(KMt,'n' ),K(KMt,'m'),K(KMt,','),K(KMt,'.' ),KIGNORE   ,
  21110. +  KSHIFT    ,K(KTc,Kcu),KPADA_1   ,KPADA_2    ,KPADA_3   ,KCAPSLK   ,KALT       ,K(KMt,' '),
  21111. +  KALTGR    ,KCTRL     ,CONS_DEC  ,K(KTc,Kcd ),CONS_INC  ,KPADA_0   ,KPAD_DT    ,KPAD_EN
  21112. +};
  21113. +
  21114. +u_short ctrl_alt_map[]=
  21115. +{
  21116. +  KIGNORE   ,K(KCn, 0 ),K(KCn, 1 ),K(KCn, 2  ),K(KCn, 3 ),K(KCn, 4 ),K(KCn, 5  ),K(KCn, 6 ),
  21117. +  K(KCn, 7 ),K(KCn, 8 ),K(KCn, 9 ),K(KCn,10  ),K(KCn,11 ),KIGNORE   ,KIGNORE    ,KINTR     ,
  21118. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
  21119. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
  21120. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KMt,17 ),
  21121. +  K(KMt,23 ),K(KMt, 5 ),K(KMt,18 ),K(KMt,20  ),K(KMt,25 ),K(KMt,21 ),K(KMt, 9  ),K(KMt,15 ),
  21122. +  K(KMt,16 ),KIGNORE   ,KIGNORE   ,KIGNORE    ,KREBOOT   ,K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
  21123. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KMt, 1 ),K(KMt,19 ),K(KMt, 4  ),K(KMt, 6 ),
  21124. +  K(KMt, 7 ),K(KMt, 8 ),K(KMt,10 ),K(KMt,11  ),K(KMt,12 ),KIGNORE   ,KIGNORE    ,KENTER    ,
  21125. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KMt,26  ),K(KMt,24 ),
  21126. +  K(KMt, 3 ),K(KMt,22 ),K(KMt, 2 ),K(KMt,14  ),K(KMt,13 ),KIGNORE   ,KIGNORE    ,KIGNORE   ,
  21127. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,KIGNORE   ,
  21128. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KREBOOT    ,KPAD_EN
  21129. +};
  21130. +
  21131. +ushort *key_maps[MAX_NR_KEYMAPS] = {
  21132. +    plain_map, shift_map, altgr_map, 0,
  21133. +    ctrl_map, shift_ctrl_map, 0, 0,
  21134. +    alt_map, 0, 0, 0,
  21135. +    ctrl_alt_map,    0
  21136. +};
  21137. +
  21138. +unsigned int keymap_count = 7;
  21139. +
  21140. +/*
  21141. + * Philosophy: most people do not define more strings, but they who do
  21142. + * often want quite a lot of string space. So, we statically allocate
  21143. + * the default and allocate dynamically in chunks of 512 bytes.
  21144. + */
  21145. +
  21146. +char func_buf[] = {
  21147. +    '\033', '[', '[', 'A', 0,
  21148. +    '\033', '[', '[', 'B', 0,
  21149. +    '\033', '[', '[', 'C', 0,
  21150. +    '\033', '[', '[', 'D', 0,
  21151. +    '\033', '[', '[', 'E', 0,
  21152. +    '\033', '[', '1', '7', '~', 0,
  21153. +    '\033', '[', '1', '8', '~', 0,
  21154. +    '\033', '[', '1', '9', '~', 0,
  21155. +    '\033', '[', '2', '0', '~', 0,
  21156. +    '\033', '[', '2', '1', '~', 0,
  21157. +    '\033', '[', '2', '3', '~', 0,
  21158. +    '\033', '[', '2', '4', '~', 0,
  21159. +    '\033', '[', '2', '5', '~', 0,
  21160. +    '\033', '[', '2', '6', '~', 0,
  21161. +    '\033', '[', '2', '8', '~', 0,
  21162. +    '\033', '[', '2', '9', '~', 0,
  21163. +    '\033', '[', '3', '1', '~', 0,
  21164. +    '\033', '[', '3', '2', '~', 0,
  21165. +    '\033', '[', '3', '3', '~', 0,
  21166. +    '\033', '[', '3', '4', '~', 0,
  21167. +    '\033', '[', '1', '~', 0,
  21168. +    '\033', '[', '2', '~', 0,
  21169. +    '\033', '[', '3', '~', 0,
  21170. +    '\033', '[', '4', '~', 0,
  21171. +    '\033', '[', '5', '~', 0,
  21172. +    '\033', '[', '6', '~', 0,
  21173. +    '\033', '[', 'M', 0,
  21174. +    '\033', '[', 'P', 0,
  21175. +};
  21176. +
  21177. +char *funcbufptr = func_buf;
  21178. +int funcbufsize = sizeof(func_buf);
  21179. +int funcbufleft = 0;          /* space left */
  21180. +
  21181. +char *func_table[MAX_NR_FUNC] = {
  21182. +    func_buf + 0,
  21183. +    func_buf + 5,
  21184. +    func_buf + 10,
  21185. +    func_buf + 15,
  21186. +    func_buf + 20,
  21187. +    func_buf + 25,
  21188. +    func_buf + 31,
  21189. +    func_buf + 37,
  21190. +    func_buf + 43,
  21191. +    func_buf + 49,
  21192. +    func_buf + 55,
  21193. +    func_buf + 61,
  21194. +    func_buf + 67,
  21195. +    func_buf + 73,
  21196. +    func_buf + 79,
  21197. +    func_buf + 85,
  21198. +    func_buf + 91,
  21199. +    func_buf + 97,
  21200. +    func_buf + 103,
  21201. +    func_buf + 109,
  21202. +    func_buf + 115,
  21203. +    func_buf + 120,
  21204. +    func_buf + 125,
  21205. +    func_buf + 130,
  21206. +    func_buf + 135,
  21207. +    func_buf + 140,
  21208. +    func_buf + 145,
  21209. +    0,
  21210. +    0,
  21211. +    func_buf + 149,
  21212. +    0,
  21213. +};
  21214. +
  21215. +struct kbdiacr accent_table[MAX_DIACR] = {
  21216. +    {'`', 'A', '\300'},    {'`', 'a', '\340'},
  21217. +    {'\'', 'A', '\301'},    {'\'', 'a', '\341'},
  21218. +    {'^', 'A', '\302'},    {'^', 'a', '\342'},
  21219. +    {'~', 'A', '\303'},    {'~', 'a', '\343'},
  21220. +    {'"', 'A', '\304'},    {'"', 'a', '\344'},
  21221. +    {'O', 'A', '\305'},    {'o', 'a', '\345'},
  21222. +    {'0', 'A', '\305'},    {'0', 'a', '\345'},
  21223. +    {'A', 'A', '\305'},    {'a', 'a', '\345'},
  21224. +    {'A', 'E', '\306'},    {'a', 'e', '\346'},
  21225. +    {',', 'C', '\307'},    {',', 'c', '\347'},
  21226. +    {'`', 'E', '\310'},    {'`', 'e', '\350'},
  21227. +    {'\'', 'E', '\311'},    {'\'', 'e', '\351'},
  21228. +    {'^', 'E', '\312'},    {'^', 'e', '\352'},
  21229. +    {'"', 'E', '\313'},    {'"', 'e', '\353'},
  21230. +    {'`', 'I', '\314'},    {'`', 'i', '\354'},
  21231. +    {'\'', 'I', '\315'},    {'\'', 'i', '\355'},
  21232. +    {'^', 'I', '\316'},    {'^', 'i', '\356'},
  21233. +    {'"', 'I', '\317'},    {'"', 'i', '\357'},
  21234. +    {'-', 'D', '\320'},    {'-', 'd', '\360'},
  21235. +    {'~', 'N', '\321'},    {'~', 'n', '\361'},
  21236. +    {'`', 'O', '\322'},    {'`', 'o', '\362'},
  21237. +    {'\'', 'O', '\323'},    {'\'', 'o', '\363'},
  21238. +    {'^', 'O', '\324'},    {'^', 'o', '\364'},
  21239. +    {'~', 'O', '\325'},    {'~', 'o', '\365'},
  21240. +    {'"', 'O', '\326'},    {'"', 'o', '\366'},
  21241. +    {'/', 'O', '\330'},    {'/', 'o', '\370'},
  21242. +    {'`', 'U', '\331'},    {'`', 'u', '\371'},
  21243. +    {'\'', 'U', '\332'},    {'\'', 'u', '\372'},
  21244. +    {'^', 'U', '\333'},    {'^', 'u', '\373'},
  21245. +    {'"', 'U', '\334'},    {'"', 'u', '\374'},
  21246. +    {'\'', 'Y', '\335'},    {'\'', 'y', '\375'},
  21247. +    {'T', 'H', '\336'},    {'t', 'h', '\376'},
  21248. +    {'s', 's', '\337'},    {'"', 'y', '\377'},
  21249. +    {'s', 'z', '\337'},    {'i', 'j', '\377'},
  21250. +};
  21251. +
  21252. +unsigned int accent_table_size = 68;
  21253. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/diacr.h linux/arch/arm/drivers/char/diacr.h
  21254. --- linux.orig/arch/arm/drivers/char/diacr.h    Thu Jan  1 01:00:00 1970
  21255. +++ linux/arch/arm/drivers/char/diacr.h    Thu Aug  8 23:34:50 1996
  21256. @@ -0,0 +1,8 @@
  21257. +#ifndef _DIACR_H
  21258. +#define _DIACR_H
  21259. +#include <linux/kd.h>
  21260. +
  21261. +extern struct kbdiacr accent_table[];
  21262. +extern unsigned int accent_table_size;
  21263. +
  21264. +#endif /* _DIACR_H */
  21265. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/kbd_kern.h linux/arch/arm/drivers/char/kbd_kern.h
  21266. --- linux.orig/arch/arm/drivers/char/kbd_kern.h    Thu Jan  1 01:00:00 1970
  21267. +++ linux/arch/arm/drivers/char/kbd_kern.h    Sat Sep  7 10:31:12 1996
  21268. @@ -0,0 +1,131 @@
  21269. +#ifndef _KBD_KERN_H
  21270. +#define _KBD_KERN_H
  21271. +
  21272. +#include <linux/interrupt.h>
  21273. +#include <linux/keyboard.h>
  21274. +
  21275. +extern int shift_state;
  21276. +extern char *func_table[MAX_NR_FUNC];
  21277. +extern char func_buf[];
  21278. +extern char *funcbufptr;
  21279. +extern int funcbufsize, funcbufleft;
  21280. +
  21281. +#ifndef _VT_KERN_H
  21282. +#include "vt_kern.h"
  21283. +#endif
  21284. +
  21285. +extern void compute_shiftstate (void);
  21286. +extern int kbd_struct_init (struct vt *vt, int init);
  21287. +extern int kbd_ioctl (struct vt *vt, int cmd, unsigned long arg);
  21288. +extern int kbd_init (void);
  21289. +
  21290. +/*
  21291. + * kbd->xxx contains the VC-local things (flag settings etc..)
  21292. + *
  21293. + * Note: externally visible are LED_SCR, LED_NUM, LED_CAP defined in kd.h
  21294. + *       The code in KDGETLED / KDSETLED depends on the internal and
  21295. + *       external order being the same.
  21296. + *
  21297. + * Note: lockstate is used as index in the array key_map.
  21298. + */
  21299. +struct kbd_struct {
  21300. +
  21301. +    unsigned char lockstate;
  21302. +/* 8 modifiers - the names do not have any meaning at all;
  21303. +   they can be associated to arbitrarily chosen keys */
  21304. +#define VC_SHIFTLOCK    KG_SHIFT    /* shift lock mode */
  21305. +#define VC_ALTGRLOCK    KG_ALTGR    /* altgr lock mode */
  21306. +#define VC_CTRLLOCK    KG_CTRL     /* control lock mode */
  21307. +#define VC_ALTLOCK    KG_ALT      /* alt lock mode */
  21308. +#define VC_SHIFTLLOCK    KG_SHIFTL    /* shiftl lock mode */
  21309. +#define VC_SHIFTRLOCK    KG_SHIFTR    /* shiftr lock mode */
  21310. +#define VC_CTRLLLOCK    KG_CTRLL     /* ctrll lock mode */
  21311. +#define VC_CTRLRLOCK    KG_CTRLR     /* ctrlr lock mode */
  21312. +    unsigned char slockstate;     /* for `sticky' Shift, Ctrl, etc. */
  21313. +
  21314. +    unsigned char ledmode:2;     /* one 2-bit value */
  21315. +#define LED_SHOW_FLAGS 0        /* traditional state */
  21316. +#define LED_SHOW_IOCTL 1        /* only change leds upon ioctl */
  21317. +#define LED_SHOW_MEM 2          /* `heartbeat': peek into memory */
  21318. +
  21319. +    unsigned char ledflagstate:3;    /* flags, not lights */
  21320. +    unsigned char default_ledflagstate:3;
  21321. +#define VC_SCROLLOCK    0    /* scroll-lock mode */
  21322. +#define VC_NUMLOCK    1    /* numeric lock mode */
  21323. +#define VC_CAPSLOCK    2    /* capslock mode */
  21324. +
  21325. +    unsigned char kbdmode:2;    /* one 2-bit value */
  21326. +#define VC_XLATE    0    /* translate keycodes using keymap */
  21327. +#define VC_MEDIUMRAW    1    /* medium raw (keycode) mode */
  21328. +#define VC_RAW        2    /* raw (scancode) mode */
  21329. +#define VC_UNICODE    3    /* Unicode mode */
  21330. +
  21331. +    unsigned char modeflags:5;
  21332. +#define VC_APPLIC    0    /* application key mode */
  21333. +#define VC_CKMODE    1    /* cursor key mode */
  21334. +#define VC_REPEAT    2    /* keyboard repeat */
  21335. +#define VC_CRLF        3    /* 0 - enter sends CR, 1 - enter sends CRLF */
  21336. +#define VC_META        4    /* 0 - meta, 1 - meta=prefix with ESC */
  21337. +};
  21338. +
  21339. +extern unsigned char getledstate(void);
  21340. +extern void setledstate(struct kbd_struct *kbd, unsigned int led);
  21341. +
  21342. +extern inline void set_leds(void)
  21343. +{
  21344. +    mark_bh(KEYBOARD_BH);
  21345. +}
  21346. +
  21347. +extern inline int vc_kbd_mode(struct kbd_struct * kbd, int flag)
  21348. +{
  21349. +    return ((kbd->modeflags >> flag) & 1);
  21350. +}
  21351. +
  21352. +extern inline int vc_kbd_led(struct kbd_struct * kbd, int flag)
  21353. +{
  21354. +    return ((kbd->ledflagstate >> flag) & 1);
  21355. +}
  21356. +
  21357. +extern inline void set_vc_kbd_mode(struct kbd_struct * kbd, int flag)
  21358. +{
  21359. +    kbd->modeflags |= 1 << flag;
  21360. +}
  21361. +
  21362. +extern inline void set_vc_kbd_led(struct kbd_struct * kbd, int flag)
  21363. +{
  21364. +    kbd->ledflagstate |= 1 << flag;
  21365. +}
  21366. +
  21367. +extern inline void clr_vc_kbd_mode(struct kbd_struct * kbd, int flag)
  21368. +{
  21369. +    kbd->modeflags &= ~(1 << flag);
  21370. +}
  21371. +
  21372. +extern inline void clr_vc_kbd_led(struct kbd_struct * kbd, int flag)
  21373. +{
  21374. +    kbd->ledflagstate &= ~(1 << flag);
  21375. +}
  21376. +
  21377. +extern inline void chg_vc_kbd_lock(struct kbd_struct * kbd, int flag)
  21378. +{
  21379. +    kbd->lockstate ^= 1 << flag;
  21380. +}
  21381. +
  21382. +extern inline void chg_vc_kbd_slock(struct kbd_struct * kbd, int flag)
  21383. +{
  21384. +    kbd->slockstate ^= 1 << flag;
  21385. +}
  21386. +
  21387. +extern inline void chg_vc_kbd_mode(struct kbd_struct * kbd, int flag)
  21388. +{
  21389. +    kbd->modeflags ^= 1 << flag;
  21390. +}
  21391. +
  21392. +extern inline void chg_vc_kbd_led(struct kbd_struct * kbd, int flag)
  21393. +{
  21394. +    kbd->ledflagstate ^= 1 << flag;
  21395. +}
  21396. +
  21397. +#define U(x) ((x) ^ 0xf000)
  21398. +
  21399. +#endif
  21400. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/kbdmouse.c linux/arch/arm/drivers/char/kbdmouse.c
  21401. --- linux.orig/arch/arm/drivers/char/kbdmouse.c    Thu Jan  1 01:00:00 1970
  21402. +++ linux/arch/arm/drivers/char/kbdmouse.c    Tue Jul  2 09:47:58 1996
  21403. @@ -0,0 +1,178 @@
  21404. +/*
  21405. + * linux/arch/arm/drivers/char/kbdmouse.c
  21406. + *
  21407. + * Copyright (C) 1995, 1996 Russell King
  21408. + *
  21409. + * Medium-level interface for quadrature mouse connected to the keyboard.
  21410. + */
  21411. +
  21412. +#include <linux/module.h>
  21413. +
  21414. +#include <linux/kernel.h>
  21415. +#include <linux/sched.h>
  21416. +#include <linux/signal.h>
  21417. +#include <linux/errno.h>
  21418. +#include <linux/mm.h>
  21419. +#include <linux/miscdevice.h>
  21420. +#include <linux/random.h>
  21421. +
  21422. +#include <asm/system.h>
  21423. +#include <asm/segment.h>
  21424. +
  21425. +char   mouse_buttons;
  21426. +int    mouse_dxpos;
  21427. +int    mouse_dypos;
  21428. +int    mouse_present;
  21429. +char   mouse_ready;
  21430. +char   mouse_active;
  21431. +struct wait_queue *mouse_wait;
  21432. +struct fasync_struct *fasyncptr;
  21433. +
  21434. +static int fasync_mouse(struct inode *inode, struct file *filp, int on)
  21435. +{
  21436. +    int retval;
  21437. +
  21438. +    retval = fasync_helper(inode, filp, on, &fasyncptr);
  21439. +    if (retval < 0)
  21440. +    return retval;
  21441. +    return 0;
  21442. +}
  21443. +
  21444. +static void close_mouse(struct inode *inode, struct file *file)
  21445. +{
  21446. +    fasync_mouse (inode, file, 0);
  21447. +    if (--mouse_active)
  21448. +    return;
  21449. +    mouse_ready = 0;
  21450. +
  21451. +    MOD_DEC_USE_COUNT;
  21452. +}
  21453. +
  21454. +static int open_mouse(struct inode *inode,struct file *file)
  21455. +{
  21456. +    unsigned long flags;
  21457. +
  21458. +    if (!mouse_present)
  21459. +    return -EINVAL;
  21460. +    if (mouse_active++)
  21461. +    return 0;
  21462. +
  21463. +    save_flags_cli (flags);
  21464. +    mouse_active  = 1;
  21465. +    mouse_ready   = 0;
  21466. +    mouse_dxpos   = 0;
  21467. +    mouse_dypos   = 0;
  21468. +    mouse_buttons = 0;
  21469. +    restore_flags (flags);
  21470. +
  21471. +    MOD_INC_USE_COUNT;
  21472. +
  21473. +    return 0;
  21474. +}
  21475. +
  21476. +static int write_mouse(struct inode *inode,struct file *file,const char *buffer,int count)
  21477. +{
  21478. +    return -EINVAL;
  21479. +}
  21480. +
  21481. +static int read_mouse(struct inode *inode,struct file *file,char *buffer,int count)
  21482. +{
  21483. +    unsigned long flags;
  21484. +    int dxpos, dypos, i, buttons;
  21485. +
  21486. +    if (count < 3)
  21487. +    return -EINVAL;
  21488. +    if ((i = verify_area(VERIFY_WRITE, buffer, count)))
  21489. +    return i;
  21490. +    if (!mouse_ready)
  21491. +    return -EAGAIN;
  21492. +
  21493. +    save_flags_cli (flags);
  21494. +
  21495. +    dxpos = mouse_dxpos;
  21496. +    dypos = mouse_dypos;
  21497. +    buttons = mouse_buttons ^ 7;
  21498. +
  21499. +    if (dxpos < -127)
  21500. +    dxpos =- 127;
  21501. +    if (dxpos > 127)
  21502. +    dxpos = 127;
  21503. +    if (dypos <- 127)
  21504. +    dypos =- 127;
  21505. +    if (dypos > 127)
  21506. +    dypos = 127;
  21507. +
  21508. +    mouse_dxpos -= dxpos;
  21509. +    mouse_dypos -= dypos;
  21510. +    mouse_ready = 0;
  21511. +
  21512. +    restore_flags (flags);
  21513. +
  21514. +    put_fs_byte ((char) buttons | 0x80, buffer);
  21515. +    put_fs_byte ((char) dxpos, buffer + 1);
  21516. +    put_fs_byte ((char) dypos, buffer + 2);
  21517. +    for(i = 3; i < count; i++)
  21518. +    put_fs_byte (0x00, buffer + i);
  21519. +
  21520. +    return i;
  21521. +}
  21522. +
  21523. +static int select_mouse(struct inode *inode,struct file *file,int sel_type,select_table *wait)
  21524. +{
  21525. +    if (sel_type == SEL_IN) {
  21526. +    if (mouse_ready)
  21527. +        return 1;
  21528. +    select_wait (&mouse_wait,wait);
  21529. +    }
  21530. +    return 0;
  21531. +}
  21532. +
  21533. +struct file_operations kbd_mouse_fops=
  21534. +{
  21535. +    NULL,            /* mouse_seek */
  21536. +    read_mouse,
  21537. +    write_mouse,
  21538. +    NULL,            /* mouse_readdir */
  21539. +    select_mouse,
  21540. +    NULL,            /* mouse_ioctl */
  21541. +    NULL,            /* mouse_mmap */
  21542. +    open_mouse,
  21543. +    close_mouse,
  21544. +    NULL,
  21545. +    fasync_mouse,
  21546. +};
  21547. +
  21548. +static struct miscdevice kbd_mouse = {
  21549. +    6, "kbdmouse", &kbd_mouse_fops, NULL, NULL
  21550. +};
  21551. +
  21552. +int arch_mouse_init(void)
  21553. +{
  21554. +    unsigned long flags;
  21555. +
  21556. +    save_flags_cli (flags);
  21557. +
  21558. +    mouse_buttons=0;
  21559. +    mouse_dxpos  =0;
  21560. +    mouse_dypos  =0;
  21561. +    mouse_present=1;
  21562. +    mouse_ready  =0;
  21563. +    mouse_active =0;
  21564. +    mouse_wait   =NULL;
  21565. +
  21566. +    restore_flags (flags);
  21567. +    misc_register (&kbd_mouse);
  21568. +    return 0;
  21569. +}
  21570. +
  21571. +#ifdef MODULE
  21572. +int init_module(void)
  21573. +{
  21574. +    return arch_mouse_init();
  21575. +}
  21576. +
  21577. +void cleanup_module(void)
  21578. +{
  21579. +    misc_deregister (&kbd_mouse);
  21580. +}
  21581. +#endif
  21582. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/keyboard.c linux/arch/arm/drivers/char/keyboard.c
  21583. --- linux.orig/arch/arm/drivers/char/keyboard.c    Thu Jan  1 01:00:00 1970
  21584. +++ linux/arch/arm/drivers/char/keyboard.c    Sat Aug 24 18:34:06 1996
  21585. @@ -0,0 +1,1769 @@
  21586. +/*
  21587. + * linux/arch/arm/drivers/block/keyboard.c
  21588. + *
  21589. + * Keyboard driver for Linux using Latin-1.
  21590. + *
  21591. + * Written for linux by Johan Myreen as a translation from
  21592. + * the assembly version by Linus (with diacriticals added)
  21593. + *
  21594. + * Some additional features added by Christoph Niemann (ChN), March 1993
  21595. + *
  21596. + * Loadable keymaps by Risto Kankkunen, May 1993
  21597. + *
  21598. + * Diacriticals redone & other small changes, aeb@cwi.nl, June 93
  21599. + * Added decr/incr_console, dynamic keymaps, unicode support,
  21600. + * dynamic function/string keys, led setting,  Sept 1994
  21601. + * `Sticky' modifier keys, 951006
  21602. + *
  21603. + * Majorly altered for use with arm Russell King (rmk92@ecs.soton.ac.uk).
  21604. + */
  21605. +
  21606. +#define IRQ_KEYBOARDRX 15
  21607. +#define IRQ_KEYBOARDTX 14
  21608. +
  21609. +#define VERSION 104
  21610. +
  21611. +#include <linux/config.h>
  21612. +#include <linux/sched.h>
  21613. +#include <linux/interrupt.h>
  21614. +#include <linux/tty.h>
  21615. +#include <linux/tty_flip.h>
  21616. +#include <linux/mm.h>
  21617. +#include <linux/malloc.h>
  21618. +#include <linux/ptrace.h>
  21619. +#include <linux/signal.h>
  21620. +#include <linux/timer.h>
  21621. +#include <linux/random.h>
  21622. +#include <linux/ctype.h>
  21623. +
  21624. +#include <asm/bitops.h>
  21625. +#include <asm/irq.h>
  21626. +#include <asm/hardware.h>
  21627. +
  21628. +#include "kbd_kern.h"
  21629. +#include "diacr.h"
  21630. +#include "vt_kern.h"
  21631. +
  21632. +#define SIZE(x) (sizeof(x)/sizeof((x)[0]))
  21633. +
  21634. +#define KBD_REPORT_ERR
  21635. +#define KBD_REPORT_UNKN
  21636. +
  21637. +#ifndef KBD_DEFMODE
  21638. +#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
  21639. +#endif
  21640. +
  21641. +#ifndef KBD_DEFLEDS
  21642. +/*
  21643. + * Starts with NumLock off.
  21644. + */
  21645. +#define KBD_DEFLEDS 0
  21646. +#endif
  21647. +
  21648. +#ifndef KBD_DEFLOCK
  21649. +#define KBD_DEFLOCK 0
  21650. +#endif
  21651. +
  21652. +#define REPEAT_TIMEOUT HZ*300/1000
  21653. +#define REPEAT_RATE    HZ*30/1000
  21654. +
  21655. +/*
  21656. + * these are the valid i/o ports we're allowed to change. they map all the
  21657. + * video ports
  21658. + */
  21659. +#define GPFIRST 0x3b4
  21660. +#define GPLAST 0x3df
  21661. +#define GPNUM (GPLAST - GPFIRST + 1)
  21662. +
  21663. +extern ushort *key_maps[];
  21664. +extern unsigned int keymap_count;
  21665. +extern void ctrl_alt_del (void);
  21666. +
  21667. +/*
  21668. + * global state includes the following, and various static variables
  21669. + * in this module: shift_state, diacr, npadch, dead_key_next.
  21670. + * (last console is now a global variable).
  21671. + */
  21672. +
  21673. +/* shift state counters.. */
  21674. +static unsigned char k_down[NR_SHIFT] = {0, };
  21675. +/*
  21676. + * Key down counters
  21677. + */
  21678. +#define BITS_PER_SHORT (8*sizeof (unsigned short))
  21679. +static unsigned short key_down[256/BITS_PER_SHORT] = {0, };
  21680. +
  21681. +extern struct vt *last_console;
  21682. +static struct vt *want_console;
  21683. +static int dead_key_next;
  21684. +/*
  21685. + * In order to retrieve the shift_state (for the mouse server), either
  21686. + * the variable must be global, or a new procedure must be created to
  21687. + * return the value. I chose the former way.
  21688. + */
  21689. +/*static*/ int shift_state;
  21690. +static int npadch            = -1;        /* -1 or number assembled on pad */
  21691. +static unsigned char diacr;
  21692. +static char rep;                /* Flag telling character repeat */
  21693. +static int kbd_repeatkey     = -1;
  21694. +static int kbd_repeattimeout = REPEAT_TIMEOUT;
  21695. +static int kbd_repeatrate    = REPEAT_RATE;
  21696. +static int kbd_id            = -1;
  21697. +static struct wait_queue *kbd_waitq;
  21698. +
  21699. +static struct kbd_struct * kbd = NULL;
  21700. +static struct tty_struct * tty = NULL;
  21701. +
  21702. +extern void compute_shiftstate (void);
  21703. +
  21704. +typedef void (*k_hand)(unsigned char value, char up_flag);
  21705. +typedef void (k_handfn)(unsigned char value, char up_flag);
  21706. +
  21707. +static k_handfn
  21708. +    do_self, do_fn, do_spec, do_pad, do_dead, do_cons, do_cur, do_shift,
  21709. +    do_meta, do_ascii, do_lock, do_lowercase, do_slock, do_ignore;
  21710. +
  21711. +static k_hand key_handler[16] = {
  21712. +    do_self, do_fn, do_spec, do_pad, do_dead, do_cons, do_cur, do_shift,
  21713. +    do_meta, do_ascii, do_lock, do_lowercase, do_slock,
  21714. +    do_ignore, do_ignore, do_ignore
  21715. +};
  21716. +
  21717. +typedef void (*void_fnp)(void);
  21718. +typedef void (void_fn)(void);
  21719. +
  21720. +static void_fn do_null, enter, show_ptregs, send_intr, lastcons, caps_toggle,
  21721. +    num, hold, scroll_forw, scroll_back, boot_it, caps_on, compose,
  21722. +    SAK, decr_console, incr_console, spawn_console, show_stack, bare_num;
  21723. +
  21724. +static void_fnp spec_fn_table[] = {
  21725. +    do_null,    enter,        show_ptregs,    show_mem,
  21726. +    show_state,    send_intr,    lastcons,    caps_toggle,
  21727. +    num,        hold,        scroll_forw,    scroll_back,
  21728. +    boot_it,    caps_on,    compose,    SAK,
  21729. +    decr_console,    incr_console,    show_stack,     bare_num
  21730. +};
  21731. +
  21732. +/* maximum values each key_handler can handle */
  21733. +const int max_vals[] = {
  21734. +    255, SIZE(func_table) - 1, SIZE(spec_fn_table) - 1, NR_PAD - 1,
  21735. +    NR_DEAD - 1, 255, 3, NR_SHIFT - 1,
  21736. +    255, NR_ASCII - 1, NR_LOCK - 1, 255,
  21737. +    NR_LOCK - 1
  21738. +};
  21739. +
  21740. +const int NR_TYPES = SIZE(max_vals);
  21741. +
  21742. +static void put_queue(int);
  21743. +static unsigned char handle_diacr(unsigned char);
  21744. +
  21745. +/* pt_regs - set by keyboard_interrupt(), used by show_ptregs() */
  21746. +static struct pt_regs * pt_regs;
  21747. +
  21748. +/*
  21749. + * Many other routines do put_queue, but I think either
  21750. + * they produce ASCII, or they produce some user-assigned
  21751. + * string, and in both cases we might assume that it is
  21752. + * in utf-8 already.
  21753. + */
  21754. +void to_utf8(ushort c) {
  21755. +    if (c < 0x80)
  21756. +    put_queue(c);            /*  0*******  */
  21757. +    else if (c < 0x800) {
  21758. +    put_queue(0xc0 | (c >> 6));     /*  110***** 10******  */
  21759. +    put_queue(0x80 | (c & 0x3f));
  21760. +    } else {
  21761. +    put_queue(0xe0 | (c >> 12));     /*  1110**** 10****** 10******  */
  21762. +    put_queue(0x80 | ((c >> 6) & 0x3f));
  21763. +    put_queue(0x80 | (c & 0x3f));
  21764. +    }
  21765. +     /* uft-8 is defined for words of up to 36 bits,
  21766. +       but we need only 16 bits here */
  21767. +}
  21768. +
  21769. +/*
  21770. + * ARM mouse specifics stuff.
  21771. + *
  21772. + * Since the mouse movements and buttons are part of the
  21773. + * keyboard protocol, we have to handle this part in this
  21774. + * driver.  The mouse specific parts are in arcmouse.c.
  21775. + */
  21776. +#ifdef CONFIG_KBDMOUSE
  21777. +extern struct wait_queue *mouse_wait;
  21778. +extern char        mouse_buttons;
  21779. +extern int        mouse_dxpos;
  21780. +extern int        mouse_dypos;
  21781. +extern char        mouse_ready;
  21782. +#endif
  21783. +/*
  21784. + * Protocol codes to send the keyboard.
  21785. + */
  21786. +/* reset keyboard */
  21787. +#define HRST 0xff
  21788. +/* reset response */
  21789. +#define RAK1 0xfe
  21790. +/* reset response */
  21791. +#define RAK2 0xfd
  21792. +/* Ack for first keyboard pair */
  21793. +#define BACK 0x3f
  21794. +/* Last data byte ack (key scanning + mouse movement scanning) */
  21795. +#define SMAK 0x33
  21796. +/* Last data byte ack (mouse movement scanning) */
  21797. +#define MACK 0x32
  21798. +/* Last data byte ack (key scanning) */
  21799. +#define SACK 0x31
  21800. +/* Last data byte ack (no scanning, mouse data) */
  21801. +#define NACK 0x30
  21802. +/* Request mouse data */
  21803. +#define RQMP 0x22
  21804. +/* nothing */
  21805. +#define PRST 0x21
  21806. +/* Request ID */
  21807. +#define RQID 0x20
  21808. +
  21809. +#define UP_FLAG 0x0100
  21810. +
  21811. +static unsigned char    kbd_sendvala[4];
  21812. +static unsigned char    kbd_sendptri;
  21813. +static unsigned char    kbd_sendptro;
  21814. +static unsigned char    ledstate;
  21815. +static unsigned char    getleds(void);
  21816. +
  21817. +/*
  21818. + * This array converts the scancode that we get from the keyboard to the
  21819. + * real rows/columns on the A5000 keyboard.  This might be keyboard specific...
  21820. + *
  21821. + * It is these values that we use to maintain the key down array.  That way, we
  21822. + * should pick up on the ghost key presses (which is what happens when you press
  21823. + * three keys, and the keyboard thinks you have pressed four!)
  21824. + *
  21825. + * Row 8 (0x80+c) is actually a column with one key per row.  It is isolated from
  21826. + * the other keys, and can't cause these problems (its used for shift, ctrl, alt etc).
  21827. + *
  21828. + * Illegal scancodes are denoted by an 0xff (in other words, we don't know about
  21829. + * them, and can't process them for ghosts).  This does however, cause problems with
  21830. + * autorepeat processing...
  21831. + */
  21832. +static unsigned char scancode_2_colrow[256] = {
  21833. +  0x01, 0x42, 0x32, 0x33, 0x43, 0x56, 0x5a, 0x6c, 0x7c, 0x5c, 0x5b, 0x6b, 0x7b, 0x84, 0x70, 0x60,
  21834. +  0x11, 0x51, 0x62, 0x63, 0x44, 0x54, 0x55, 0x45, 0x46, 0x4a, 0x3c, 0x4b, 0x59, 0x49, 0x69, 0x79,
  21835. +  0x83, 0x40, 0x30, 0x3b, 0x39, 0x38, 0x31, 0x61, 0x72, 0x73, 0x64, 0x74, 0x75, 0x65, 0x66, 0x6a,
  21836. +  0x1c, 0x2c, 0x7a, 0x36, 0x48, 0x68, 0x78, 0x20, 0x2b, 0x29, 0x28, 0x81, 0x71, 0x22, 0x23, 0x34,
  21837. +  0x24, 0x25, 0x35, 0x26, 0x3a, 0x0c, 0x2a, 0x76, 0x10, 0x1b, 0x19, 0x18, 0x82, 0xff, 0x21, 0x12,
  21838. +  0x13, 0x14, 0x04, 0x05, 0x15, 0x16, 0x1a, 0x0a, 0x85, 0x77, 0x00, 0x0b, 0x09, 0x02, 0x80, 0x03,
  21839. +  0x87, 0x86, 0x06, 0x17, 0x27, 0x07, 0x37, 0x08, 0xff,
  21840. +};
  21841. +
  21842. +static unsigned short ghost_down[128/BITS_PER_SHORT];
  21843. +
  21844. +/*
  21845. + * As yet, we don't support setting and getting the
  21846. + * key codes.  I'll have to find out where this is used.
  21847. + */
  21848. +int setkeycode(unsigned int scancode, unsigned int keycode)
  21849. +{
  21850. +#if 0
  21851. +    if (scancode < SC_LIM || scancode > 255 || keycode > 127)
  21852. +        return -EINVAL;
  21853. +    if (scancode < 128)
  21854. +        high_keys[scancode - SC_LIM] = keycode;
  21855. +    else
  21856. +        e0_keys[scancode - 128] = keycode;
  21857. +    return 0;
  21858. +#else
  21859. +    return -EINVAL;
  21860. +#endif
  21861. +}
  21862. +
  21863. +int getkeycode(unsigned int scancode)
  21864. +{
  21865. +#if 0
  21866. +    return
  21867. +        (scancode < SC_LIM || scancode > 255) ? -EINVAL :
  21868. +        (scancode < 128) ? high_keys[scancode - SC_LIM] :
  21869. +        e0_keys[scancode - 128];
  21870. +#else
  21871. +    return -EINVAL;
  21872. +#endif
  21873. +}
  21874. +
  21875. +
  21876. +/* ----------------------------------------------------------------------------------------- */
  21877. +/*
  21878. + * This is the keyboard specific part.
  21879. + */
  21880. +static void key_callback(unsigned long nr)
  21881. +{
  21882. +  rep = 1;
  21883. +  mark_bh (KEYBOARD_BH);
  21884. +}
  21885. +
  21886. +static struct timer_list key_timer =
  21887. +{
  21888. +  NULL, NULL, 0, 0, key_callback
  21889. +};
  21890. +
  21891. +static void kbd_key(unsigned int raw_keycode, int repeat_timeout)
  21892. +{
  21893. +    unsigned int up_flag;
  21894. +    unsigned int keycode;
  21895. +    unsigned char real_keycode;
  21896. +
  21897. +    up_flag = raw_keycode & UP_FLAG;
  21898. +    keycode = raw_keycode & 255;
  21899. +
  21900. +    /*
  21901. +     * Separate out the mouse stuff first
  21902. +     */
  21903. +    if (keycode >= 0x70 && keycode <= 0x72) {
  21904. +#ifdef CONFIG_KBDMOUSE
  21905. +    switch (keycode) {
  21906. +    case 0x70: /* Left mouse button */
  21907. +        if (up_flag)
  21908. +        mouse_buttons &= ~4;
  21909. +        else
  21910. +        mouse_buttons |= 4;
  21911. +        break;
  21912. +
  21913. +    case 0x71: /* Middle mouse button */
  21914. +        if (up_flag)
  21915. +        mouse_buttons &= ~2;
  21916. +        else
  21917. +        mouse_buttons |= 2;
  21918. +        break;
  21919. +
  21920. +    case 0x72:/* Right mouse button */
  21921. +        if (up_flag)
  21922. +        mouse_buttons &= ~1;
  21923. +        else
  21924. +        mouse_buttons |= 1;
  21925. +        break;
  21926. +    default:
  21927. +#ifdef KBD_REPORT_UNKN
  21928. +        printk ("kbd: unknown scancode 0x%04x\n", raw_keycode);
  21929. +#endif
  21930. +        return;
  21931. +    }
  21932. +    add_mouse_randomness (mouse_buttons << 16);
  21933. +    mouse_ready = 1;
  21934. +    wake_up_interruptible (&mouse_wait);
  21935. +#endif
  21936. +    mark_bh (KEYBOARD_BH);
  21937. +    return;
  21938. +    }
  21939. +
  21940. +    if (keycode >= 0x70) {
  21941. +#ifdef KBD_REPORT_UNKN
  21942. +    printk ("kbd: unknown scancode 0x%04x\n", raw_keycode);
  21943. +#endif
  21944. +    return;
  21945. +    }
  21946. +
  21947. +    real_keycode = scancode_2_colrow[keycode];
  21948. +
  21949. +    /*
  21950. +     * We have to work out if we accept this key press as a real key, or
  21951. +     * if it is a ghost.  IE. If you press three keys, the keyboard will think
  21952. +     * that you've pressed a fouth: (@ = key down, # = ghost)
  21953. +     *
  21954. +     *   0 1 2 3 4 5 6 7
  21955. +     *   | | | | | | | |
  21956. +     * 0-+-+-+-+-+-+-+-+-
  21957. +     *   | | | | | | | |
  21958. +     * 1-+-@-+-+-+-@-+-+-
  21959. +     *   | | | | | | | |
  21960. +     * 2-+-+-+-+-+-+-+-+-
  21961. +     *   | | | | | | | |
  21962. +     * 3-+-@-+-+-+-#-+-+-
  21963. +     *   | | | | | | | |
  21964. +     *
  21965. +     * This is what happens when you have a matrix keyboard...
  21966. +     */
  21967. +
  21968. +    if ((real_keycode & 0x80) == 0) {
  21969. +    int rr, kc = (real_keycode >> 4) & 7;
  21970. +    int cc;
  21971. +    unsigned short res, kdownkc;
  21972. +
  21973. +    kdownkc = ghost_down[kc] | (1 << (real_keycode & 15));
  21974. +
  21975. +    for (rr = 0; rr < 128/BITS_PER_SHORT; rr++)
  21976. +        if (rr != kc && (res = ghost_down[rr] & kdownkc)) {
  21977. +            /*
  21978. +         * we have found a second row with at least one key pressed in the
  21979. +             * same column.
  21980. +             */
  21981. +            for (cc = 0; res; res >>= 1)
  21982. +            cc += (res & 1);
  21983. +
  21984. +        if (cc > 1)
  21985. +            return; /* ignore it */
  21986. +        }
  21987. +    if (up_flag)
  21988. +        clear_bit (real_keycode, ghost_down);
  21989. +    else
  21990. +        set_bit (real_keycode, ghost_down);
  21991. +
  21992. +    }
  21993. +
  21994. +    if (kbd_repeatkey == (raw_keycode & ~UP_FLAG) || !up_flag)
  21995. +    kbd_repeatkey = -1;
  21996. +
  21997. +    add_keyboard_randomness (raw_keycode);
  21998. +
  21999. +    /*
  22000. +     * We have to disable interrupts here to prevent the timer from
  22001. +     * being put on the list twice or a key being released during
  22002. +     * the processing of autorepeat
  22003. +     */
  22004. +    del_timer (&key_timer);
  22005. +
  22006. +    tty = *vtdata.fgconsole->tty;
  22007. +    kbd = vtdata.fgconsole->kbd;
  22008. +
  22009. +    if (up_flag) {
  22010. +        rep = 0;
  22011. +    clear_bit (keycode, key_down);
  22012. +    /* don't report an error if key is already up - happens when a ghost key is released */
  22013. +    } else
  22014. +    rep = set_bit (keycode, key_down);
  22015. +
  22016. +    if (kbd->kbdmode == VC_RAW || kbd->kbdmode == VC_MEDIUMRAW) {
  22017. +    put_queue (keycode | (up_flag ? 0x80 : 0));
  22018. +    return;
  22019. +    }
  22020. +
  22021. +    /*
  22022. +     * We have to do our own auto-repeat processing...
  22023. +     */
  22024. +    if (!up_flag && repeat_timeout) {
  22025. +        kbd_repeatkey = raw_keycode;
  22026. +    if (vc_kbd_mode(kbd, VC_REPEAT)) {
  22027. +        key_timer.expires = jiffies + repeat_timeout;
  22028. +        add_timer(&key_timer);
  22029. +    }
  22030. +    }
  22031. +
  22032. +    /*
  22033. +     * Repeat a key only if the input buffers are empty or the
  22034. +     * characters get echoed locally.  This makes key repeat
  22035. +     * usable with slow applications and under heavy loads.
  22036. +     */
  22037. +    if (!rep || (vc_kbd_mode (kbd, VC_REPEAT) && tty &&
  22038. +               (L_ECHO(tty) || (tty->driver.chars_in_buffer (tty) == 0)))) {
  22039. +    u_short keysym;
  22040. +    u_char  type;
  22041. +
  22042. +    /* the XOR below used to be an OR */
  22043. +    int     shift_final = shift_state ^ kbd->lockstate ^ kbd->slockstate;
  22044. +    u_short *key_map = key_maps[shift_final];
  22045. +
  22046. +    if (key_map != NULL) {
  22047. +        keysym = key_map[keycode];
  22048. +        type   = KTYP(keysym);
  22049. +
  22050. +        if (type >= 0xf0) {
  22051. +        type -= 0xf0;
  22052. +
  22053. +        if (type == KT_LETTER) {
  22054. +            type = KT_LATIN;
  22055. +            if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
  22056. +            key_map = key_maps[shift_final ^ (1<<KG_SHIFT)];
  22057. +            if (key_map)
  22058. +                keysym = key_map[keycode];
  22059. +            }
  22060. +        }
  22061. +        (*key_handler[type])(keysym & 0xff, up_flag ? 0x80 : 0);
  22062. +        if (type != KT_SLOCK)
  22063. +            kbd->slockstate = 0;
  22064. +        } else {
  22065. +        if (!up_flag)
  22066. +            to_utf8(keysym);
  22067. +        }
  22068. +    } else {
  22069. +        /*
  22070. +         * maybe beep?
  22071. +         * we have at least to update shift_state
  22072. +         * how? two almost equivalent choices follow
  22073. +         */
  22074. +#if 1
  22075. +        compute_shiftstate ();
  22076. +#else
  22077. +        keysym = U(plain_map[keycode]);
  22078. +        type   = KTYP(keysym);
  22079. +        if (type == KT_SHIFT)
  22080. +        (*key_handler[type]) (keysym & 0xff, up_flag ? 0x80 : 0);
  22081. +#endif
  22082. +    }
  22083. +    }
  22084. +}
  22085. +
  22086. +static void kbd_sendval(unsigned char val)
  22087. +{
  22088. +    kbd_sendvala[kbd_sendptri] = val;
  22089. +    kbd_sendptri = (kbd_sendptri + 1) & 3;
  22090. +    disable_irq (15);
  22091. +    enable_irq (14);
  22092. +}
  22093. +
  22094. +static void kbd_tx(int irq, void *dev_id, struct pt_regs *regs)
  22095. +{
  22096. +  if(kbd_sendptri != kbd_sendptro) {
  22097. +    IOC_KARTTX = kbd_sendvala[kbd_sendptro];
  22098. +    kbd_sendptro = (kbd_sendptro + 1) & 3;
  22099. +  }
  22100. +  if(kbd_sendptri == kbd_sendptro) {
  22101. +    disable_irq (14);
  22102. +    enable_irq (15);
  22103. +  }
  22104. +}
  22105. +
  22106. +static void kbd_reset(void)
  22107. +{
  22108. +    int i;
  22109. +
  22110. +    for (i = 0; i < NR_SHIFT; i++)
  22111. +    k_down[i] = 0;
  22112. +
  22113. +    for (i = 0; i < 256/BITS_PER_SHORT; i++)
  22114. +    key_down[i] = 0;
  22115. +
  22116. +    for (i = 0; i < 128/BITS_PER_SHORT; i++)
  22117. +    ghost_down[i] = 0;
  22118. +
  22119. +    shift_state = 0;
  22120. +}
  22121. +
  22122. +/*
  22123. + * Keyboard states:
  22124. + *  0 initial reset condition, sent HRST, wait for HRST
  22125. + *  1 Send HRST, wait for HRST acknowledge
  22126. + *  2 Sent RAK1, wait for RAK1
  22127. + *  3 Sent RAK2, wait for RAK2
  22128. + *  4 Sent SMAK, wait for anything
  22129. + *  5 Wait for second keyboard nibble for key pressed
  22130. + *  6 Wait for second keyboard nibble for key released
  22131. + *  7 Wait for second part of mouse data
  22132. + */
  22133. +#define KBD_INITRST    0
  22134. +#define KBD_RAK1    1
  22135. +#define KBD_RAK2    2
  22136. +#define KBD_ID        3
  22137. +#define KBD_IDLE    4
  22138. +#define KBD_KEYDOWN    5
  22139. +#define KBD_KEYUP    6
  22140. +#define KBD_MOUSE    7
  22141. +
  22142. +static void kbd_rx(int irq, void *dev_id, struct pt_regs *regs)
  22143. +{
  22144. +    int keyval;
  22145. +    static signed char kbd_mousedx=0;
  22146. +           signed char kbd_mousedy;
  22147. +    static unsigned char kbd_state=KBD_INITRST;
  22148. +    static unsigned char kbd_keyhigh=0;
  22149. +
  22150. +    pt_regs = regs;
  22151. +
  22152. +    keyval = IOC_KARTRX;
  22153. +
  22154. +    switch(kbd_state) {
  22155. +    case KBD_INITRST: /* hard reset - sent HRST */
  22156. +    if (keyval == HRST) {
  22157. +        kbd_reset ();
  22158. +        kbd_sendval (RAK1);
  22159. +        kbd_state = KBD_RAK1;
  22160. +    } else
  22161. +        goto kbd_wontreset;
  22162. +    break;
  22163. +
  22164. +    case KBD_RAK1:/* Sent RAK1 */
  22165. +    switch (keyval) {
  22166. +    case HRST:
  22167. +        kbd_sendval (RAK1);
  22168. +        kbd_state = KBD_INITRST;
  22169. +        break;
  22170. +    case RAK1:
  22171. +        kbd_sendval (RAK2);
  22172. +        kbd_state = KBD_RAK2;
  22173. +        break;
  22174. +    default:
  22175. +        goto kbd_wontreset;
  22176. +    }
  22177. +    break;
  22178. +
  22179. +    case KBD_RAK2:/* Sent RAK2 */
  22180. +    switch (keyval) {
  22181. +    case HRST:
  22182. +        kbd_sendval (HRST);
  22183. +        kbd_state = KBD_INITRST;
  22184. +        break;
  22185. +    case RAK2:
  22186. +        if (kbd_id == -1) {
  22187. +        kbd_sendval (NACK);
  22188. +        kbd_sendval (RQID);
  22189. +        kbd_state = KBD_ID;
  22190. +        } else {
  22191. +        kbd_sendval (SMAK);
  22192. +        kbd_state = KBD_IDLE;
  22193. +        ledstate  = 0xff;
  22194. +        mark_bh (KEYBOARD_BH);
  22195. +        }
  22196. +        break;
  22197. +    default:
  22198. +        goto kbd_wontreset;
  22199. +    }
  22200. +    break;
  22201. +
  22202. +    case KBD_ID:
  22203. +    if (keyval == HRST) {
  22204. +        kbd_sendval (HRST);
  22205. +        kbd_state = KBD_INITRST;
  22206. +        kbd_id = -2;
  22207. +        wake_up(&kbd_waitq);
  22208. +        break;
  22209. +    } else
  22210. +    if ((keyval & 0xc0) == 0x80) {
  22211. +        kbd_id = keyval & 0x3f;
  22212. +        kbd_sendval (SMAK);
  22213. +        kbd_state = KBD_IDLE;
  22214. +        ledstate  = 0xff;
  22215. +        mark_bh (KEYBOARD_BH);
  22216. +        wake_up(&kbd_waitq);
  22217. +        break;
  22218. +    }
  22219. +    break;
  22220. +
  22221. +    case KBD_IDLE:/* Send SMAK, ready for any reply */
  22222. +    if (keyval == HRST) {
  22223. +        kbd_sendval (HRST);
  22224. +        kbd_state = KBD_INITRST;
  22225. +    } else
  22226. +    if (keyval & 0x80) {
  22227. +        if (!(keyval & 0x40)) {
  22228. +            if (kbd_id == -1)
  22229. +            kbd_id = keyval & 0x3f;
  22230. +        else {
  22231. +            kbd_state = KBD_INITRST;
  22232. +            kbd_sendval (HRST);
  22233. +        }
  22234. +        break;
  22235. +        }
  22236. +        switch (keyval & 0xf0) {
  22237. +        case 0xc0:
  22238. +        kbd_keyhigh = keyval;
  22239. +        kbd_state   = KBD_KEYDOWN;
  22240. +        kbd_sendval (BACK);
  22241. +        break;
  22242. +
  22243. +        case 0xd0:
  22244. +        kbd_keyhigh = keyval;
  22245. +        kbd_state   = KBD_KEYUP;
  22246. +        kbd_sendval (BACK);
  22247. +        break;
  22248. +
  22249. +        default:
  22250. +        kbd_state = KBD_INITRST;
  22251. +        kbd_sendval (HRST);
  22252. +        }
  22253. +    } else {
  22254. +        kbd_mousedx = keyval & 0x40 ? keyval|0x80 : keyval;
  22255. +        kbd_state   = KBD_MOUSE;
  22256. +        kbd_sendval (BACK);
  22257. +    }
  22258. +    break;
  22259. +
  22260. +    case KBD_KEYDOWN:
  22261. +    if ((keyval & 0xf0) != 0xc0)
  22262. +        goto kbd_error;
  22263. +    else {
  22264. +        kbd_state = KBD_IDLE;
  22265. +        kbd_sendval (SMAK);
  22266. +        if (((kbd_keyhigh ^ keyval) & 0xf0) == 0) {
  22267. +        kbd_key ((keyval & 0x0f) | ((kbd_keyhigh << 4) & 0xf0), kbd_repeattimeout);
  22268. +        mark_bh (KEYBOARD_BH);
  22269. +        }
  22270. +    }
  22271. +    break;
  22272. +
  22273. +    case KBD_KEYUP:
  22274. +    if ((keyval & 0xf0) != 0xd0)
  22275. +        goto kbd_error;
  22276. +    else {
  22277. +        kbd_state = KBD_IDLE;
  22278. +        kbd_sendval (SMAK);
  22279. +        if (((kbd_keyhigh ^ keyval) & 0xf0) == 0) {
  22280. +        kbd_key ((keyval & 0x0f) | ((kbd_keyhigh << 4) & 0xf0) | UP_FLAG, 0);
  22281. +        mark_bh (KEYBOARD_BH);
  22282. +        }
  22283. +    }
  22284. +    break;
  22285. +
  22286. +    case KBD_MOUSE:
  22287. +    if (keyval & 0x80)
  22288. +        goto kbd_error;
  22289. +    else {
  22290. +        kbd_state = KBD_IDLE;
  22291. +        kbd_sendval (SMAK);
  22292. +        kbd_mousedy = (char)(keyval & 0x40 ? keyval | 0x80 : keyval);
  22293. +#ifdef CONFIG_KBDMOUSE
  22294. +        mouse_dypos += (int)kbd_mousedy;
  22295. +        mouse_dxpos += (int)kbd_mousedx;
  22296. +        add_mouse_randomness ((mouse_buttons << 16) + (kbd_mousedy << 8) + kbd_mousedx);
  22297. +        mouse_ready = 1;
  22298. +        wake_up_interruptible (&mouse_wait);
  22299. +#endif
  22300. +        mark_bh (KEYBOARD_BH);
  22301. +    }
  22302. +    break;
  22303. +    }
  22304. +    return;
  22305. +kbd_wontreset:
  22306. +#ifdef KBD_REPORT_ERR
  22307. +    printk ("kbd: keyboard won't reset (kbdstate %d, keyval %02X)\n", kbd_state,
  22308. +        keyval);
  22309. +#endif
  22310. +    kbd_sendval (HRST);
  22311. +    kbd_state = KBD_INITRST;
  22312. +    return;
  22313. +kbd_error:
  22314. +#ifdef KBD_REPORT_ERR
  22315. +    printk ("kbd: keyboard out of sync - resetting\n");
  22316. +#endif
  22317. +    kbd_sendval (HRST);
  22318. +    kbd_state = KBD_INITRST;
  22319. +    return;
  22320. +}
  22321. +
  22322. +/* ----------------------------------------------------------------------------------------- */
  22323. +/*
  22324. + * Here starts a copy of the PC keyboard code from linux/drivers/char/keyboard.c
  22325. + */
  22326. +
  22327. +static void put_queue (int ch)
  22328. +{
  22329. +    wake_up (&keypress_wait);
  22330. +    if (tty) {
  22331. +    tty_insert_flip_char (tty, ch, 0);
  22332. +    tty_schedule_flip (tty);
  22333. +    }
  22334. +}
  22335. +
  22336. +static void puts_queue(char *cp)
  22337. +{
  22338. +    wake_up (&keypress_wait);
  22339. +    if (!tty)
  22340. +    return;
  22341. +
  22342. +    while (*cp)
  22343. +    tty_insert_flip_char (tty, *cp++, 0);
  22344. +    tty_schedule_flip (tty);
  22345. +}
  22346. +
  22347. +static void applkey(int key, char mode)
  22348. +{
  22349. +    static char buf[] = { 0x1b, 'O', 0x00, 0x00};
  22350. +
  22351. +    buf[1] = (mode ? 'O' : '[');
  22352. +    buf[2] = key;
  22353. +    puts_queue(buf);
  22354. +}
  22355. +
  22356. +static void enter(void)
  22357. +{
  22358. +    put_queue (13);
  22359. +    if (vc_kbd_mode(kbd, VC_CRLF))
  22360. +    put_queue (10);
  22361. +}
  22362. +
  22363. +static void caps_toggle(void)
  22364. +{
  22365. +    if(rep)
  22366. +    return;
  22367. +    chg_vc_kbd_led(kbd, VC_CAPSLOCK);
  22368. +}
  22369. +
  22370. +static void caps_on (void)
  22371. +{
  22372. +    if (rep)
  22373. +    return;
  22374. +    set_vc_kbd_led (kbd, VC_CAPSLOCK);
  22375. +}
  22376. +
  22377. +static void show_ptregs (void)
  22378. +{
  22379. +    if (pt_regs)
  22380. +    show_regs (pt_regs);
  22381. +}
  22382. +
  22383. +static void show_stack (void)
  22384. +{
  22385. +    unsigned long *p;
  22386. +    unsigned long *q = (unsigned long *)((int)current->kernel_stack_page + 4096);
  22387. +    int i;
  22388. +    __asm__("mov %0, sp\n\t": "=r" (p));
  22389. +
  22390. +    for(i=0; p < q; p++, i++) {
  22391. +    if(i && !(i & 7))
  22392. +        printk("\n");
  22393. +    printk("%08lX ", *p);
  22394. +    }
  22395. +}
  22396. +
  22397. +static void hold (void)
  22398. +{
  22399. +    if(rep || !tty)
  22400. +    return;
  22401. +
  22402. +    /*
  22403. +     * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
  22404. +     * these routines are also activated by ^S/^Q.
  22405. +     * (And SCROLLOCK can also be set by the KDSKBLED.)
  22406. +     */
  22407. +    if (tty->stopped)
  22408. +    start_tty (tty);
  22409. +    else
  22410. +    stop_tty (tty);
  22411. +}
  22412. +
  22413. +static void num (void)
  22414. +{
  22415. +    if(vc_kbd_mode(kbd,VC_APPLIC))
  22416. +    applkey('P', 1);
  22417. +    else
  22418. +        bare_num ();
  22419. +}
  22420. +
  22421. +/*
  22422. + * Bind this to Shift-NumLock if you work in application keypad mode
  22423. + * but want to be able to change the NumLock flag.
  22424. + * Bind this to NumLock if you prefer that the NumLock key always
  22425. + * changes the NumLock flag.
  22426. + */
  22427. +static void bare_num (void)
  22428. +{
  22429. +    if (!rep)
  22430. +    chg_vc_kbd_led (kbd, VC_NUMLOCK);
  22431. +}
  22432. +
  22433. +static void lastcons (void)
  22434. +{
  22435. +    want_console = last_console;
  22436. +}
  22437. +
  22438. +static void decr_console (void)
  22439. +{
  22440. +    int i;
  22441. +    int fgnum = vtdata.fgconsole->num - 1;
  22442. +
  22443. +    for (i = fgnum - 1; i != fgnum; i--) {
  22444. +    if (i == -1)
  22445. +        i = MAX_NR_CONSOLES - 1;
  22446. +    if (vt_allocated (vt_con_data + i))
  22447. +        break;
  22448. +    }
  22449. +    want_console = vt_con_data + i;
  22450. +}
  22451. +
  22452. +static void incr_console (void)
  22453. +{
  22454. +    int i;
  22455. +    int fgnum = vtdata.fgconsole->num - 1;
  22456. +
  22457. +    for (i = fgnum + 1; i != fgnum; i++) {
  22458. +    if (i == MAX_NR_CONSOLES)
  22459. +        i = 0;
  22460. +    if (vt_allocated (vt_con_data + i))
  22461. +        break;
  22462. +    }
  22463. +    want_console = vt_con_data + i;
  22464. +}
  22465. +
  22466. +static void send_intr (void)
  22467. +{
  22468. +    if (!tty)
  22469. +    return;
  22470. +    tty_insert_flip_char (tty, 0, TTY_BREAK);
  22471. +    tty_schedule_flip (tty);
  22472. +}
  22473. +
  22474. +static void scroll_forw (void)
  22475. +{
  22476. +}
  22477. +
  22478. +static void scroll_back (void)
  22479. +{
  22480. +}
  22481. +
  22482. +static void boot_it (void)
  22483. +{
  22484. +    ctrl_alt_del();
  22485. +}
  22486. +
  22487. +static void compose (void)
  22488. +{
  22489. +    dead_key_next = 1;
  22490. +}
  22491. +
  22492. +static int spawnpid, spawnsig;
  22493. +
  22494. +static void spawn_console (void)
  22495. +{
  22496. +    if (spawnpid)
  22497. +    if (kill_proc (spawnpid, spawnsig, 1))
  22498. +        spawnpid = 0;
  22499. +}
  22500. +
  22501. +static void SAK (void)
  22502. +{
  22503. +    do_SAK(tty);
  22504. +#if 0
  22505. +    /*
  22506. +     * Need to fix SAK handling to fix up RAW/MEDIUM_RAW and
  22507. +     * vt_cons modes before we can enable RAW/MEDIUM_RAW SAK
  22508. +     * handling.
  22509. +     *
  22510. +     * We should do this some day --- the whole point of a secure
  22511. +     * attention key is that it should be guaranteed to always
  22512. +     * work.
  22513. +     */
  22514. +    vt_reset (vtdata.fgconsole);
  22515. +    do_unblank_screen ();    /* not in interrupt routine? */
  22516. +#endif
  22517. +}
  22518. +
  22519. +static void do_ignore (unsigned char value, char up_flag)
  22520. +{
  22521. +}
  22522. +
  22523. +static void do_null (void)
  22524. +{
  22525. +    compute_shiftstate ();
  22526. +}
  22527. +
  22528. +static void do_spec (unsigned char value,char up_flag)
  22529. +{
  22530. +    if (up_flag)
  22531. +    return;
  22532. +    if (value >= SIZE(spec_fn_table))
  22533. +    return;
  22534. +    if (!spec_fn_table[value])
  22535. +    return;
  22536. +    spec_fn_table[value] ();
  22537. +}
  22538. +
  22539. +static void do_lowercase (unsigned char value, char up_flag)
  22540. +{
  22541. +    printk("keyboard.c: do_lowercase was called - impossible\n");
  22542. +}
  22543. +
  22544. +static void do_self(unsigned char value, char up_flag)
  22545. +{
  22546. +    if (up_flag)
  22547. +    return;        /* no action, if this is a key release */
  22548. +
  22549. +    if (diacr)
  22550. +    value = handle_diacr (value);
  22551. +
  22552. +    if (dead_key_next) {
  22553. +    dead_key_next = 0;
  22554. +    diacr = value;
  22555. +    return;
  22556. +    }
  22557. +    put_queue (value);
  22558. +}
  22559. +
  22560. +#define A_GRAVE '`'
  22561. +#define A_ACUTE '\''
  22562. +#define A_CFLEX '^'
  22563. +#define A_TILDE '~'
  22564. +#define A_DIAER '"'
  22565. +static unsigned char ret_diacr[] = {A_GRAVE, A_ACUTE, A_CFLEX, A_TILDE, A_DIAER };
  22566. +
  22567. +static void do_dead(unsigned char value, char up_flag)
  22568. +{
  22569. +    if (up_flag)
  22570. +    return;
  22571. +
  22572. +    value = ret_diacr[value];
  22573. +    if (diacr == value) { /* pressed twice */
  22574. +    diacr = 0;
  22575. +    put_queue (value);
  22576. +    return;
  22577. +    }
  22578. +    diacr = value;
  22579. +}
  22580. +
  22581. +static unsigned char handle_diacr(unsigned char ch)
  22582. +{
  22583. +    int d = diacr;
  22584. +    int i;
  22585. +
  22586. +    diacr = 0;
  22587. +    if (ch == ' ')
  22588. +    return d;
  22589. +
  22590. +    for (i = 0; i < accent_table_size; i++) {
  22591. +    if (accent_table[i].diacr == d && accent_table[i].base == ch)
  22592. +        return accent_table[i].result;
  22593. +    }
  22594. +
  22595. +    put_queue (d);
  22596. +    return ch;
  22597. +}
  22598. +
  22599. +static void do_cons(unsigned char value, char up_flag)
  22600. +{
  22601. +    if (up_flag)
  22602. +    return;
  22603. +    want_console = vt_con_data + value;
  22604. +}
  22605. +
  22606. +static void do_fn(unsigned char value, char up_flag)
  22607. +{
  22608. +    if (up_flag)
  22609. +    return;
  22610. +
  22611. +    if (value < SIZE(func_table)) {
  22612. +    if (func_table[value])
  22613. +        puts_queue (func_table[value]);
  22614. +    } else
  22615. +    printk ("do_fn called with value=%d\n",value);
  22616. +}
  22617. +
  22618. +static void do_pad(unsigned char value, char up_flag)
  22619. +{
  22620. +    static char *pad_chars = "0123456789+-*/\015,.?#";
  22621. +    static char *app_map   = "pqrstuvwxylmRQMnn?S";
  22622. +
  22623. +    if (up_flag)
  22624. +    return;
  22625. +
  22626. +    if (vc_kbd_mode (kbd, VC_APPLIC) && !k_down[KG_SHIFT]) {
  22627. +    applkey (app_map[value], 1);
  22628. +    return;
  22629. +    }
  22630. +
  22631. +    if (!vc_kbd_led (kbd,VC_NUMLOCK))
  22632. +    switch (value) {
  22633. +        case 15:
  22634. +        case 16: do_fn (22, 0); return;
  22635. +        case 7:  do_fn (20, 0); return;
  22636. +        case 8:  do_cur( 3, 0); return;
  22637. +        case 9:  do_fn (24, 0); return;
  22638. +        case 4:  do_cur( 1, 0); return;
  22639. +        case 6:  do_cur( 2, 0); return;
  22640. +        case 1:  do_fn (23, 0); return;
  22641. +        case 2:  do_cur( 0, 0); return;
  22642. +        case 3:  do_fn (25, 0); return;
  22643. +        case 5:  applkey('G',vc_kbd_mode(kbd, VC_APPLIC)); return;
  22644. +    }
  22645. +
  22646. +    put_queue (pad_chars[value]);
  22647. +    if (value == 14 && vc_kbd_mode (kbd, VC_CRLF))
  22648. +    put_queue (10);
  22649. +}
  22650. +
  22651. +static void do_cur(unsigned char value, char up_flag)
  22652. +{
  22653. +    static char *cur_chars = "BDCA";
  22654. +
  22655. +    if (up_flag)
  22656. +    return;
  22657. +
  22658. +    applkey (cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
  22659. +}
  22660. +
  22661. +static void do_shift(unsigned char value, char up_flag)
  22662. +{
  22663. +    int old_state = shift_state;
  22664. +
  22665. +    if (rep)
  22666. +    return;
  22667. +
  22668. +    /* Mimic typewriter: a CapsShift key acts like Shift but undoes CapsLock */
  22669. +    if (value == KVAL(K_CAPSSHIFT)) {
  22670. +    value = KVAL(K_SHIFT);
  22671. +    if (!up_flag)
  22672. +        clr_vc_kbd_led (kbd, VC_CAPSLOCK);
  22673. +    }
  22674. +
  22675. +    if(up_flag) {
  22676. +    /* handle the case that two shift or control
  22677. +       keys are depressed simultaneously */
  22678. +    if(k_down[value])
  22679. +        k_down[value]--;
  22680. +    } else
  22681. +    k_down[value]++;
  22682. +
  22683. +    if(k_down[value])
  22684. +    shift_state |= (1 << value);
  22685. +    else
  22686. +    shift_state &= ~ (1 << value);
  22687. +
  22688. +    /* kludge */
  22689. +    if(up_flag && shift_state != old_state && npadch != -1) {
  22690. +    if(kbd->kbdmode == VC_UNICODE)
  22691. +        to_utf8(npadch & 0xffff);
  22692. +    else
  22693. +        put_queue(npadch & 0xff);
  22694. +    npadch = -1;
  22695. +    }
  22696. +}
  22697. +
  22698. +/*
  22699. + * Called after returning from RAW mode or when changing consoles -
  22700. + * recompute k_down[] and shift_state from key_down[]
  22701. + * Maybe called when keymap is undefined so that shift key release is seen
  22702. + */
  22703. +void compute_shiftstate(void)
  22704. +{
  22705. +    int i, j, k, sym, val;
  22706. +
  22707. +    shift_state = 0;
  22708. +    for (i = 0; i < SIZE(k_down); i++)
  22709. +    k_down[i] = 0;
  22710. +
  22711. +    for (i = 0; i < SIZE(key_down); i++)
  22712. +    if (key_down[i]) {            /* skip this short word if zero */
  22713. +        k = i * BITS_PER_SHORT;
  22714. +        for (j = 0; j < BITS_PER_SHORT; j++, k++)
  22715. +        if (test_bit (k, key_down)) {
  22716. +            sym = U(plain_map[k]);
  22717. +            if (KTYP(sym) == KT_SHIFT) {
  22718. +            val = KVAL (sym);
  22719. +            if (val == KVAL(K_CAPSSHIFT))
  22720. +                val = KVAL(K_SHIFT);
  22721. +            k_down[val] ++;
  22722. +            shift_state |= (1 << val);
  22723. +            }
  22724. +        }
  22725. +    }
  22726. +}
  22727. +
  22728. +static void do_meta(unsigned char value, char up_flag)
  22729. +{
  22730. +    if(up_flag)
  22731. +    return;
  22732. +
  22733. +    if(vc_kbd_mode(kbd, VC_META)) {
  22734. +    put_queue ('\033');
  22735. +    put_queue (value);
  22736. +    } else
  22737. +    put_queue (value | 0x80);
  22738. +}
  22739. +
  22740. +static void do_ascii(unsigned char value, char up_flag)
  22741. +{
  22742. +    int base;
  22743. +
  22744. +    if(up_flag)
  22745. +    return;
  22746. +
  22747. +    if(value < 10)
  22748. +    base = 10;
  22749. +    else {
  22750. +    value -= 10;
  22751. +    base = 16;
  22752. +    }
  22753. +
  22754. +    if(npadch == -1)
  22755. +    npadch = value;
  22756. +    else
  22757. +    npadch = npadch * base + value;
  22758. +}
  22759. +
  22760. +static void do_lock (unsigned char value, char up_flag)
  22761. +{
  22762. +    if (up_flag || rep)
  22763. +    return;
  22764. +    chg_vc_kbd_lock (kbd, value);
  22765. +}
  22766. +
  22767. +static void do_slock (unsigned char value, char up_flag)
  22768. +{
  22769. +    if (up_flag || rep)
  22770. +    return;
  22771. +    chg_vc_kbd_slock (kbd, value);
  22772. +}
  22773. +
  22774. +/* --------------------------------------------------------------------------------------- *
  22775. + * Led driver                                           *
  22776. + * --------------------------------------------------------------------------------------- */
  22777. +
  22778. +/*
  22779. + * The leds display either
  22780. + * (i)   The status of NumLock, CapsLock and ScrollLock.
  22781. + * (ii)  Whatever pattern of lights people wait to show using KDSETLED.
  22782. + * (iii) Specified bits of specified words in kernel memory.
  22783. + */
  22784. +
  22785. +static unsigned char ledioctl;
  22786. +
  22787. +unsigned char getledstate(void)
  22788. +{
  22789. +    return ledstate;
  22790. +}
  22791. +
  22792. +void setledstate(struct kbd_struct *kbd, unsigned int led)
  22793. +{
  22794. +    if(!(led & ~7)) {
  22795. +    ledioctl = led;
  22796. +    kbd->ledmode = LED_SHOW_IOCTL;
  22797. +    } else
  22798. +    kbd->ledmode = LED_SHOW_FLAGS;
  22799. +    set_leds();
  22800. +}
  22801. +
  22802. +static struct ledptr
  22803. +{
  22804. +    unsigned int *addr;
  22805. +    unsigned int mask;
  22806. +    unsigned char valid:1;
  22807. +} ledptrs[3];
  22808. +
  22809. +void register_leds(int console, unsigned int led, unsigned int *addr, unsigned int mask)
  22810. +{
  22811. +    struct kbd_struct *kbd = vt_con_data[console].kbd;
  22812. +
  22813. +    if(led < 3) {
  22814. +    ledptrs[led].addr = addr;
  22815. +    ledptrs[led].mask = mask;
  22816. +    ledptrs[led].valid= 1;
  22817. +    kbd->ledmode = LED_SHOW_MEM;
  22818. +    } else
  22819. +    kbd->ledmode = LED_SHOW_FLAGS;
  22820. +}
  22821. +
  22822. +static inline unsigned char getleds(void)
  22823. +{
  22824. +    struct kbd_struct *kbd = vtdata.fgconsole->kbd;
  22825. +    unsigned char leds;
  22826. +
  22827. +    if(kbd->ledmode == LED_SHOW_IOCTL)
  22828. +    return ledioctl;
  22829. +
  22830. +    leds = kbd->ledflagstate;
  22831. +    if (kbd->ledmode == LED_SHOW_MEM) {
  22832. +    if (ledptrs[0].valid) {
  22833. +        if (*ledptrs[0].addr & ledptrs[0].mask)
  22834. +        leds |= 1;
  22835. +        else
  22836. +        leds &= ~1;
  22837. +        }
  22838. +    if (ledptrs[1].valid) {
  22839. +        if (*ledptrs[1].addr & ledptrs[1].mask)
  22840. +        leds |= 2;
  22841. +        else
  22842. +        leds &= ~2;
  22843. +        }
  22844. +    if (ledptrs[2].valid) {
  22845. +        if(*ledptrs[2].addr & ledptrs[2].mask)
  22846. +        leds |= 4;
  22847. +        else
  22848. +        leds &= ~4;
  22849. +        }
  22850. +    }
  22851. +    return leds;
  22852. +}
  22853. +
  22854. +/*
  22855. + * This routine is the bottom half of the keyboard interrupt
  22856. + * routine, and runs with all interrupts enabled.  It does
  22857. + * console changing, led setting, and copy_to_cooked, which can
  22858. + * take a reasonably long time.
  22859. + *
  22860. + * Aside from timing (which isn't really that important for
  22861. + * keyboard interrupts as they happen often), using the software
  22862. + * interrupt routines for this thing allows us to easily mask
  22863. + * this when we don't want any of the above to happen.  Not yet
  22864. + * used, but this allows for easy and efficient race-condition
  22865. + * prevention later on.
  22866. + */
  22867. +static void kbd_bh(void)
  22868. +{
  22869. +    unsigned char leds;
  22870. +
  22871. +    tty = *vtdata.fgconsole->tty;
  22872. +    kbd = vtdata.fgconsole->kbd;
  22873. +
  22874. +    if (rep) {
  22875. +    /*
  22876. +     * This prevents the kbd_key routine from being called
  22877. +     * twice, once by this BH, and once by the interrupt
  22878. +     * routine.  Maybe we should put the key press in a
  22879. +     * buffer or variable, and then call the BH...
  22880. +     */
  22881. +        disable_irq (IRQ_KEYBOARDRX);
  22882. +    if (kbd_repeatkey != -1)
  22883. +        kbd_key (kbd_repeatkey, kbd_repeatrate);
  22884. +    enable_irq (IRQ_KEYBOARDRX);
  22885. +    rep = 0;
  22886. +    }
  22887. +
  22888. +    if (want_console) {
  22889. +    if(want_console != vtdata.fgconsole) {
  22890. +        vt_changeconsole (want_console);
  22891. +        /* we only changed when the console had already
  22892. +         * been allocated - a new console is not created
  22893. +         * in an interrupt routine.
  22894. +         */
  22895. +    }
  22896. +    want_console = NULL;
  22897. +    }
  22898. +
  22899. +    leds = getleds ();
  22900. +    if (leds != ledstate) {
  22901. +    unsigned long flags;
  22902. +    ledstate = leds;
  22903. +    leds = ((leds & (1<<VC_SCROLLOCK))?4:0) | ((leds & (1<<VC_NUMLOCK))?2:0) |
  22904. +           ((leds & (1<<VC_CAPSLOCK))?1:0);
  22905. +
  22906. +    save_flags_cli (flags);
  22907. +    intr_count -= 1;
  22908. +
  22909. +    kbd_sendval (leds);
  22910. +
  22911. +    intr_count += 1;
  22912. +    restore_flags(flags);
  22913. +    }
  22914. +    vt_pokeblankedconsole();
  22915. +}
  22916. +
  22917. +/*
  22918. + * Initialise a kbd struct
  22919. + */
  22920. +int kbd_struct_init (struct vt *vt, int init)
  22921. +{
  22922. +    vt->kbd->ledflagstate      =
  22923. +    vt->kbd->default_ledflagstate = KBD_DEFLEDS;
  22924. +    vt->kbd->ledmode          = LED_SHOW_FLAGS;
  22925. +    vt->kbd->lockstate          = KBD_DEFLOCK;
  22926. +    vt->kbd->slockstate          = 0;
  22927. +    vt->kbd->modeflags          = KBD_DEFMODE;
  22928. +    vt->kbd->kbdmode          = VC_XLATE;
  22929. +    return 0;
  22930. +}
  22931. +
  22932. +int kbd_ioctl (struct vt *vt, int cmd, unsigned long arg)
  22933. +{
  22934. +    asmlinkage int sys_ioperm(unsigned long from, unsigned long num, int on);
  22935. +    int i;
  22936. +
  22937. +    switch (cmd) {
  22938. +    case KDGKBTYPE:
  22939. +    /*
  22940. +     * This is naive.
  22941. +     */
  22942. +    i = verify_area (VERIFY_WRITE, (void *)arg, sizeof (unsigned char));
  22943. +    if (!i)
  22944. +        put_user (KB_101, (char *)arg);
  22945. +    return i;
  22946. +
  22947. +    case KDADDIO:
  22948. +    case KDDELIO:
  22949. +    /*
  22950. +     * KDADDIO and KDDELIO may be able to add ports beyond what
  22951. +     * we reject here, but to be safe...
  22952. +     */
  22953. +    if (arg < GPFIRST || arg > GPLAST)
  22954. +        return -EINVAL;
  22955. +    return sys_ioperm (arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
  22956. +
  22957. +    case KDENABIO:
  22958. +    case KDDISABIO:
  22959. +    return sys_ioperm (GPFIRST, GPLAST, (cmd == KDENABIO)) ? -ENXIO : 0;
  22960. +
  22961. +    case KDMAPDISP:
  22962. +    case KDUNMAPDISP:
  22963. +    /*
  22964. +     * These work like a combination of mmap and KDENABIO.
  22965. +     * this could easily be finished.
  22966. +     */
  22967. +    return -EINVAL;
  22968. +
  22969. +    case KDSKBMODE:
  22970. +    switch (arg) {
  22971. +    case K_RAW:
  22972. +        vt->kbd->kbdmode = VC_RAW;
  22973. +        break;
  22974. +    case K_MEDIUMRAW:
  22975. +        vt->kbd->kbdmode = VC_MEDIUMRAW;
  22976. +        break;
  22977. +    case K_XLATE:
  22978. +        vt->kbd->kbdmode = VC_XLATE;
  22979. +        compute_shiftstate ();
  22980. +        break;
  22981. +    case K_UNICODE:
  22982. +        vt->kbd->kbdmode = VC_UNICODE;
  22983. +        compute_shiftstate ();
  22984. +        break;
  22985. +    default:
  22986. +        return -EINVAL;
  22987. +    }
  22988. +    if (tty->ldisc.flush_buffer)
  22989. +        tty->ldisc.flush_buffer (*vt->tty);
  22990. +    return 0;
  22991. +
  22992. +    case KDGKBMODE:
  22993. +    i = verify_area (VERIFY_WRITE, (void *)arg, sizeof (unsigned long));
  22994. +    if (!i) {
  22995. +        int ucval;
  22996. +        ucval = ((vt->kbd->kbdmode == VC_RAW) ? K_RAW :
  22997. +             (vt->kbd->kbdmode == VC_MEDIUMRAW) ? K_MEDIUMRAW :
  22998. +             (vt->kbd->kbdmode == VC_UNICODE) ? K_UNICODE : K_XLATE);
  22999. +        put_user (ucval, (int *)arg);
  23000. +    }
  23001. +    return i;
  23002. +
  23003. +    case KDSKBMETA:
  23004. +    /*
  23005. +     * this could be folded into KDSKBMODE, but for compatibility
  23006. +     * reasons, it is not so easy to fold kDGKBMETA into KDGKBMODE.
  23007. +     */
  23008. +    switch (arg) {
  23009. +    case K_METABIT:
  23010. +        clr_vc_kbd_mode (vt->kbd, VC_META);
  23011. +        break;
  23012. +    case K_ESCPREFIX:
  23013. +        set_vc_kbd_mode (vt->kbd, VC_META);
  23014. +        break;
  23015. +    default:
  23016. +        return -EINVAL;
  23017. +    }
  23018. +    return 0;
  23019. +
  23020. +    case KDGKBMETA:
  23021. +    i = verify_area (VERIFY_WRITE, (void *)arg, sizeof (unsigned long));
  23022. +    if (!i) {
  23023. +        int ucval;
  23024. +        ucval = (vc_kbd_mode (vt->kbd, VC_META) ? K_ESCPREFIX : K_METABIT);
  23025. +        put_user (ucval, (int *)arg);
  23026. +    }
  23027. +    return i;
  23028. +
  23029. +    case KDGETKEYCODE: {
  23030. +    struct kbkeycode *const a = (struct kbkeycode *)arg;
  23031. +
  23032. +    i = verify_area (VERIFY_WRITE, a, sizeof (struct kbkeycode));
  23033. +    if (!i) {
  23034. +        unsigned int sc;
  23035. +
  23036. +        sc = get_user (&a->scancode);
  23037. +        i = getkeycode (sc);
  23038. +        if (i > 0)
  23039. +        put_user (i, &a->keycode);
  23040. +        i = 0;
  23041. +    }
  23042. +    return i;
  23043. +        }
  23044. +
  23045. +    case KDSETKEYCODE: {
  23046. +    struct kbkeycode *const a = (struct kbkeycode *)arg;
  23047. +
  23048. +    i = verify_area (VERIFY_READ, a, sizeof (struct kbkeycode));
  23049. +    if (!i) {
  23050. +        unsigned int sc, kc;
  23051. +        sc = get_user (&a->scancode);
  23052. +        kc = get_user (&a->keycode);
  23053. +        i = setkeycode (sc, kc);
  23054. +    }
  23055. +    return i;
  23056. +        }
  23057. +
  23058. +    case KDGKBENT: {
  23059. +    struct kbentry *const a = (struct kbentry *)arg;
  23060. +
  23061. +    i = verify_area (VERIFY_WRITE, a, sizeof (struct kbentry));
  23062. +    if (!i) {
  23063. +        ushort *keymap, val;
  23064. +        u_char s;
  23065. +        i = get_user (&a->kb_index);
  23066. +        if (i >= NR_KEYS)
  23067. +        return -EINVAL;
  23068. +        s = get_user (&a->kb_table);
  23069. +        if (s >= MAX_NR_KEYMAPS)
  23070. +        return -EINVAL;
  23071. +        keymap = key_maps[s];
  23072. +        if (keymap) {
  23073. +        val = U(keymap[i]);
  23074. +        if (vt->kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
  23075. +            val = K_HOLE;
  23076. +        } else
  23077. +        val = (i ? K_HOLE : K_NOSUCHMAP);
  23078. +        put_user (val, &a->kb_value);
  23079. +        i = 0;
  23080. +    }
  23081. +    return i;
  23082. +        }
  23083. +
  23084. +    case KDSKBENT: {
  23085. +    struct kbentry *const a = (struct kbentry *)arg;
  23086. +
  23087. +    i = verify_area (VERIFY_WRITE, a, sizeof (struct kbentry));
  23088. +    if (!i) {
  23089. +        ushort *key_map;
  23090. +        u_char s;
  23091. +        u_short v, ov;
  23092. +
  23093. +        if ((i = get_user(&a->kb_index)) >= NR_KEYS)
  23094. +        return -EINVAL;
  23095. +        if ((s = get_user(&a->kb_table)) >= MAX_NR_KEYMAPS)
  23096. +        return -EINVAL;
  23097. +        v = get_user(&a->kb_value);
  23098. +        if (!i && v == K_NOSUCHMAP) {
  23099. +        /* disallocate map */
  23100. +        key_map = key_maps[s];
  23101. +        if (s && key_map) {
  23102. +            key_maps[s] = 0;
  23103. +            if (key_map[0] == U(K_ALLOCATED)) {
  23104. +            kfree_s(key_map, sizeof(plain_map));
  23105. +            keymap_count--;
  23106. +            }
  23107. +        }
  23108. +        return 0;
  23109. +        }
  23110. +
  23111. +        if (KTYP(v) < NR_TYPES) {
  23112. +        if (KVAL(v) > max_vals[KTYP(v)])
  23113. +            return -EINVAL;
  23114. +        } else
  23115. +        if (kbd->kbdmode != VC_UNICODE)
  23116. +            return -EINVAL;
  23117. +
  23118. +        /* assignment to entry 0 only tests validity of args */
  23119. +        if (!i)
  23120. +        return 0;
  23121. +
  23122. +        if (!(key_map = key_maps[s])) {
  23123. +        int j;
  23124. +            
  23125. +        if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && !suser())
  23126. +            return -EPERM;
  23127. +
  23128. +        key_map = (ushort *) kmalloc(sizeof(plain_map),
  23129. +                         GFP_KERNEL);
  23130. +        if (!key_map)
  23131. +            return -ENOMEM;
  23132. +        key_maps[s] = key_map;
  23133. +        key_map[0] = U(K_ALLOCATED);
  23134. +        for (j = 1; j < NR_KEYS; j++)
  23135. +            key_map[j] = U(K_HOLE);
  23136. +        keymap_count++;
  23137. +        }
  23138. +        ov = U(key_map[i]);
  23139. +        if (v == ov)
  23140. +        return 0;    /* nothing to do */
  23141. +        /*
  23142. +         * Only the Superuser can set or unset the Secure
  23143. +         * Attention Key.
  23144. +         */
  23145. +        if (((ov == K_SAK) || (v == K_SAK)) && !suser())
  23146. +        return -EPERM;
  23147. +        key_map[i] = U(v);
  23148. +        if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
  23149. +        compute_shiftstate();
  23150. +        return 0;
  23151. +    }
  23152. +    return i;
  23153. +        }
  23154. +
  23155. +    case KDGKBSENT: {
  23156. +    struct kbsentry *a = (struct kbsentry *)arg;
  23157. +    char *p;
  23158. +    u_char *q;
  23159. +    int sz;
  23160. +
  23161. +    i = verify_area(VERIFY_WRITE, (void *)a, sizeof(struct kbsentry));
  23162. +    if (i)
  23163. +        return i;
  23164. +    if ((i = get_user(&a->kb_func)) >= MAX_NR_FUNC || i < 0)
  23165. +        return -EINVAL;
  23166. +    sz = sizeof(a->kb_string) - 1; /* sz should have been
  23167. +                      a struct member */
  23168. +    q = a->kb_string;
  23169. +    p = func_table[i];
  23170. +    if(p)
  23171. +        for ( ; *p && sz; p++, sz--)
  23172. +        put_user(*p, q++);
  23173. +    put_user('\0', q);
  23174. +    return ((p && *p) ? -EOVERFLOW : 0);
  23175. +        }
  23176. +
  23177. +    case KDSKBSENT: {
  23178. +    struct kbsentry * const a = (struct kbsentry *)arg;
  23179. +    int delta;
  23180. +    char *first_free, *fj, *fnw;
  23181. +    int j, k, sz;
  23182. +    u_char *p;
  23183. +    char *q;
  23184. +
  23185. +    i = verify_area(VERIFY_READ, (void *)a, sizeof(struct kbsentry));
  23186. +    if (i)
  23187. +        return i;
  23188. +    if ((i = get_user(&a->kb_func)) >= MAX_NR_FUNC)
  23189. +        return -EINVAL;
  23190. +    q = func_table[i];
  23191. +
  23192. +    first_free = funcbufptr + (funcbufsize - funcbufleft);
  23193. +    for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++) ;
  23194. +    if (j < MAX_NR_FUNC)
  23195. +        fj = func_table[j];
  23196. +    else
  23197. +        fj = first_free;
  23198. +
  23199. +    delta = (q ? -strlen(q) : 1);
  23200. +    sz = sizeof(a->kb_string);     /* sz should have been
  23201. +                       a struct member */
  23202. +    for (p = a->kb_string; get_user(p) && sz; p++,sz--)
  23203. +        delta++;
  23204. +    if (!sz)
  23205. +        return -EOVERFLOW;
  23206. +    if (delta <= funcbufleft) {     /* it fits in current buf */
  23207. +        if (j < MAX_NR_FUNC) {
  23208. +        memmove(fj + delta, fj, first_free - fj);
  23209. +        for (k = j; k < MAX_NR_FUNC; k++)
  23210. +            if (func_table[k])
  23211. +            func_table[k] += delta;
  23212. +        }
  23213. +        if (!q)
  23214. +        func_table[i] = fj;
  23215. +        funcbufleft -= delta;
  23216. +    } else {            /* allocate a larger buffer */
  23217. +        sz = 256;
  23218. +        while (sz < funcbufsize - funcbufleft + delta)
  23219. +        sz <<= 1;
  23220. +        fnw = (char *) kmalloc(sz, GFP_KERNEL);
  23221. +        if(!fnw)
  23222. +        return -ENOMEM;
  23223. +
  23224. +        if (!q)
  23225. +        func_table[i] = fj;
  23226. +        if (fj > funcbufptr)
  23227. +        memmove(fnw, funcbufptr, fj - funcbufptr);
  23228. +        for (k = 0; k < j; k++)
  23229. +        if (func_table[k])
  23230. +            func_table[k] = fnw + (func_table[k] - funcbufptr);
  23231. +
  23232. +        if (first_free > fj) {
  23233. +        memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
  23234. +        for (k = j; k < MAX_NR_FUNC; k++)
  23235. +            if (func_table[k])
  23236. +            func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
  23237. +        }
  23238. +        if (funcbufptr != func_buf)
  23239. +        kfree_s(funcbufptr, funcbufsize);
  23240. +        funcbufptr = fnw;
  23241. +        funcbufleft = funcbufleft - delta + sz - funcbufsize;
  23242. +        funcbufsize = sz;
  23243. +    }
  23244. +    for (p = a->kb_string, q = func_table[i]; ; p++, q++)
  23245. +        if (!(*q = get_user(p)))
  23246. +        break;
  23247. +    return 0;
  23248. +    }
  23249. +
  23250. +    case KDGKBDIACR: {
  23251. +    struct kbdiacrs *a = (struct kbdiacrs *)arg;
  23252. +
  23253. +    i = verify_area(VERIFY_WRITE, (void *) a, sizeof(struct kbdiacrs));
  23254. +    if (i)
  23255. +        return i;
  23256. +    put_user(accent_table_size, &a->kb_cnt);
  23257. +    memcpy_tofs(a->kbdiacr, accent_table,
  23258. +            accent_table_size*sizeof(struct kbdiacr));
  23259. +    return 0;
  23260. +    }
  23261. +
  23262. +    case KDSKBDIACR: {
  23263. +    struct kbdiacrs *a = (struct kbdiacrs *)arg;
  23264. +    unsigned int ct;
  23265. +
  23266. +    i = verify_area(VERIFY_READ, (void *) a, sizeof(struct kbdiacrs));
  23267. +    if (i)
  23268. +        return i;
  23269. +    ct = get_user(&a->kb_cnt);
  23270. +    if (ct >= MAX_DIACR)
  23271. +        return -EINVAL;
  23272. +    accent_table_size = ct;
  23273. +    memcpy_fromfs(accent_table, a->kbdiacr, ct*sizeof(struct kbdiacr));
  23274. +    return 0;
  23275. +    }
  23276. +
  23277. +    /* the ioctls below read/set the flags usually shown in the leds */
  23278. +    /* don't use them - they will go away without warning */
  23279. +    case KDGKBLED:
  23280. +    i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned char));
  23281. +    if (i)
  23282. +        return i;
  23283. +    put_user(vt->kbd->ledflagstate |
  23284. +            (vt->kbd->default_ledflagstate << 4), (char *) arg);
  23285. +    return 0;
  23286. +
  23287. +    case KDSKBLED:
  23288. +    if (arg & ~0x77)
  23289. +        return -EINVAL;
  23290. +    vt->kbd->ledflagstate = (arg & 7);
  23291. +    vt->kbd->default_ledflagstate = ((arg >> 4) & 7);
  23292. +    set_leds ();
  23293. +    return 0;
  23294. +
  23295. +    /* the ioctls below only set the lights, not the functions */
  23296. +    /* for those, see KDGKBLED and KDSKBLED above */
  23297. +    case KDGETLED:
  23298. +    i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned char));
  23299. +    if (i)
  23300. +            return i;
  23301. +    put_user(getledstate(), (char *) arg);
  23302. +    return 0;
  23303. +
  23304. +    case KDSETLED:
  23305. +    setledstate(kbd, arg);
  23306. +    return 0;
  23307. +
  23308. +    /*
  23309. +     * A process can indicate its willingness to accept signals
  23310. +     * generated by pressing an appropriate key combination.
  23311. +     * Thus, one can have a daemon that e.g. spawns a new console
  23312. +     * upon a keypess and then changes to it.
  23313. +     * Probably init should be changed to do this (and have a
  23314. +     * field ks (`keyboard signal') in inittab describing the
  23315. +     * desired acion), so that the number of background daemons
  23316. +     * does not increase.
  23317. +     */
  23318. +    case KDSIGACCEPT: {
  23319. +    if (arg < 1 || arg > NSIG || arg == SIGKILL)
  23320. +        return -EINVAL;
  23321. +    spawnpid = current->pid;
  23322. +    spawnsig = arg;
  23323. +    return 0;
  23324. +    }
  23325. +    default:
  23326. +    return -ENOIOCTLCMD;
  23327. +    }
  23328. +}
  23329. +
  23330. +int kbd_init (void)
  23331. +{
  23332. +    unsigned long flags;
  23333. +
  23334. +    save_flags_cli (flags);
  23335. +    if (request_irq (IRQ_KEYBOARDRX, kbd_rx, 0, "keyboard", NULL)!=0)
  23336. +    panic("Could not allocate keyboard receive IRQ!");
  23337. +    if (request_irq (IRQ_KEYBOARDTX, kbd_tx, 0, "keyboard", NULL)!=0)
  23338. +    panic("Could not allocate keyboard transmit IRQ!");
  23339. +    disable_irq (IRQ_KEYBOARDTX);
  23340. +    (void)IOC_KARTRX;
  23341. +    restore_flags (flags);
  23342. +
  23343. +    kbd_sendval (HRST);
  23344. +    init_bh (KEYBOARD_BH, kbd_bh);
  23345. +
  23346. +    current->timeout = jiffies + HZ; /* wait 1s for keyboard to initialise */
  23347. +    interruptible_sleep_on(&kbd_waitq);
  23348. +
  23349. +    printk (KERN_INFO "Keyboard driver installed v%d.%02d. (", VERSION/100, VERSION%100);
  23350. +    if (kbd_id != -1)
  23351. +      printk ("id=%d ", kbd_id);
  23352. +    printk ("English)\n");
  23353. +    return 0;
  23354. +}
  23355. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/mem.c linux/arch/arm/drivers/char/mem.c
  23356. --- linux.orig/arch/arm/drivers/char/mem.c    Thu Jan  1 01:00:00 1970
  23357. +++ linux/arch/arm/drivers/char/mem.c    Sun Jul 28 20:48:00 1996
  23358. @@ -0,0 +1,361 @@
  23359. +/*
  23360. + *  linux/arch/arm/drivers/char/mem.c
  23361. + *
  23362. + *  Copyright (C) 1991, 1992  Linus Torvalds
  23363. + *
  23364. + *  Modifications for ARM Copyright (C) 1995, 1996 Russell King
  23365. + */
  23366. +
  23367. +#include <linux/config.h>
  23368. +#include <linux/types.h>
  23369. +#include <linux/errno.h>
  23370. +#include <linux/sched.h>
  23371. +#include <linux/kernel.h>
  23372. +#include <linux/major.h>
  23373. +#include <linux/tty.h>
  23374. +#include <linux/miscdevice.h>
  23375. +#include <linux/tpqic02.h>
  23376. +#include <linux/malloc.h>
  23377. +#include <linux/mman.h>
  23378. +#include <linux/mm.h>
  23379. +#include <linux/random.h>
  23380. +
  23381. +#include <asm/segment.h>
  23382. +#include <asm/io.h>
  23383. +#include <asm/pgtable.h>
  23384. +
  23385. +#ifdef CONFIG_SOUND
  23386. +void soundcard_init(void);
  23387. +#endif
  23388. +
  23389. +static int read_ram(struct inode * inode, struct file * file, char * buf, int count)
  23390. +{
  23391. +    return -EIO;
  23392. +}
  23393. +
  23394. +static int write_ram(struct inode * inode, struct file * file, const char * buf, int count)
  23395. +{
  23396. +    return -EIO;
  23397. +}
  23398. +
  23399. +static int read_mem(struct inode * inode, struct file * file, char * buf, int count)
  23400. +{
  23401. +    unsigned long p = file->f_pos;
  23402. +
  23403. +    p += PAGE_OFFSET;
  23404. +    if (count < 0)
  23405. +        return -EINVAL;
  23406. +    if (MAP_NR(p) >= MAP_NR(high_memory))
  23407. +        return 0;
  23408. +    if (count > high_memory - p)
  23409. +        count = high_memory - p;
  23410. +    memcpy_tofs(buf,(void *) p,count);
  23411. +    file->f_pos += count;
  23412. +    return count;
  23413. +}
  23414. +
  23415. +static int write_mem(struct inode * inode, struct file * file, const char * buf, int count)
  23416. +{
  23417. +    unsigned long p = file->f_pos;
  23418. +
  23419. +    p += PAGE_OFFSET;
  23420. +    if (count < 0)
  23421. +        return -EINVAL;
  23422. +    if (MAP_NR(p) >= MAP_NR(high_memory))
  23423. +        return 0;
  23424. +    if (count > high_memory - p)
  23425. +        count = high_memory - p;
  23426. +    memcpy_fromfs((void *) p,buf,count);
  23427. +    file->f_pos += count;
  23428. +    return count;
  23429. +}
  23430. +
  23431. +static int mmap_mem(struct inode * inode, struct file * file, struct vm_area_struct * vma)
  23432. +{
  23433. +    if (vma->vm_offset & ~PAGE_MASK)
  23434. +        return -ENXIO;
  23435. +
  23436. +    if (remap_page_range(vma->vm_start, vma->vm_offset, vma->vm_end - vma->vm_start, vma->vm_page_prot))
  23437. +        return -EAGAIN;
  23438. +    vma->vm_inode = inode;
  23439. +    inode->i_count++;
  23440. +    return 0;
  23441. +}
  23442. +
  23443. +static int read_kmem(struct inode *inode, struct file *file, char *buf, int count)
  23444. +{
  23445. +    int read1, read2;
  23446. +
  23447. +    read1 = read_mem(inode, file, buf, count);
  23448. +    if (read1 < 0)
  23449. +        return read1;
  23450. +    read2 = vread(buf + read1, (char *) ((unsigned long) file->f_pos), count - read1);
  23451. +    if (read2 < 0)
  23452. +        return read2;
  23453. +    file->f_pos += read2;
  23454. +    return read1 + read2;
  23455. +}
  23456. +
  23457. +static int read_port(struct inode * inode, struct file * file,char * buf, int count)
  23458. +{
  23459. +    unsigned int i = file->f_pos;
  23460. +    char * tmp = buf;
  23461. +
  23462. +    while (count-- > 0 && i < 65536) {
  23463. +        put_user(inb(i),tmp);
  23464. +        i++;
  23465. +        tmp++;
  23466. +    }
  23467. +    file->f_pos = i;
  23468. +    return tmp-buf;
  23469. +}
  23470. +
  23471. +static int write_port(struct inode * inode, struct file * file, const char * buf, int count)
  23472. +{
  23473. +    unsigned int i = file->f_pos;
  23474. +    const char * tmp = buf;
  23475. +
  23476. +    while (count-- > 0 && i < 65536) {
  23477. +        outb(get_user(tmp),i);
  23478. +        i++;
  23479. +        tmp++;
  23480. +    }
  23481. +    file->f_pos = i;
  23482. +    return tmp-buf;
  23483. +}
  23484. +
  23485. +static int read_null(struct inode * node, struct file * file, char * buf, int count)
  23486. +{
  23487. +    return 0;
  23488. +}
  23489. +
  23490. +static int write_null(struct inode * inode, struct file * file, const char * buf, int count)
  23491. +{
  23492. +    return count;
  23493. +}
  23494. +
  23495. +static int read_zero(struct inode * node, struct file * file, char * buf, int count)
  23496. +{
  23497. +    int left;
  23498. +
  23499. +    for (left = count; left > 0; left--) {
  23500. +        put_user(0,buf);
  23501. +        buf++;
  23502. +        if (need_resched)
  23503. +            schedule();
  23504. +    }
  23505. +    return count;
  23506. +}
  23507. +
  23508. +static int mmap_zero(struct inode * inode, struct file * file, struct vm_area_struct * vma)
  23509. +{
  23510. +    if (vma->vm_flags & VM_SHARED)
  23511. +        return -EINVAL;
  23512. +    if (zeromap_page_range(vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_page_prot))
  23513. +        return -EAGAIN;
  23514. +    return 0;
  23515. +}
  23516. +
  23517. +static int read_full(struct inode * node, struct file * file, char * buf,int count)
  23518. +{
  23519. +    return count;
  23520. +}
  23521. +
  23522. +static int write_full(struct inode * inode, struct file * file, const char * buf, int count)
  23523. +{
  23524. +    return -ENOSPC;
  23525. +}
  23526. +
  23527. +/*
  23528. + * Special lseek() function for /dev/null and /dev/zero.  Most notably, you can fopen()
  23529. + * both devices with "a" now.  This was previously impossible.  SRB.
  23530. + */
  23531. +
  23532. +static int null_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
  23533. +{
  23534. +    return file->f_pos=0;
  23535. +}
  23536. +/*
  23537. + * The memory devices use the full 32/64 bits of the offset, and so we cannot
  23538. + * check against negative addresses: they are ok. The return value is weird,
  23539. + * though, in that case (0).
  23540. + *
  23541. + * also note that seeking relative to the "end of file" isn't supported:
  23542. + * it has no meaning, so it returns -EINVAL.
  23543. + */
  23544. +static int memory_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
  23545. +{
  23546. +    switch (orig) {
  23547. +        case 0:
  23548. +            file->f_pos = offset;
  23549. +            return file->f_pos;
  23550. +        case 1:
  23551. +            file->f_pos += offset;
  23552. +            return file->f_pos;
  23553. +        default:
  23554. +            return -EINVAL;
  23555. +    }
  23556. +    if (file->f_pos < 0)
  23557. +        return 0;
  23558. +    return file->f_pos;
  23559. +}
  23560. +
  23561. +#define write_kmem    write_mem
  23562. +#define mmap_kmem    mmap_mem
  23563. +#define zero_lseek    null_lseek
  23564. +#define write_zero    write_null
  23565. +
  23566. +static struct file_operations ram_fops = {
  23567. +    memory_lseek,
  23568. +    read_ram,
  23569. +    write_ram,
  23570. +    NULL,        /* ram_readdir */
  23571. +    NULL,        /* ram_select */
  23572. +    NULL,        /* ram_ioctl */
  23573. +    NULL,        /* ram_mmap */
  23574. +    NULL,        /* no special open code */
  23575. +    NULL,        /* no special release code */
  23576. +    NULL        /* fsync */
  23577. +};
  23578. +
  23579. +static struct file_operations mem_fops = {
  23580. +    memory_lseek,
  23581. +    read_mem,
  23582. +    write_mem,
  23583. +    NULL,        /* mem_readdir */
  23584. +    NULL,        /* mem_select */
  23585. +    NULL,        /* mem_ioctl */
  23586. +    mmap_mem,
  23587. +    NULL,        /* no special open code */
  23588. +    NULL,        /* no special release code */
  23589. +    NULL        /* fsync */
  23590. +};
  23591. +
  23592. +static struct file_operations kmem_fops = {
  23593. +    memory_lseek,
  23594. +    read_kmem,
  23595. +    write_kmem,
  23596. +    NULL,        /* kmem_readdir */
  23597. +    NULL,        /* kmem_select */
  23598. +    NULL,        /* kmem_ioctl */
  23599. +    mmap_kmem,
  23600. +    NULL,        /* no special open code */
  23601. +    NULL,        /* no special release code */
  23602. +    NULL        /* fsync */
  23603. +};
  23604. +
  23605. +static struct file_operations null_fops = {
  23606. +    null_lseek,
  23607. +    read_null,
  23608. +    write_null,
  23609. +    NULL,        /* null_readdir */
  23610. +    NULL,        /* null_select */
  23611. +    NULL,        /* null_ioctl */
  23612. +    NULL,        /* null_mmap */
  23613. +    NULL,        /* no special open code */
  23614. +    NULL,        /* no special release code */
  23615. +    NULL        /* fsync */
  23616. +};
  23617. +
  23618. +static struct file_operations port_fops = {
  23619. +    memory_lseek,
  23620. +    read_port,
  23621. +    write_port,
  23622. +    NULL,        /* port_readdir */
  23623. +    NULL,        /* port_select */
  23624. +    NULL,        /* port_ioctl */
  23625. +    NULL,        /* port_mmap */
  23626. +    NULL,        /* no special open code */
  23627. +    NULL,        /* no special release code */
  23628. +    NULL        /* fsync */
  23629. +};
  23630. +
  23631. +static struct file_operations zero_fops = {
  23632. +    zero_lseek,
  23633. +    read_zero,
  23634. +    write_zero,
  23635. +    NULL,        /* zero_readdir */
  23636. +    NULL,        /* zero_select */
  23637. +    NULL,        /* zero_ioctl */
  23638. +    mmap_zero,
  23639. +    NULL,        /* no special open code */
  23640. +    NULL        /* no special release code */
  23641. +};
  23642. +
  23643. +static struct file_operations full_fops = {
  23644. +    memory_lseek,
  23645. +    read_full,
  23646. +    write_full,
  23647. +    NULL,        /* full_readdir */
  23648. +    NULL,        /* full_select */
  23649. +    NULL,        /* full_ioctl */
  23650. +    NULL,        /* full_mmap */
  23651. +    NULL,        /* no special open code */
  23652. +    NULL        /* no special release code */
  23653. +};
  23654. +
  23655. +static int memory_open(struct inode * inode, struct file * filp)
  23656. +{
  23657. +    switch (MINOR(inode->i_rdev)) {
  23658. +        case 0:
  23659. +            filp->f_op = &ram_fops;
  23660. +            break;
  23661. +        case 1:
  23662. +            filp->f_op = &mem_fops;
  23663. +            break;
  23664. +        case 2:
  23665. +            filp->f_op = &kmem_fops;
  23666. +            break;
  23667. +        case 3:
  23668. +            filp->f_op = &null_fops;
  23669. +            break;
  23670. +        case 4:
  23671. +            filp->f_op = &port_fops;
  23672. +            break;
  23673. +        case 5:
  23674. +            filp->f_op = &zero_fops;
  23675. +            break;
  23676. +        case 7:
  23677. +            filp->f_op = &full_fops;
  23678. +            break;
  23679. +        case 8:
  23680. +            filp->f_op = &random_fops;
  23681. +            break;
  23682. +        case 9:
  23683. +            filp->f_op = &urandom_fops;
  23684. +            break;
  23685. +        default:
  23686. +            return -ENXIO;
  23687. +    }
  23688. +    if (filp->f_op && filp->f_op->open)
  23689. +        return filp->f_op->open(inode,filp);
  23690. +    return 0;
  23691. +}
  23692. +
  23693. +static struct file_operations memory_fops = {
  23694. +    NULL,        /* lseek */
  23695. +    NULL,        /* read */
  23696. +    NULL,        /* write */
  23697. +    NULL,        /* readdir */
  23698. +    NULL,        /* select */
  23699. +    NULL,        /* ioctl */
  23700. +    NULL,        /* mmap */
  23701. +    memory_open,    /* just a selector for the real open */
  23702. +    NULL,        /* release */
  23703. +    NULL        /* fsync */
  23704. +};
  23705. +
  23706. +int chr_dev_init(void)
  23707. +{
  23708. +    if (register_chrdev(MEM_MAJOR,"mem",&memory_fops))
  23709. +        printk("unable to get major %d for memory devs\n", MEM_MAJOR);
  23710. +    rand_initialize();
  23711. +    tty_init();
  23712. +#ifdef CONFIG_PRINTER
  23713. +    lp_init();
  23714. +#endif
  23715. +#if defined(CONFIG_KBDMOUSE) || defined(CONFIG_SOFT_WATCHDOG)
  23716. +    misc_init();
  23717. +#endif
  23718. +    return 0;
  23719. +}
  23720. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/misc.c linux/arch/arm/drivers/char/misc.c
  23721. --- linux.orig/arch/arm/drivers/char/misc.c    Thu Jan  1 01:00:00 1970
  23722. +++ linux/arch/arm/drivers/char/misc.c    Wed Jul 31 20:26:12 1996
  23723. @@ -0,0 +1,209 @@
  23724. +/*
  23725. + * linux/arch/arm/drivers/char/mouse.c
  23726. + *
  23727. + * Generic misc open routine by Johan Myreen
  23728. + *
  23729. + * Based on code from Linus
  23730. + *
  23731. + * Teemu Rantanen's Microsoft Busmouse support and Derrick Cole's
  23732. + *   changes incorporated into 0.97pl4
  23733. + *   by Peter Cervasio (pete%q106fm.uucp@wupost.wustl.edu) (08SEP92)
  23734. + *   See busmouse.c for particulars.
  23735. + *
  23736. + * Made things a lot mode modular - easy to compile in just one or two
  23737. + * of the misc drivers, as they are now completely independent. Linus.
  23738. + *
  23739. + * Support for loadable modules. 8-Sep-95 Philip Blundell <pjb27@cam.ac.uk>
  23740. + *
  23741. + * Fixed a failing symbol register to free the device registration
  23742. + *        Alan Cox <alan@lxorguk.ukuu.org.uk> 21-Jan-96
  23743. + *
  23744. + * Dynamic minors and /proc/mice by Alessandro Rubini. 26-Mar-96
  23745. + *
  23746. + * Renamed to misc and miscdevice to be more accurate. Alan Cox 26-Mar-96
  23747. + *
  23748. + * Handling of mouse minor numbers for kerneld:
  23749. + *  Idea by Jacques Gelinas <jack@solucorp.qc.ca>,
  23750. + *  adapted by Bjorn Ekwall <bj0rn@blox.se>
  23751. + *  corrected by Alan Cox <alan@lxorguk.ukuu.org.uk>
  23752. + */
  23753. +
  23754. +#include <linux/config.h>
  23755. +#include <linux/module.h>
  23756. +
  23757. +#include <linux/fs.h>
  23758. +#include <linux/errno.h>
  23759. +#include <linux/miscdevice.h>
  23760. +#include <linux/kernel.h>
  23761. +#include <linux/major.h>
  23762. +#include <linux/malloc.h>
  23763. +#include <linux/proc_fs.h>
  23764. +#include <linux/stat.h>
  23765. +
  23766. +#include <linux/tty.h> /* needed by selection.h */
  23767. +#include "vt_kern.h"
  23768. +#include "selection.h" /* export its symbols */
  23769. +#ifdef CONFIG_KERNELD
  23770. +#include <linux/kerneld.h>
  23771. +#endif
  23772. +
  23773. +/*
  23774. + * Head entry for the doubly linked miscdevice list
  23775. + */
  23776. +static struct miscdevice misc_list = { 0, "head", NULL, &misc_list, &misc_list };
  23777. +
  23778. +/*
  23779. + * Assigned numbers, used for dynamic minors
  23780. + */
  23781. +#define DYNAMIC_MINORS 64 /* like dynamic majors */
  23782. +static unsigned char misc_minors[DYNAMIC_MINORS / 8];
  23783. +
  23784. +#ifndef MODULE
  23785. +extern void watchdog_init(void);
  23786. +extern int arch_mouse_init(void);
  23787. +
  23788. +#ifdef CONFIG_PROC_FS
  23789. +static int proc_misc_read(char *buf, char **start, off_t offset, int len, int unused)
  23790. +{
  23791. +    struct miscdevice *p;
  23792. +
  23793. +    len=0;
  23794. +    for (p = misc_list.next; p != &misc_list; p = p->next)
  23795. +        len += sprintf(buf+len, "%3i %s\n",p->minor, p->name ?: "");
  23796. +    return len;
  23797. +}
  23798. +
  23799. +#endif /* PROC_FS */
  23800. +#endif /* !MODULE */
  23801. +
  23802. +static int misc_open(struct inode * inode, struct file * file)
  23803. +{
  23804. +    int minor = MINOR(inode->i_rdev);
  23805. +    struct miscdevice *c = misc_list.next;
  23806. +    file->f_op = NULL;
  23807. +
  23808. +    while ((c != &misc_list) && (c->minor != minor))
  23809. +        c = c->next;
  23810. +    if (c == &misc_list) {
  23811. +#ifdef CONFIG_KERNELD
  23812. +        char modname[20];
  23813. +        sprintf(modname, "char-major-%d-%d", MISC_MAJOR, minor);
  23814. +        request_module(modname);
  23815. +        c = misc_list.next;
  23816. +        while ((c != &misc_list) && (c->minor != minor))
  23817. +            c = c->next;
  23818. +        if (c == &misc_list)
  23819. +#endif
  23820. +            return -ENODEV;
  23821. +    }
  23822. +
  23823. +    if ((file->f_op = c->fops))
  23824. +        return file->f_op->open(inode,file);
  23825. +    else
  23826. +        return -ENODEV;
  23827. +}
  23828. +
  23829. +static struct file_operations misc_fops = {
  23830. +        NULL,        /* seek */
  23831. +    NULL,        /* read */
  23832. +    NULL,        /* write */
  23833. +    NULL,        /* readdir */
  23834. +    NULL,        /* select */
  23835. +    NULL,        /* ioctl */
  23836. +    NULL,        /* mmap */
  23837. +        misc_open,
  23838. +        NULL        /* release */
  23839. +};
  23840. +
  23841. +int misc_register(struct miscdevice * misc)
  23842. +{
  23843. +    if (misc->next || misc->prev)
  23844. +        return -EBUSY;
  23845. +    if (misc->minor == MISC_DYNAMIC_MINOR) {
  23846. +        int i = DYNAMIC_MINORS;
  23847. +        while (--i >= 0)
  23848. +            if ( (misc_minors[i>>3] & (1 << (i&7))) == 0)
  23849. +                break;
  23850. +        if (i<0) return -EBUSY;
  23851. +        misc->minor = i;
  23852. +    }
  23853. +    if (misc->minor < DYNAMIC_MINORS)
  23854. +        misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);
  23855. +    MOD_INC_USE_COUNT;
  23856. +    misc->next = &misc_list;
  23857. +    misc->prev = misc_list.prev;
  23858. +    misc->prev->next = misc;
  23859. +    misc->next->prev = misc;
  23860. +    return 0;
  23861. +}
  23862. +
  23863. +int misc_deregister(struct miscdevice * misc)
  23864. +{
  23865. +    int i = misc->minor;
  23866. +    if (!misc->next || !misc->prev)
  23867. +        return -EINVAL;
  23868. +    MOD_DEC_USE_COUNT;
  23869. +    misc->prev->next = misc->next;
  23870. +    misc->next->prev = misc->prev;
  23871. +    misc->next = NULL;
  23872. +    misc->prev = NULL;
  23873. +    if (i < DYNAMIC_MINORS && i>0) {
  23874. +        misc_minors[i>>3] &= ~(1 << (misc->minor & 7));
  23875. +    }
  23876. +    return 0;
  23877. +}
  23878. +
  23879. +#ifdef MODULE
  23880. +
  23881. +#define misc_init init_module
  23882. +
  23883. +void cleanup_module(void)
  23884. +{
  23885. +    unregister_chrdev(MISC_MAJOR, "misc");
  23886. +}
  23887. +
  23888. +#endif
  23889. +
  23890. +static struct symbol_table misc_syms = {
  23891. +/* Should this be surrounded with "#ifdef CONFIG_MODULES" ? */
  23892. +#include <linux/symtab_begin.h>
  23893. +    X(misc_register),
  23894. +    X(misc_deregister),
  23895. +#ifndef MODULE
  23896. +    X(set_selection),   /* used by the kmouse module, can only */
  23897. +    X(paste_selection), /* be exported if misc.c is in linked in */
  23898. +#endif
  23899. +#include <linux/symtab_end.h>
  23900. +};
  23901. +
  23902. +int misc_init(void)
  23903. +{
  23904. +#ifndef MODULE
  23905. +#ifdef CONFIG_PROC_FS
  23906. +    proc_register_dynamic(&proc_root, &(struct proc_dir_entry) {
  23907. +        0, 4, "misc",
  23908. +        S_IFREG | S_IRUGO, 1, 0, 0,
  23909. +        0, NULL /* ops -- default to array */,
  23910. +        &proc_misc_read /* get_info */,
  23911. +    });    
  23912. +#endif /* PROC_FS */
  23913. +#ifdef CONFIG_KBDMOUSE
  23914. +    arch_mouse_init();
  23915. +#endif
  23916. +#ifdef CONFIG_SOFT_WATCHDOG
  23917. +    watchdog_init();
  23918. +#endif
  23919. +#endif /* !MODULE */
  23920. +    if (register_chrdev(MISC_MAJOR,"misc",&misc_fops)) {
  23921. +      printk("unable to get major %d for misc devices\n",
  23922. +         MISC_MAJOR);
  23923. +        return -EIO;
  23924. +    }
  23925. +
  23926. +    if(register_symtab(&misc_syms)!=0)
  23927. +    {
  23928. +        unregister_chrdev(MISC_MAJOR, "misc");
  23929. +        return -EIO;
  23930. +    }
  23931. +    return 0;
  23932. +}
  23933. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/n_tty.c linux/arch/arm/drivers/char/n_tty.c
  23934. --- linux.orig/arch/arm/drivers/char/n_tty.c    Thu Jan  1 01:00:00 1970
  23935. +++ linux/arch/arm/drivers/char/n_tty.c    Fri Sep  6 21:12:49 1996
  23936. @@ -0,0 +1,1030 @@
  23937. +/*
  23938. + * n_tty.c --- implements the N_TTY line discipline.
  23939. + * 
  23940. + * This code used to be in tty_io.c, but things are getting hairy
  23941. + * enough that it made sense to split things off.  (The N_TTY
  23942. + * processing has changed so much that it's hardly recognizable,
  23943. + * anyway...)
  23944. + *
  23945. + * Note that the open routine for N_TTY is guaranteed never to return
  23946. + * an error.  This is because Linux will fall back to setting a line
  23947. + * to N_TTY if it can not switch to any other line discipline.  
  23948. + *
  23949. + * Written by Theodore Ts'o, Copyright 1994.
  23950. + * 
  23951. + * This file also contains code originally written by Linus Torvalds,
  23952. + * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
  23953. + * 
  23954. + * This file may be redistributed under the terms of the GNU Public
  23955. + * License.
  23956. + *
  23957. + * Altered for ARM to reduce memory usage.
  23958. + */
  23959. +
  23960. +#include <linux/types.h>
  23961. +#include <linux/major.h>
  23962. +#include <linux/errno.h>
  23963. +#include <linux/signal.h>
  23964. +#include <linux/fcntl.h>
  23965. +#include <linux/sched.h>
  23966. +#include <linux/interrupt.h>
  23967. +#include <linux/tty.h>
  23968. +#include <linux/timer.h>
  23969. +#include <linux/ctype.h>
  23970. +#include <linux/kd.h>
  23971. +#include <linux/mm.h>
  23972. +#include <linux/string.h>
  23973. +#include <linux/malloc.h>
  23974. +
  23975. +#include <asm/segment.h>
  23976. +#include <asm/system.h>
  23977. +#include <asm/bitops.h>
  23978. +
  23979. +#define CONSOLE_DEV MKDEV(TTY_MAJOR,0)
  23980. +
  23981. +#ifndef MIN
  23982. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  23983. +#endif
  23984. +
  23985. +/* number of characters left in xmit buffer before select has we have room */
  23986. +#define WAKEUP_CHARS 256
  23987. +
  23988. +/*
  23989. + * This defines the low- and high-watermarks for throttling and
  23990. + * unthrottling the TTY driver.  These watermarks are used for
  23991. + * controlling the space in the read buffer.
  23992. + */
  23993. +#define TTY_THRESHOLD_THROTTLE        (N_TTY_BUF_SIZE - 128)
  23994. +#define TTY_THRESHOLD_UNTHROTTLE     128
  23995. +
  23996. +static inline void put_tty_queue(unsigned char c, struct tty_struct *tty)
  23997. +{
  23998. +    if (tty->read_cnt < N_TTY_BUF_SIZE) {
  23999. +        tty->read_buf[tty->read_head] = c;
  24000. +        tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
  24001. +        tty->read_cnt++;
  24002. +    }
  24003. +}
  24004. +
  24005. +/*
  24006. + * Flush the input buffer
  24007. + */
  24008. +void n_tty_flush_buffer(struct tty_struct * tty)
  24009. +{
  24010. +    tty->read_head = tty->read_tail = tty->read_cnt = 0;
  24011. +    tty->canon_head = tty->canon_data = tty->erasing = 0;
  24012. +    memset(&tty->read_flags, 0, sizeof tty->read_flags);
  24013. +    
  24014. +    if (!tty->link)
  24015. +        return;
  24016. +
  24017. +    if (tty->driver.unthrottle)
  24018. +        (tty->driver.unthrottle)(tty);
  24019. +    if (tty->link->packet) {
  24020. +        tty->ctrl_status |= TIOCPKT_FLUSHREAD;
  24021. +        wake_up_interruptible(&tty->link->read_wait);
  24022. +    }
  24023. +}
  24024. +
  24025. +/*
  24026. + * Return number of characters buffered to be delivered to user
  24027. + */
  24028. +int n_tty_chars_in_buffer(struct tty_struct *tty)
  24029. +{
  24030. +    return tty->read_cnt;
  24031. +}
  24032. +
  24033. +/*
  24034. + * Perform OPOST processing.  Returns -1 when the output device is
  24035. + * full and the character must be retried.
  24036. + */
  24037. +static int opost(unsigned char c, struct tty_struct *tty)
  24038. +{
  24039. +    int    space, spaces;
  24040. +
  24041. +    space = tty->driver.write_room(tty);
  24042. +    if (!space)
  24043. +        return -1;
  24044. +
  24045. +    if (O_OPOST(tty)) {
  24046. +        switch (c) {
  24047. +        case '\n':
  24048. +            if (O_ONLRET(tty))
  24049. +                tty->column = 0;
  24050. +            if (O_ONLCR(tty)) {
  24051. +                if (space < 2)
  24052. +                    return -1;
  24053. +                tty->driver.put_char(tty, '\r');
  24054. +                tty->column = 0;
  24055. +            }
  24056. +            tty->canon_column = tty->column;
  24057. +            break;
  24058. +        case '\r':
  24059. +            if (O_ONOCR(tty) && tty->column == 0)
  24060. +                return 0;
  24061. +            if (O_OCRNL(tty)) {
  24062. +                c = '\n';
  24063. +                if (O_ONLRET(tty))
  24064. +                    tty->canon_column = tty->column = 0;
  24065. +                break;
  24066. +            }
  24067. +            tty->canon_column = tty->column = 0;
  24068. +            break;
  24069. +        case '\t':
  24070. +            spaces = 8 - (tty->column & 7);
  24071. +            if (O_TABDLY(tty) == XTABS) {
  24072. +                if (space < spaces)
  24073. +                    return -1;
  24074. +                tty->column += spaces;
  24075. +                tty->driver.write(tty, 0, "        ", spaces);
  24076. +                return 0;
  24077. +            }
  24078. +            tty->column += spaces;
  24079. +            break;
  24080. +        case '\b':
  24081. +            if (tty->column > 0)
  24082. +                tty->column--;
  24083. +            break;
  24084. +        default:
  24085. +            if (O_OLCUC(tty))
  24086. +                c = toupper(c);
  24087. +            if (!iscntrl(c))
  24088. +                tty->column++;
  24089. +            break;
  24090. +        }
  24091. +    }
  24092. +    tty->driver.put_char(tty, c);
  24093. +    return 0;
  24094. +}
  24095. +
  24096. +static inline void put_char(unsigned char c, struct tty_struct *tty)
  24097. +{
  24098. +    tty->driver.put_char(tty, c);
  24099. +}
  24100. +
  24101. +/* Must be called only when L_ECHO(tty) is true. */
  24102. +
  24103. +static void echo_char(unsigned char c, struct tty_struct *tty)
  24104. +{
  24105. +    if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t') {
  24106. +        put_char('^', tty);
  24107. +        put_char(c ^ 0100, tty);
  24108. +        tty->column += 2;
  24109. +    } else
  24110. +        opost(c, tty);
  24111. +}
  24112. +
  24113. +static inline void finish_erasing(struct tty_struct *tty)
  24114. +{
  24115. +    if (tty->erasing) {
  24116. +        put_char('/', tty);
  24117. +        tty->column += 2;
  24118. +        tty->erasing = 0;
  24119. +    }
  24120. +}
  24121. +
  24122. +static void eraser(unsigned char c, struct tty_struct *tty)
  24123. +{
  24124. +    enum { ERASE, WERASE, KILL } kill_type;
  24125. +    int head, seen_alnums;
  24126. +
  24127. +    if (tty->read_head == tty->canon_head) {
  24128. +        /* opost('\a', tty); */        /* what do you think? */
  24129. +        return;
  24130. +    }
  24131. +    if (c == ERASE_CHAR(tty))
  24132. +        kill_type = ERASE;
  24133. +    else if (c == WERASE_CHAR(tty))
  24134. +        kill_type = WERASE;
  24135. +    else {
  24136. +        if (!L_ECHO(tty)) {
  24137. +            tty->read_cnt -= ((tty->read_head - tty->canon_head) &
  24138. +                      (N_TTY_BUF_SIZE - 1));
  24139. +            tty->read_head = tty->canon_head;
  24140. +            return;
  24141. +        }
  24142. +        if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
  24143. +            tty->read_cnt -= ((tty->read_head - tty->canon_head) &
  24144. +                      (N_TTY_BUF_SIZE - 1));
  24145. +            tty->read_head = tty->canon_head;
  24146. +            finish_erasing(tty);
  24147. +            echo_char(KILL_CHAR(tty), tty);
  24148. +            /* Add a newline if ECHOK is on and ECHOKE is off. */
  24149. +            if (L_ECHOK(tty))
  24150. +                opost('\n', tty);
  24151. +            return;
  24152. +        }
  24153. +        kill_type = KILL;
  24154. +    }
  24155. +
  24156. +    seen_alnums = 0;
  24157. +    while (tty->read_head != tty->canon_head) {
  24158. +        head = (tty->read_head - 1) & (N_TTY_BUF_SIZE-1);
  24159. +        c = tty->read_buf[head];
  24160. +        if (kill_type == WERASE) {
  24161. +            /* Equivalent to BSD's ALTWERASE. */
  24162. +            if (isalnum(c) || c == '_')
  24163. +                seen_alnums++;
  24164. +            else if (seen_alnums)
  24165. +                break;
  24166. +        }
  24167. +        tty->read_head = head;
  24168. +        tty->read_cnt--;
  24169. +        if (L_ECHO(tty)) {
  24170. +            if (L_ECHOPRT(tty)) {
  24171. +                if (!tty->erasing) {
  24172. +                    put_char('\\', tty);
  24173. +                    tty->column++;
  24174. +                    tty->erasing = 1;
  24175. +                }
  24176. +                echo_char(c, tty);
  24177. +            } else if (kill_type == ERASE && !L_ECHOE(tty)) {
  24178. +                echo_char(ERASE_CHAR(tty), tty);
  24179. +            } else if (c == '\t') {
  24180. +                unsigned int col = tty->canon_column;
  24181. +                unsigned long tail = tty->canon_head;
  24182. +
  24183. +                /* Find the column of the last char. */
  24184. +                while (tail != tty->read_head) {
  24185. +                    c = tty->read_buf[tail];
  24186. +                    if (c == '\t')
  24187. +                        col = (col | 7) + 1;
  24188. +                    else if (iscntrl(c)) {
  24189. +                        if (L_ECHOCTL(tty))
  24190. +                            col += 2;
  24191. +                    } else
  24192. +                        col++;
  24193. +                    tail = (tail+1) & (N_TTY_BUF_SIZE-1);
  24194. +                }
  24195. +
  24196. +                /* should never happen */
  24197. +                if (tty->column > 0x80000000)
  24198. +                    tty->column = 0;
  24199. +
  24200. +                /* Now backup to that column. */
  24201. +                while (tty->column > col) {
  24202. +                    /* Can't use opost here. */
  24203. +                    put_char('\b', tty);
  24204. +                    if (tty->column > 0)
  24205. +                        tty->column--;
  24206. +                }
  24207. +            } else {
  24208. +                if (iscntrl(c) && L_ECHOCTL(tty)) {
  24209. +                    put_char('\b', tty);
  24210. +                    put_char(' ', tty);
  24211. +                    put_char('\b', tty);
  24212. +                    if (tty->column > 0)
  24213. +                        tty->column--;
  24214. +                }
  24215. +                if (!iscntrl(c) || L_ECHOCTL(tty)) {
  24216. +                    put_char('\b', tty);
  24217. +                    put_char(' ', tty);
  24218. +                    put_char('\b', tty);
  24219. +                    if (tty->column > 0)
  24220. +                        tty->column--;
  24221. +                }
  24222. +            }
  24223. +        }
  24224. +        if (kill_type == ERASE)
  24225. +            break;
  24226. +    }
  24227. +    if (tty->read_head == tty->canon_head)
  24228. +        finish_erasing(tty);
  24229. +}
  24230. +
  24231. +static inline void isig(int sig, struct tty_struct *tty, int flush)
  24232. +{
  24233. +    if (tty->pgrp > 0)
  24234. +        kill_pg(tty->pgrp, sig, 1);
  24235. +    if (flush || !L_NOFLSH(tty)) {
  24236. +        n_tty_flush_buffer(tty);
  24237. +        if (tty->driver.flush_buffer)
  24238. +            tty->driver.flush_buffer(tty);
  24239. +    }
  24240. +}
  24241. +
  24242. +static inline void n_tty_receive_break(struct tty_struct *tty)
  24243. +{
  24244. +    if (I_IGNBRK(tty))
  24245. +        return;
  24246. +    if (I_BRKINT(tty)) {
  24247. +        isig(SIGINT, tty, 1);
  24248. +        return;
  24249. +    }
  24250. +    if (I_PARMRK(tty)) {
  24251. +        put_tty_queue('\377', tty);
  24252. +        put_tty_queue('\0', tty);
  24253. +    }
  24254. +    put_tty_queue('\0', tty);
  24255. +    wake_up_interruptible(&tty->read_wait);
  24256. +}
  24257. +
  24258. +static inline void n_tty_receive_overrun(struct tty_struct *tty)
  24259. +{
  24260. +    char buf[64];
  24261. +
  24262. +    tty->num_overrun++;
  24263. +    if (tty->overrun_time < (jiffies - HZ)) {
  24264. +        printk("%s: %d input overrun(s)\n", _tty_name(tty, buf),
  24265. +               tty->num_overrun);
  24266. +        tty->overrun_time = jiffies;
  24267. +        tty->num_overrun = 0;
  24268. +    }
  24269. +}
  24270. +
  24271. +static inline void n_tty_receive_parity_error(struct tty_struct *tty,
  24272. +                          unsigned char c)
  24273. +{
  24274. +    if (I_IGNPAR(tty)) {
  24275. +        return;
  24276. +    }
  24277. +    if (I_PARMRK(tty)) {
  24278. +        put_tty_queue('\377', tty);
  24279. +        put_tty_queue('\0', tty);
  24280. +        put_tty_queue(c, tty);
  24281. +    } else    if (I_INPCK(tty))
  24282. +        put_tty_queue('\0', tty);
  24283. +    else
  24284. +        put_tty_queue(c, tty);
  24285. +    wake_up_interruptible(&tty->read_wait);
  24286. +}
  24287. +
  24288. +static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
  24289. +{
  24290. +    if (tty->raw) {
  24291. +        put_tty_queue(c, tty);
  24292. +        return;
  24293. +    }
  24294. +    
  24295. +    if (tty->stopped && I_IXON(tty) && I_IXANY(tty)) {
  24296. +        start_tty(tty);
  24297. +        return;
  24298. +    }
  24299. +    
  24300. +    if (I_ISTRIP(tty))
  24301. +        c &= 0x7f;
  24302. +    if (I_IUCLC(tty) && L_IEXTEN(tty))
  24303. +        c=tolower(c);
  24304. +
  24305. +    if (tty->closing) {
  24306. +        if (I_IXON(tty)) {
  24307. +            if (c == START_CHAR(tty))
  24308. +                start_tty(tty);
  24309. +            else if (c == STOP_CHAR(tty))
  24310. +                stop_tty(tty);
  24311. +        }
  24312. +        return;
  24313. +    }
  24314. +
  24315. +    /*
  24316. +     * If the previous character was LNEXT, or we know that this
  24317. +     * character is not one of the characters that we'll have to
  24318. +     * handle specially, do shortcut processing to speed things
  24319. +     * up.
  24320. +     */
  24321. +    if (!test_bit(c, &tty->process_char_map) || tty->lnext) {
  24322. +        finish_erasing(tty);
  24323. +        tty->lnext = 0;
  24324. +        if (L_ECHO(tty)) {
  24325. +            if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  24326. +                put_char('\a', tty); /* beep if no space */
  24327. +                return;
  24328. +            }
  24329. +            /* Record the column of first canon char. */
  24330. +            if (tty->canon_head == tty->read_head)
  24331. +                tty->canon_column = tty->column;
  24332. +            echo_char(c, tty);
  24333. +        }
  24334. +        if (I_PARMRK(tty) && c == (unsigned char) '\377')
  24335. +            put_tty_queue(c, tty);
  24336. +        put_tty_queue(c, tty);
  24337. +        return;
  24338. +    }
  24339. +        
  24340. +    if (c == '\r') {
  24341. +        if (I_IGNCR(tty))
  24342. +            return;
  24343. +        if (I_ICRNL(tty))
  24344. +            c = '\n';
  24345. +    } else if (c == '\n' && I_INLCR(tty))
  24346. +        c = '\r';
  24347. +    if (I_IXON(tty)) {
  24348. +        if (c == START_CHAR(tty)) {
  24349. +            start_tty(tty);
  24350. +            return;
  24351. +        }
  24352. +        if (c == STOP_CHAR(tty)) {
  24353. +            stop_tty(tty);
  24354. +            return;
  24355. +        }
  24356. +    }
  24357. +    if (L_ISIG(tty)) {
  24358. +        int signal;
  24359. +        signal = SIGINT;
  24360. +        if (c == INTR_CHAR(tty))
  24361. +            goto send_signal;
  24362. +        signal = SIGQUIT;
  24363. +        if (c == QUIT_CHAR(tty))
  24364. +            goto send_signal;
  24365. +        signal = SIGTSTP;
  24366. +        if (c == SUSP_CHAR(tty)) {
  24367. +send_signal:
  24368. +            isig(signal, tty, 0);
  24369. +            return;
  24370. +        }
  24371. +    }
  24372. +    if (L_ICANON(tty)) {
  24373. +        if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
  24374. +            (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
  24375. +            eraser(c, tty);
  24376. +            return;
  24377. +        }
  24378. +        if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
  24379. +            tty->lnext = 1;
  24380. +            if (L_ECHO(tty)) {
  24381. +                finish_erasing(tty);
  24382. +                if (L_ECHOCTL(tty)) {
  24383. +                    put_char('^', tty);
  24384. +                    put_char('\b', tty);
  24385. +                }
  24386. +            }
  24387. +            return;
  24388. +        }
  24389. +        if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
  24390. +            L_IEXTEN(tty)) {
  24391. +            unsigned long tail = tty->canon_head;
  24392. +
  24393. +            finish_erasing(tty);
  24394. +            echo_char(c, tty);
  24395. +            opost('\n', tty);
  24396. +            while (tail != tty->read_head) {
  24397. +                echo_char(tty->read_buf[tail], tty);
  24398. +                tail = (tail+1) & (N_TTY_BUF_SIZE-1);
  24399. +            }
  24400. +            return;
  24401. +        }
  24402. +        if (c == '\n') {
  24403. +            if (L_ECHO(tty) || L_ECHONL(tty)) {
  24404. +                if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  24405. +                    put_char('\a', tty);
  24406. +                    return;
  24407. +                }
  24408. +                opost('\n', tty);
  24409. +            }
  24410. +            goto handle_newline;
  24411. +        }
  24412. +        if (c == EOF_CHAR(tty)) {
  24413. +                if (tty->canon_head != tty->read_head)
  24414. +                    set_bit(TTY_PUSH, &tty->flags);
  24415. +            c = __DISABLED_CHAR;
  24416. +            goto handle_newline;
  24417. +        }
  24418. +        if ((c == EOL_CHAR(tty)) ||
  24419. +            (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
  24420. +            /*
  24421. +             * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
  24422. +             */
  24423. +            if (L_ECHO(tty)) {
  24424. +                if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  24425. +                    put_char('\a', tty);
  24426. +                    return;
  24427. +                }
  24428. +                /* Record the column of first canon char. */
  24429. +                if (tty->canon_head == tty->read_head)
  24430. +                    tty->canon_column = tty->column;
  24431. +                echo_char(c, tty);
  24432. +            }
  24433. +            /*
  24434. +             * XXX does PARMRK doubling happen for
  24435. +             * EOL_CHAR and EOL2_CHAR?
  24436. +             */
  24437. +            if (I_PARMRK(tty) && c == (unsigned char) '\377')
  24438. +                put_tty_queue(c, tty);
  24439. +
  24440. +        handle_newline:
  24441. +            set_bit(tty->read_head, &tty->read_flags);
  24442. +            put_tty_queue(c, tty);
  24443. +            tty->canon_head = tty->read_head;
  24444. +            tty->canon_data++;
  24445. +            if (tty->fasync)
  24446. +                kill_fasync(tty->fasync, SIGIO);
  24447. +            if (tty->read_wait)
  24448. +                wake_up_interruptible(&tty->read_wait);
  24449. +            return;
  24450. +        }
  24451. +    }
  24452. +    
  24453. +    finish_erasing(tty);
  24454. +    if (L_ECHO(tty)) {
  24455. +        if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  24456. +            put_char('\a', tty); /* beep if no space */
  24457. +            return;
  24458. +        }
  24459. +        if (c == '\n')
  24460. +            opost('\n', tty);
  24461. +        else {
  24462. +            /* Record the column of first canon char. */
  24463. +            if (tty->canon_head == tty->read_head)
  24464. +                tty->canon_column = tty->column;
  24465. +            echo_char(c, tty);
  24466. +        }
  24467. +    }
  24468. +
  24469. +    if (I_PARMRK(tty) && c == (unsigned char) '\377')
  24470. +        put_tty_queue(c, tty);
  24471. +
  24472. +    put_tty_queue(c, tty);
  24473. +}    
  24474. +
  24475. +static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
  24476. +                  char *fp, int count)
  24477. +{
  24478. +    const unsigned char *p;
  24479. +    char *f, flags = 0;
  24480. +    int    i;
  24481. +
  24482. +    if (!tty->read_buf)
  24483. +        return;
  24484. +
  24485. +    if (tty->real_raw) {
  24486. +        i = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
  24487. +                   N_TTY_BUF_SIZE - tty->read_head));
  24488. +        memcpy(tty->read_buf + tty->read_head, cp, i);
  24489. +        tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
  24490. +        tty->read_cnt += i;
  24491. +        cp += i;
  24492. +        count -= i;
  24493. +
  24494. +        i = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
  24495. +                   N_TTY_BUF_SIZE - tty->read_head));
  24496. +        memcpy(tty->read_buf + tty->read_head, cp, i);
  24497. +        tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
  24498. +        tty->read_cnt += i;
  24499. +    } else {
  24500. +        for (i=count, p = cp, f = fp; i; i--, p++) {
  24501. +            if (f)
  24502. +                flags = *f++;
  24503. +            switch (flags) {
  24504. +            case TTY_NORMAL:
  24505. +                n_tty_receive_char(tty, *p);
  24506. +                break;
  24507. +            case TTY_BREAK:
  24508. +                n_tty_receive_break(tty);
  24509. +                break;
  24510. +            case TTY_PARITY:
  24511. +            case TTY_FRAME:
  24512. +                n_tty_receive_parity_error(tty, *p);
  24513. +                break;
  24514. +            case TTY_OVERRUN:
  24515. +                n_tty_receive_overrun(tty);
  24516. +                break;
  24517. +            default:
  24518. +                printk("%s: unknown flag %d\n", tty_name(tty),
  24519. +                       flags);
  24520. +                break;
  24521. +            }
  24522. +        }
  24523. +        if (tty->driver.flush_chars)
  24524. +            tty->driver.flush_chars(tty);
  24525. +    }
  24526. +
  24527. +    if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) {
  24528. +        if (tty->fasync)
  24529. +            kill_fasync(tty->fasync, SIGIO);
  24530. +        if (tty->read_wait)
  24531. +            wake_up_interruptible(&tty->read_wait);
  24532. +    }
  24533. +
  24534. +    if ((tty->read_cnt >= TTY_THRESHOLD_THROTTLE) &&
  24535. +        tty->driver.throttle &&
  24536. +        !set_bit(TTY_THROTTLED, &tty->flags))
  24537. +        tty->driver.throttle(tty);
  24538. +}
  24539. +
  24540. +static int n_tty_receive_room(struct tty_struct *tty)
  24541. +{
  24542. +    int    left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
  24543. +
  24544. +    /*
  24545. +     * If we are doing input canonicalization, and there are no
  24546. +     * pending newlines, let characters through without limit, so
  24547. +     * that erase characters will be handled.  Other excess
  24548. +     * characters will be beeped.
  24549. +     */
  24550. +    if (tty->icanon && !tty->canon_data)
  24551. +        return N_TTY_BUF_SIZE;
  24552. +
  24553. +    if (left > 0)
  24554. +        return left;
  24555. +    return 0;
  24556. +}
  24557. +
  24558. +int is_ignored(int sig)
  24559. +{
  24560. +    return ((current->blocked & (1<<(sig-1))) ||
  24561. +            (current->sig->action[sig-1].sa_handler == SIG_IGN));
  24562. +}
  24563. +
  24564. +static void n_tty_set_termios(struct tty_struct *tty, struct termios * old)
  24565. +{
  24566. +    if (!tty)
  24567. +        return;
  24568. +    
  24569. +    tty->icanon = (L_ICANON(tty) != 0);
  24570. +    if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
  24571. +        I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
  24572. +        I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
  24573. +        I_PARMRK(tty)) {
  24574. +        cli();
  24575. +        memset(tty->process_char_map, 0, 256/8);
  24576. +
  24577. +        if (I_IGNCR(tty) || I_ICRNL(tty))
  24578. +            set_bit('\r', &tty->process_char_map);
  24579. +        if (I_INLCR(tty))
  24580. +            set_bit('\n', &tty->process_char_map);
  24581. +
  24582. +        if (L_ICANON(tty)) {
  24583. +            set_bit(ERASE_CHAR(tty), &tty->process_char_map);
  24584. +            set_bit(KILL_CHAR(tty), &tty->process_char_map);
  24585. +            set_bit(EOF_CHAR(tty), &tty->process_char_map);
  24586. +            set_bit('\n', &tty->process_char_map);
  24587. +            set_bit(EOL_CHAR(tty), &tty->process_char_map);
  24588. +            if (L_IEXTEN(tty)) {
  24589. +                set_bit(WERASE_CHAR(tty),
  24590. +                    &tty->process_char_map);
  24591. +                set_bit(LNEXT_CHAR(tty),
  24592. +                    &tty->process_char_map);
  24593. +                set_bit(EOL2_CHAR(tty),
  24594. +                    &tty->process_char_map);
  24595. +                if (L_ECHO(tty))
  24596. +                    set_bit(REPRINT_CHAR(tty),
  24597. +                        &tty->process_char_map);
  24598. +            }
  24599. +        }
  24600. +        if (I_IXON(tty)) {
  24601. +            set_bit(START_CHAR(tty), &tty->process_char_map);
  24602. +            set_bit(STOP_CHAR(tty), &tty->process_char_map);
  24603. +        }
  24604. +        if (L_ISIG(tty)) {
  24605. +            set_bit(INTR_CHAR(tty), &tty->process_char_map);
  24606. +            set_bit(QUIT_CHAR(tty), &tty->process_char_map);
  24607. +            set_bit(SUSP_CHAR(tty), &tty->process_char_map);
  24608. +        }
  24609. +        clear_bit(__DISABLED_CHAR, &tty->process_char_map);
  24610. +        sti();
  24611. +        tty->raw = 0;
  24612. +        tty->real_raw = 0;
  24613. +    } else {
  24614. +        tty->raw = 1;
  24615. +        if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
  24616. +            (I_IGNPAR(tty) || !I_INPCK(tty)) &&
  24617. +            (tty->driver.flags & TTY_DRIVER_REAL_RAW))
  24618. +            tty->real_raw = 1;
  24619. +        else
  24620. +            tty->real_raw = 0;
  24621. +    }
  24622. +}
  24623. +
  24624. +static void n_tty_close(struct tty_struct *tty)
  24625. +{
  24626. +    n_tty_flush_buffer(tty);
  24627. +    if (tty->read_buf) {
  24628. +        kfree_s (tty->read_buf, N_TTY_BUF_SIZE);
  24629. +        tty->read_buf = 0;
  24630. +    }
  24631. +}
  24632. +
  24633. +static int n_tty_open(struct tty_struct *tty)
  24634. +{
  24635. +    if (!tty)
  24636. +        return -EINVAL;
  24637. +
  24638. +    if (!tty->read_buf) {
  24639. +        tty->read_buf = (unsigned char *)
  24640. +            kmalloc (N_TTY_BUF_SIZE, intr_count ? GFP_ATOMIC : GFP_KERNEL);
  24641. +        if (!tty->read_buf)
  24642. +            return -ENOMEM;
  24643. +    }
  24644. +    memset(tty->read_buf, 0, N_TTY_BUF_SIZE);
  24645. +    tty->read_head = tty->read_tail = tty->read_cnt = 0;
  24646. +    tty->canon_head = tty->canon_data = tty->erasing = 0;
  24647. +    tty->column = 0;
  24648. +    memset(tty->read_flags, 0, sizeof(tty->read_flags));
  24649. +    n_tty_set_termios(tty, 0);
  24650. +    tty->minimum_to_wake = 1;
  24651. +    tty->closing = 0;
  24652. +    return 0;
  24653. +}
  24654. +
  24655. +static inline int input_available_p(struct tty_struct *tty, int amt)
  24656. +{
  24657. +    if (L_ICANON(tty)) {
  24658. +        if (tty->canon_data)
  24659. +            return 1;
  24660. +    } else if (tty->read_cnt >= (amt ? amt : 1))
  24661. +        return 1;
  24662. +
  24663. +    return 0;
  24664. +}
  24665. +
  24666. +/*
  24667. + * Helper function to speed up read_chan.  It is only called when
  24668. + * ICANON is off; it copies characters straight from the tty queue to
  24669. + * user space directly.  It can be profitably called twice; once to
  24670. + * drain the space from the tail pointer to the (physical) end of the
  24671. + * buffer, and once to drain the space from the (physical) beginning of
  24672. + * the buffer to head pointer.
  24673. + */
  24674. +static inline void copy_from_read_buf(struct tty_struct *tty,
  24675. +                      unsigned char **b,
  24676. +                      unsigned int *nr)
  24677. +
  24678. +{
  24679. +    int    n;
  24680. +
  24681. +    n = MIN(*nr, MIN(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail));
  24682. +    if (!n)
  24683. +        return;
  24684. +    memcpy_tofs(*b, &tty->read_buf[tty->read_tail], n);
  24685. +    tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
  24686. +    tty->read_cnt -= n;
  24687. +    *b += n;
  24688. +    *nr -= n;
  24689. +}
  24690. +
  24691. +static int read_chan(struct tty_struct *tty, struct file *file,
  24692. +             unsigned char *buf, unsigned int nr)
  24693. +{
  24694. +    struct wait_queue wait = { current, NULL };
  24695. +    int c;
  24696. +    unsigned char *b = buf;
  24697. +    int minimum, time;
  24698. +    int retval = 0;
  24699. +    int size;
  24700. +
  24701. +do_it_again:
  24702. +
  24703. +    if (!tty->read_buf) {
  24704. +        printk("n_tty_read_chan: called with read_buf == NULL?!?\n");
  24705. +        return -EIO;
  24706. +    }
  24707. +
  24708. +    /* Job control check -- must be done at start and after
  24709. +       every sleep (POSIX.1 7.1.1.4). */
  24710. +    /* NOTE: not yet done after every sleep pending a thorough
  24711. +       check of the logic of this change. -- jlc */
  24712. +    /* don't stop on /dev/console */
  24713. +    if (file->f_inode->i_rdev != CONSOLE_DEV &&
  24714. +        current->tty == tty) {
  24715. +        if (tty->pgrp <= 0)
  24716. +            printk("read_chan: tty->pgrp <= 0!\n");
  24717. +        else if (current->pgrp != tty->pgrp) {
  24718. +            if (is_ignored(SIGTTIN) ||
  24719. +                is_orphaned_pgrp(current->pgrp))
  24720. +                return -EIO;
  24721. +            kill_pg(current->pgrp, SIGTTIN, 1);
  24722. +            return -ERESTARTSYS;
  24723. +        }
  24724. +    }
  24725. +
  24726. +    if (L_ICANON(tty)) {
  24727. +        minimum = time = 0;
  24728. +        current->timeout = (unsigned long) -1;
  24729. +    } else {
  24730. +        time = (HZ / 10) * TIME_CHAR(tty);
  24731. +        minimum = MIN_CHAR(tty);
  24732. +        if (minimum) {
  24733. +              current->timeout = (unsigned long) -1;
  24734. +            if (time)
  24735. +                tty->minimum_to_wake = 1;
  24736. +            else if (!waitqueue_active(&tty->read_wait) ||
  24737. +                 (tty->minimum_to_wake > minimum))
  24738. +                tty->minimum_to_wake = minimum;
  24739. +        } else {
  24740. +            if (time) {
  24741. +                current->timeout = time + jiffies;
  24742. +                time = 0;
  24743. +            } else
  24744. +                current->timeout = 0;
  24745. +            tty->minimum_to_wake = minimum = 1;
  24746. +        }
  24747. +    }
  24748. +
  24749. +    add_wait_queue(&tty->read_wait, &wait);
  24750. +    while (1) {
  24751. +        /* First test for status change. */
  24752. +        if (tty->packet && tty->link->ctrl_status) {
  24753. +            if (b != buf)
  24754. +                break;
  24755. +            put_user(tty->link->ctrl_status, b++);
  24756. +            tty->link->ctrl_status = 0;
  24757. +            break;
  24758. +        }
  24759. +        /* This statement must be first before checking for input
  24760. +           so that any interrupt will set the state back to
  24761. +           TASK_RUNNING. */
  24762. +        current->state = TASK_INTERRUPTIBLE;
  24763. +        
  24764. +        if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
  24765. +            ((minimum - (b - buf)) >= 1))
  24766. +            tty->minimum_to_wake = (minimum - (b - buf));
  24767. +        
  24768. +        if (!input_available_p(tty, 0)) {
  24769. +            if (tty->flags & (1 << TTY_OTHER_CLOSED)) {
  24770. +                retval = -EIO;
  24771. +                break;
  24772. +            }
  24773. +            if (tty_hung_up_p(file))
  24774. +                break;
  24775. +            if (!current->timeout)
  24776. +                break;
  24777. +            if (file->f_flags & O_NONBLOCK) {
  24778. +                retval = -EAGAIN;
  24779. +                break;
  24780. +            }
  24781. +            if (current->signal & ~current->blocked) {
  24782. +                retval = -ERESTARTSYS;
  24783. +                break;
  24784. +            }
  24785. +            schedule();
  24786. +            continue;
  24787. +        }
  24788. +        current->state = TASK_RUNNING;
  24789. +
  24790. +        /* Deal with packet mode. */
  24791. +        if (tty->packet && b == buf) {
  24792. +            put_user(TIOCPKT_DATA, b++);
  24793. +            nr--;
  24794. +        }
  24795. +
  24796. +        if (L_ICANON(tty)) {
  24797. +            while (1) {
  24798. +                int eol;
  24799. +
  24800. +                disable_bh(TQUEUE_BH);
  24801. +                if (!tty->read_cnt) {
  24802. +                    enable_bh(TQUEUE_BH);
  24803. +                    break;
  24804. +                }
  24805. +                eol = clear_bit(tty->read_tail,
  24806. +                        &tty->read_flags);
  24807. +                c = tty->read_buf[tty->read_tail];
  24808. +                tty->read_tail = ((tty->read_tail+1) &
  24809. +                          (N_TTY_BUF_SIZE-1));
  24810. +                tty->read_cnt--;
  24811. +                enable_bh(TQUEUE_BH);
  24812. +                if (!eol) {
  24813. +                    put_user(c, b++);
  24814. +                    if (--nr)
  24815. +                        continue;
  24816. +                    break;
  24817. +                }
  24818. +                if (--tty->canon_data < 0) {
  24819. +                    tty->canon_data = 0;
  24820. +                }
  24821. +                if (c != __DISABLED_CHAR) {
  24822. +                    put_user(c, b++);
  24823. +                    nr--;
  24824. +                }
  24825. +                break;
  24826. +            }
  24827. +        } else {
  24828. +            disable_bh(TQUEUE_BH);
  24829. +            copy_from_read_buf(tty, &b, &nr);
  24830. +            copy_from_read_buf(tty, &b, &nr);
  24831. +            enable_bh(TQUEUE_BH);
  24832. +        }
  24833. +
  24834. +        /* If there is enough space in the read buffer now, let the
  24835. +           low-level driver know. */
  24836. +        if (tty->driver.unthrottle &&
  24837. +            (tty->read_cnt <= TTY_THRESHOLD_UNTHROTTLE)
  24838. +            && clear_bit(TTY_THROTTLED, &tty->flags))
  24839. +            tty->driver.unthrottle(tty);
  24840. +
  24841. +        if (b - buf >= minimum || !nr)
  24842. +            break;
  24843. +        if (time)
  24844. +            current->timeout = time + jiffies;
  24845. +    }
  24846. +    remove_wait_queue(&tty->read_wait, &wait);
  24847. +
  24848. +    if (!waitqueue_active(&tty->read_wait))
  24849. +        tty->minimum_to_wake = minimum;
  24850. +
  24851. +    current->state = TASK_RUNNING;
  24852. +    current->timeout = 0;
  24853. +    size = b - buf;
  24854. +    if (size && nr)
  24855. +            clear_bit(TTY_PUSH, &tty->flags);
  24856. +        if (!size && clear_bit(TTY_PUSH, &tty->flags))
  24857. +                goto do_it_again;
  24858. +    if (!size && !retval)
  24859. +            clear_bit(TTY_PUSH, &tty->flags);
  24860. +        return (size ? size : retval);
  24861. +}
  24862. +
  24863. +static int write_chan(struct tty_struct * tty, struct file * file,
  24864. +              const unsigned char * buf, unsigned int nr)
  24865. +{
  24866. +    struct wait_queue wait = { current, NULL };
  24867. +    int c;
  24868. +    const unsigned char *b = buf;
  24869. +    int retval = 0;
  24870. +
  24871. +    /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
  24872. +    if (L_TOSTOP(tty) && file->f_inode->i_rdev != CONSOLE_DEV) {
  24873. +        retval = tty_check_change(tty);
  24874. +        if (retval)
  24875. +            return retval;
  24876. +    }
  24877. +
  24878. +    add_wait_queue(&tty->write_wait, &wait);
  24879. +    while (1) {
  24880. +        current->state = TASK_INTERRUPTIBLE;
  24881. +        if (current->signal & ~current->blocked) {
  24882. +            retval = -ERESTARTSYS;
  24883. +            break;
  24884. +        }
  24885. +        if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
  24886. +            retval = -EIO;
  24887. +            break;
  24888. +        }
  24889. +        if (O_OPOST(tty)) {
  24890. +            while (nr > 0) {
  24891. +                c = get_user(b);
  24892. +                if (opost(c, tty) < 0)
  24893. +                    break;
  24894. +                b++; nr--;
  24895. +            }
  24896. +            if (tty->driver.flush_chars)
  24897. +                tty->driver.flush_chars(tty);
  24898. +        } else {
  24899. +            c = tty->driver.write(tty, 1, b, nr);
  24900. +            b += c;
  24901. +            nr -= c;
  24902. +        }
  24903. +        if (!nr)
  24904. +            break;
  24905. +        if (file->f_flags & O_NONBLOCK) {
  24906. +            retval = -EAGAIN;
  24907. +            break;
  24908. +        }
  24909. +        schedule();
  24910. +    }
  24911. +    current->state = TASK_RUNNING;
  24912. +    remove_wait_queue(&tty->write_wait, &wait);
  24913. +    return (b - buf) ? b - buf : retval;
  24914. +}
  24915. +
  24916. +static int normal_select(struct tty_struct * tty, struct inode * inode,
  24917. +             struct file * file, int sel_type, select_table *wait)
  24918. +{
  24919. +    switch (sel_type) {
  24920. +        case SEL_IN:
  24921. +            if (input_available_p(tty, TIME_CHAR(tty) ? 0 :
  24922. +                          MIN_CHAR(tty)))
  24923. +                return 1;
  24924. +            /* fall through */
  24925. +        case SEL_EX:
  24926. +            if (tty->packet && tty->link->ctrl_status)
  24927. +                return 1;
  24928. +            if (tty->flags & (1 << TTY_OTHER_CLOSED))
  24929. +                return 1;
  24930. +            if (tty_hung_up_p(file))
  24931. +                return 1;
  24932. +            if (!waitqueue_active(&tty->read_wait)) {
  24933. +                if (MIN_CHAR(tty) && !TIME_CHAR(tty))
  24934. +                    tty->minimum_to_wake = MIN_CHAR(tty);
  24935. +                else
  24936. +                    tty->minimum_to_wake = 1;
  24937. +            }
  24938. +            select_wait(&tty->read_wait, wait);
  24939. +            return 0;
  24940. +        case SEL_OUT:
  24941. +            if (tty->driver.chars_in_buffer(tty) < WAKEUP_CHARS)
  24942. +                return 1;
  24943. +            select_wait(&tty->write_wait, wait);
  24944. +            return 0;
  24945. +    }
  24946. +    return 0;
  24947. +}
  24948. +
  24949. +struct tty_ldisc tty_ldisc_N_TTY = {
  24950. +    TTY_LDISC_MAGIC,    /* magic */
  24951. +    0,            /* num */
  24952. +    0,            /* flags */
  24953. +    n_tty_open,        /* open */
  24954. +    n_tty_close,        /* close */
  24955. +    n_tty_flush_buffer,    /* flush_buffer */
  24956. +    n_tty_chars_in_buffer,    /* chars_in_buffer */
  24957. +    read_chan,        /* read */
  24958. +    write_chan,        /* write */
  24959. +    n_tty_ioctl,        /* ioctl */
  24960. +    n_tty_set_termios,    /* set_termios */
  24961. +    normal_select,        /* select */
  24962. +    n_tty_receive_buf,    /* receive_buf */
  24963. +    n_tty_receive_room,    /* receive_room */
  24964. +    0            /* write_wakeup */
  24965. +};
  24966. +
  24967. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/pty.c linux/arch/arm/drivers/char/pty.c
  24968. --- linux.orig/arch/arm/drivers/char/pty.c    Thu Jan  1 01:00:00 1970
  24969. +++ linux/arch/arm/drivers/char/pty.c    Sun Jul  7 12:50:23 1996
  24970. @@ -0,0 +1,324 @@
  24971. +/*
  24972. + *  linux/arch/arm/drivers/char/pty.c
  24973. + *
  24974. + *  Copyright (C) 1991, 1992  Linus Torvalds
  24975. + *
  24976. + *  Modifications for ARM processor Copyright (C) 1995, 1996 Russell King.
  24977. + */
  24978. +
  24979. +/*
  24980. + *    pty.c
  24981. + *
  24982. + * This module exports the following pty function:
  24983. + *
  24984. + *     int  pty_open(struct tty_struct * tty, struct file * filp);
  24985. + */
  24986. +
  24987. +#include <linux/errno.h>
  24988. +#include <linux/sched.h>
  24989. +#include <linux/interrupt.h>
  24990. +#include <linux/tty.h>
  24991. +#include <linux/tty_flip.h>
  24992. +#include <linux/fcntl.h>
  24993. +#include <linux/string.h>
  24994. +#include <linux/major.h>
  24995. +#include <linux/mm.h>
  24996. +#include <linux/malloc.h>
  24997. +
  24998. +#include <asm/segment.h>
  24999. +#include <asm/system.h>
  25000. +#include <asm/bitops.h>
  25001. +
  25002. +struct pty_struct {
  25003. +    int    magic;
  25004. +    struct wait_queue * open_wait;
  25005. +};
  25006. +
  25007. +#define PTY_MAGIC 0x5001
  25008. +
  25009. +#define PTY_BUF_SIZE 4096/2
  25010. +
  25011. +/*
  25012. + * tmp_buf is used as a temporary buffer by pty_write.  We need to
  25013. + * lock it in case the memcpy_fromfs blocks while swapping in a page,
  25014. + * and some other program tries to do a pty write at the same time.
  25015. + * Since the lock will only come under contention when the system is
  25016. + * swapping and available memory is low, it makes sense to share one
  25017. + * buffer across all the PTY's, since it significantly saves memory if
  25018. + * large numbers of PTY's are open.
  25019. + */
  25020. +static unsigned char *tmp_buf;
  25021. +static struct semaphore tmp_buf_sem = MUTEX;
  25022. +
  25023. +struct tty_driver pty_driver, pty_slave_driver;
  25024. +struct tty_driver old_pty_driver, old_pty_slave_driver;
  25025. +static int pty_refcount;
  25026. +
  25027. +static struct tty_struct *pty_table[NR_PTYS];
  25028. +static struct termios *pty_termios[NR_PTYS];
  25029. +static struct termios *pty_termios_locked[NR_PTYS];
  25030. +static struct tty_struct *ttyp_table[NR_PTYS];
  25031. +static struct termios *ttyp_termios[NR_PTYS];
  25032. +static struct termios *ttyp_termios_locked[NR_PTYS];
  25033. +static struct pty_struct pty_state[NR_PTYS];
  25034. +
  25035. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  25036. +
  25037. +static void pty_close(struct tty_struct * tty, struct file * filp)
  25038. +{
  25039. +    if (!tty)
  25040. +        return;
  25041. +    if (tty->driver.subtype == PTY_TYPE_MASTER) {
  25042. +        if (tty->count > 1)
  25043. +            printk("master pty_close: count = %d!!\n", tty->count);
  25044. +    } else {
  25045. +        if (tty->count > 2)
  25046. +            return;
  25047. +    }
  25048. +    wake_up_interruptible(&tty->read_wait);
  25049. +    wake_up_interruptible(&tty->write_wait);
  25050. +    if (!tty->link)
  25051. +        return;
  25052. +    wake_up_interruptible(&tty->link->read_wait);
  25053. +    wake_up_interruptible(&tty->link->write_wait);
  25054. +    set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
  25055. +    if (tty->driver.subtype == PTY_TYPE_MASTER) {
  25056. +        tty_hangup(tty->link);
  25057. +        set_bit(TTY_OTHER_CLOSED, &tty->flags);
  25058. +    }
  25059. +}
  25060. +
  25061. +/*
  25062. + * The unthrottle routine is called by the line discipline to signal
  25063. + * that it can receive more characters.  For PTY's, the TTY_THROTTLED
  25064. + * flag is always set, to force the line discipline to always call the
  25065. + * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
  25066. + * characters in the queue.  This is necessary since each time this
  25067. + * happens, we need to wake up any sleeping processes that could be
  25068. + * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
  25069. + * for the pty buffer to be drained.
  25070. + */
  25071. +static void pty_unthrottle(struct tty_struct * tty)
  25072. +{
  25073. +    struct tty_struct *o_tty = tty->link;
  25074. +
  25075. +    if (!o_tty)
  25076. +        return;
  25077. +
  25078. +    if ((o_tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  25079. +        o_tty->ldisc.write_wakeup)
  25080. +        (o_tty->ldisc.write_wakeup)(o_tty);
  25081. +    wake_up_interruptible(&o_tty->write_wait);
  25082. +    set_bit(TTY_THROTTLED, &tty->flags);
  25083. +}
  25084. +
  25085. +static int pty_write(struct tty_struct * tty, int from_user,
  25086. +               const unsigned char *buf, int count)
  25087. +{
  25088. +    struct tty_struct *to = tty->link;
  25089. +    int    c=0, n, r;
  25090. +    char    *temp_buffer;
  25091. +
  25092. +    if (!to || tty->stopped)
  25093. +        return 0;
  25094. +
  25095. +    if (from_user) {
  25096. +        down(&tmp_buf_sem);
  25097. +        temp_buffer = tmp_buf +
  25098. +            ((tty->driver.subtype-1) * PTY_BUF_SIZE);
  25099. +        while (count > 0) {
  25100. +            n = MIN(count, PTY_BUF_SIZE);
  25101. +            memcpy_fromfs(temp_buffer, buf, n);
  25102. +            r = to->ldisc.receive_room(to);
  25103. +            if (r <= 0)
  25104. +                break;
  25105. +            n = MIN(n, r);
  25106. +            to->ldisc.receive_buf(to, temp_buffer, 0, n);
  25107. +            buf += n;  c+= n;
  25108. +            count -= n;
  25109. +        }
  25110. +        up(&tmp_buf_sem);
  25111. +    } else {
  25112. +        c = MIN(count, to->ldisc.receive_room(to));
  25113. +        to->ldisc.receive_buf(to, buf, 0, c);
  25114. +    }
  25115. +
  25116. +    return c;
  25117. +}
  25118. +
  25119. +static int pty_write_room(struct tty_struct *tty)
  25120. +{
  25121. +    struct tty_struct *to = tty->link;
  25122. +
  25123. +    if (!to || tty->stopped)
  25124. +        return 0;
  25125. +
  25126. +    return to->ldisc.receive_room(to);
  25127. +}
  25128. +
  25129. +static int pty_chars_in_buffer(struct tty_struct *tty)
  25130. +{
  25131. +    struct tty_struct *to = tty->link;
  25132. +
  25133. +    if (!to || !to->ldisc.chars_in_buffer)
  25134. +        return 0;
  25135. +
  25136. +    return to->ldisc.chars_in_buffer(to);
  25137. +}
  25138. +
  25139. +static void pty_flush_buffer(struct tty_struct *tty)
  25140. +{
  25141. +    struct tty_struct *to = tty->link;
  25142. +
  25143. +    if (!to)
  25144. +        return;
  25145. +
  25146. +    if (to->ldisc.flush_buffer)
  25147. +        to->ldisc.flush_buffer(to);
  25148. +
  25149. +    if (to->packet) {
  25150. +        tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
  25151. +        wake_up_interruptible(&to->read_wait);
  25152. +    }
  25153. +}
  25154. +
  25155. +int pty_open(struct tty_struct *tty, struct file * filp)
  25156. +{
  25157. +#if PTY_SLAVE_WAITS_ON_OPEN
  25158. +    struct wait_queue wait = { current, NULL };
  25159. +#endif
  25160. +    int    retval;
  25161. +    int    line;
  25162. +    struct    pty_struct *pty;
  25163. +
  25164. +    if (!tty || !tty->link)
  25165. +        return -ENODEV;
  25166. +    line = MINOR(tty->device) - tty->driver.minor_start;
  25167. +    if ((line < 0) || (line >= NR_PTYS))
  25168. +        return -ENODEV;
  25169. +    pty = pty_state + line;
  25170. +    tty->driver_data = pty;
  25171. +
  25172. +    if (!tmp_buf) {
  25173. +        unsigned long page = (unsigned long) kmalloc(PTY_BUF_SIZE*2,GFP_KERNEL);
  25174. +        if (!tmp_buf) {
  25175. +            if (!page)
  25176. +                return -ENOMEM;
  25177. +            tmp_buf = (unsigned char *) page;
  25178. +        } else
  25179. +            kfree((void *)page);
  25180. +    }
  25181. +
  25182. +    clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
  25183. +    wake_up_interruptible(&pty->open_wait);
  25184. +    set_bit(TTY_THROTTLED, &tty->flags);
  25185. +    if (filp->f_flags & O_NDELAY)
  25186. +        return 0;
  25187. +    /*
  25188. +     * If we're opening the master pty, just return.  If we're
  25189. +     * trying to open the slave pty, then we have to wait for the
  25190. +     * master pty to open.
  25191. +     */
  25192. +    if (tty->driver.subtype == PTY_TYPE_MASTER)
  25193. +        return 0;
  25194. +    retval = 0;
  25195. +#if PTY_SLAVE_WAITS_ON_OPEN
  25196. +    add_wait_queue(&pty->open_wait, &wait);
  25197. +    while (1) {
  25198. +        if (current->signal & ~current->blocked) {
  25199. +            retval = -ERESTARTSYS;
  25200. +            break;
  25201. +        }
  25202. +        /*
  25203. +         * Block until the master is open...
  25204. +         */
  25205. +        current->state = TASK_INTERRUPTIBLE;
  25206. +        if (tty->link->count &&
  25207. +            !test_bit(TTY_OTHER_CLOSED, &tty->flags))
  25208. +            break;
  25209. +        schedule();
  25210. +    }
  25211. +    current->state = TASK_RUNNING;
  25212. +    remove_wait_queue(&pty->open_wait, &wait);
  25213. +#else
  25214. +    if (!tty->link->count || test_bit(TTY_OTHER_CLOSED, &tty->flags))
  25215. +        retval = -EPERM;
  25216. +#endif
  25217. +    return retval;
  25218. +}
  25219. +
  25220. +static void pty_set_termios(struct tty_struct *tty, struct termios *old_termios)
  25221. +{
  25222. +    tty->termios->c_cflag &= ~(CSIZE | PARENB);
  25223. +    tty->termios->c_cflag |= (CS8 | CREAD);
  25224. +}
  25225. +
  25226. +int pty_init(void)
  25227. +{
  25228. +    memset(&pty_state, 0, sizeof(pty_state));
  25229. +    memset(&pty_driver, 0, sizeof(struct tty_driver));
  25230. +    pty_driver.magic = TTY_DRIVER_MAGIC;
  25231. +    pty_driver.name = "pty";
  25232. +    pty_driver.major = PTY_MASTER_MAJOR;
  25233. +    pty_driver.minor_start = 0;
  25234. +    pty_driver.num = NR_PTYS;
  25235. +    pty_driver.type = TTY_DRIVER_TYPE_PTY;
  25236. +    pty_driver.subtype = PTY_TYPE_MASTER;
  25237. +    pty_driver.init_termios = tty_std_termios;
  25238. +    pty_driver.init_termios.c_iflag = 0;
  25239. +    pty_driver.init_termios.c_oflag = 0;
  25240. +    pty_driver.init_termios.c_cflag = B38400 | CS8 | CREAD;
  25241. +    pty_driver.init_termios.c_lflag = 0;
  25242. +    pty_driver.flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW;
  25243. +    pty_driver.refcount = &pty_refcount;
  25244. +    pty_driver.table = pty_table;
  25245. +    pty_driver.termios = pty_termios;
  25246. +    pty_driver.termios_locked = pty_termios_locked;
  25247. +    pty_driver.other = &pty_slave_driver;
  25248. +
  25249. +    pty_driver.open = pty_open;
  25250. +    pty_driver.close = pty_close;
  25251. +    pty_driver.write = pty_write;
  25252. +    pty_driver.write_room = pty_write_room;
  25253. +    pty_driver.flush_buffer = pty_flush_buffer;
  25254. +    pty_driver.chars_in_buffer = pty_chars_in_buffer;
  25255. +    pty_driver.unthrottle = pty_unthrottle;
  25256. +    pty_driver.set_termios = pty_set_termios;
  25257. +
  25258. +    pty_slave_driver = pty_driver;
  25259. +    pty_slave_driver.name = "ttyp";
  25260. +    pty_slave_driver.subtype = PTY_TYPE_SLAVE;
  25261. +    pty_slave_driver.major = PTY_SLAVE_MAJOR;
  25262. +    pty_slave_driver.minor_start = 0;
  25263. +    pty_slave_driver.init_termios = tty_std_termios;
  25264. +    pty_slave_driver.init_termios.c_cflag = B38400 | CS8 | CREAD;
  25265. +    pty_slave_driver.table = ttyp_table;
  25266. +    pty_slave_driver.termios = ttyp_termios;
  25267. +    pty_slave_driver.termios_locked = ttyp_termios_locked;
  25268. +    pty_slave_driver.other = &pty_driver;
  25269. +
  25270. +    old_pty_driver = pty_driver;
  25271. +    old_pty_driver.major = TTY_MAJOR;
  25272. +    old_pty_driver.minor_start = 128;
  25273. +    old_pty_driver.num = (NR_PTYS > 64) ? 64 : NR_PTYS;
  25274. +    old_pty_driver.other = &old_pty_slave_driver;
  25275. +
  25276. +    old_pty_slave_driver = pty_slave_driver;
  25277. +    old_pty_slave_driver.major = TTY_MAJOR;
  25278. +    old_pty_slave_driver.minor_start = 192;
  25279. +    old_pty_slave_driver.num = (NR_PTYS > 64) ? 64 : NR_PTYS;
  25280. +    old_pty_slave_driver.other = &old_pty_driver;
  25281. +
  25282. +    tmp_buf = 0;
  25283. +
  25284. +    if (tty_register_driver(&pty_driver))
  25285. +        panic("Couldn't register pty driver");
  25286. +    if (tty_register_driver(&pty_slave_driver))
  25287. +        panic("Couldn't register pty slave driver");
  25288. +    if (tty_register_driver(&old_pty_driver))
  25289. +        panic("Couldn't register compat pty driver");
  25290. +    if (tty_register_driver(&old_pty_slave_driver))
  25291. +        panic("Couldn't register compat pty slave driver");
  25292. +
  25293. +    return 0;
  25294. +}
  25295. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/selection.c linux/arch/arm/drivers/char/selection.c
  25296. --- linux.orig/arch/arm/drivers/char/selection.c    Thu Jan  1 01:00:00 1970
  25297. +++ linux/arch/arm/drivers/char/selection.c    Sun Jun 23 11:38:41 1996
  25298. @@ -0,0 +1,298 @@
  25299. +/*
  25300. + * linux/arch/arm/drivers/char/console/selection.c
  25301. + *
  25302. + * This module exports the functions:
  25303. + *
  25304. + *  'int set_selection (const unsigned long arg)'
  25305. + *  'void clear_selection (void)'
  25306. + *  'int paste_selection (struct tty_struct *tty)'
  25307. + *  'int sel_loadlut (const unsigned long arg)'
  25308. + *
  25309. + * Now that /dev/vcs exists, most of this can disappear again.
  25310. + */
  25311. +
  25312. +#include <linux/tty.h>
  25313. +#include <linux/sched.h>
  25314. +#include <linux/mm.h>
  25315. +#include <linux/malloc.h>
  25316. +#include <linux/types.h>
  25317. +
  25318. +#include <asm/segment.h>
  25319. +
  25320. +#include "vt_kern.h"
  25321. +#include "consolemap.h"
  25322. +#include "selection.h"
  25323. +
  25324. +#ifndef MIN
  25325. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  25326. +#endif
  25327. +
  25328. +/* Don't take this from <ctype.h>: 011-015 in the buffer aren't spaces */
  25329. +#define isspace(c)    ((c) == ' ')
  25330. +
  25331. +#define sel_pos(n)    inverse_translate(scrw2glyph(screen_word(vtdata.select.vt, n)))
  25332. +
  25333. +/*
  25334. + * clear_selection, highlight and highlight_pointer can be called
  25335. + * from interrupt (via scrollback/front)
  25336. + */
  25337. +
  25338. +/*
  25339. + * set reverse video on characters s-e of console with selection.
  25340. + */
  25341. +static inline void highlight (const int s, const int e)
  25342. +{
  25343. +    invert_screen (vtdata.select.vt, s, e - s);
  25344. +}
  25345. +
  25346. +/*
  25347. + * use complementary color to show the pointer
  25348. + */
  25349. +static inline void highlight_pointer (const int where)
  25350. +{
  25351. +    complement_pos (vtdata.select.vt, where);
  25352. +}
  25353. +
  25354. +/*
  25355. + * Remove the current selection highlight, if any,
  25356. + * from the console holding selection.
  25357. + */
  25358. +void clear_selection (void)
  25359. +{
  25360. +    highlight_pointer (-1); /* hide the pointer */
  25361. +    if (vtdata.select.start != -1) {
  25362. +    highlight (vtdata.select.start, vtdata.select.end);
  25363. +    vtdata.select.start = -1;
  25364. +    }
  25365. +}
  25366. +
  25367. +/*
  25368. + * User settable table: what characters are to be considered alphabetic?
  25369. + * 256 bits
  25370. + */
  25371. +static u32 inwordLut[8]={
  25372. +  0x00000000, /* control chars     */
  25373. +  0x03FF0000, /* digits            */
  25374. +  0x87FFFFFE, /* uppercase and '_' */
  25375. +  0x07FFFFFE, /* lowercase         */
  25376. +  0x00000000,
  25377. +  0x00000000,
  25378. +  0xFF7FFFFF, /* latin-1 accented letters, not multiplication sign */
  25379. +  0xFF7FFFFF  /* latin-1 accented letters, not division sign */
  25380. +};
  25381. +
  25382. +static inline int inword (const unsigned char c)
  25383. +{
  25384. +    return (inwordLut[c>>5] >> (c & 31)) & 1;
  25385. +}
  25386. +
  25387. +/*
  25388. + * set inwordLut contents.  Invoked by ioctl().
  25389. + */
  25390. +int sel_loadlut (const unsigned long arg)
  25391. +{
  25392. +    int i = verify_area (VERIFY_READ, (char *) arg, 36);
  25393. +    if (i)
  25394. +    return i;
  25395. +    memcpy_fromfs (inwordLut, (u32 *)(arg + 4), 32);
  25396. +    return 0;
  25397. +}
  25398. +
  25399. +/*
  25400. + * does buffer offset p correspond to character at LH/RH edge of screen?
  25401. + */
  25402. +static inline int atedge (const int p)
  25403. +{
  25404. +    return (!(p % vtdata.numcolumns) || !((p + 1) % vtdata.numcolumns));
  25405. +}
  25406. +
  25407. +/*
  25408. + * constrain v such that v <= u
  25409. + */
  25410. +static inline int limit (const int v, const int u)
  25411. +{
  25412. +    return ((v > u) ? u : v);
  25413. +}
  25414. +
  25415. +/*
  25416. + * set the current selection.  Invoked by ioctl().
  25417. + */
  25418. +int set_selection (const unsigned long arg, struct tty_struct *tty)
  25419. +{
  25420. +    struct vt * vt = vtdata.fgconsole;
  25421. +    int sel_mode, new_sel_start, new_sel_end, spc;
  25422. +    char *bp, *obp;
  25423. +    int i, ps, pe;
  25424. +
  25425. +    vt_do_unblankscreen ();
  25426. +
  25427. +    {
  25428. +    unsigned short *args, xs, ys, xe, ye;
  25429. +
  25430. +    args = (unsigned short *)(arg + 1);
  25431. +    xs = get_user (args ++) - 1;
  25432. +    ys = get_user (args ++) - 1;
  25433. +    xe = get_user (args ++) - 1;
  25434. +    ye = get_user (args ++) - 1;
  25435. +    sel_mode = get_user (args);
  25436. +
  25437. +    xs = limit (xs, vtdata.numcolumns - 1);
  25438. +    ys = limit (ys, vtdata.numrows - 1);
  25439. +    xe = limit (xe, vtdata.numcolumns - 1);
  25440. +    ye = limit (ye, vtdata.numrows - 1);
  25441. +    ps = ys * vtdata.numcolumns + xs;
  25442. +    pe = ye * vtdata.numcolumns + xe;
  25443. +
  25444. +    if (sel_mode == 4) {
  25445. +        /* useful for screendump without selection highlights */
  25446. +        clear_selection ();
  25447. +        return 0;
  25448. +    }
  25449. +
  25450. +    if (vt->vcd->report_mouse && sel_mode & 16) {
  25451. +        mouse_report (tty, sel_mode & 15, xs, ys);
  25452. +        return 0;
  25453. +    }
  25454. +    }
  25455. +
  25456. +    if (ps > pe) { /* make sel_start <= sel_end */
  25457. +    ps ^= pe;
  25458. +    pe ^= ps;
  25459. +    ps ^= pe;
  25460. +    }
  25461. +
  25462. +    if (vt != vtdata.select.vt) {
  25463. +    clear_selection ();
  25464. +    vtdata.select.vt = vt;
  25465. +    }
  25466. +
  25467. +    switch (sel_mode) {
  25468. +    case 0: /* character-by-character selection */
  25469. +    new_sel_start = ps;
  25470. +    new_sel_end = pe;
  25471. +    break;
  25472. +    case 1: /* word-by-word selection */
  25473. +    spc = isspace (sel_pos (ps));
  25474. +    for (new_sel_start = ps; ; ps --) {
  25475. +        if (( spc && !isspace (sel_pos (ps))) ||
  25476. +            (!spc && !inword (sel_pos (ps))))
  25477. +        break;
  25478. +        new_sel_start = ps;
  25479. +        if (!(ps % vtdata.numcolumns))
  25480. +        break;
  25481. +    }
  25482. +    spc = isspace (sel_pos (pe));
  25483. +    for (new_sel_end = pe; ; pe ++) {
  25484. +        if (( spc && !isspace (sel_pos (pe))) ||
  25485. +            (!spc && !inword (sel_pos (pe))))
  25486. +        break;
  25487. +        new_sel_end = pe;
  25488. +        if (!((pe + 1) % vtdata.numcolumns))
  25489. +        break;
  25490. +    }
  25491. +    break;
  25492. +    case 2: /* line-by-line selection */
  25493. +    new_sel_start = ps - ps % vtdata.numcolumns;
  25494. +    new_sel_end = pe + vtdata.numcolumns - pe % vtdata.numcolumns - 1;
  25495. +    break;
  25496. +    case 3:
  25497. +    highlight_pointer (pe);
  25498. +    return 0;
  25499. +    default:
  25500. +    return -EINVAL;
  25501. +    }
  25502. +
  25503. +    /* remove the pointer */
  25504. +    highlight_pointer (-1);
  25505. +
  25506. +    /* select to end of line if on trailing space */
  25507. +    if (new_sel_end > new_sel_start && !atedge(new_sel_end) && isspace(sel_pos(new_sel_end))) {
  25508. +    for (pe = new_sel_end + 1; ; pe ++)
  25509. +        if (!isspace (sel_pos (pe)) || atedge (pe))
  25510. +        break;
  25511. +    if (isspace (sel_pos (pe)))
  25512. +        new_sel_end = pe;
  25513. +    }
  25514. +    if (vtdata.select.start == -1)            /* no current selection */
  25515. +    highlight (new_sel_start, new_sel_end);
  25516. +    else if (new_sel_start == vtdata.select.start) {
  25517. +    if (new_sel_end == vtdata.select.end)        /* no action required */
  25518. +        return 0;
  25519. +    else if (new_sel_end > vtdata.select.end)    /* extend to right */
  25520. +        highlight (vtdata.select.end + 1, new_sel_end);
  25521. +    else                        /* contract from right */
  25522. +        highlight (new_sel_end + 1, vtdata.select.end);
  25523. +    } else if (new_sel_end == vtdata.select.end) {
  25524. +    if (new_sel_start < vtdata.select.start)    /* extend to left */
  25525. +        highlight (new_sel_start, vtdata.select.start - 1);
  25526. +    else                /* contract from left */
  25527. +        highlight (vtdata.select.start, new_sel_start - 1);
  25528. +    } else {    /* some other case; start selection from scratch */
  25529. +    clear_selection ();
  25530. +    highlight (new_sel_start, new_sel_end);
  25531. +    }
  25532. +    vtdata.select.start = new_sel_start;
  25533. +    vtdata.select.end = new_sel_end;
  25534. +
  25535. +    if (vtdata.select.buffer)
  25536. +    kfree (vtdata.select.buffer);
  25537. +    vtdata.select.buffer = kmalloc (vtdata.select.end - vtdata.select.start + 1, GFP_KERNEL);
  25538. +    if (!vtdata.select.buffer) {
  25539. +    printk ("selection: kmalloc() failed\n");
  25540. +    clear_selection ();
  25541. +    return -ENOMEM;
  25542. +    }
  25543. +
  25544. +    obp = bp = vtdata.select.buffer;
  25545. +    for (i = vtdata.select.start; i <= vtdata.select.end; i++) {
  25546. +    *bp = sel_pos (i);
  25547. +    if (!isspace (*bp++))
  25548. +        obp = bp;
  25549. +    if (!((i + 1) % vtdata.numcolumns)) {
  25550. +        /* strip trailing blanks from line and add newline,
  25551. +         * unless non-space at end of line.
  25552. +         */
  25553. +        if (obp != bp) {
  25554. +        bp = obp;
  25555. +        *bp++ = '\r';
  25556. +        }
  25557. +        obp = bp;
  25558. +    }
  25559. +    }
  25560. +    vtdata.select.length = bp - vtdata.select.buffer;
  25561. +    return 0;
  25562. +}
  25563. +
  25564. +/* Insert the contents of the selection buffer into the queue of the
  25565. + * tty associated with the current console. Invoked by ioctl().
  25566. + */
  25567. +int paste_selection (struct tty_struct *tty)
  25568. +{
  25569. +    struct wait_queue wait = { current, NULL };
  25570. +    struct vt_struct *vt = ((struct vt *)tty->driver_data)->vtd;
  25571. +    char *bp = vtdata.select.buffer;
  25572. +    int c = vtdata.select.length;
  25573. +    int l;
  25574. +
  25575. +    if (!bp || !c)
  25576. +    return 0;
  25577. +
  25578. +    vt_do_unblankscreen ();
  25579. +
  25580. +    current->state = TASK_INTERRUPTIBLE;
  25581. +    add_wait_queue (&vt->paste_wait, &wait);
  25582. +
  25583. +    while (c) {
  25584. +    if (test_bit(TTY_THROTTLED, &tty->flags)) {
  25585. +        schedule();
  25586. +        continue;
  25587. +    }
  25588. +    l = MIN(c, tty->ldisc.receive_room(tty));
  25589. +    tty->ldisc.receive_buf(tty, bp, 0, l);
  25590. +    c -= l;
  25591. +    bp += l;
  25592. +    }
  25593. +    current->state = TASK_RUNNING;
  25594. +    return 0;
  25595. +}
  25596. +
  25597. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/selection.h linux/arch/arm/drivers/char/selection.h
  25598. --- linux.orig/arch/arm/drivers/char/selection.h    Thu Jan  1 01:00:00 1970
  25599. +++ linux/arch/arm/drivers/char/selection.h    Fri May 10 21:09:16 1996
  25600. @@ -0,0 +1,22 @@
  25601. +/*
  25602. + * selection.h
  25603. + *
  25604. + * Interface between console.c, tty_io.c, vt.c, vc_screen.c and selection.c
  25605. + */
  25606. +
  25607. +extern void clear_selection (void);
  25608. +extern int set_selection (const unsigned long arg, struct tty_struct *tty);
  25609. +extern int paste_selection (struct tty_struct *tty);
  25610. +extern int sel_loadlut (const unsigned long arg);
  25611. +extern int mouse_reporting (void);
  25612. +extern void mouse_report (struct tty_struct *tty, int butt, int mrx, int mry);
  25613. +
  25614. +extern void vt_do_unblankscreen (void);
  25615. +extern unsigned long *screen_pos (const struct vt *const vt, int offset);
  25616. +extern unsigned long screen_word (const struct vt *const vt, int offset);
  25617. +extern int scrw2glyph (unsigned long scr_word);
  25618. +extern void invert_screen (const struct vt *const vt, int offset, int count);
  25619. +
  25620. +extern void getconsxy (const struct vt *const vt, char *p);
  25621. +extern void putconsxy (const struct vt *const vt, char *p);
  25622. +extern void update_scrmem (const struct vt *const vt, int offset, int length);
  25623. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/serial-atomwide.c linux/arch/arm/drivers/char/serial-atomwide.c
  25624. --- linux.orig/arch/arm/drivers/char/serial-atomwide.c    Thu Jan  1 01:00:00 1970
  25625. +++ linux/arch/arm/drivers/char/serial-atomwide.c    Tue Jul 30 17:49:18 1996
  25626. @@ -0,0 +1,140 @@
  25627. +/*
  25628. + * linux/arch/arm/drivers/char/serial-atomwide.c
  25629. + *
  25630. + * Copyright (c) 1996 Russell King.
  25631. + *
  25632. + * Changelog:
  25633. + *  02-05-1996    RMK    Created
  25634. + *  07-05-1996    RMK    Altered for greater number of cards.
  25635. + *  30-07-1996    RMK    Now uses generic card code.
  25636. + */
  25637. +
  25638. +#if 0
  25639. +#include <linux/module.h>
  25640. +#include <linux/serial.h>
  25641. +#include <linux/errno.h>
  25642. +
  25643. +#include <asm/ecard.h>
  25644. +
  25645. +#define NUM_SERIALS    3 * MAX_ECARDS
  25646. +
  25647. +static const int serial_prods[] = { 0x0090 };
  25648. +static const int serial_manus[] = { 0x0017 };
  25649. +
  25650. +#ifndef MODULE
  25651. +
  25652. +int atomwide_serial_init (void)
  25653. +{
  25654. +    struct expansion_card *ec;
  25655. +    struct serial_struct req;
  25656. +    unsigned long port;
  25657. +    int prt, i;
  25658. +
  25659. +    req.baud_base = 7372800 / 16;
  25660. +
  25661. +    while (1) {
  25662. +
  25663. +    if ((ec = ecard_find (0, sizeof (serial_prods) / sizeof (int), serial_prods, serial_manus))
  25664. +        == NULL)
  25665. +        break;
  25666. +
  25667. +    port = ((unsigned long)ecard_address (ec->slot_no, ECARD_IOC, ECARD_SLOW) + 0x2000) >> 2;
  25668. +
  25669. +    for (prt = 0; prt < 3; prt ++) {
  25670. +        req.irq  = ec->irq;
  25671. +        req.port = port + 0x200 - prt * 0x100;
  25672. +
  25673. +        i = register_pre_init_serial (&req);
  25674. +        if (i < 0)
  25675. +        break;
  25676. +    }
  25677. +
  25678. +    if (prt)
  25679. +        ecard_claim (ec);
  25680. +
  25681. +    if (i < 0)
  25682. +        break;
  25683. +    }
  25684. +
  25685. +    return 0;
  25686. +}
  25687. +
  25688. +#else
  25689. +
  25690. +static int atomwide_serial_lines[NUM_SERIALS];
  25691. +static int atomwide_num_lines;
  25692. +static struct expansion_card *ec[MAX_ECARDS];
  25693. +
  25694. +static inline void atomwide_serial_register (int slot_no, int irq_no)
  25695. +{
  25696. +    struct serial_struct req;
  25697. +    unsigned long port;
  25698. +    int line, prt;
  25699. +    
  25700. +    port = ((unsigned long)ecard_address (slot_no, ECARD_IOC, ECARD_SLOW) + 0x2000) >> 2;
  25701. +
  25702. +    req.baud_base = 7372800 / 16;
  25703. +
  25704. +    for (prt = 0; prt < 3; prt ++) {
  25705. +    req.irq  = irq_no;
  25706. +    req.port = port + 0x200 - prt * 0x100;
  25707. +
  25708. +    line = register_serial (&req);
  25709. +    if (line >= 0)
  25710. +        atomwide_serial_lines[atomwide_num_lines++] = line;
  25711. +    }
  25712. +}
  25713. +
  25714. +int init_module (void)
  25715. +{
  25716. +    int i;
  25717. +
  25718. +    for (i = 0; i < NUM_SERIALS; i ++)
  25719. +    atomwide_serial_lines[i] = -1;
  25720. +
  25721. +    atomwide_num_lines = 0;
  25722. +
  25723. +    for (i = 0; i < MAX_ECARDS; i ++)
  25724. +    ec[i] = NULL;
  25725. +
  25726. +    i = 0;
  25727. +
  25728. +    do {
  25729. +    if ((ec[i] = ecard_find (0, sizeof (serial_prods) / sizeof (int), serial_prods, serial_manus))
  25730. +        == NULL)
  25731. +        break;
  25732. +
  25733. +    ecard_claim (ec[i]);
  25734. +    atomwide_serial_register (ec[i]->slot_no, ec[i]->irq);
  25735. +    i++;
  25736. +    } while (i < MAX_ECARDS);
  25737. +
  25738. +    return i ? 0 : -ENODEV;
  25739. +}
  25740. +
  25741. +void cleanup_module (void)
  25742. +{
  25743. +    int i;
  25744. +    for (i = 0; i < atomwide_num_lines; i++)
  25745. +    unregister_serial (atomwide_serial_lines[i]);
  25746. +
  25747. +    for (i = 0; i < MAX_ECARDS; i++)
  25748. +    if (ec[i]) {
  25749. +        ecard_release (ec[i]);
  25750. +        ec[i] = NULL;
  25751. +    }
  25752. +}
  25753. +#endif
  25754. +
  25755. +#else
  25756. +#define MY_PRODS 0x0090
  25757. +#define MY_MANUS 0x0017
  25758. +#define MY_NUMPORTS 3
  25759. +#define MY_BAUD_BASE (7372800 / 16)
  25760. +#define MY_INIT atomwide_serial_init
  25761. +#define MY_BASE_ADDRESS(ec) \
  25762. +    ((unsigned long)ecard_address ((ec)->slot_no, ECARD_IOC, ECARD_SLOW) + 0x2000) >> 2
  25763. +#define MY_PORT_ADDRESS(port,cardaddr) \
  25764. +    ((cardaddr) + 0x200 - (port) * 0x100)
  25765. +#include "serial-card.c"
  25766. +#endif
  25767. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/serial-card.c linux/arch/arm/drivers/char/serial-card.c
  25768. --- linux.orig/arch/arm/drivers/char/serial-card.c    Thu Jan  1 01:00:00 1970
  25769. +++ linux/arch/arm/drivers/char/serial-card.c    Tue Jul 30 17:05:14 1996
  25770. @@ -0,0 +1,108 @@
  25771. +/*
  25772. + * linux/arch/arm/drivers/char/serial-module.c
  25773. + *
  25774. + * Copyright (c) 1996 Russell King.
  25775. + *
  25776. + * A generic handler of serial expansion cards that use 16550s or
  25777. + * the like.
  25778. + *
  25779. + * Definitions:
  25780. + *  MY_PRODS        Product numbers to identify this card by
  25781. + *  MY_MANUS        Manufacturer numbers to identify this card by
  25782. + *  MY_NUMPORTS        Number of ports per card
  25783. + *  MY_BAUD_BASE    Baud base for the card
  25784. + *  MY_INIT        Initialisation routine name
  25785. + *  MY_BASE_ADDRESS(ec)    Return base address for ports
  25786. + *  MY_PORT_ADDRESS
  25787. + *    (port,cardaddr)    Return address for port using base address
  25788. + *            from above.
  25789. + *
  25790. + * Changelog:
  25791. + *  30-07-1996    RMK    Created
  25792. + */
  25793. +#include <linux/module.h>
  25794. +#include <linux/serial.h>
  25795. +#include <linux/errno.h>
  25796. +#include <asm/ecard.h>
  25797. +
  25798. +#ifndef NUM_SERIALS
  25799. +#define NUM_SERIALS    MY_NUMPORTS * MAX_ECARDS
  25800. +#endif
  25801. +
  25802. +#ifdef MODULE
  25803. +static int __serial_ports[NUM_SERIALS];
  25804. +static int __serial_pcount;
  25805. +static struct expansion_card *expcard[MAX_ECARDS];
  25806. +#define ADD_ECARD(ec,card) expcard[(card)] = (ec)
  25807. +#define ADD_PORT(port) __serial_ports[__serial_pcount++] = (port)
  25808. +#undef MY_INIT
  25809. +#define MY_INIT init_module
  25810. +#else
  25811. +#define ADD_ECARD(ec,card)
  25812. +#define ADD_PORT(port)
  25813. +#endif
  25814. +
  25815. +static const int serial_prods[] = { MY_PRODS };
  25816. +static const int serial_manus[] = { MY_MANUS };
  25817. +
  25818. +static inline int serial_register_onedev (int at_boot, unsigned long port, int irq)
  25819. +{
  25820. +    struct serial_struct req;
  25821. +    int line;
  25822. +
  25823. +    req.baud_base = MY_BAUD_BASE;
  25824. +    req.irq = irq;
  25825. +    req.port = port;
  25826. +
  25827. +    if (at_boot)
  25828. +    line = register_pre_init_serial (&req);
  25829. +    else
  25830. +    line = register_serial (&req);
  25831. +    return line;
  25832. +}
  25833. +
  25834. +int MY_INIT (void)
  25835. +{
  25836. +    int card = 0;
  25837. +    do {
  25838. +    struct expansion_card *ec;
  25839. +    unsigned long cardaddr;
  25840. +    int port;
  25841. +
  25842. +    ec = ecard_find (0, sizeof (serial_prods) / sizeof (int), serial_prods, serial_manus);
  25843. +    if (!ec)
  25844. +        break;
  25845. +
  25846. +    cardaddr = MY_BASE_ADDRESS(ec);
  25847. +
  25848. +    for (port = 0; port < MY_NUMPORTS; port ++) {
  25849. +        int line;
  25850. +
  25851. +        line = serial_register_onedev (1, MY_PORT_ADDRESS(port, cardaddr), ec->irq);
  25852. +        if (line < 0)
  25853. +        break;
  25854. +        ADD_PORT(line);
  25855. +    }
  25856. +
  25857. +    if (port) {
  25858. +        ecard_claim (ec);
  25859. +        ADD_ECARD(ec, card);
  25860. +    } else
  25861. +        break;
  25862. +    } while (++card < MAX_ECARDS);
  25863. +    return card ? 0 : -ENODEV;
  25864. +}
  25865. +
  25866. +#ifdef MODULE
  25867. +void cleanup_module (void)
  25868. +{
  25869. +    int i;
  25870. +
  25871. +    for (i = 0; i < __serial_pcount; i++)
  25872. +    unregister_serial (__serial_port[i]);
  25873. +
  25874. +    for (i = 0; i < MAX_ECARDS; i++)
  25875. +    if (expcard[i])
  25876. +        ecard_release (expcard[i]);
  25877. +}
  25878. +#endif
  25879. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/serial-dualsp.c linux/arch/arm/drivers/char/serial-dualsp.c
  25880. --- linux.orig/arch/arm/drivers/char/serial-dualsp.c    Thu Jan  1 01:00:00 1970
  25881. +++ linux/arch/arm/drivers/char/serial-dualsp.c    Tue Jul 30 17:04:37 1996
  25882. @@ -0,0 +1,19 @@
  25883. +/*
  25884. + * linux/arch/arm/drivers/char/serial-dualsp.c
  25885. + *
  25886. + * Copyright (c) 1996 Russell King.
  25887. + *
  25888. + * Changelog:
  25889. + *  30-07-1996    RMK    Created
  25890. + */
  25891. +#define MY_PRODS 0x00B9
  25892. +#define MY_MANUS 0x003F
  25893. +#define MY_NUMPORTS 2
  25894. +#define MY_BAUD_BASE (3686400 / 16)
  25895. +#define MY_INIT dualsp_serial_init
  25896. +#define MY_BASE_ADDRESS(ec) \
  25897. +    ((unsigned long)ecard_address (ec->slot_no, ECARD_IOC, ECARD_SLOW) + 0x2000) >> 2
  25898. +#define MY_PORT_ADDRESS(port,cardaddress) \
  25899. +    ((cardaddress) + (port) * 8)
  25900. +#include "serial-card.c"
  25901. +
  25902. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/serial.c linux/arch/arm/drivers/char/serial.c
  25903. --- linux.orig/arch/arm/drivers/char/serial.c    Thu Jan  1 01:00:00 1970
  25904. +++ linux/arch/arm/drivers/char/serial.c    Tue Jul 30 17:07:42 1996
  25905. @@ -0,0 +1,2955 @@
  25906. +/*
  25907. + *  linux/arch/arm/drivers/char/serial.c
  25908. + *
  25909. + *  Copyright (C) 1991, 1992  Linus Torvalds
  25910. + *
  25911. + *  Extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92.  Now
  25912. + *  much more extensible to support other serial cards based on the
  25913. + *  16450/16550A UART's.  Added support for the AST FourPort and the
  25914. + *  Accent Async board.  
  25915. + *
  25916. + *  set_serial_info fixed to set the flags, custom divisor, and uart
  25917. + *     type fields.  Fix suggested by Michael K. Johnson 12/12/92.
  25918. + *
  25919. + *  11/95: TIOCMIWAIT, TIOCGICOUNT by Angelo Haritsis <ah@doc.ic.ac.uk>
  25920. + *
  25921. + *  03/96: Modularised by Angelo Haritsis <ah@doc.ic.ac.uk>
  25922. + *
  25923. + *  rs_set_termios fixed to look also for changes of the input
  25924. + *    flags INPCK, BRKINT, PARMRK, IGNPAR and IGNBRK.
  25925. + *                        Bernd Anhäupl 05/17/96.
  25926. + *
  25927. + * This module exports the following rs232 io functions:
  25928. + *
  25929. + *    int rs_init(void);
  25930. + *     int rs_open(struct tty_struct * tty, struct file * filp)
  25931. + *
  25932. + *  Slight modifications for ARM Copyright (C) 1995, 1996 Russell King
  25933. + */
  25934. +
  25935. +#include <linux/module.h>
  25936. +#include <linux/errno.h>
  25937. +#include <linux/signal.h>
  25938. +#include <linux/sched.h>
  25939. +#include <linux/timer.h>
  25940. +#include <linux/interrupt.h>
  25941. +#include <linux/tty.h>
  25942. +#include <linux/tty_flip.h>
  25943. +#include <linux/serial.h>
  25944. +#include <linux/serial_reg.h>
  25945. +#include <linux/config.h>
  25946. +#include <linux/major.h>
  25947. +#include <linux/string.h>
  25948. +#include <linux/fcntl.h>
  25949. +#include <linux/ptrace.h>
  25950. +#include <linux/ioport.h>
  25951. +#include <linux/mm.h>
  25952. +
  25953. +#include <asm/system.h>
  25954. +#include <asm/io.h>
  25955. +#include <asm/segment.h>
  25956. +#include <asm/bitops.h>
  25957. +
  25958. +static char *serial_name = "Serial driver";
  25959. +static char *serial_version = "4.13";
  25960. +
  25961. +DECLARE_TASK_QUEUE(tq_serial);
  25962. +
  25963. +struct tty_driver serial_driver, callout_driver;
  25964. +static int serial_refcount;
  25965. +
  25966. +/* serial subtype definitions */
  25967. +#define SERIAL_TYPE_NORMAL    1
  25968. +#define SERIAL_TYPE_CALLOUT    2
  25969. +
  25970. +/* number of characters left in xmit buffer before we ask for more */
  25971. +#define WAKEUP_CHARS 256
  25972. +
  25973. +/*
  25974. + * Serial driver configuration section.  Here are the various options:
  25975. + *
  25976. + * CONFIG_HUB6
  25977. + *        Enables support for the venerable Bell Technologies
  25978. + *        HUB6 card.
  25979. + *
  25980. + * SERIAL_PARANOIA_CHECK
  25981. + *         Check the magic number for the async_structure where
  25982. + *         ever possible.
  25983. + */
  25984. +
  25985. +#define SERIAL_PARANOIA_CHECK
  25986. +#define CONFIG_SERIAL_NOPAUSE_IO
  25987. +#define SERIAL_DO_RESTART
  25988. +
  25989. +#undef SERIAL_DEBUG_INTR
  25990. +#undef SERIAL_DEBUG_OPEN
  25991. +#undef SERIAL_DEBUG_FLOW
  25992. +
  25993. +#define RS_STROBE_TIME (10*HZ)
  25994. +#define RS_ISR_PASS_LIMIT 256
  25995. +
  25996. +#define IRQ_T(info) ((info->flags & ASYNC_SHARE_IRQ) ? SA_SHIRQ : SA_INTERRUPT)
  25997. +
  25998. +#define _INLINE_ inline
  25999. +
  26000. +#if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT)
  26001. +#define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \
  26002. + kdevname(tty->device), (info->flags), serial_refcount,info->count,tty->count,s)
  26003. +#else
  26004. +#define DBG_CNT(s)
  26005. +#endif
  26006. +  
  26007. +/*
  26008. + * IRQ_timeout        - How long the timeout should be for each IRQ
  26009. + *                 should be after the IRQ has been active.
  26010. + */
  26011. +
  26012. +static struct async_struct *IRQ_ports[32];
  26013. +static struct rs_multiport_struct rs_multiport[32];
  26014. +static int IRQ_timeout[32];
  26015. +static volatile int rs_irq_triggered;
  26016. +static volatile int rs_triggered;
  26017. +static int rs_wild_int_mask;
  26018. +
  26019. +static void autoconfig(struct async_struct * info);
  26020. +static void change_speed(struct async_struct *info);
  26021. +    
  26022. +/*
  26023. + * This assumes you have a 1.8432 MHz clock for your UART.
  26024. + *
  26025. + * It'd be nice if someone built a serial card with a 24.576 MHz
  26026. + * clock, since the 16550A is capable of handling a top speed of 1.5
  26027. + * megabits/second; but this requires the faster clock.
  26028. + */
  26029. +#define BASE_BAUD ( 1843200 / 16 )
  26030. +
  26031. +#define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST )
  26032. +
  26033. +struct async_struct rs_table[] = {
  26034. +     /* UART CLK        PORT  IRQ     FLAGS        */
  26035. +#ifndef CONFIG_ARCH_ARC
  26036. +    { 0, BASE_BAUD, 0x3F8, 10, STD_COM_FLAGS },    /* ttyS0 */
  26037. +    { 0, BASE_BAUD, 0x2F8, 10, STD_COM_FLAGS },    /* ttyS1 */
  26038. +#else
  26039. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS2 */
  26040. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS3 */
  26041. +#endif
  26042. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS2 */
  26043. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS3 */
  26044. +
  26045. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },     /* ttyS4 */
  26046. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS5 */
  26047. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS6 */
  26048. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS7 */
  26049. +
  26050. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS8 */
  26051. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS9 */
  26052. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS10 */
  26053. +    { 0, BASE_BAUD, 0    ,  0, STD_COM_FLAGS },    /* ttyS11 */
  26054. +    
  26055. +};
  26056. +
  26057. +#define NR_PORTS    (sizeof(rs_table)/sizeof(struct async_struct))
  26058. +
  26059. +static struct tty_struct *serial_table[NR_PORTS];
  26060. +static struct termios *serial_termios[NR_PORTS];
  26061. +static struct termios *serial_termios_locked[NR_PORTS];
  26062. +
  26063. +#ifndef MIN
  26064. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  26065. +#endif
  26066. +
  26067. +/*
  26068. + * tmp_buf is used as a temporary buffer by serial_write.  We need to
  26069. + * lock it in case the memcpy_fromfs blocks while swapping in a page,
  26070. + * and some other program tries to do a serial write at the same time.
  26071. + * Since the lock will only come under contention when the system is
  26072. + * swapping and available memory is low, it makes sense to share one
  26073. + * buffer across all the serial ports, since it significantly saves
  26074. + * memory if large numbers of serial ports are open.
  26075. + */
  26076. +static unsigned char *tmp_buf;
  26077. +static struct semaphore tmp_buf_sem = MUTEX;
  26078. +
  26079. +static inline int serial_paranoia_check(struct async_struct *info,
  26080. +                    kdev_t device, const char *routine)
  26081. +{
  26082. +#ifdef SERIAL_PARANOIA_CHECK
  26083. +    static const char *badmagic =
  26084. +        "Warning: bad magic number for serial struct (%s) in %s\n";
  26085. +    static const char *badinfo =
  26086. +        "Warning: null async_struct for (%s) in %s\n";
  26087. +
  26088. +    if (!info) {
  26089. +        printk(badinfo, kdevname(device), routine);
  26090. +        return 1;
  26091. +    }
  26092. +    if (info->magic != SERIAL_MAGIC) {
  26093. +        printk(badmagic, kdevname(device), routine);
  26094. +        return 1;
  26095. +    }
  26096. +#endif
  26097. +    return 0;
  26098. +}
  26099. +
  26100. +/*
  26101. + * This is used to figure out the divisor speeds and the timeouts
  26102. + */
  26103. +static int baud_table[] = {
  26104. +    0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  26105. +    9600, 19200, 38400, 57600, 115200, 0 };
  26106. +
  26107. +static inline unsigned int serial_in(struct async_struct *info, int offset)
  26108. +{
  26109. +#ifdef CONFIG_HUB6
  26110. +    if (info->hub6) {
  26111. +    outb(info->hub6 - 1 + offset, info->port);
  26112. +    return inb(info->port+1);
  26113. +    } else
  26114. +#endif
  26115. +    return inb(info->port + offset);
  26116. +}
  26117. +
  26118. +static inline unsigned int serial_inp(struct async_struct *info, int offset)
  26119. +{
  26120. +#ifdef CONFIG_HUB6
  26121. +    if (info->hub6) {
  26122. +    outb(info->hub6 - 1 + offset, info->port);
  26123. +    return inb_p(info->port+1);
  26124. +    } else
  26125. +#endif
  26126. +#ifdef CONFIG_SERIAL_NOPAUSE_IO
  26127. +    return inb(info->port + offset);
  26128. +#else
  26129. +    return inb_p(info->port + offset);
  26130. +#endif
  26131. +}
  26132. +
  26133. +static inline void serial_out(struct async_struct *info, int offset, int value)
  26134. +{
  26135. +#ifdef CONFIG_HUB6
  26136. +    if (info->hub6) {
  26137. +    outb(info->hub6 - 1 + offset, info->port);
  26138. +    outb(value, info->port+1);
  26139. +    } else
  26140. +#endif
  26141. +    outb(value, info->port+offset);
  26142. +}
  26143. +
  26144. +static inline void serial_outp(struct async_struct *info, int offset,
  26145. +                   int value)
  26146. +{
  26147. +#ifdef CONFIG_HUB6
  26148. +    if (info->hub6) {
  26149. +    outb(info->hub6 - 1 + offset, info->port);
  26150. +    outb_p(value, info->port+1);
  26151. +    } else
  26152. +#endif
  26153. +#ifdef CONFIG_SERIAL_NOPAUSE_IO
  26154. +    outb(value, info->port+offset);
  26155. +#else
  26156. +        outb_p(value, info->port+offset);
  26157. +#endif
  26158. +}
  26159. +
  26160. +/*
  26161. + * ------------------------------------------------------------
  26162. + * rs_stop() and rs_start()
  26163. + *
  26164. + * This routines are called before setting or resetting tty->stopped.
  26165. + * They enable or disable transmitter interrupts, as necessary.
  26166. + * ------------------------------------------------------------
  26167. + */
  26168. +static void rs_stop(struct tty_struct *tty)
  26169. +{
  26170. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  26171. +    unsigned long flags;
  26172. +
  26173. +    if (serial_paranoia_check(info, tty->device, "rs_stop"))
  26174. +        return;
  26175. +    
  26176. +    save_flags_cli (flags);
  26177. +    if (info->IER & UART_IER_THRI) {
  26178. +        info->IER &= ~UART_IER_THRI;
  26179. +        serial_out(info, UART_IER, info->IER);
  26180. +    }
  26181. +    restore_flags(flags);
  26182. +}
  26183. +
  26184. +static void rs_start(struct tty_struct *tty)
  26185. +{
  26186. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  26187. +    unsigned long flags;
  26188. +    
  26189. +    if (serial_paranoia_check(info, tty->device, "rs_start"))
  26190. +        return;
  26191. +    
  26192. +    save_flags_cli (flags);
  26193. +    if (info->xmit_cnt && info->xmit_buf && !(info->IER & UART_IER_THRI)) {
  26194. +        info->IER |= UART_IER_THRI;
  26195. +        serial_out(info, UART_IER, info->IER);
  26196. +    }
  26197. +    restore_flags(flags);
  26198. +}
  26199. +
  26200. +/*
  26201. + * ----------------------------------------------------------------------
  26202. + *
  26203. + * Here starts the interrupt handling routines.  All of the following
  26204. + * subroutines are declared as inline and are folded into
  26205. + * rs_interrupt().  They were separated out for readability's sake.
  26206. + *
  26207. + * Note: rs_interrupt() is a "fast" interrupt, which means that it
  26208. + * runs with interrupts turned off.  People who may want to modify
  26209. + * rs_interrupt() should try to keep the interrupt handler as fast as
  26210. + * possible.  After you are done making modifications, it is not a bad
  26211. + * idea to do:
  26212. + * 
  26213. + * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
  26214. + *
  26215. + * and look at the resulting assemble code in serial.s.
  26216. + *
  26217. + *                 - Ted Ts'o (tytso@mit.edu), 7-Mar-93
  26218. + * -----------------------------------------------------------------------
  26219. + */
  26220. +
  26221. +/*
  26222. + * This is the serial driver's interrupt routine while we are probing
  26223. + * for submarines.
  26224. + */
  26225. +static void rs_probe(int irq, void *dev_id, struct pt_regs * regs)
  26226. +{
  26227. +    rs_irq_triggered = irq;
  26228. +    rs_triggered |= 1 << irq;
  26229. +    return;
  26230. +}
  26231. +
  26232. +/*
  26233. + * This routine is used by the interrupt handler to schedule
  26234. + * processing in the software interrupt portion of the driver.
  26235. + */
  26236. +static _INLINE_ void rs_sched_event(struct async_struct *info,
  26237. +                  int event)
  26238. +{
  26239. +    info->event |= 1 << event;
  26240. +    queue_task_irq_off(&info->tqueue, &tq_serial);
  26241. +    mark_bh(SERIAL_BH);
  26242. +}
  26243. +
  26244. +static _INLINE_ void receive_chars(struct async_struct *info,
  26245. +                 int *status)
  26246. +{
  26247. +    struct tty_struct *tty = info->tty;
  26248. +    unsigned char ch;
  26249. +    int ignored = 0;
  26250. +
  26251. +    do {
  26252. +        ch = serial_inp(info, UART_RX);
  26253. +        if (*status & info->ignore_status_mask) {
  26254. +            if (++ignored > 100)
  26255. +                break;
  26256. +            goto ignore_char;
  26257. +        }
  26258. +        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  26259. +            break;
  26260. +        tty->flip.count++;
  26261. +        if (*status & (UART_LSR_BI)) {
  26262. +#ifdef SERIAL_DEBUG_INTR
  26263. +            printk("handling break....");
  26264. +#endif
  26265. +            *tty->flip.flag_buf_ptr++ = TTY_BREAK;
  26266. +            if (info->flags & ASYNC_SAK)
  26267. +                do_SAK(tty);
  26268. +        } else if (*status & UART_LSR_PE)
  26269. +            *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  26270. +        else if (*status & UART_LSR_FE)
  26271. +            *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  26272. +        else if (*status & UART_LSR_OE) 
  26273. +            *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  26274. +        else
  26275. +            *tty->flip.flag_buf_ptr++ = 0;
  26276. +        *tty->flip.char_buf_ptr++ = ch;
  26277. +    ignore_char:
  26278. +        *status = serial_inp(info, UART_LSR) & info->read_status_mask;
  26279. +    } while (*status & UART_LSR_DR);
  26280. +    queue_task_irq_off(&tty->flip.tqueue, &tq_timer);
  26281. +#ifdef SERIAL_DEBUG_INTR
  26282. +    printk("DR...");
  26283. +#endif
  26284. +}
  26285. +
  26286. +static _INLINE_ void transmit_chars(struct async_struct *info, int *intr_done)
  26287. +{
  26288. +    int count;
  26289. +    
  26290. +    if (info->x_char) {
  26291. +        serial_outp(info, UART_TX, info->x_char);
  26292. +        info->x_char = 0;
  26293. +        if (intr_done)
  26294. +            *intr_done = 0;
  26295. +        return;
  26296. +    }
  26297. +    if ((info->xmit_cnt <= 0) || info->tty->stopped ||
  26298. +        info->tty->hw_stopped) {
  26299. +        info->IER &= ~UART_IER_THRI;
  26300. +        serial_out(info, UART_IER, info->IER);
  26301. +        return;
  26302. +    }
  26303. +    
  26304. +    count = info->xmit_fifo_size;
  26305. +    do {
  26306. +        serial_out(info, UART_TX, info->xmit_buf[info->xmit_tail++]);
  26307. +        info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  26308. +        if (--info->xmit_cnt <= 0)
  26309. +            break;
  26310. +    } while (--count > 0);
  26311. +    
  26312. +    if (info->xmit_cnt < WAKEUP_CHARS)
  26313. +        rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  26314. +
  26315. +#ifdef SERIAL_DEBUG_INTR
  26316. +    printk("THRE...");
  26317. +#endif
  26318. +    if (intr_done)
  26319. +        *intr_done = 0;
  26320. +
  26321. +    if (info->xmit_cnt <= 0) {
  26322. +        info->IER &= ~UART_IER_THRI;
  26323. +        serial_out(info, UART_IER, info->IER);
  26324. +    }
  26325. +}
  26326. +
  26327. +static _INLINE_ void check_modem_status(struct async_struct *info)
  26328. +{
  26329. +    int    status;
  26330. +    
  26331. +    status = serial_in(info, UART_MSR);
  26332. +
  26333. +    if (status & UART_MSR_ANY_DELTA) {
  26334. +        /* update input line counters */
  26335. +        if (status & UART_MSR_TERI)
  26336. +            info->icount.rng++;
  26337. +        if (status & UART_MSR_DDSR)
  26338. +            info->icount.dsr++;
  26339. +        if (status & UART_MSR_DDCD)
  26340. +            info->icount.dcd++;
  26341. +        if (status & UART_MSR_DCTS)
  26342. +            info->icount.cts++;
  26343. +        wake_up_interruptible(&info->delta_msr_wait);
  26344. +    }
  26345. +
  26346. +    if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
  26347. +#if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
  26348. +        printk("ttys%d CD now %s...", info->line,
  26349. +               (status & UART_MSR_DCD) ? "on" : "off");
  26350. +#endif        
  26351. +        if (status & UART_MSR_DCD)
  26352. +            wake_up_interruptible(&info->open_wait);
  26353. +        else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  26354. +               (info->flags & ASYNC_CALLOUT_NOHUP))) {
  26355. +#ifdef SERIAL_DEBUG_OPEN
  26356. +            printk("scheduling hangup...");
  26357. +#endif
  26358. +            queue_task_irq_off(&info->tqueue_hangup,
  26359. +                       &tq_scheduler);
  26360. +        }
  26361. +    }
  26362. +    if (info->flags & ASYNC_CTS_FLOW) {
  26363. +        if (info->tty->hw_stopped) {
  26364. +            if (status & UART_MSR_CTS) {
  26365. +#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  26366. +                printk("CTS tx start...");
  26367. +#endif
  26368. +                info->tty->hw_stopped = 0;
  26369. +                info->IER |= UART_IER_THRI;
  26370. +                serial_out(info, UART_IER, info->IER);
  26371. +                rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  26372. +                return;
  26373. +            }
  26374. +        } else {
  26375. +            if (!(status & UART_MSR_CTS)) {
  26376. +#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  26377. +                printk("CTS tx stop...");
  26378. +#endif
  26379. +                info->tty->hw_stopped = 1;
  26380. +                info->IER &= ~UART_IER_THRI;
  26381. +                serial_out(info, UART_IER, info->IER);
  26382. +            }
  26383. +        }
  26384. +    }
  26385. +}
  26386. +
  26387. +/*
  26388. + * This is the serial driver's generic interrupt routine
  26389. + */
  26390. +static void rs_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  26391. +{
  26392. +    int status;
  26393. +    struct async_struct * info;
  26394. +    int pass_counter = 0;
  26395. +    struct async_struct *end_mark = 0;
  26396. +    int first_multi = 0;
  26397. +    struct rs_multiport_struct *multi;
  26398. +
  26399. +#ifdef SERIAL_DEBUG_INTR
  26400. +    printk("rs_interrupt(%d)...", irq);
  26401. +#endif
  26402. +    
  26403. +    info = IRQ_ports[irq];
  26404. +    if (!info)
  26405. +        return;
  26406. +    
  26407. +    multi = &rs_multiport[irq];
  26408. +    if (multi->port_monitor)
  26409. +        first_multi = inb(multi->port_monitor);
  26410. +
  26411. +    do {
  26412. +        if (!info->tty ||
  26413. +            (serial_in(info, UART_IIR) & UART_IIR_NO_INT)) {
  26414. +            if (!end_mark)
  26415. +                end_mark = info;
  26416. +            goto next;
  26417. +        }
  26418. +        end_mark = 0;
  26419. +
  26420. +        info->last_active = jiffies;
  26421. +
  26422. +        status = serial_inp(info, UART_LSR) & info->read_status_mask;
  26423. +#ifdef SERIAL_DEBUG_INTR
  26424. +        printk("status = %x...", status);
  26425. +#endif
  26426. +        if (status & UART_LSR_DR)
  26427. +            receive_chars(info, &status);
  26428. +        check_modem_status(info);
  26429. +        if (status & UART_LSR_THRE)
  26430. +            transmit_chars(info, 0);
  26431. +
  26432. +    next:
  26433. +        info = info->next_port;
  26434. +        if (!info) {
  26435. +            info = IRQ_ports[irq];
  26436. +            if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  26437. +#if 0
  26438. +                printk("rs loop break\n");
  26439. +#endif
  26440. +                break;     /* Prevent infinite loops */
  26441. +            }
  26442. +            continue;
  26443. +        }
  26444. +    } while (end_mark != info);
  26445. +    if (multi->port_monitor)
  26446. +        printk("rs port monitor (normal) irq %d: 0x%x, 0x%x\n",
  26447. +               info->irq, first_multi, inb(multi->port_monitor));
  26448. +#ifdef SERIAL_DEBUG_INTR
  26449. +    printk("end.\n");
  26450. +#endif
  26451. +}
  26452. +
  26453. +/*
  26454. + * This is the serial driver's interrupt routine for a single port
  26455. + */
  26456. +static void rs_interrupt_single(int irq, void *dev_id, struct pt_regs * regs)
  26457. +{
  26458. +    int status;
  26459. +    int pass_counter = 0;
  26460. +    int first_multi = 0;
  26461. +    struct async_struct * info;
  26462. +    struct rs_multiport_struct *multi;
  26463. +    
  26464. +#ifdef SERIAL_DEBUG_INTR
  26465. +    printk("rs_interrupt_single(%d)...", irq);
  26466. +#endif
  26467. +    
  26468. +    info = IRQ_ports[irq];
  26469. +    if (!info || !info->tty)
  26470. +        return;
  26471. +
  26472. +    multi = &rs_multiport[irq];
  26473. +    if (multi->port_monitor)
  26474. +        first_multi = inb(multi->port_monitor);
  26475. +
  26476. +    do {
  26477. +        status = serial_inp(info, UART_LSR) & info->read_status_mask;
  26478. +#ifdef SERIAL_DEBUG_INTR
  26479. +        printk("status = %x...", status);
  26480. +#endif
  26481. +        if (status & UART_LSR_DR)
  26482. +            receive_chars(info, &status);
  26483. +        check_modem_status(info);
  26484. +        if (status & UART_LSR_THRE)
  26485. +            transmit_chars(info, 0);
  26486. +        if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  26487. +#if 0
  26488. +            printk("rs_single loop break.\n");
  26489. +#endif
  26490. +            break;
  26491. +        }
  26492. +    } while (!(serial_in(info, UART_IIR) & UART_IIR_NO_INT));
  26493. +    info->last_active = jiffies;
  26494. +    if (multi->port_monitor)
  26495. +        printk("rs port monitor (single) irq %d: 0x%x, 0x%x\n",
  26496. +               info->irq, first_multi, inb(multi->port_monitor));
  26497. +#ifdef SERIAL_DEBUG_INTR
  26498. +    printk("end.\n");
  26499. +#endif
  26500. +}
  26501. +
  26502. +/*
  26503. + * This is the serial driver's for multiport boards
  26504. + */
  26505. +static void rs_interrupt_multi(int irq, void *dev_id, struct pt_regs * regs)
  26506. +{
  26507. +    int status;
  26508. +    struct async_struct * info;
  26509. +    int pass_counter = 0;
  26510. +    int first_multi= 0;
  26511. +    struct rs_multiport_struct *multi;
  26512. +
  26513. +#ifdef SERIAL_DEBUG_INTR
  26514. +    printk("rs_interrupt_multi(%d)...", irq);
  26515. +#endif
  26516. +    
  26517. +    info = IRQ_ports[irq];
  26518. +    if (!info)
  26519. +        return;
  26520. +    multi = &rs_multiport[irq];
  26521. +    if (!multi->port1) {
  26522. +        /* Should never happen */
  26523. +        printk("rs_interrupt_multi: NULL port1!\n");
  26524. +        return;
  26525. +    }
  26526. +    if (multi->port_monitor)
  26527. +        first_multi = inb(multi->port_monitor);
  26528. +    
  26529. +    while (1) {
  26530. +        if (!info->tty ||
  26531. +            (serial_in(info, UART_IIR) & UART_IIR_NO_INT))
  26532. +            goto next;
  26533. +
  26534. +        info->last_active = jiffies;
  26535. +
  26536. +        status = serial_inp(info, UART_LSR) & info->read_status_mask;
  26537. +#ifdef SERIAL_DEBUG_INTR
  26538. +        printk("status = %x...", status);
  26539. +#endif
  26540. +        if (status & UART_LSR_DR)
  26541. +            receive_chars(info, &status);
  26542. +        check_modem_status(info);
  26543. +        if (status & UART_LSR_THRE)
  26544. +            transmit_chars(info, 0);
  26545. +
  26546. +    next:
  26547. +        info = info->next_port;
  26548. +        if (info)
  26549. +            continue;
  26550. +
  26551. +        info = IRQ_ports[irq];
  26552. +        if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  26553. +#if 1
  26554. +            printk("rs_multi loop break\n");
  26555. +#endif
  26556. +            break;     /* Prevent infinite loops */
  26557. +        }
  26558. +        if (multi->port_monitor)
  26559. +            printk("rs port monitor irq %d: 0x%x, 0x%x\n",
  26560. +                   info->irq, first_multi,
  26561. +                   inb(multi->port_monitor));
  26562. +        if ((inb(multi->port1) & multi->mask1) != multi->match1)
  26563. +            continue;
  26564. +        if (!multi->port2)
  26565. +            break;
  26566. +        if ((inb(multi->port2) & multi->mask2) != multi->match2)
  26567. +            continue;
  26568. +        if (!multi->port3)
  26569. +            break;
  26570. +        if ((inb(multi->port3) & multi->mask3) != multi->match3)
  26571. +            continue;
  26572. +        if (!multi->port4)
  26573. +            break;
  26574. +        if ((inb(multi->port4) & multi->mask4) == multi->match4)
  26575. +            continue;
  26576. +        break;
  26577. +    } 
  26578. +#ifdef SERIAL_DEBUG_INTR
  26579. +    printk("end.\n");
  26580. +#endif
  26581. +}
  26582. +
  26583. +
  26584. +/*
  26585. + * -------------------------------------------------------------------
  26586. + * Here ends the serial interrupt routines.
  26587. + * -------------------------------------------------------------------
  26588. + */
  26589. +
  26590. +/*
  26591. + * This routine is used to handle the "bottom half" processing for the
  26592. + * serial driver, known also the "software interrupt" processing.
  26593. + * This processing is done at the kernel interrupt level, after the
  26594. + * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  26595. + * is where time-consuming activities which can not be done in the
  26596. + * interrupt driver proper are done; the interrupt driver schedules
  26597. + * them using rs_sched_event(), and they get done here.
  26598. + */
  26599. +static void do_serial_bh(void)
  26600. +{
  26601. +    run_task_queue(&tq_serial);
  26602. +}
  26603. +
  26604. +static void do_softint(void *private_)
  26605. +{
  26606. +    struct async_struct    *info = (struct async_struct *) private_;
  26607. +    struct tty_struct    *tty;
  26608. +    
  26609. +    tty = info->tty;
  26610. +    if (!tty)
  26611. +        return;
  26612. +
  26613. +    if (clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  26614. +        if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  26615. +            tty->ldisc.write_wakeup)
  26616. +            (tty->ldisc.write_wakeup)(tty);
  26617. +        wake_up_interruptible(&tty->write_wait);
  26618. +    }
  26619. +}
  26620. +
  26621. +/*
  26622. + * This routine is called from the scheduler tqueue when the interrupt
  26623. + * routine has signalled that a hangup has occurred.  The path of
  26624. + * hangup processing is:
  26625. + *
  26626. + *     serial interrupt routine -> (scheduler tqueue) ->
  26627. + *     do_serial_hangup() -> tty->hangup() -> rs_hangup()
  26628. + * 
  26629. + */
  26630. +static void do_serial_hangup(void *private_)
  26631. +{
  26632. +    struct async_struct    *info = (struct async_struct *) private_;
  26633. +    struct tty_struct    *tty;
  26634. +    
  26635. +    tty = info->tty;
  26636. +    if (!tty)
  26637. +        return;
  26638. +
  26639. +    tty_hangup(tty);
  26640. +}
  26641. +
  26642. +
  26643. +/*
  26644. + * This subroutine is called when the RS_TIMER goes off.  It is used
  26645. + * by the serial driver to handle ports that do not have an interrupt
  26646. + * (irq=0).  This doesn't work very well for 16450's, but gives barely
  26647. + * passable results for a 16550A.  (Although at the expense of much
  26648. + * CPU overhead).
  26649. + */
  26650. +static void rs_timer(void)
  26651. +{
  26652. +    static unsigned long last_strobe = 0;
  26653. +    struct async_struct *info;
  26654. +    unsigned int    i;
  26655. +
  26656. +    if ((jiffies - last_strobe) >= RS_STROBE_TIME) {
  26657. +        for (i=0; i < 32; i++) {
  26658. +            info = IRQ_ports[i];
  26659. +            if (!info)
  26660. +                continue;
  26661. +            cli();
  26662. +            if (info->next_port) {
  26663. +                do {
  26664. +                    serial_out(info, UART_IER, 0);
  26665. +                    info->IER |= UART_IER_THRI;
  26666. +                    serial_out(info, UART_IER, info->IER);
  26667. +                    info = info->next_port;
  26668. +                } while (info);
  26669. +                if (rs_multiport[i].port1)
  26670. +                    rs_interrupt_multi(i, NULL, NULL);
  26671. +                else
  26672. +                    rs_interrupt(i, NULL, NULL);
  26673. +            } else
  26674. +                rs_interrupt_single(i, NULL, NULL);
  26675. +            sti();
  26676. +        }
  26677. +    }
  26678. +    last_strobe = jiffies;
  26679. +    timer_table[RS_TIMER].expires = jiffies + RS_STROBE_TIME;
  26680. +    timer_active |= 1 << RS_TIMER;
  26681. +
  26682. +    if (IRQ_ports[0]) {
  26683. +        cli();
  26684. +        rs_interrupt(0, NULL, NULL);
  26685. +        sti();
  26686. +
  26687. +        timer_table[RS_TIMER].expires = jiffies + IRQ_timeout[0] - 2;
  26688. +    }
  26689. +}
  26690. +
  26691. +/*
  26692. + * ---------------------------------------------------------------
  26693. + * Low level utility subroutines for the serial driver:  routines to
  26694. + * figure out the appropriate timeout for an interrupt chain, routines
  26695. + * to initialize and startup a serial port, and routines to shutdown a
  26696. + * serial port.  Useful stuff like that.
  26697. + * ---------------------------------------------------------------
  26698. + */
  26699. +
  26700. +/*
  26701. + * Grab all interrupts in preparation for doing an automatic irq
  26702. + * detection.  dontgrab is a mask of irq's _not_ to grab.  Returns a
  26703. + * mask of irq's which were grabbed and should therefore be freed
  26704. + * using free_all_interrupts().
  26705. + */
  26706. +static int grab_all_interrupts(int dontgrab)
  26707. +{
  26708. +    int             irq_lines = 0;
  26709. +    int            i, mask;
  26710. +    
  26711. +    for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
  26712. +        if (!(mask & dontgrab) && !request_irq(i, rs_probe, SA_INTERRUPT, "serial probe", NULL)) {
  26713. +            irq_lines |= mask;
  26714. +        }
  26715. +    }
  26716. +    return irq_lines;
  26717. +}
  26718. +
  26719. +/*
  26720. + * Release all interrupts grabbed by grab_all_interrupts
  26721. + */
  26722. +static void free_all_interrupts(int irq_lines)
  26723. +{
  26724. +    int    i;
  26725. +    
  26726. +    for (i = 0; i < 16; i++) {
  26727. +        if (irq_lines & (1 << i))
  26728. +            free_irq(i, NULL);
  26729. +    }
  26730. +}
  26731. +
  26732. +/*
  26733. + * This routine figures out the correct timeout for a particular IRQ.
  26734. + * It uses the smallest timeout of all of the serial ports in a
  26735. + * particular interrupt chain.  Now only used for IRQ 0....
  26736. + */
  26737. +static void figure_IRQ_timeout(int irq)
  26738. +{
  26739. +    struct    async_struct    *info;
  26740. +    int    timeout = 60*HZ;    /* 60 seconds === a long time :-) */
  26741. +
  26742. +    info = IRQ_ports[irq];
  26743. +    if (!info) {
  26744. +        IRQ_timeout[irq] = 60*HZ;
  26745. +        return;
  26746. +    }
  26747. +    while (info) {
  26748. +        if (info->timeout < timeout)
  26749. +            timeout = info->timeout;
  26750. +        info = info->next_port;
  26751. +    }
  26752. +    if (!irq)
  26753. +        timeout = timeout / 2;
  26754. +    IRQ_timeout[irq] = timeout ? timeout : 1;
  26755. +}
  26756. +
  26757. +static int startup(struct async_struct * info)
  26758. +{
  26759. +    unsigned short ICP;
  26760. +    unsigned long flags;
  26761. +    int    retval;
  26762. +    void (*handler)(int, void *, struct pt_regs *);
  26763. +    unsigned long page;
  26764. +
  26765. +    page = get_free_page(GFP_KERNEL);
  26766. +    if (!page)
  26767. +        return -ENOMEM;
  26768. +
  26769. +
  26770. +    save_flags_cli(flags);
  26771. +
  26772. +    if (info->flags & ASYNC_INITIALIZED) {
  26773. +        free_page(page);
  26774. +        restore_flags(flags);
  26775. +        return 0;
  26776. +    }
  26777. +
  26778. +    if (!info->port || !info->type) {
  26779. +        if (info->tty)
  26780. +            set_bit(TTY_IO_ERROR, &info->tty->flags);
  26781. +        free_page(page);
  26782. +        restore_flags(flags);
  26783. +        return 0;
  26784. +    }
  26785. +    if (info->xmit_buf)
  26786. +        free_page(page);
  26787. +    else
  26788. +        info->xmit_buf = (unsigned char *) page;
  26789. +
  26790. +#ifdef SERIAL_DEBUG_OPEN
  26791. +    printk("starting up ttys%d (irq %d)...", info->line, info->irq);
  26792. +#endif
  26793. +
  26794. +    /*
  26795. +     * Clear the FIFO buffers and disable them
  26796. +     * (they will be reenabled in change_speed())
  26797. +     */
  26798. +    if (info->type == PORT_16650) {
  26799. +        serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  26800. +                         UART_FCR_CLEAR_XMIT));
  26801. +        info->xmit_fifo_size = 1; /* disabled for now */
  26802. +    } else if (info->type == PORT_16550A) {
  26803. +        serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  26804. +                         UART_FCR_CLEAR_XMIT));
  26805. +        info->xmit_fifo_size = 16;
  26806. +    } else
  26807. +        info->xmit_fifo_size = 1;
  26808. +
  26809. +    /*
  26810. +     * At this point there's no way the LSR could still be 0xFF;
  26811. +     * if it is, then bail out, because there's likely no UART
  26812. +     * here.
  26813. +     */
  26814. +    if (serial_inp(info, UART_LSR) == 0xff) {
  26815. +        restore_flags(flags);
  26816. +        if (suser()) {
  26817. +            if (info->tty)
  26818. +                set_bit(TTY_IO_ERROR, &info->tty->flags);
  26819. +            return 0;
  26820. +        } else
  26821. +            return -ENODEV;
  26822. +    }
  26823. +    
  26824. +    /*
  26825. +     * Allocate the IRQ if necessary
  26826. +     */
  26827. +    if (info->irq && (!IRQ_ports[info->irq] ||
  26828. +              !IRQ_ports[info->irq]->next_port)) {
  26829. +        if (IRQ_ports[info->irq]) {
  26830. +            free_irq(info->irq, NULL);
  26831. +            if (rs_multiport[info->irq].port1)
  26832. +                handler = rs_interrupt_multi;
  26833. +            else
  26834. +                handler = rs_interrupt;
  26835. +        } else 
  26836. +            handler = rs_interrupt_single;
  26837. +
  26838. +        retval = request_irq(info->irq, handler, IRQ_T(info),
  26839. +                     "serial", NULL);
  26840. +        if (retval) {
  26841. +            restore_flags(flags);
  26842. +            if (suser()) {
  26843. +                if (info->tty)
  26844. +                    set_bit(TTY_IO_ERROR,
  26845. +                        &info->tty->flags);
  26846. +                return 0;
  26847. +            } else
  26848. +                return retval;
  26849. +        }
  26850. +    }
  26851. +
  26852. +    /*
  26853. +     * Clear the interrupt registers.
  26854. +     */
  26855. +     /* (void) serial_inp(info, UART_LSR); */   /* (see above) */
  26856. +    (void) serial_inp(info, UART_RX);
  26857. +    (void) serial_inp(info, UART_IIR);
  26858. +    (void) serial_inp(info, UART_MSR);
  26859. +
  26860. +    /*
  26861. +     * Now, initialize the UART 
  26862. +     */
  26863. +    serial_outp(info, UART_LCR, UART_LCR_WLEN8);    /* reset DLAB */
  26864. +    if (info->flags & ASYNC_FOURPORT) {
  26865. +        info->MCR = UART_MCR_DTR | UART_MCR_RTS;
  26866. +        info->MCR_noint = UART_MCR_DTR | UART_MCR_OUT1;
  26867. +    } else {
  26868. +        info->MCR = UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2;
  26869. +        info->MCR_noint = UART_MCR_DTR | UART_MCR_RTS;
  26870. +    }
  26871. +#if defined(__alpha__) && !defined(CONFIG_PCI)
  26872. +    info->MCR |= UART_MCR_OUT1 | UART_MCR_OUT2;
  26873. +    info->MCR_noint |= UART_MCR_OUT1 | UART_MCR_OUT2;
  26874. +#endif
  26875. +    if (info->irq == 0)
  26876. +        info->MCR = info->MCR_noint;
  26877. +    serial_outp(info, UART_MCR, info->MCR);
  26878. +    
  26879. +    /*
  26880. +     * Finally, enable interrupts
  26881. +     */
  26882. +    info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
  26883. +    serial_outp(info, UART_IER, info->IER);    /* enable interrupts */
  26884. +    
  26885. +    if (info->flags & ASYNC_FOURPORT) {
  26886. +        /* Enable interrupts on the AST Fourport board */
  26887. +        ICP = (info->port & 0xFE0) | 0x01F;
  26888. +        outb_p(0x80, ICP);
  26889. +        (void) inb_p(ICP);
  26890. +    }
  26891. +
  26892. +    /*
  26893. +     * And clear the interrupt registers again for luck.
  26894. +     */
  26895. +    (void)serial_inp(info, UART_LSR);
  26896. +    (void)serial_inp(info, UART_RX);
  26897. +    (void)serial_inp(info, UART_IIR);
  26898. +    (void)serial_inp(info, UART_MSR);
  26899. +
  26900. +    if (info->tty)
  26901. +        clear_bit(TTY_IO_ERROR, &info->tty->flags);
  26902. +    info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  26903. +
  26904. +    /*
  26905. +     * Insert serial port into IRQ chain.
  26906. +     */
  26907. +    info->prev_port = 0;
  26908. +    info->next_port = IRQ_ports[info->irq];
  26909. +    if (info->next_port)
  26910. +        info->next_port->prev_port = info;
  26911. +    IRQ_ports[info->irq] = info;
  26912. +    figure_IRQ_timeout(info->irq);
  26913. +
  26914. +    /*
  26915. +     * Set up serial timers...
  26916. +     */
  26917. +    timer_table[RS_TIMER].expires = jiffies + 2*HZ/100;
  26918. +    timer_active |= 1 << RS_TIMER;
  26919. +
  26920. +    /*
  26921. +     * and set the speed of the serial port
  26922. +     */
  26923. +    change_speed(info);
  26924. +
  26925. +    info->flags |= ASYNC_INITIALIZED;
  26926. +    restore_flags(flags);
  26927. +    return 0;
  26928. +}
  26929. +
  26930. +/*
  26931. + * This routine will shutdown a serial port; interrupts are disabled, and
  26932. + * DTR is dropped if the hangup on close termio flag is on.
  26933. + */
  26934. +static void shutdown(struct async_struct * info)
  26935. +{
  26936. +    unsigned long    flags;
  26937. +    int        retval;
  26938. +
  26939. +    if (!(info->flags & ASYNC_INITIALIZED))
  26940. +        return;
  26941. +
  26942. +#ifdef SERIAL_DEBUG_OPEN
  26943. +    printk("Shutting down serial port %d (irq %d)....", info->line,
  26944. +           info->irq);
  26945. +#endif
  26946. +    
  26947. +    save_flags_cli(flags); /* Disable interrupts */
  26948. +
  26949. +    /*
  26950. +     * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
  26951. +     * here so the queue might never be waken up
  26952. +     */
  26953. +    wake_up_interruptible(&info->delta_msr_wait);
  26954. +    
  26955. +    /*
  26956. +     * First unlink the serial port from the IRQ chain...
  26957. +     */
  26958. +    if (info->next_port)
  26959. +        info->next_port->prev_port = info->prev_port;
  26960. +    if (info->prev_port)
  26961. +        info->prev_port->next_port = info->next_port;
  26962. +    else
  26963. +        IRQ_ports[info->irq] = info->next_port;
  26964. +    figure_IRQ_timeout(info->irq);
  26965. +    
  26966. +    /*
  26967. +     * Free the IRQ, if necessary
  26968. +     */
  26969. +    if (info->irq && (!IRQ_ports[info->irq] ||
  26970. +              !IRQ_ports[info->irq]->next_port)) {
  26971. +        if (IRQ_ports[info->irq]) {
  26972. +            free_irq(info->irq, NULL);
  26973. +            retval = request_irq(info->irq, rs_interrupt_single,
  26974. +                         IRQ_T(info), "serial", NULL);
  26975. +            
  26976. +            if (retval)
  26977. +                printk("serial shutdown: request_irq: error %d"
  26978. +                       "  Couldn't reacquire IRQ.\n", retval);
  26979. +        } else
  26980. +            free_irq(info->irq, NULL);
  26981. +    }
  26982. +
  26983. +    if (info->xmit_buf) {
  26984. +        free_page((unsigned long) info->xmit_buf);
  26985. +        info->xmit_buf = 0;
  26986. +    }
  26987. +
  26988. +    info->IER = 0;
  26989. +    serial_outp(info, UART_IER, 0x00);    /* disable all intrs */
  26990. +    if (info->flags & ASYNC_FOURPORT) {
  26991. +        /* reset interrupts on the AST Fourport board */
  26992. +        (void) inb((info->port & 0xFE0) | 0x01F);
  26993. +    }
  26994. +    
  26995. +    if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
  26996. +        info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS);
  26997. +        info->MCR_noint &= ~(UART_MCR_DTR|UART_MCR_RTS);
  26998. +    }
  26999. +    serial_outp(info, UART_MCR, info->MCR_noint);
  27000. +
  27001. +    /* disable FIFO's */    
  27002. +    serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  27003. +                     UART_FCR_CLEAR_XMIT));
  27004. +    (void)serial_in(info, UART_RX);    /* read data port to reset things */
  27005. +    
  27006. +    if (info->tty)
  27007. +        set_bit(TTY_IO_ERROR, &info->tty->flags);
  27008. +    
  27009. +    info->flags &= ~ASYNC_INITIALIZED;
  27010. +    restore_flags(flags);
  27011. +}
  27012. +
  27013. +/*
  27014. + * This routine is called to set the UART divisor registers to match
  27015. + * the specified baud rate for a serial port.
  27016. + */
  27017. +static void change_speed(struct async_struct *info)
  27018. +{
  27019. +    unsigned short port;
  27020. +    int    quot = 0;
  27021. +    unsigned cflag,cval,fcr;
  27022. +    int    i;
  27023. +
  27024. +    if (!info->tty || !info->tty->termios)
  27025. +        return;
  27026. +    cflag = info->tty->termios->c_cflag;
  27027. +    if (!(port = info->port))
  27028. +        return;
  27029. +    i = cflag & CBAUD;
  27030. +    if (i & CBAUDEX) {
  27031. +        i &= ~CBAUDEX;
  27032. +        if (i < 1 || i > 2) 
  27033. +            info->tty->termios->c_cflag &= ~CBAUDEX;
  27034. +        else
  27035. +            i += 15;
  27036. +    }
  27037. +    if (i == 15) {
  27038. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  27039. +            i += 1;
  27040. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  27041. +            i += 2;
  27042. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
  27043. +            quot = info->custom_divisor;
  27044. +    }
  27045. +    if (quot) {
  27046. +        info->timeout = ((info->xmit_fifo_size*HZ*15*quot) /
  27047. +                 info->baud_base) + 2;
  27048. +    } else if (baud_table[i] == 134) {
  27049. +        quot = (2*info->baud_base / 269);
  27050. +        info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
  27051. +    } else if (baud_table[i]) {
  27052. +        quot = info->baud_base / baud_table[i];
  27053. +        info->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
  27054. +    } else {
  27055. +        quot = 0;
  27056. +        info->timeout = 0;
  27057. +    }
  27058. +    if (quot) {
  27059. +        info->MCR |= UART_MCR_DTR;
  27060. +        info->MCR_noint |= UART_MCR_DTR;
  27061. +        cli();
  27062. +        serial_out(info, UART_MCR, info->MCR);
  27063. +        sti();
  27064. +    } else {
  27065. +        info->MCR &= ~UART_MCR_DTR;
  27066. +        info->MCR_noint &= ~UART_MCR_DTR;
  27067. +        cli();
  27068. +        serial_out(info, UART_MCR, info->MCR);
  27069. +        sti();
  27070. +        return;
  27071. +    }
  27072. +    /* byte size and parity */
  27073. +    switch (cflag & CSIZE) {
  27074. +        case CS5: cval = 0x00; break;
  27075. +        case CS6: cval = 0x01; break;
  27076. +        case CS7: cval = 0x02; break;
  27077. +        case CS8: cval = 0x03; break;
  27078. +        default: cval = 0x00; break;   /* too keep GCC shut... */
  27079. +    }
  27080. +    if (cflag & CSTOPB) {
  27081. +        cval |= 0x04;
  27082. +    }    
  27083. +    if (cflag & PARENB)
  27084. +        cval |= UART_LCR_PARITY;
  27085. +    if (!(cflag & PARODD))
  27086. +        cval |= UART_LCR_EPAR;
  27087. +    if (info->type == PORT_16550A) {
  27088. +        if ((info->baud_base / quot) < 2400)
  27089. +            fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
  27090. +        else
  27091. +            fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
  27092. +    } else if (info->type == PORT_16650) {
  27093. +        /*
  27094. +         * On the 16650, we disable the FIFOs altogether
  27095. +         * because of a design bug in how the implement
  27096. +         * things.  We could support it by completely changing
  27097. +         * how we handle the interrupt driver, but not today....
  27098. +         *
  27099. +         * N.B.  Because there's no way to set a FIFO trigger
  27100. +         * at 1 char, we'd probably disable at speed below
  27101. +         * 2400 baud anyway...
  27102. +         */
  27103. +        fcr = 0;
  27104. +    } else
  27105. +        fcr = 0;
  27106. +    
  27107. +    /* CTS flow control flag and modem status interrupts */
  27108. +    info->IER &= ~UART_IER_MSI;
  27109. +    if (cflag & CRTSCTS) {
  27110. +        info->flags |= ASYNC_CTS_FLOW;
  27111. +        info->IER |= UART_IER_MSI;
  27112. +    } else
  27113. +        info->flags &= ~ASYNC_CTS_FLOW;
  27114. +    if (cflag & CLOCAL)
  27115. +        info->flags &= ~ASYNC_CHECK_CD;
  27116. +    else {
  27117. +        info->flags |= ASYNC_CHECK_CD;
  27118. +        info->IER |= UART_IER_MSI;
  27119. +    }
  27120. +    serial_out(info, UART_IER, info->IER);
  27121. +
  27122. +    /*
  27123. +     * Set up parity check flag
  27124. +     */
  27125. +#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
  27126. +
  27127. +    info->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
  27128. +    if (I_INPCK(info->tty))
  27129. +        info->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
  27130. +    if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
  27131. +        info->read_status_mask |= UART_LSR_BI;
  27132. +    
  27133. +    info->ignore_status_mask = 0;
  27134. +#if 0
  27135. +    /* This should be safe, but for some broken bits of hardware... */
  27136. +    if (I_IGNPAR(info->tty)) {
  27137. +        info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
  27138. +        info->read_status_mask |= UART_LSR_PE | UART_LSR_FE;
  27139. +    }
  27140. +#endif
  27141. +    if (I_IGNBRK(info->tty)) {
  27142. +        info->ignore_status_mask |= UART_LSR_BI;
  27143. +        info->read_status_mask |= UART_LSR_BI;
  27144. +        /*
  27145. +         * If we're ignore parity and break indicators, ignore 
  27146. +         * overruns too.  (For real raw support).
  27147. +         */
  27148. +        if (I_IGNPAR(info->tty)) {
  27149. +            info->ignore_status_mask |= UART_LSR_OE |
  27150. +                UART_LSR_PE | UART_LSR_FE;
  27151. +            info->read_status_mask |= UART_LSR_OE |
  27152. +                UART_LSR_PE | UART_LSR_FE;
  27153. +        }
  27154. +    }
  27155. +    cli();
  27156. +    serial_outp(info, UART_LCR, cval | UART_LCR_DLAB);    /* set DLAB */
  27157. +    serial_outp(info, UART_DLL, quot & 0xff);    /* LS of divisor */
  27158. +    serial_outp(info, UART_DLM, quot >> 8);        /* MS of divisor */
  27159. +    serial_outp(info, UART_LCR, cval);        /* reset DLAB */
  27160. +    serial_outp(info, UART_FCR, fcr);     /* set fcr */
  27161. +    sti();
  27162. +}
  27163. +
  27164. +static void rs_put_char(struct tty_struct *tty, unsigned char ch)
  27165. +{
  27166. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27167. +    unsigned long flags;
  27168. +
  27169. +    if (serial_paranoia_check(info, tty->device, "rs_put_char"))
  27170. +        return;
  27171. +
  27172. +    if (!tty || !info->xmit_buf)
  27173. +        return;
  27174. +
  27175. +    save_flags_cli (flags);
  27176. +    if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
  27177. +        restore_flags(flags);
  27178. +        return;
  27179. +    }
  27180. +
  27181. +    info->xmit_buf[info->xmit_head++] = ch;
  27182. +    info->xmit_head &= SERIAL_XMIT_SIZE-1;
  27183. +    info->xmit_cnt++;
  27184. +    restore_flags(flags);
  27185. +}
  27186. +
  27187. +static void rs_flush_chars(struct tty_struct *tty)
  27188. +{
  27189. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27190. +    unsigned long flags;
  27191. +                
  27192. +    if (serial_paranoia_check(info, tty->device, "rs_flush_chars"))
  27193. +        return;
  27194. +
  27195. +    if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  27196. +        !info->xmit_buf)
  27197. +        return;
  27198. +
  27199. +    save_flags_cli (flags);
  27200. +    info->IER |= UART_IER_THRI;
  27201. +    serial_out(info, UART_IER, info->IER);
  27202. +    restore_flags(flags);
  27203. +}
  27204. +
  27205. +static int rs_write(struct tty_struct * tty, int from_user,
  27206. +            const unsigned char *buf, int count)
  27207. +{
  27208. +    int    c, total = 0;
  27209. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27210. +    unsigned long flags;
  27211. +                
  27212. +    if (serial_paranoia_check(info, tty->device, "rs_write"))
  27213. +        return 0;
  27214. +
  27215. +    if (!tty || !info->xmit_buf || !tmp_buf)
  27216. +        return 0;
  27217. +        
  27218. +    if (from_user)
  27219. +        down(&tmp_buf_sem);
  27220. +    save_flags(flags);
  27221. +    while (1) {
  27222. +        cli();        
  27223. +        c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  27224. +                   SERIAL_XMIT_SIZE - info->xmit_head));
  27225. +        if (c <= 0)
  27226. +            break;
  27227. +
  27228. +        if (from_user) {
  27229. +            memcpy_fromfs(tmp_buf, buf, c);
  27230. +            c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  27231. +                       SERIAL_XMIT_SIZE - info->xmit_head));
  27232. +            memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
  27233. +        } else
  27234. +            memcpy(info->xmit_buf + info->xmit_head, buf, c);
  27235. +        info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  27236. +        info->xmit_cnt += c;
  27237. +        restore_flags(flags);
  27238. +        buf += c;
  27239. +        count -= c;
  27240. +        total += c;
  27241. +    }
  27242. +    if (from_user)
  27243. +        up(&tmp_buf_sem);
  27244. +    if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
  27245. +        !(info->IER & UART_IER_THRI)) {
  27246. +        info->IER |= UART_IER_THRI;
  27247. +        serial_out(info, UART_IER, info->IER);
  27248. +    }
  27249. +    restore_flags(flags);
  27250. +    return total;
  27251. +}
  27252. +
  27253. +static int rs_write_room(struct tty_struct *tty)
  27254. +{
  27255. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27256. +    int    ret;
  27257. +                
  27258. +    if (serial_paranoia_check(info, tty->device, "rs_write_room"))
  27259. +        return 0;
  27260. +    ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
  27261. +    if (ret < 0)
  27262. +        ret = 0;
  27263. +    return ret;
  27264. +}
  27265. +
  27266. +static int rs_chars_in_buffer(struct tty_struct *tty)
  27267. +{
  27268. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27269. +                
  27270. +    if (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
  27271. +        return 0;
  27272. +    return info->xmit_cnt;
  27273. +}
  27274. +
  27275. +static void rs_flush_buffer(struct tty_struct *tty)
  27276. +{
  27277. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27278. +                
  27279. +    if (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
  27280. +        return;
  27281. +    cli();
  27282. +    info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  27283. +    sti();
  27284. +    wake_up_interruptible(&tty->write_wait);
  27285. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  27286. +        tty->ldisc.write_wakeup)
  27287. +        (tty->ldisc.write_wakeup)(tty);
  27288. +}
  27289. +
  27290. +/*
  27291. + * ------------------------------------------------------------
  27292. + * rs_throttle()
  27293. + * 
  27294. + * This routine is called by the upper-layer tty layer to signal that
  27295. + * incoming characters should be throttled.
  27296. + * ------------------------------------------------------------
  27297. + */
  27298. +static void rs_throttle(struct tty_struct * tty)
  27299. +{
  27300. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27301. +#ifdef SERIAL_DEBUG_THROTTLE
  27302. +    char    buf[64];
  27303. +    
  27304. +    printk("throttle %s: %d....\n", _tty_name(tty, buf),
  27305. +           tty->ldisc.chars_in_buffer(tty));
  27306. +#endif
  27307. +
  27308. +    if (serial_paranoia_check(info, tty->device, "rs_throttle"))
  27309. +        return;
  27310. +    
  27311. +    if (I_IXOFF(tty))
  27312. +        info->x_char = STOP_CHAR(tty);
  27313. +
  27314. +    info->MCR &= ~UART_MCR_RTS;
  27315. +    info->MCR_noint &= ~UART_MCR_RTS;
  27316. +    cli();
  27317. +    serial_out(info, UART_MCR, info->MCR);
  27318. +    sti();
  27319. +}
  27320. +
  27321. +static void rs_unthrottle(struct tty_struct * tty)
  27322. +{
  27323. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27324. +#ifdef SERIAL_DEBUG_THROTTLE
  27325. +    char    buf[64];
  27326. +    
  27327. +    printk("unthrottle %s: %d....\n", _tty_name(tty, buf),
  27328. +           tty->ldisc.chars_in_buffer(tty));
  27329. +#endif
  27330. +
  27331. +    if (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
  27332. +        return;
  27333. +    
  27334. +    if (I_IXOFF(tty)) {
  27335. +        if (info->x_char)
  27336. +            info->x_char = 0;
  27337. +        else
  27338. +            info->x_char = START_CHAR(tty);
  27339. +    }
  27340. +    info->MCR |= UART_MCR_RTS;
  27341. +    info->MCR_noint |= UART_MCR_RTS;
  27342. +    cli();
  27343. +    serial_out(info, UART_MCR, info->MCR);
  27344. +    sti();
  27345. +}
  27346. +
  27347. +/*
  27348. + * ------------------------------------------------------------
  27349. + * rs_ioctl() and friends
  27350. + * ------------------------------------------------------------
  27351. + */
  27352. +
  27353. +static int get_serial_info(struct async_struct * info,
  27354. +               struct serial_struct * retinfo)
  27355. +{
  27356. +    struct serial_struct tmp;
  27357. +  
  27358. +    if (!retinfo)
  27359. +        return -EFAULT;
  27360. +    memset(&tmp, 0, sizeof(tmp));
  27361. +    tmp.type = info->type;
  27362. +    tmp.line = info->line;
  27363. +    tmp.port = info->port;
  27364. +    tmp.irq = info->irq;
  27365. +    tmp.flags = info->flags;
  27366. +    tmp.baud_base = info->baud_base;
  27367. +    tmp.close_delay = info->close_delay;
  27368. +    tmp.closing_wait = info->closing_wait;
  27369. +    tmp.custom_divisor = info->custom_divisor;
  27370. +    tmp.hub6 = info->hub6;
  27371. +    memcpy_tofs(retinfo,&tmp,sizeof(*retinfo));
  27372. +    return 0;
  27373. +}
  27374. +
  27375. +static int set_serial_info(struct async_struct * info,
  27376. +               struct serial_struct * new_info)
  27377. +{
  27378. +    struct serial_struct new_serial;
  27379. +    struct async_struct old_info;
  27380. +    unsigned int        i,change_irq,change_port;
  27381. +    int             retval = 0;
  27382. +
  27383. +    if (!new_info)
  27384. +        return -EFAULT;
  27385. +    memcpy_fromfs(&new_serial,new_info,sizeof(new_serial));
  27386. +    old_info = *info;
  27387. +
  27388. +    change_irq = new_serial.irq != info->irq;
  27389. +    change_port = (new_serial.port != info->port) || (new_serial.hub6 != info->hub6);
  27390. +
  27391. +    if (!suser()) {
  27392. +        if (change_irq || change_port ||
  27393. +            (new_serial.baud_base != info->baud_base) ||
  27394. +            (new_serial.type != info->type) ||
  27395. +            (new_serial.close_delay != info->close_delay) ||
  27396. +            ((new_serial.flags & ~ASYNC_USR_MASK) !=
  27397. +             (info->flags & ~ASYNC_USR_MASK)))
  27398. +            return -EPERM;
  27399. +        info->flags = ((info->flags & ~ASYNC_USR_MASK) |
  27400. +                   (new_serial.flags & ASYNC_USR_MASK));
  27401. +        info->custom_divisor = new_serial.custom_divisor;
  27402. +        goto check_and_exit;
  27403. +    }
  27404. +#if 0
  27405. +    if (new_serial.irq == 2)
  27406. +        new_serial.irq = 9;
  27407. +
  27408. +    if ((new_serial.irq > 15) || (new_serial.port > 0xffff) ||
  27409. +        (new_serial.type < PORT_UNKNOWN) || (new_serial.type > PORT_MAX)) {
  27410. +        return -EINVAL;
  27411. +    }
  27412. +#else
  27413. +    if ((new_serial.irq > 31) || (new_serial.type < PORT_UNKNOWN) ||
  27414. +        (new_serial.type > PORT_MAX)) {
  27415. +        return -EINVAL;
  27416. +    }
  27417. +#endif
  27418. +
  27419. +    /* Make sure address is not already in use */
  27420. +    if (new_serial.type) {
  27421. +        for (i = 0 ; i < NR_PORTS; i++)
  27422. +            if ((info != &rs_table[i]) &&
  27423. +                (rs_table[i].port == new_serial.port) &&
  27424. +                rs_table[i].type)
  27425. +                return -EADDRINUSE;
  27426. +    }
  27427. +
  27428. +    if ((change_port || change_irq) && (info->count > 1))
  27429. +        return -EBUSY;
  27430. +
  27431. +    /*
  27432. +     * OK, past this point, all the error checking has been done.
  27433. +     * At this point, we start making changes.....
  27434. +     */
  27435. +
  27436. +    info->baud_base = new_serial.baud_base;
  27437. +    info->flags = ((info->flags & ~ASYNC_FLAGS) |
  27438. +            (new_serial.flags & ASYNC_FLAGS));
  27439. +    info->custom_divisor = new_serial.custom_divisor;
  27440. +    info->type = new_serial.type;
  27441. +    info->close_delay = new_serial.close_delay * HZ/100;
  27442. +    info->closing_wait = new_serial.closing_wait * HZ/100;
  27443. +
  27444. +    release_region(info->port,8);
  27445. +    if (change_port || change_irq) {
  27446. +        /*
  27447. +         * We need to shutdown the serial port at the old
  27448. +         * port/irq combination.
  27449. +         */
  27450. +        shutdown(info);
  27451. +        info->irq = new_serial.irq;
  27452. +        info->port = new_serial.port;
  27453. +        info->hub6 = new_serial.hub6;
  27454. +    }
  27455. +    if(info->type != PORT_UNKNOWN)
  27456. +        request_region(info->port,8,"serial(set)");
  27457. +
  27458. +    
  27459. +check_and_exit:
  27460. +    if (!info->port || !info->type)
  27461. +        return 0;
  27462. +    if (info->flags & ASYNC_INITIALIZED) {
  27463. +        if (((old_info.flags & ASYNC_SPD_MASK) !=
  27464. +             (info->flags & ASYNC_SPD_MASK)) ||
  27465. +            (old_info.custom_divisor != info->custom_divisor))
  27466. +            change_speed(info);
  27467. +    } else
  27468. +        retval = startup(info);
  27469. +    return retval;
  27470. +}
  27471. +
  27472. +
  27473. +/*
  27474. + * get_lsr_info - get line status register info
  27475. + *
  27476. + * Purpose: Let user call ioctl() to get info when the UART physically
  27477. + *         is emptied.  On bus types like RS485, the transmitter must
  27478. + *         release the bus after transmitting. This must be done when
  27479. + *         the transmit shift register is empty, not be done when the
  27480. + *         transmit holding register is empty.  This functionality
  27481. + *         allows an RS485 driver to be written in user space. 
  27482. + */
  27483. +static int get_lsr_info(struct async_struct * info, unsigned int *value)
  27484. +{
  27485. +    unsigned char status;
  27486. +    unsigned int result;
  27487. +
  27488. +    cli();
  27489. +    status = serial_in(info, UART_LSR);
  27490. +    sti();
  27491. +    result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0);
  27492. +    put_user(result,value);
  27493. +    return 0;
  27494. +}
  27495. +
  27496. +
  27497. +static int get_modem_info(struct async_struct * info, unsigned int *value)
  27498. +{
  27499. +    unsigned char control, status;
  27500. +    unsigned int result;
  27501. +
  27502. +    control = info->MCR;
  27503. +    cli();
  27504. +    status = serial_in(info, UART_MSR);
  27505. +    sti();
  27506. +    result =  ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
  27507. +        | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
  27508. +        | ((status  & UART_MSR_DCD) ? TIOCM_CAR : 0)
  27509. +        | ((status  & UART_MSR_RI) ? TIOCM_RNG : 0)
  27510. +        | ((status  & UART_MSR_DSR) ? TIOCM_DSR : 0)
  27511. +        | ((status  & UART_MSR_CTS) ? TIOCM_CTS : 0);
  27512. +    put_user(result,value);
  27513. +    return 0;
  27514. +}
  27515. +
  27516. +static int set_modem_info(struct async_struct * info, unsigned int cmd,
  27517. +              unsigned int *value)
  27518. +{
  27519. +    int error;
  27520. +    unsigned int arg;
  27521. +
  27522. +    error = verify_area(VERIFY_READ, value, sizeof(int));
  27523. +    if (error)
  27524. +        return error;
  27525. +    arg = get_user(value);
  27526. +    switch (cmd) {
  27527. +    case TIOCMBIS: 
  27528. +        if (arg & TIOCM_RTS) {
  27529. +            info->MCR |= UART_MCR_RTS;
  27530. +            info->MCR_noint |= UART_MCR_RTS;
  27531. +        }
  27532. +        if (arg & TIOCM_DTR) {
  27533. +            info->MCR |= UART_MCR_DTR;
  27534. +            info->MCR_noint |= UART_MCR_DTR;
  27535. +        }
  27536. +        break;
  27537. +    case TIOCMBIC:
  27538. +        if (arg & TIOCM_RTS) {
  27539. +            info->MCR &= ~UART_MCR_RTS;
  27540. +            info->MCR_noint &= ~UART_MCR_RTS;
  27541. +        }
  27542. +        if (arg & TIOCM_DTR) {
  27543. +            info->MCR &= ~UART_MCR_DTR;
  27544. +            info->MCR_noint &= ~UART_MCR_DTR;
  27545. +        }
  27546. +        break;
  27547. +    case TIOCMSET:
  27548. +        info->MCR = ((info->MCR & ~(UART_MCR_RTS | UART_MCR_DTR))
  27549. +                 | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
  27550. +                 | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  27551. +        info->MCR_noint = ((info->MCR_noint
  27552. +                    & ~(UART_MCR_RTS | UART_MCR_DTR))
  27553. +                   | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
  27554. +                   | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  27555. +        break;
  27556. +    default:
  27557. +        return -EINVAL;
  27558. +    }
  27559. +    cli();
  27560. +    serial_out(info, UART_MCR, info->MCR);
  27561. +    sti();
  27562. +    return 0;
  27563. +}
  27564. +
  27565. +static int do_autoconfig(struct async_struct * info)
  27566. +{
  27567. +    int            retval;
  27568. +    
  27569. +    if (!suser())
  27570. +        return -EPERM;
  27571. +    
  27572. +    if (info->count > 1)
  27573. +        return -EBUSY;
  27574. +    
  27575. +    shutdown(info);
  27576. +
  27577. +    cli();
  27578. +    autoconfig(info);
  27579. +    sti();
  27580. +
  27581. +    retval = startup(info);
  27582. +    if (retval)
  27583. +        return retval;
  27584. +    return 0;
  27585. +}
  27586. +
  27587. +
  27588. +/*
  27589. + * This routine sends a break character out the serial port.
  27590. + */
  27591. +static void send_break(    struct async_struct * info, int duration)
  27592. +{
  27593. +    if (!info->port)
  27594. +        return;
  27595. +    current->state = TASK_INTERRUPTIBLE;
  27596. +    current->timeout = jiffies + duration;
  27597. +    cli();
  27598. +    serial_out(info, UART_LCR, serial_inp(info, UART_LCR) | UART_LCR_SBC);
  27599. +    schedule();
  27600. +    serial_out(info, UART_LCR, serial_inp(info, UART_LCR) & ~UART_LCR_SBC);
  27601. +    sti();
  27602. +}
  27603. +
  27604. +/*
  27605. + * This routine returns a bitfield of "wild interrupts".  Basically,
  27606. + * any unclaimed interrupts which is flapping around.
  27607. + */
  27608. +static int check_wild_interrupts(int doprint)
  27609. +{
  27610. +    int    i, mask;
  27611. +    int    wild_interrupts = 0;
  27612. +    int    irq_lines;
  27613. +    unsigned long timeout;
  27614. +    unsigned long flags;
  27615. +    
  27616. +    /* Turn on interrupts (they may be off) */
  27617. +    save_flags(flags); sti();
  27618. +
  27619. +    irq_lines = grab_all_interrupts(0);
  27620. +    
  27621. +    /*
  27622. +     * Delay for 0.1 seconds -- we use a busy loop since this may 
  27623. +     * occur during the bootup sequence
  27624. +     */
  27625. +    timeout = jiffies+HZ/10;
  27626. +    while (timeout >= jiffies)
  27627. +        ;
  27628. +    
  27629. +    rs_triggered = 0;    /* Reset after letting things settle */
  27630. +
  27631. +    timeout = jiffies+HZ/10;
  27632. +    while (timeout >= jiffies)
  27633. +        ;
  27634. +    
  27635. +    for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
  27636. +        if ((rs_triggered & (1 << i)) &&
  27637. +            (irq_lines & (1 << i))) {
  27638. +            wild_interrupts |= mask;
  27639. +            if (doprint)
  27640. +                printk("Wild interrupt?  (IRQ %d)\n", i);
  27641. +        }
  27642. +    }
  27643. +    free_all_interrupts(irq_lines);
  27644. +    restore_flags(flags);
  27645. +    return wild_interrupts;
  27646. +}
  27647. +
  27648. +static int get_multiport_struct(struct async_struct * info,
  27649. +                struct serial_multiport_struct *retinfo)
  27650. +{
  27651. +    struct serial_multiport_struct ret;
  27652. +    struct rs_multiport_struct *multi;
  27653. +    
  27654. +    multi = &rs_multiport[info->irq];
  27655. +
  27656. +    ret.port_monitor = multi->port_monitor;
  27657. +    
  27658. +    ret.port1 = multi->port1;
  27659. +    ret.mask1 = multi->mask1;
  27660. +    ret.match1 = multi->match1;
  27661. +    
  27662. +    ret.port2 = multi->port2;
  27663. +    ret.mask2 = multi->mask2;
  27664. +    ret.match2 = multi->match2;
  27665. +    
  27666. +    ret.port3 = multi->port3;
  27667. +    ret.mask3 = multi->mask3;
  27668. +    ret.match3 = multi->match3;
  27669. +    
  27670. +    ret.port4 = multi->port4;
  27671. +    ret.mask4 = multi->mask4;
  27672. +    ret.match4 = multi->match4;
  27673. +
  27674. +    ret.irq = info->irq;
  27675. +
  27676. +    memcpy_tofs(retinfo,&ret,sizeof(*retinfo));
  27677. +    return 0;
  27678. +    
  27679. +}
  27680. +
  27681. +static int set_multiport_struct(struct async_struct * info,
  27682. +                struct serial_multiport_struct *in_multi)
  27683. +{
  27684. +    struct serial_multiport_struct new_multi;
  27685. +    struct rs_multiport_struct *multi;
  27686. +    int    was_multi, now_multi;
  27687. +    int    retval;
  27688. +    void (*handler)(int, void *, struct pt_regs *);
  27689. +
  27690. +    if (!suser())
  27691. +        return -EPERM;
  27692. +    if (!in_multi)
  27693. +        return -EFAULT;
  27694. +    memcpy_fromfs(&new_multi, in_multi,
  27695. +              sizeof(struct serial_multiport_struct));
  27696. +
  27697. +    if (new_multi.irq != info->irq || info->irq == 0 ||
  27698. +        !IRQ_ports[info->irq])
  27699. +        return -EINVAL;
  27700. +
  27701. +    multi = &rs_multiport[info->irq];
  27702. +    was_multi = (multi->port1 != 0);
  27703. +    
  27704. +    multi->port_monitor = new_multi.port_monitor;
  27705. +    
  27706. +    if (multi->port1)
  27707. +        release_region(multi->port1,1);
  27708. +    multi->port1 = new_multi.port1;
  27709. +    multi->mask1 = new_multi.mask1;
  27710. +    multi->match1 = new_multi.match1;
  27711. +    if (multi->port1)
  27712. +        request_region(multi->port1,1,"serial(multiport1)");
  27713. +
  27714. +    if (multi->port2)
  27715. +        release_region(multi->port2,1);
  27716. +    multi->port2 = new_multi.port2;
  27717. +    multi->mask2 = new_multi.mask2;
  27718. +    multi->match2 = new_multi.match2;
  27719. +    if (multi->port2)
  27720. +        request_region(multi->port2,1,"serial(multiport2)");
  27721. +
  27722. +    if (multi->port3)
  27723. +        release_region(multi->port3,1);
  27724. +    multi->port3 = new_multi.port3;
  27725. +    multi->mask3 = new_multi.mask3;
  27726. +    multi->match3 = new_multi.match3;
  27727. +    if (multi->port3)
  27728. +        request_region(multi->port3,1,"serial(multiport3)");
  27729. +
  27730. +    if (multi->port4)
  27731. +        release_region(multi->port4,1);
  27732. +    multi->port4 = new_multi.port4;
  27733. +    multi->mask4 = new_multi.mask4;
  27734. +    multi->match4 = new_multi.match4;
  27735. +    if (multi->port4)
  27736. +        request_region(multi->port4,1,"serial(multiport4)");
  27737. +
  27738. +    now_multi = (multi->port1 != 0);
  27739. +    
  27740. +    if (IRQ_ports[info->irq]->next_port &&
  27741. +        (was_multi != now_multi)) {
  27742. +        free_irq(info->irq, NULL);
  27743. +        if (now_multi)
  27744. +            handler = rs_interrupt_multi;
  27745. +        else
  27746. +            handler = rs_interrupt;
  27747. +
  27748. +        retval = request_irq(info->irq, handler, IRQ_T(info),
  27749. +                     "serial", NULL);
  27750. +        if (retval) {
  27751. +            printk("Couldn't reallocate serial interrupt "
  27752. +                   "driver!!\n");
  27753. +        }
  27754. +    }
  27755. +
  27756. +    return 0;
  27757. +}
  27758. +
  27759. +static int rs_ioctl(struct tty_struct *tty, struct file * file,
  27760. +            unsigned int cmd, unsigned long arg)
  27761. +{
  27762. +    int error;
  27763. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  27764. +    int retval;
  27765. +    struct async_icount cprev, cnow;    /* kernel counter temps */
  27766. +    struct serial_icounter_struct *p_cuser;    /* user space */
  27767. +
  27768. +    if (serial_paranoia_check(info, tty->device, "rs_ioctl"))
  27769. +        return -ENODEV;
  27770. +
  27771. +    if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
  27772. +        (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
  27773. +        (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT) &&
  27774. +        (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
  27775. +        if (tty->flags & (1 << TTY_IO_ERROR))
  27776. +            return -EIO;
  27777. +    }
  27778. +    
  27779. +    switch (cmd) {
  27780. +        case TCSBRK:    /* SVID version: non-zero arg --> no break */
  27781. +            retval = tty_check_change(tty);
  27782. +            if (retval)
  27783. +                return retval;
  27784. +            tty_wait_until_sent(tty, 0);
  27785. +            if (!arg)
  27786. +                send_break(info, HZ/4);    /* 1/4 second */
  27787. +            return 0;
  27788. +        case TCSBRKP:    /* support for POSIX tcsendbreak() */
  27789. +            retval = tty_check_change(tty);
  27790. +            if (retval)
  27791. +                return retval;
  27792. +            tty_wait_until_sent(tty, 0);
  27793. +            send_break(info, arg ? arg*(HZ/10) : HZ/4);
  27794. +            return 0;
  27795. +        case TIOCGSOFTCAR:
  27796. +            error = verify_area(VERIFY_WRITE, (void *) arg,sizeof(long));
  27797. +            if (error)
  27798. +                return error;
  27799. +            put_fs_long(C_CLOCAL(tty) ? 1 : 0,
  27800. +                    (unsigned long *) arg);
  27801. +            return 0;
  27802. +        case TIOCSSOFTCAR:
  27803. +            error = verify_area(VERIFY_READ, (void *) arg,sizeof(long));
  27804. +            if (error)
  27805. +                return error;
  27806. +            arg = get_fs_long((unsigned long *) arg);
  27807. +            tty->termios->c_cflag =
  27808. +                ((tty->termios->c_cflag & ~CLOCAL) |
  27809. +                 (arg ? CLOCAL : 0));
  27810. +            return 0;
  27811. +        case TIOCMGET:
  27812. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  27813. +                sizeof(unsigned int));
  27814. +            if (error)
  27815. +                return error;
  27816. +            return get_modem_info(info, (unsigned int *) arg);
  27817. +        case TIOCMBIS:
  27818. +        case TIOCMBIC:
  27819. +        case TIOCMSET:
  27820. +            return set_modem_info(info, cmd, (unsigned int *) arg);
  27821. +        case TIOCGSERIAL:
  27822. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  27823. +                        sizeof(struct serial_struct));
  27824. +            if (error)
  27825. +                return error;
  27826. +            return get_serial_info(info,
  27827. +                           (struct serial_struct *) arg);
  27828. +        case TIOCSSERIAL:
  27829. +            error = verify_area(VERIFY_READ, (void *) arg,
  27830. +                        sizeof(struct serial_struct));
  27831. +            if (error)
  27832. +                return error; 
  27833. +            return set_serial_info(info,
  27834. +                           (struct serial_struct *) arg);
  27835. +        case TIOCSERCONFIG:
  27836. +            return do_autoconfig(info);
  27837. +
  27838. +        case TIOCSERGWILD:
  27839. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  27840. +                        sizeof(int));
  27841. +            if (error)
  27842. +                return error;
  27843. +            put_fs_long(rs_wild_int_mask, (unsigned long *) arg);
  27844. +            return 0;
  27845. +
  27846. +        case TIOCSERGETLSR: /* Get line status register */
  27847. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  27848. +                sizeof(unsigned int));
  27849. +            if (error)
  27850. +                return error;
  27851. +            else
  27852. +                return get_lsr_info(info, (unsigned int *) arg);
  27853. +
  27854. +        case TIOCSERSWILD:
  27855. +            if (!suser())
  27856. +                return -EPERM;
  27857. +            error = verify_area(VERIFY_READ, (void *) arg,sizeof(long));
  27858. +            if (error)
  27859. +                return error;
  27860. +            rs_wild_int_mask = get_fs_long((unsigned long *) arg);
  27861. +            if (rs_wild_int_mask < 0)
  27862. +                rs_wild_int_mask = check_wild_interrupts(0);
  27863. +            return 0;
  27864. +
  27865. +        case TIOCSERGSTRUCT:
  27866. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  27867. +                        sizeof(struct async_struct));
  27868. +            if (error)
  27869. +                return error;
  27870. +            memcpy_tofs((struct async_struct *) arg,
  27871. +                    info, sizeof(struct async_struct));
  27872. +            return 0;
  27873. +            
  27874. +        case TIOCSERGETMULTI:
  27875. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  27876. +                    sizeof(struct serial_multiport_struct));
  27877. +            if (error)
  27878. +                return error;
  27879. +            return get_multiport_struct(info,
  27880. +                       (struct serial_multiport_struct *) arg);
  27881. +        case TIOCSERSETMULTI:
  27882. +            error = verify_area(VERIFY_READ, (void *) arg,
  27883. +                    sizeof(struct serial_multiport_struct));
  27884. +            if (error)
  27885. +                return error;
  27886. +            return set_multiport_struct(info,
  27887. +                       (struct serial_multiport_struct *) arg);
  27888. +        /*
  27889. +         * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
  27890. +         * - mask passed in arg for lines of interest
  27891. +         *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
  27892. +         * Caller should use TIOCGICOUNT to see which one it was
  27893. +         */
  27894. +        case TIOCMIWAIT:
  27895. +            cli();
  27896. +            cprev = info->icount;    /* note the counters on entry */
  27897. +            sti();
  27898. +            while (1) {
  27899. +                interruptible_sleep_on(&info->delta_msr_wait);
  27900. +                /* see if a signal did it */
  27901. +                if (current->signal & ~current->blocked)
  27902. +                    return -ERESTARTSYS;
  27903. +                cli();
  27904. +                cnow = info->icount;    /* atomic copy */
  27905. +                sti();
  27906. +                if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
  27907. +                    cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
  27908. +                    return -EIO; /* no change => error */
  27909. +                if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
  27910. +                     ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
  27911. +                     ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
  27912. +                     ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
  27913. +                    return 0;
  27914. +                }
  27915. +                cprev = cnow;
  27916. +            }
  27917. +            /* NOTREACHED */
  27918. +
  27919. +        /*
  27920. +         * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
  27921. +         * Return: write counters to the user passed counter struct
  27922. +         * NB: both 1->0 and 0->1 transitions are counted except for
  27923. +         *     RI where only 0->1 is counted.
  27924. +         */
  27925. +        case TIOCGICOUNT:
  27926. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  27927. +                sizeof(struct serial_icounter_struct));
  27928. +            if (error)
  27929. +                return error;
  27930. +            cli();
  27931. +            cnow = info->icount;
  27932. +            sti();
  27933. +            p_cuser = (struct serial_icounter_struct *) arg;
  27934. +            put_user(cnow.cts, &p_cuser->cts);
  27935. +            put_user(cnow.dsr, &p_cuser->dsr);
  27936. +            put_user(cnow.rng, &p_cuser->rng);
  27937. +            put_user(cnow.dcd, &p_cuser->dcd);
  27938. +            return 0;
  27939. +
  27940. +        default:
  27941. +            return -ENOIOCTLCMD;
  27942. +        }
  27943. +    return 0;
  27944. +}
  27945. +
  27946. +static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
  27947. +{
  27948. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  27949. +
  27950. +    if (   (tty->termios->c_cflag == old_termios->c_cflag)
  27951. +        && (   RELEVANT_IFLAG(tty->termios->c_iflag)
  27952. +            == RELEVANT_IFLAG(old_termios->c_iflag)))
  27953. +      return;
  27954. +
  27955. +    change_speed(info);
  27956. +
  27957. +    if ((old_termios->c_cflag & CRTSCTS) &&
  27958. +        !(tty->termios->c_cflag & CRTSCTS)) {
  27959. +        tty->hw_stopped = 0;
  27960. +        rs_start(tty);
  27961. +    }
  27962. +
  27963. +#if 0
  27964. +    /*
  27965. +     * No need to wake up processes in open wait, since they
  27966. +     * sample the CLOCAL flag once, and don't recheck it.
  27967. +     * XXX  It's not clear whether the current behavior is correct
  27968. +     * or not.  Hence, this may change.....
  27969. +     */
  27970. +    if (!(old_termios->c_cflag & CLOCAL) &&
  27971. +        (tty->termios->c_cflag & CLOCAL))
  27972. +        wake_up_interruptible(&info->open_wait);
  27973. +#endif
  27974. +}
  27975. +
  27976. +/*
  27977. + * ------------------------------------------------------------
  27978. + * rs_close()
  27979. + * 
  27980. + * This routine is called when the serial port gets closed.  First, we
  27981. + * wait for the last remaining data to be sent.  Then, we unlink its
  27982. + * async structure from the interrupt chain if necessary, and we free
  27983. + * that IRQ if nothing is left in the chain.
  27984. + * ------------------------------------------------------------
  27985. + */
  27986. +static void rs_close(struct tty_struct *tty, struct file * filp)
  27987. +{
  27988. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  27989. +    unsigned long flags;
  27990. +    unsigned long timeout;
  27991. +
  27992. +    if (!info || serial_paranoia_check(info, tty->device, "rs_close"))
  27993. +        return;
  27994. +    
  27995. +    save_flags_cli (flags);
  27996. +    
  27997. +    if (tty_hung_up_p(filp)) {
  27998. +        DBG_CNT("before DEC-hung");
  27999. +        MOD_DEC_USE_COUNT;
  28000. +        restore_flags(flags);
  28001. +        return;
  28002. +    }
  28003. +    
  28004. +#ifdef SERIAL_DEBUG_OPEN
  28005. +    printk("rs_close ttys%d, count = %d\n", info->line, info->count);
  28006. +#endif
  28007. +    if ((tty->count == 1) && (info->count != 1)) {
  28008. +        /*
  28009. +         * Uh, oh.  tty->count is 1, which means that the tty
  28010. +         * structure will be freed.  Info->count should always
  28011. +         * be one in these conditions.  If it's greater than
  28012. +         * one, we've got real problems, since it means the
  28013. +         * serial port won't be shutdown.
  28014. +         */
  28015. +        printk("rs_close: bad serial port count; tty->count is 1, "
  28016. +               "info->count is %d\n", info->count);
  28017. +        info->count = 1;
  28018. +    }
  28019. +    if (--info->count < 0) {
  28020. +        printk("rs_close: bad serial port count for ttys%d: %d\n",
  28021. +               info->line, info->count);
  28022. +        info->count = 0;
  28023. +    }
  28024. +    if (info->count) {
  28025. +        DBG_CNT("before DEC-2");
  28026. +        MOD_DEC_USE_COUNT;
  28027. +        restore_flags(flags);
  28028. +        return;
  28029. +    }
  28030. +    info->flags |= ASYNC_CLOSING;
  28031. +    /*
  28032. +     * Save the termios structure, since this port may have
  28033. +     * separate termios for callout and dialin.
  28034. +     */
  28035. +    if (info->flags & ASYNC_NORMAL_ACTIVE)
  28036. +        info->normal_termios = *tty->termios;
  28037. +    if (info->flags & ASYNC_CALLOUT_ACTIVE)
  28038. +        info->callout_termios = *tty->termios;
  28039. +    /*
  28040. +     * Now we wait for the transmit buffer to clear; and we notify 
  28041. +     * the line discipline to only process XON/XOFF characters.
  28042. +     */
  28043. +    tty->closing = 1;
  28044. +    if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  28045. +        tty_wait_until_sent(tty, info->closing_wait);
  28046. +    /*
  28047. +     * At this point we stop accepting input.  To do this, we
  28048. +     * disable the receive line status interrupts, and tell the
  28049. +     * interrupt driver to stop checking the data ready bit in the
  28050. +     * line status register.
  28051. +     */
  28052. +    info->IER &= ~UART_IER_RLSI;
  28053. +    info->read_status_mask &= ~UART_LSR_DR;
  28054. +    if (info->flags & ASYNC_INITIALIZED) {
  28055. +        serial_out(info, UART_IER, info->IER);
  28056. +        /*
  28057. +         * Before we drop DTR, make sure the UART transmitter
  28058. +         * has completely drained; this is especially
  28059. +         * important if there is a transmit FIFO!
  28060. +         */
  28061. +        timeout = jiffies+HZ;
  28062. +        while (!(serial_inp(info, UART_LSR) & UART_LSR_TEMT)) {
  28063. +            current->state = TASK_INTERRUPTIBLE;
  28064. +            current->timeout = jiffies + info->timeout;
  28065. +            schedule();
  28066. +            if (jiffies > timeout)
  28067. +                break;
  28068. +        }
  28069. +    }
  28070. +    shutdown(info);
  28071. +    if (tty->driver.flush_buffer)
  28072. +        tty->driver.flush_buffer(tty);
  28073. +    if (tty->ldisc.flush_buffer)
  28074. +        tty->ldisc.flush_buffer(tty);
  28075. +    tty->closing = 0;
  28076. +    info->event = 0;
  28077. +    info->tty = 0;
  28078. +    if (info->blocked_open) {
  28079. +        if (info->close_delay) {
  28080. +            current->state = TASK_INTERRUPTIBLE;
  28081. +            current->timeout = jiffies + info->close_delay;
  28082. +            schedule();
  28083. +        }
  28084. +        wake_up_interruptible(&info->open_wait);
  28085. +    }
  28086. +    info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  28087. +             ASYNC_CLOSING);
  28088. +    wake_up_interruptible(&info->close_wait);
  28089. +    MOD_DEC_USE_COUNT;
  28090. +    restore_flags(flags);
  28091. +}
  28092. +
  28093. +/*
  28094. + * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
  28095. + */
  28096. +void rs_hangup(struct tty_struct *tty)
  28097. +{
  28098. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  28099. +    
  28100. +    if (serial_paranoia_check(info, tty->device, "rs_hangup"))
  28101. +        return;
  28102. +    
  28103. +    rs_flush_buffer(tty);
  28104. +    shutdown(info);
  28105. +    info->event = 0;
  28106. +    info->count = 0;
  28107. +    info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  28108. +    info->tty = 0;
  28109. +    wake_up_interruptible(&info->open_wait);
  28110. +}
  28111. +
  28112. +/*
  28113. + * ------------------------------------------------------------
  28114. + * rs_open() and friends
  28115. + * ------------------------------------------------------------
  28116. + */
  28117. +static int block_til_ready(struct tty_struct *tty, struct file * filp,
  28118. +               struct async_struct *info)
  28119. +{
  28120. +    struct wait_queue wait = { current, NULL };
  28121. +    int        retval;
  28122. +    int        do_clocal = 0;
  28123. +
  28124. +    /*
  28125. +     * If the device is in the middle of being closed, then block
  28126. +     * until it's done, and then try again.
  28127. +     */
  28128. +    if (tty_hung_up_p(filp) ||
  28129. +        (info->flags & ASYNC_CLOSING)) {
  28130. +            if (info->flags & ASYNC_CLOSING)
  28131. +                interruptible_sleep_on(&info->close_wait);
  28132. +#ifdef SERIAL_DO_RESTART
  28133. +        if (info->flags & ASYNC_HUP_NOTIFY)
  28134. +            return -EAGAIN;
  28135. +        else
  28136. +            return -ERESTARTSYS;
  28137. +#else
  28138. +        return -EAGAIN;
  28139. +#endif
  28140. +    }
  28141. +
  28142. +    /*
  28143. +     * If this is a callout device, then just make sure the normal
  28144. +     * device isn't being used.
  28145. +     */
  28146. +    if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  28147. +        if (info->flags & ASYNC_NORMAL_ACTIVE)
  28148. +            return -EBUSY;
  28149. +        if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  28150. +            (info->flags & ASYNC_SESSION_LOCKOUT) &&
  28151. +            (info->session != current->session))
  28152. +            return -EBUSY;
  28153. +        if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  28154. +            (info->flags & ASYNC_PGRP_LOCKOUT) &&
  28155. +            (info->pgrp != current->pgrp))
  28156. +            return -EBUSY;
  28157. +        info->flags |= ASYNC_CALLOUT_ACTIVE;
  28158. +        return 0;
  28159. +    }
  28160. +    
  28161. +    /*
  28162. +     * If non-blocking mode is set, or the port is not enabled,
  28163. +     * then make the check up front and then exit.
  28164. +     */
  28165. +    if ((filp->f_flags & O_NONBLOCK) ||
  28166. +        (tty->flags & (1 << TTY_IO_ERROR))) {
  28167. +        if (info->flags & ASYNC_CALLOUT_ACTIVE)
  28168. +            return -EBUSY;
  28169. +        info->flags |= ASYNC_NORMAL_ACTIVE;
  28170. +        return 0;
  28171. +    }
  28172. +
  28173. +    if (info->flags & ASYNC_CALLOUT_ACTIVE) {
  28174. +        if (info->normal_termios.c_cflag & CLOCAL)
  28175. +            do_clocal = 1;
  28176. +    } else {
  28177. +        if (tty->termios->c_cflag & CLOCAL)
  28178. +            do_clocal = 1;
  28179. +    }
  28180. +    
  28181. +    /*
  28182. +     * Block waiting for the carrier detect and the line to become
  28183. +     * free (i.e., not in use by the callout).  While we are in
  28184. +     * this loop, info->count is dropped by one, so that
  28185. +     * rs_close() knows when to free things.  We restore it upon
  28186. +     * exit, either normal or abnormal.
  28187. +     */
  28188. +    retval = 0;
  28189. +    add_wait_queue(&info->open_wait, &wait);
  28190. +#ifdef SERIAL_DEBUG_OPEN
  28191. +    printk("block_til_ready before block: ttys%d, count = %d\n",
  28192. +           info->line, info->count);
  28193. +#endif
  28194. +    cli();
  28195. +    if (!tty_hung_up_p(filp))
  28196. +        info->count--;
  28197. +    sti();
  28198. +    info->blocked_open++;
  28199. +    while (1) {
  28200. +        cli();
  28201. +        if (!(info->flags & ASYNC_CALLOUT_ACTIVE))
  28202. +            serial_out(info, UART_MCR,
  28203. +                   serial_inp(info, UART_MCR) |
  28204. +                   (UART_MCR_DTR | UART_MCR_RTS));
  28205. +        sti();
  28206. +        current->state = TASK_INTERRUPTIBLE;
  28207. +        if (tty_hung_up_p(filp) ||
  28208. +            !(info->flags & ASYNC_INITIALIZED)) {
  28209. +#ifdef SERIAL_DO_RESTART
  28210. +            if (info->flags & ASYNC_HUP_NOTIFY)
  28211. +                retval = -EAGAIN;
  28212. +            else
  28213. +                retval = -ERESTARTSYS;    
  28214. +#else
  28215. +            retval = -EAGAIN;
  28216. +#endif
  28217. +            break;
  28218. +        }
  28219. +        if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  28220. +            !(info->flags & ASYNC_CLOSING) &&
  28221. +            (do_clocal || (serial_in(info, UART_MSR) &
  28222. +                   UART_MSR_DCD)))
  28223. +            break;
  28224. +        if (current->signal & ~current->blocked) {
  28225. +            retval = -ERESTARTSYS;
  28226. +            break;
  28227. +        }
  28228. +#ifdef SERIAL_DEBUG_OPEN
  28229. +        printk("block_til_ready blocking: ttys%d, count = %d\n",
  28230. +               info->line, info->count);
  28231. +#endif
  28232. +        schedule();
  28233. +    }
  28234. +    current->state = TASK_RUNNING;
  28235. +    remove_wait_queue(&info->open_wait, &wait);
  28236. +    if (!tty_hung_up_p(filp))
  28237. +        info->count++;
  28238. +    info->blocked_open--;
  28239. +#ifdef SERIAL_DEBUG_OPEN
  28240. +    printk("block_til_ready after blocking: ttys%d, count = %d\n",
  28241. +           info->line, info->count);
  28242. +#endif
  28243. +    if (retval)
  28244. +        return retval;
  28245. +    info->flags |= ASYNC_NORMAL_ACTIVE;
  28246. +    return 0;
  28247. +}    
  28248. +
  28249. +/*
  28250. + * This routine is called whenever a serial port is opened.  It
  28251. + * enables interrupts for a serial port, linking in its async structure into
  28252. + * the IRQ chain.   It also performs the serial-specific
  28253. + * initialization for the tty structure.
  28254. + */
  28255. +int rs_open(struct tty_struct *tty, struct file * filp)
  28256. +{
  28257. +    struct async_struct    *info;
  28258. +    int             retval, line;
  28259. +    unsigned long        page;
  28260. +
  28261. +    line = MINOR(tty->device) - tty->driver.minor_start;
  28262. +    if ((line < 0) || (line >= NR_PORTS))
  28263. +        return -ENODEV;
  28264. +    info = rs_table + line;
  28265. +    if (serial_paranoia_check(info, tty->device, "rs_open"))
  28266. +        return -ENODEV;
  28267. +
  28268. +#ifdef SERIAL_DEBUG_OPEN
  28269. +    printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
  28270. +           info->count);
  28271. +#endif
  28272. +    info->count++;
  28273. +    tty->driver_data = info;
  28274. +    info->tty = tty;
  28275. +
  28276. +    if (!tmp_buf) {
  28277. +        page = get_free_page(GFP_KERNEL);
  28278. +        if (!page)
  28279. +            return -ENOMEM;
  28280. +        if (tmp_buf)
  28281. +            free_page(page);
  28282. +        else
  28283. +            tmp_buf = (unsigned char *) page;
  28284. +    }
  28285. +    
  28286. +    /*
  28287. +     * Start up serial port
  28288. +     */
  28289. +    retval = startup(info);
  28290. +    if (retval)
  28291. +        return retval;
  28292. +
  28293. +    MOD_INC_USE_COUNT;
  28294. +    retval = block_til_ready(tty, filp, info);
  28295. +    if (retval) {
  28296. +#ifdef SERIAL_DEBUG_OPEN
  28297. +        printk("rs_open returning after block_til_ready with %d\n",
  28298. +               retval);
  28299. +#endif
  28300. +        return retval;
  28301. +    }
  28302. +
  28303. +    if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
  28304. +        if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  28305. +            *tty->termios = info->normal_termios;
  28306. +        else 
  28307. +            *tty->termios = info->callout_termios;
  28308. +        change_speed(info);
  28309. +    }
  28310. +
  28311. +    info->session = current->session;
  28312. +    info->pgrp = current->pgrp;
  28313. +
  28314. +#ifdef SERIAL_DEBUG_OPEN
  28315. +    printk("rs_open ttys%d successful...", info->line);
  28316. +#endif
  28317. +    return 0;
  28318. +}
  28319. +
  28320. +/*
  28321. + * ---------------------------------------------------------------------
  28322. + * rs_init() and friends
  28323. + *
  28324. + * rs_init() is called at boot-time to initialize the serial driver.
  28325. + * ---------------------------------------------------------------------
  28326. + */
  28327. +
  28328. +/*
  28329. + * This routine prints out the appropriate serial driver version
  28330. + * number, and identifies which options were configured into this
  28331. + * driver.
  28332. + */
  28333. +static void show_serial_version(void)
  28334. +{
  28335. +    printk(KERN_INFO "%s version %s with", serial_name, serial_version);
  28336. +#ifdef CONFIG_HUB6
  28337. +    printk(" HUB-6");
  28338. +#define SERIAL_OPT
  28339. +#endif
  28340. +#ifdef SERIAL_OPT
  28341. +    printk(" enabled\n");
  28342. +#else
  28343. +    printk(" no serial options enabled\n");
  28344. +#endif
  28345. +#undef SERIAL_OPT
  28346. +}
  28347. +
  28348. +/*
  28349. + * This routine is called by do_auto_irq(); it attempts to determine
  28350. + * which interrupt a serial port is configured to use.  It is not
  28351. + * fool-proof, but it works a large part of the time.
  28352. + */
  28353. +static int get_auto_irq(struct async_struct *info)
  28354. +{
  28355. +    unsigned char save_MCR, save_IER, save_ICP=0;
  28356. +    unsigned short ICP=0, port = info->port;
  28357. +    unsigned long timeout;
  28358. +    
  28359. +    /*
  28360. +     * Enable interrupts and see who answers
  28361. +     */
  28362. +    rs_irq_triggered = 0;
  28363. +    cli();
  28364. +    save_IER = serial_inp(info, UART_IER);
  28365. +    save_MCR = serial_inp(info, UART_MCR);
  28366. +    if (info->flags & ASYNC_FOURPORT)  {
  28367. +        serial_outp(info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
  28368. +        serial_outp(info, UART_IER, 0x0f);    /* enable all intrs */
  28369. +        ICP = (port & 0xFE0) | 0x01F;
  28370. +        save_ICP = inb_p(ICP);
  28371. +        outb_p(0x80, ICP);
  28372. +        (void) inb_p(ICP);
  28373. +    } else {
  28374. +        serial_outp(info, UART_MCR,
  28375. +                UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
  28376. +        serial_outp(info, UART_IER, 0x0f);    /* enable all intrs */
  28377. +    }
  28378. +    sti();
  28379. +    /*
  28380. +     * Next, clear the interrupt registers.
  28381. +     */
  28382. +    (void)serial_inp(info, UART_LSR);
  28383. +    (void)serial_inp(info, UART_RX);
  28384. +    (void)serial_inp(info, UART_IIR);
  28385. +    (void)serial_inp(info, UART_MSR);
  28386. +    
  28387. +    timeout = jiffies+2*HZ/100;
  28388. +    while (timeout >= jiffies) {
  28389. +        if (rs_irq_triggered)
  28390. +            break;
  28391. +    }
  28392. +    /*
  28393. +     * Now check to see if we got any business, and clean up.
  28394. +     */
  28395. +    cli();
  28396. +    serial_outp(info, UART_IER, save_IER);
  28397. +    serial_outp(info, UART_MCR, save_MCR);
  28398. +    if (info->flags & ASYNC_FOURPORT)
  28399. +        outb_p(save_ICP, ICP);
  28400. +    sti();
  28401. +    return(rs_irq_triggered);
  28402. +}
  28403. +
  28404. +/*
  28405. + * Calls get_auto_irq() multiple times, to make sure we don't get
  28406. + * faked out by random interrupts
  28407. + */
  28408. +static int do_auto_irq(struct async_struct * info)
  28409. +{
  28410. +    unsigned         port = info->port;
  28411. +    int             irq_lines = 0;
  28412. +    int            irq_try_1 = 0, irq_try_2 = 0;
  28413. +    int            retries;
  28414. +    unsigned long flags;
  28415. +
  28416. +    if (!port)
  28417. +        return 0;
  28418. +
  28419. +    /* Turn on interrupts (they may be off) */
  28420. +    save_flags(flags); sti();
  28421. +
  28422. +    irq_lines = grab_all_interrupts(rs_wild_int_mask);
  28423. +    
  28424. +    for (retries = 0; retries < 5; retries++) {
  28425. +        if (!irq_try_1)
  28426. +            irq_try_1 = get_auto_irq(info);
  28427. +        if (!irq_try_2)
  28428. +            irq_try_2 = get_auto_irq(info);
  28429. +        if (irq_try_1 && irq_try_2) {
  28430. +            if (irq_try_1 == irq_try_2)
  28431. +                break;
  28432. +            irq_try_1 = irq_try_2 = 0;
  28433. +        }
  28434. +    }
  28435. +    restore_flags(flags);
  28436. +    free_all_interrupts(irq_lines);
  28437. +    return (irq_try_1 == irq_try_2) ? irq_try_1 : 0;
  28438. +}
  28439. +
  28440. +/*
  28441. + * This routine is called by rs_init() to initialize a specific serial
  28442. + * port.  It determines what type of UART chip this serial port is
  28443. + * using: 8250, 16450, 16550, 16550A.  The important question is
  28444. + * whether or not this UART is a 16550A or not, since this will
  28445. + * determine whether or not we can use its FIFO features or not.
  28446. + */
  28447. +static void autoconfig(struct async_struct * info)
  28448. +{
  28449. +    unsigned char status1, status2, scratch, scratch2;
  28450. +    unsigned port = info->port;
  28451. +    unsigned long flags;
  28452. +
  28453. +    info->type = PORT_UNKNOWN;
  28454. +    
  28455. +    if (!port)
  28456. +        return;
  28457. +
  28458. +    save_flags_cli (flags);
  28459. +    
  28460. +    /*
  28461. +     * Do a simple existence test first; if we fail this, there's
  28462. +     * no point trying anything else.
  28463. +     *
  28464. +     * 0x80 is used as a nonsense port to prevent against false
  28465. +     * positives due to ISA bus float.  The assumption is that
  28466. +     * 0x80 is a non-existent port; which should be safe since
  28467. +     * include/asm/io.h also makes this assumption.
  28468. +     */
  28469. +    scratch = serial_inp(info, UART_IER);
  28470. +    serial_outp(info, UART_IER, 0);
  28471. +    outb(0xff, 0x080);
  28472. +    scratch2 = serial_inp(info, UART_IER);
  28473. +    serial_outp(info, UART_IER, scratch);
  28474. +    if (scratch2) {
  28475. +        restore_flags(flags);
  28476. +        return;        /* We failed; there's nothing here */
  28477. +    }
  28478. +
  28479. +    /* 
  28480. +     * Check to see if a UART is really there.  Certain broken
  28481. +     * internal modems based on the Rockwell chipset fail this
  28482. +     * test, because they apparently don't implement the loopback
  28483. +     * test mode.  So this test is skipped on the COM 1 through
  28484. +     * COM 4 ports.  This *should* be safe, since no board
  28485. +     * manufacturer would be stupid enough to design a board
  28486. +     * that conflicts with COM 1-4 --- we hope!
  28487. +     */
  28488. +    if (!(info->flags & ASYNC_SKIP_TEST)) {
  28489. +        scratch = serial_inp(info, UART_MCR);
  28490. +        serial_outp(info, UART_MCR, UART_MCR_LOOP | scratch);
  28491. +        scratch2 = serial_inp(info, UART_MSR);
  28492. +        serial_outp(info, UART_MCR, UART_MCR_LOOP | 0x0A);
  28493. +        status1 = serial_inp(info, UART_MSR) & 0xF0;
  28494. +        serial_outp(info, UART_MCR, scratch);
  28495. +        serial_outp(info, UART_MSR, scratch2);
  28496. +        if (status1 != 0x90) {
  28497. +            restore_flags(flags);
  28498. +            return;
  28499. +        }
  28500. +    } 
  28501. +    
  28502. +    /*
  28503. +     * If the AUTO_IRQ flag is set, try to do the automatic IRQ
  28504. +     * detection.
  28505. +     */
  28506. +    if (info->flags & ASYNC_AUTO_IRQ)
  28507. +        info->irq = do_auto_irq(info);
  28508. +        
  28509. +    scratch2 = serial_in(info, UART_LCR);
  28510. +    serial_outp(info, UART_LCR, scratch2 | UART_LCR_DLAB);
  28511. +    serial_outp(info, UART_EFR, 0);    /* EFR is the same as FCR */
  28512. +    serial_outp(info, UART_LCR, scratch2);
  28513. +    serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO);
  28514. +    scratch = serial_in(info, UART_IIR) >> 6;
  28515. +    info->xmit_fifo_size = 1;
  28516. +    switch (scratch) {
  28517. +        case 0:
  28518. +            info->type = PORT_16450;
  28519. +            break;
  28520. +        case 1:
  28521. +            info->type = PORT_UNKNOWN;
  28522. +            break;
  28523. +        case 2:
  28524. +            info->type = PORT_16550;
  28525. +            break;
  28526. +        case 3:
  28527. +            serial_outp(info, UART_LCR, scratch2 | UART_LCR_DLAB);
  28528. +            if (serial_in(info, UART_EFR) == 0) {
  28529. +                info->type = PORT_16650;
  28530. +                info->xmit_fifo_size = 32;
  28531. +            } else {
  28532. +                info->type = PORT_16550A;
  28533. +                info->xmit_fifo_size = 16;
  28534. +            }
  28535. +            serial_outp(info, UART_LCR, scratch2);
  28536. +            break;
  28537. +    }
  28538. +    if (info->type == PORT_16450) {
  28539. +        scratch = serial_in(info, UART_SCR);
  28540. +        serial_outp(info, UART_SCR, 0xa5);
  28541. +        status1 = serial_in(info, UART_SCR);
  28542. +        serial_outp(info, UART_SCR, 0x5a);
  28543. +        status2 = serial_in(info, UART_SCR);
  28544. +        serial_outp(info, UART_SCR, scratch);
  28545. +
  28546. +        if ((status1 != 0xa5) || (status2 != 0x5a))
  28547. +            info->type = PORT_8250;
  28548. +    }
  28549. +    request_region(info->port,8,"serial(auto)");
  28550. +
  28551. +    /*
  28552. +     * Reset the UART.
  28553. +     */
  28554. +#if defined(__alpha__) && !defined(CONFIG_PCI)
  28555. +    /*
  28556. +     * I wonder what DEC did to the OUT1 and OUT2 lines?
  28557. +     * clearing them results in endless interrupts.
  28558. +     */
  28559. +    serial_outp(info, UART_MCR, 0x0c);
  28560. +#else
  28561. +    serial_outp(info, UART_MCR, 0x00);
  28562. +#endif
  28563. +    serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  28564. +                     UART_FCR_CLEAR_XMIT));
  28565. +    (void)serial_in(info, UART_RX);
  28566. +    
  28567. +    restore_flags(flags);
  28568. +}
  28569. +
  28570. +int register_serial(struct serial_struct *req);
  28571. +void unregister_serial(int line);
  28572. +
  28573. +static struct symbol_table serial_syms = {
  28574. +#include <linux/symtab_begin.h>
  28575. +    X(register_serial),
  28576. +    X(unregister_serial),
  28577. +#include <linux/symtab_end.h>
  28578. +};
  28579. +
  28580. +/*
  28581. + * The serial driver boot-time initialization code!
  28582. + */
  28583. +int rs_init(void)
  28584. +{
  28585. +    int i;
  28586. +    struct async_struct * info;
  28587. +#ifdef CONFIG_ATOMWIDE_SERIAL
  28588. +    extern void atomwide_serial_init (void);
  28589. +
  28590. +    atomwide_serial_init ();
  28591. +#endif
  28592. +    
  28593. +    init_bh(SERIAL_BH, do_serial_bh);
  28594. +    timer_table[RS_TIMER].fn = rs_timer;
  28595. +    timer_table[RS_TIMER].expires = 0;
  28596. +#ifdef CONFIG_AUTO_IRQ
  28597. +    rs_wild_int_mask = check_wild_interrupts(1);
  28598. +#endif
  28599. +
  28600. +    for (i = 0; i < 32; i++) {
  28601. +        IRQ_ports[i] = 0;
  28602. +        IRQ_timeout[i] = 0;
  28603. +        memset(&rs_multiport[i], 0, sizeof(struct rs_multiport_struct));
  28604. +    }
  28605. +    
  28606. +    show_serial_version();
  28607. +
  28608. +    /* Initialize the tty_driver structure */
  28609. +    
  28610. +    memset(&serial_driver, 0, sizeof(struct tty_driver));
  28611. +    serial_driver.magic = TTY_DRIVER_MAGIC;
  28612. +    serial_driver.name = "ttyS";
  28613. +    serial_driver.major = TTY_MAJOR;
  28614. +    serial_driver.minor_start = 64;
  28615. +    serial_driver.num = NR_PORTS;
  28616. +    serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  28617. +    serial_driver.subtype = SERIAL_TYPE_NORMAL;
  28618. +    serial_driver.init_termios = tty_std_termios;
  28619. +    serial_driver.init_termios.c_cflag =
  28620. +        B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  28621. +    serial_driver.flags = TTY_DRIVER_REAL_RAW;
  28622. +    serial_driver.refcount = &serial_refcount;
  28623. +    serial_driver.table = serial_table;
  28624. +    serial_driver.termios = serial_termios;
  28625. +    serial_driver.termios_locked = serial_termios_locked;
  28626. +
  28627. +    serial_driver.open = rs_open;
  28628. +    serial_driver.close = rs_close;
  28629. +    serial_driver.write = rs_write;
  28630. +    serial_driver.put_char = rs_put_char;
  28631. +    serial_driver.flush_chars = rs_flush_chars;
  28632. +    serial_driver.write_room = rs_write_room;
  28633. +    serial_driver.chars_in_buffer = rs_chars_in_buffer;
  28634. +    serial_driver.flush_buffer = rs_flush_buffer;
  28635. +    serial_driver.ioctl = rs_ioctl;
  28636. +    serial_driver.throttle = rs_throttle;
  28637. +    serial_driver.unthrottle = rs_unthrottle;
  28638. +    serial_driver.set_termios = rs_set_termios;
  28639. +    serial_driver.stop = rs_stop;
  28640. +    serial_driver.start = rs_start;
  28641. +    serial_driver.hangup = rs_hangup;
  28642. +
  28643. +    /*
  28644. +     * The callout device is just like normal device except for
  28645. +     * major number and the subtype code.
  28646. +     */
  28647. +    callout_driver = serial_driver;
  28648. +    callout_driver.name = "cua";
  28649. +    callout_driver.major = TTYAUX_MAJOR;
  28650. +    callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  28651. +
  28652. +    if (tty_register_driver(&serial_driver))
  28653. +        panic("Couldn't register serial driver\n");
  28654. +    if (tty_register_driver(&callout_driver))
  28655. +        panic("Couldn't register callout driver\n");
  28656. +    
  28657. +    for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
  28658. +        info->magic = SERIAL_MAGIC;
  28659. +        info->line = i;
  28660. +        info->tty = 0;
  28661. +        info->type = PORT_UNKNOWN;
  28662. +        info->custom_divisor = 0;
  28663. +        info->close_delay = 5*HZ/10;
  28664. +        info->closing_wait = 30*HZ;
  28665. +        info->x_char = 0;
  28666. +        info->event = 0;
  28667. +        info->count = 0;
  28668. +        info->blocked_open = 0;
  28669. +        info->tqueue.routine = do_softint;
  28670. +        info->tqueue.data = info;
  28671. +        info->tqueue_hangup.routine = do_serial_hangup;
  28672. +        info->tqueue_hangup.data = info;
  28673. +        info->callout_termios =callout_driver.init_termios;
  28674. +        info->normal_termios = serial_driver.init_termios;
  28675. +        info->open_wait = 0;
  28676. +        info->close_wait = 0;
  28677. +        info->delta_msr_wait = 0;
  28678. +        info->icount.cts = info->icount.dsr =
  28679. +            info->icount.rng = info->icount.dcd = 0;
  28680. +        info->next_port = 0;
  28681. +        info->prev_port = 0;
  28682. +#if 0
  28683. +        if (info->irq == 2)
  28684. +            info->irq = 9;
  28685. +#endif
  28686. +        if (info->type == PORT_UNKNOWN) {
  28687. +            if (!(info->flags & ASYNC_BOOT_AUTOCONF))
  28688. +                continue;
  28689. +            autoconfig(info);
  28690. +            if (info->type == PORT_UNKNOWN)
  28691. +                continue;
  28692. +        }
  28693. +        printk(KERN_INFO "tty%02d%s at 0x%04x (irq = %d)", info->line, 
  28694. +               (info->flags & ASYNC_FOURPORT) ? " FourPort" : "",
  28695. +               info->port, info->irq);
  28696. +        switch (info->type) {
  28697. +            case PORT_8250:
  28698. +                printk(" is a 8250\n");
  28699. +                break;
  28700. +            case PORT_16450:
  28701. +                printk(" is a 16450\n");
  28702. +                break;
  28703. +            case PORT_16550:
  28704. +                printk(" is a 16550\n");
  28705. +                break;
  28706. +            case PORT_16550A:
  28707. +                printk(" is a 16550A\n");
  28708. +                break;
  28709. +            case PORT_16650:
  28710. +                printk(" is a 16650\n");
  28711. +                break;
  28712. +            default:
  28713. +                printk("\n");
  28714. +                break;
  28715. +        }
  28716. +    }
  28717. +    register_symtab(&serial_syms);
  28718. +    return 0;
  28719. +}
  28720. +
  28721. +int register_pre_init_serial (struct serial_struct *req)
  28722. +{
  28723. +    int i;
  28724. +    struct async_struct *info;
  28725. +
  28726. +    for (i = 0; i < NR_PORTS; i++) {
  28727. +        if (rs_table[i].port == req->port)
  28728. +            break;
  28729. +    }
  28730. +
  28731. +    if (i == NR_PORTS) {
  28732. +        for (i = 0; i < NR_PORTS; i++)
  28733. +            if (!rs_table[i].port)
  28734. +                break;
  28735. +    }
  28736. +    if (i == NR_PORTS)
  28737. +        return -1;
  28738. +
  28739. +    info = &rs_table[i];
  28740. +    if (info->count) {
  28741. +        printk ("Couldn't configure serial #%d (port=%d, irq=%d): "
  28742. +            "device already open\n", i, req->port, req->irq);
  28743. +        return -1;
  28744. +    }
  28745. +    info->irq = req->irq;
  28746. +    info->port = req->port;
  28747. +    info->baud_base = req->baud_base;
  28748. +    serial_outp (info, UART_IER, 0);
  28749. +    return 0;
  28750. +}
  28751. +
  28752. +/*
  28753. + * register_serial and unregister_serial allows for serial ports to be
  28754. + * configured at run-time, to support PCMCIA modems.
  28755. + */
  28756. +int register_serial(struct serial_struct *req)
  28757. +{
  28758. +    int i;
  28759. +    unsigned long flags;
  28760. +    struct async_struct *info;
  28761. +
  28762. +    save_flags_cli (flags);
  28763. +    for (i = 0; i < NR_PORTS; i++) {
  28764. +        if (rs_table[i].port == req->port)
  28765. +            break;
  28766. +    }
  28767. +    if (i == NR_PORTS) {
  28768. +        for (i = 0; i < NR_PORTS; i++)
  28769. +            if ((rs_table[i].type == PORT_UNKNOWN) &&
  28770. +                (rs_table[i].count == 0))
  28771. +                break;
  28772. +    }
  28773. +    if (i == NR_PORTS) {
  28774. +        restore_flags(flags);
  28775. +        return -1;
  28776. +    }
  28777. +    info = &rs_table[i];
  28778. +    if (rs_table[i].count) {
  28779. +        restore_flags(flags);
  28780. +        printk("Couldn't configure serial #%d (port=%d,irq=%d): "
  28781. +               "device already open\n", i, req->port, req->irq);
  28782. +        return -1;
  28783. +    }
  28784. +    info->irq = req->irq;
  28785. +    info->port = req->port;
  28786. +    if (req->baud_base)    /* rmk: need this to set the baud rate... */
  28787. +        info->baud_base = req->baud_base;
  28788. +    serial_outp(info, UART_IER, 0); /* rmk: need to make sure port is disabled */
  28789. +    info->flags = req->flags;
  28790. +    autoconfig(info);
  28791. +    if (info->type == PORT_UNKNOWN) {
  28792. +        restore_flags(flags);
  28793. +        printk("register_serial(): autoconfig failed\n");
  28794. +        return -1;
  28795. +    }
  28796. +    printk(KERN_INFO "tty%02d at 0x%04x (irq = %d)", info->line, 
  28797. +           info->port, info->irq);
  28798. +    switch (info->type) {
  28799. +    case PORT_8250:
  28800. +        printk(" is a 8250\n"); break;
  28801. +    case PORT_16450:
  28802. +        printk(" is a 16450\n"); break;
  28803. +    case PORT_16550:
  28804. +        printk(" is a 16550\n"); break;
  28805. +    case PORT_16550A:
  28806. +        printk(" is a 16550A\n"); break;
  28807. +    default:
  28808. +        printk("\n"); break;
  28809. +    }
  28810. +    restore_flags(flags);
  28811. +    register_symtab(&serial_syms);
  28812. +    return info->line;
  28813. +}
  28814. +
  28815. +void unregister_serial(int line)
  28816. +{
  28817. +    unsigned long flags;
  28818. +    struct async_struct *info = &rs_table[line];
  28819. +
  28820. +    save_flags_cli (flags);
  28821. +    if (info->tty)
  28822. +        tty_hangup(info->tty);
  28823. +    info->type = PORT_UNKNOWN;
  28824. +    release_region(info->port,8);
  28825. +    printk(KERN_INFO "tty%02d unloaded\n", info->line);
  28826. +    restore_flags(flags);
  28827. +}
  28828. +
  28829. +#ifdef MODULE
  28830. +int init_module(void)
  28831. +{
  28832. +    return rs_init();
  28833. +}
  28834. +
  28835. +void cleanup_module(void)
  28836. +{
  28837. +    unsigned long flags;
  28838. +    int e1, e2;
  28839. +    int i;
  28840. +
  28841. +    /* printk("Unloading %s: version %s\n", serial_name, serial_version); */
  28842. +    save_flags(flags);
  28843. +    cli();
  28844. +    timer_active &= ~(1 << RS_TIMER);
  28845. +    timer_table[RS_TIMER].fn = NULL;
  28846. +    timer_table[RS_TIMER].expires = 0;
  28847. +    if ((e1 = tty_unregister_driver(&serial_driver)))
  28848. +        printk("SERIAL: failed to unregister serial driver (%d)\n",
  28849. +               e1);
  28850. +    if ((e2 = tty_unregister_driver(&callout_driver)))
  28851. +        printk("SERIAL: failed to unregister callout driver (%d)\n",
  28852. +               e2);
  28853. +    restore_flags(flags);
  28854. +
  28855. +    for (i = 0; i < NR_PORTS; i++) {
  28856. +        if (rs_table[i].type != PORT_UNKNOWN)
  28857. +            release_region(rs_table[i].port, 8);
  28858. +    }
  28859. +}
  28860. +#endif /* MODULE */
  28861. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/serial6850.c linux/arch/arm/drivers/char/serial6850.c
  28862. --- linux.orig/arch/arm/drivers/char/serial6850.c    Thu Jan  1 01:00:00 1970
  28863. +++ linux/arch/arm/drivers/char/serial6850.c    Mon Mar 11 21:32:33 1996
  28864. @@ -0,0 +1,23 @@
  28865. +/*
  28866. + * Dummy serial functions
  28867. + *
  28868. + * Copyright (C) 1995, 1996 Russell King
  28869. + */
  28870. +
  28871. +#include <linux/errno.h>
  28872. +#include <linux/sched.h>
  28873. +#include <linux/serial.h>
  28874. +
  28875. +int rs_init (void)
  28876. +{
  28877. +    return 0;
  28878. +}
  28879. +
  28880. +int register_serial (struct serial_struct *dev)
  28881. +{
  28882. +    return -1;
  28883. +}
  28884. +
  28885. +void unregister_serial (int line)
  28886. +{
  28887. +}
  28888. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/tty_io.c linux/arch/arm/drivers/char/tty_io.c
  28889. --- linux.orig/arch/arm/drivers/char/tty_io.c    Thu Jan  1 01:00:00 1970
  28890. +++ linux/arch/arm/drivers/char/tty_io.c    Fri Sep  6 21:20:42 1996
  28891. @@ -0,0 +1,1723 @@
  28892. +/*
  28893. + *  linux/arch/arm/drivers/char/tty_io.c
  28894. + *
  28895. + *  Copyright (C) 1991, 1992  Linus Torvalds
  28896. + *
  28897. + *  Modifications for ARM processor Copright (C) 1995, 1996 Russell King.
  28898. + */
  28899. +
  28900. +/*
  28901. + * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
  28902. + * or rs-channels. It also implements echoing, cooked mode etc.
  28903. + *
  28904. + * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
  28905. + *
  28906. + * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
  28907. + * tty_struct and tty_queue structures.  Previously there was a array
  28908. + * of 256 tty_struct's which was statically allocated, and the
  28909. + * tty_queue structures were allocated at boot time.  Both are now
  28910. + * dynamically allocated only when the tty is open.
  28911. + *
  28912. + * Also restructured routines so that there is more of a separation
  28913. + * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
  28914. + * the low-level tty routines (serial.c, pty.c, console.c).  This
  28915. + * makes for cleaner and more compact code.  -TYT, 9/17/92 
  28916. + *
  28917. + * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
  28918. + * which can be dynamically activated and de-activated by the line
  28919. + * discipline handling modules (like SLIP).
  28920. + *
  28921. + * NOTE: pay no attention to the line discipline code (yet); its
  28922. + * interface is still subject to change in this version...
  28923. + * -- TYT, 1/31/92
  28924. + *
  28925. + * Added functionality to the OPOST tty handling.  No delays, but all
  28926. + * other bits should be there.
  28927. + *    -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
  28928. + *
  28929. + * Rewrote canonical mode and added more termios flags.
  28930. + *     -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
  28931. + *
  28932. + * Reorganized FASYNC support so mouse code can share it.
  28933. + *    -- ctm@ardi.com, 9Sep95
  28934. + *
  28935. + * Altered get_free_page to kmalloc's for tty structures to save memory
  28936. + *  on the ARM processor
  28937. + *      -- rmk92@ecs.soton.ac.uk
  28938. + *
  28939. + * New TIOCLINUX variants added.
  28940. + *    -- mj@k332.feld.cvut.cz, 19-Nov-95
  28941. + */
  28942. +
  28943. +#include <linux/config.h>
  28944. +#include <linux/types.h>
  28945. +#include <linux/major.h>
  28946. +#include <linux/errno.h>
  28947. +#include <linux/signal.h>
  28948. +#include <linux/fcntl.h>
  28949. +#include <linux/sched.h>
  28950. +#include <linux/interrupt.h>
  28951. +#include <linux/tty.h>
  28952. +#include <linux/tty_flip.h>
  28953. +#include <linux/timer.h>
  28954. +#include <linux/ctype.h>
  28955. +#include <linux/kd.h>
  28956. +#include <linux/mm.h>
  28957. +#include <linux/string.h>
  28958. +#include <linux/malloc.h>
  28959. +
  28960. +#include <asm/segment.h>
  28961. +#include <asm/system.h>
  28962. +#include <asm/bitops.h>
  28963. +
  28964. +/*#include <linux/scc.h>*/
  28965. +
  28966. +#include "kbd_kern.h"
  28967. +#include "vt_kern.h"
  28968. +#include "selection.h"
  28969. +
  28970. +#ifdef CONFIG_KERNELD
  28971. +#include <linux/kerneld.h>
  28972. +#endif
  28973. +
  28974. +#define CONSOLE_DEV MKDEV(TTY_MAJOR,0)
  28975. +#define TTY_DEV MKDEV(TTYAUX_MAJOR,0)
  28976. +
  28977. +#undef TTY_DEBUG_HANGUP
  28978. +
  28979. +#define TTY_PARANOIA_CHECK
  28980. +#define CHECK_TTY_COUNT
  28981. +
  28982. +/*extern void set_vesa_blanking(const unsigned long arg);*/
  28983. +
  28984. +struct termios tty_std_termios;        /* for the benefit of tty drivers  */
  28985. +struct tty_driver *tty_drivers;        /* linked list of tty drivers */
  28986. +struct tty_ldisc ldiscs[NR_LDISCS];    /* line disc dispatch table    */
  28987. +
  28988. +int kmsg_redirect;
  28989. +struct tty_struct * redirect;
  28990. +struct wait_queue * keypress_wait;
  28991. +
  28992. +static void initialize_tty_struct(struct tty_struct *tty);
  28993. +
  28994. +static int tty_read(struct inode *, struct file *, char *, int);
  28995. +static int tty_write(struct inode *, struct file *, const char *, int);
  28996. +static int tty_select(struct inode *, struct file *, int, select_table *);
  28997. +static int tty_open(struct inode *, struct file *);
  28998. +static void tty_release(struct inode *, struct file *);
  28999. +static int tty_ioctl(struct inode * inode, struct file * file,
  29000. +             unsigned int cmd, unsigned long arg);
  29001. +static int tty_fasync(struct inode * inode, struct file * filp, int on);
  29002. +
  29003. +#ifndef MIN
  29004. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  29005. +#endif
  29006. +
  29007. +/*
  29008. + * These two routines return the name of tty.  tty_name() should NOT
  29009. + * be used in interrupt drivers, since it's not re-entrant.  Use
  29010. + * _tty_name() instead.
  29011. + */
  29012. +char *_tty_name(struct tty_struct *tty, char *buf)
  29013. +{
  29014. +    if (tty)
  29015. +        sprintf(buf, "%s%d", tty->driver.name,
  29016. +            MINOR(tty->device) - tty->driver.minor_start +
  29017. +            tty->driver.name_base);
  29018. +    else
  29019. +        strcpy(buf, "NULL tty");
  29020. +    return buf;
  29021. +}
  29022. +
  29023. +char *tty_name(struct tty_struct *tty)
  29024. +{
  29025. +    static char buf[64];
  29026. +
  29027. +    return(_tty_name(tty, buf));
  29028. +}
  29029. +
  29030. +inline int tty_paranoia_check(struct tty_struct *tty, kdev_t device,
  29031. +                  const char *routine)
  29032. +{
  29033. +#ifdef TTY_PARANOIA_CHECK
  29034. +    static const char *badmagic =
  29035. +        "Warning: bad magic number for tty struct (%s) in %s\n";
  29036. +    static const char *badtty =
  29037. +        "Warning: null TTY for (%s) in %s\n";
  29038. +
  29039. +    if (!tty) {
  29040. +        printk(badtty, kdevname(device), routine);
  29041. +        return 1;
  29042. +    }
  29043. +    if (tty->magic != TTY_MAGIC) {
  29044. +        printk(badmagic, kdevname(device), routine);
  29045. +        return 1;
  29046. +    }
  29047. +#endif
  29048. +    return 0;
  29049. +}
  29050. +
  29051. +static int check_tty_count(struct tty_struct *tty, const char *routine)
  29052. +{
  29053. +#ifdef CHECK_TTY_COUNT
  29054. +    struct file *f;
  29055. +    int i, count = 0;
  29056. +    
  29057. +    for (f = first_file, i=0; i<nr_files; i++, f = f->f_next) {
  29058. +        if (!f->f_count)
  29059. +            continue;
  29060. +        if (f->private_data == tty) {
  29061. +            count++;
  29062. +        }
  29063. +    }
  29064. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  29065. +        tty->driver.subtype == PTY_TYPE_SLAVE &&
  29066. +        tty->link && tty->link->count)
  29067. +        count++;
  29068. +    if (tty->count != count) {
  29069. +        printk("Warning: dev (%s) tty->count(%d) != #fd's(%d) in %s\n",
  29070. +               kdevname(tty->device), tty->count, count, routine);
  29071. +        return count;
  29072. +       }    
  29073. +#endif
  29074. +    return 0;
  29075. +}
  29076. +
  29077. +int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
  29078. +{
  29079. +    if (disc < N_TTY || disc >= NR_LDISCS)
  29080. +        return -EINVAL;
  29081. +    
  29082. +    if (new_ldisc) {
  29083. +        ldiscs[disc] = *new_ldisc;
  29084. +        ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
  29085. +        ldiscs[disc].num = disc;
  29086. +    } else
  29087. +        memset(&ldiscs[disc], 0, sizeof(struct tty_ldisc));
  29088. +    
  29089. +    return 0;
  29090. +}
  29091. +
  29092. +/* Set the discipline of a tty line. */
  29093. +static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
  29094. +{
  29095. +    int    retval = 0;
  29096. +    struct    tty_ldisc o_ldisc;
  29097. +
  29098. +    if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
  29099. +        return -EINVAL;
  29100. +#ifdef CONFIG_KERNELD
  29101. +    /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
  29102. +    if (!(ldiscs[ldisc].flags & LDISC_FLAG_DEFINED)) {
  29103. +        char modname [20];
  29104. +        sprintf(modname, "tty-ldisc-%d", ldisc);
  29105. +        request_module (modname);
  29106. +    }
  29107. +#endif
  29108. +    if (!(ldiscs[ldisc].flags & LDISC_FLAG_DEFINED))
  29109. +        return -EINVAL;
  29110. +
  29111. +    if (tty->ldisc.num == ldisc)
  29112. +        return 0;    /* We are already in the desired discipline */
  29113. +    o_ldisc = tty->ldisc;
  29114. +
  29115. +    tty_wait_until_sent(tty, 0);
  29116. +    
  29117. +    /* Shutdown the current discipline. */
  29118. +    if (tty->ldisc.close)
  29119. +        (tty->ldisc.close)(tty);
  29120. +
  29121. +    /* Now set up the new line discipline. */
  29122. +    tty->ldisc = ldiscs[ldisc];
  29123. +    tty->termios->c_line = ldisc;
  29124. +    if (tty->ldisc.open)
  29125. +        retval = (tty->ldisc.open)(tty);
  29126. +    if (retval < 0) {
  29127. +        tty->ldisc = o_ldisc;
  29128. +        tty->termios->c_line = tty->ldisc.num;
  29129. +        if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
  29130. +            tty->ldisc = ldiscs[N_TTY];
  29131. +            tty->termios->c_line = N_TTY;
  29132. +            if (tty->ldisc.open) {
  29133. +                int r = tty->ldisc.open(tty);
  29134. +
  29135. +                if (r < 0)
  29136. +                    panic("Couldn't open N_TTY ldisc for "
  29137. +                          "%s --- error %d.",
  29138. +                          tty_name(tty), r);
  29139. +            }
  29140. +        }
  29141. +    }
  29142. +    if (tty->ldisc.num != o_ldisc.num && tty->driver.set_ldisc)
  29143. +        tty->driver.set_ldisc(tty);
  29144. +    return retval;
  29145. +}
  29146. +
  29147. +/*
  29148. + * This routine returns a tty driver structure, given a device number
  29149. + */
  29150. +struct tty_driver *get_tty_driver(kdev_t device)
  29151. +{
  29152. +    int    major, minor;
  29153. +    struct tty_driver *p;
  29154. +    
  29155. +    minor = MINOR(device);
  29156. +    major = MAJOR(device);
  29157. +
  29158. +    for (p = tty_drivers; p; p = p->next) {
  29159. +        if (p->major != major)
  29160. +            continue;
  29161. +        if (minor < p->minor_start)
  29162. +            continue;
  29163. +        if (minor >= p->minor_start + p->num)
  29164. +            continue;
  29165. +        return p;
  29166. +    }
  29167. +    return NULL;
  29168. +}
  29169. +
  29170. +/*
  29171. + * If we try to write to, or set the state of, a terminal and we're
  29172. + * not in the foreground, send a SIGTTOU.  If the signal is blocked or
  29173. + * ignored, go ahead and perform the operation.  (POSIX 7.2)
  29174. + */
  29175. +int tty_check_change(struct tty_struct * tty)
  29176. +{
  29177. +    if (current->tty != tty)
  29178. +        return 0;
  29179. +    if (tty->pgrp <= 0) {
  29180. +        printk("tty_check_change: tty->pgrp <= 0!\n");
  29181. +        return 0;
  29182. +    }
  29183. +    if (current->pgrp == tty->pgrp)
  29184. +        return 0;
  29185. +    if (is_ignored(SIGTTOU))
  29186. +        return 0;
  29187. +    if (is_orphaned_pgrp(current->pgrp))
  29188. +        return -EIO;
  29189. +    (void) kill_pg(current->pgrp,SIGTTOU,1);
  29190. +    return -ERESTARTSYS;
  29191. +}
  29192. +
  29193. +static int hung_up_tty_read(struct inode * inode, struct file * file, char * buf, int count)
  29194. +{
  29195. +    return 0;
  29196. +}
  29197. +
  29198. +static int hung_up_tty_write(struct inode * inode, struct file * file, const char * buf, int count)
  29199. +{
  29200. +    return -EIO;
  29201. +}
  29202. +
  29203. +static int hung_up_tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
  29204. +{
  29205. +    return 1;
  29206. +}
  29207. +
  29208. +static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
  29209. +                 unsigned int cmd, unsigned long arg)
  29210. +{
  29211. +    return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
  29212. +}
  29213. +
  29214. +static int tty_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
  29215. +{
  29216. +    return -ESPIPE;
  29217. +}
  29218. +
  29219. +static struct file_operations tty_fops = {
  29220. +    tty_lseek,
  29221. +    tty_read,
  29222. +    tty_write,
  29223. +    NULL,        /* tty_readdir */
  29224. +    tty_select,
  29225. +    tty_ioctl,
  29226. +    NULL,        /* tty_mmap */
  29227. +    tty_open,
  29228. +    tty_release,
  29229. +    NULL,        /* tty_fsync */
  29230. +    tty_fasync
  29231. +};
  29232. +
  29233. +static struct file_operations hung_up_tty_fops = {
  29234. +    tty_lseek,
  29235. +    hung_up_tty_read,
  29236. +    hung_up_tty_write,
  29237. +    NULL,        /* hung_up_tty_readdir */
  29238. +    hung_up_tty_select,
  29239. +    hung_up_tty_ioctl,
  29240. +    NULL,        /* hung_up_tty_mmap */
  29241. +    NULL,        /* hung_up_tty_open */
  29242. +    tty_release,    /* hung_up_tty_release */
  29243. +    NULL,        /* hung_up_tty_fsync  */
  29244. +    NULL        /* hung_up_tty_fasync */
  29245. +};
  29246. +
  29247. +void do_tty_hangup(struct tty_struct * tty, struct file_operations *fops)
  29248. +{
  29249. +    int i;
  29250. +    struct file * filp;
  29251. +    struct task_struct *p;
  29252. +
  29253. +    if (!tty)
  29254. +        return;
  29255. +    check_tty_count(tty, "do_tty_hangup");
  29256. +    for (filp = first_file, i=0; i<nr_files; i++, filp = filp->f_next) {
  29257. +        if (!filp->f_count)
  29258. +            continue;
  29259. +        if (filp->private_data != tty)
  29260. +            continue;
  29261. +        if (!filp->f_inode)
  29262. +            continue;
  29263. +        if (filp->f_inode->i_rdev == CONSOLE_DEV)
  29264. +            continue;
  29265. +        if (filp->f_op != &tty_fops)
  29266. +            continue;
  29267. +        tty_fasync(filp->f_inode, filp, 0);
  29268. +        filp->f_op = fops;
  29269. +    }
  29270. +    
  29271. +    if (tty->ldisc.flush_buffer)
  29272. +        tty->ldisc.flush_buffer(tty);
  29273. +    if (tty->driver.flush_buffer)
  29274. +        tty->driver.flush_buffer(tty);
  29275. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  29276. +        tty->ldisc.write_wakeup)
  29277. +        (tty->ldisc.write_wakeup)(tty);
  29278. +    wake_up_interruptible(&tty->write_wait);
  29279. +    wake_up_interruptible(&tty->read_wait);
  29280. +
  29281. +    /*
  29282. +     * Shutdown the current line discipline, and reset it to
  29283. +     * N_TTY.
  29284. +     */
  29285. +    if (tty->ldisc.num != ldiscs[N_TTY].num) {
  29286. +        if (tty->ldisc.close)
  29287. +            (tty->ldisc.close)(tty);
  29288. +        tty->ldisc = ldiscs[N_TTY];
  29289. +        tty->termios->c_line = N_TTY;
  29290. +        if (tty->ldisc.open) {
  29291. +            i = (tty->ldisc.open)(tty);
  29292. +            if (i < 0)
  29293. +                printk("do_tty_hangup: N_TTY open: error %d\n",
  29294. +                       -i);
  29295. +        }
  29296. +    }
  29297. +    
  29298. +     for_each_task(p) {
  29299. +        if ((tty->session > 0) && (p->session == tty->session) &&
  29300. +            p->leader) {
  29301. +            send_sig(SIGHUP,p,1);
  29302. +            send_sig(SIGCONT,p,1);
  29303. +            if (tty->pgrp > 0)
  29304. +                p->tty_old_pgrp = tty->pgrp;
  29305. +        }
  29306. +        if (p->tty == tty)
  29307. +            p->tty = NULL;
  29308. +    }
  29309. +    tty->flags = 0;
  29310. +    tty->session = 0;
  29311. +    tty->pgrp = -1;
  29312. +    tty->ctrl_status = 0;
  29313. +    if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS)
  29314. +        *tty->termios = tty->driver.init_termios;
  29315. +    if (tty->driver.hangup)
  29316. +        (tty->driver.hangup)(tty);
  29317. +}
  29318. +
  29319. +void tty_hangup(struct tty_struct * tty)
  29320. +{
  29321. +#ifdef TTY_DEBUG_HANGUP
  29322. +    printk("%s hangup...\n", tty_name(tty));
  29323. +#endif
  29324. +    do_tty_hangup(tty, &hung_up_tty_fops);
  29325. +}
  29326. +
  29327. +void tty_vhangup(struct tty_struct * tty)
  29328. +{
  29329. +#ifdef TTY_DEBUG_HANGUP
  29330. +    printk("%s vhangup...\n", tty_name(tty));
  29331. +#endif
  29332. +    do_tty_hangup(tty, &hung_up_tty_fops);
  29333. +}
  29334. +
  29335. +int tty_hung_up_p(struct file * filp)
  29336. +{
  29337. +    return (filp->f_op == &hung_up_tty_fops);
  29338. +}
  29339. +
  29340. +/*
  29341. + * This function is typically called only by the session leader, when
  29342. + * it wants to disassociate itself from its controlling tty.
  29343. + *
  29344. + * It performs the following functions:
  29345. + *     (1)  Sends a SIGHUP and SIGCONT to the foreground process group
  29346. + *     (2)  Clears the tty from being controlling the session
  29347. + *     (3)  Clears the controlling tty for all processes in the
  29348. + *         session group.
  29349. + *
  29350. + * The argument on_exit is set to 1 if called when a process is
  29351. + * exiting; it is 0 if called by the ioctl TIOCNOTTY.
  29352. + */
  29353. +void disassociate_ctty(int on_exit)
  29354. +{
  29355. +    struct tty_struct *tty = current->tty;
  29356. +    struct task_struct *p;
  29357. +    int tty_pgrp = -1;
  29358. +
  29359. +    if (tty) {
  29360. +        tty_pgrp = tty->pgrp;
  29361. +        if (on_exit && tty->driver.type != TTY_DRIVER_TYPE_PTY)
  29362. +            tty_vhangup(tty);
  29363. +    } else {
  29364. +        if (current->tty_old_pgrp) {
  29365. +            kill_pg(current->tty_old_pgrp, SIGHUP, on_exit);
  29366. +            kill_pg(current->tty_old_pgrp, SIGCONT, on_exit);
  29367. +        }
  29368. +        return;
  29369. +    }
  29370. +    if (tty_pgrp > 0) {
  29371. +        kill_pg(tty_pgrp, SIGHUP, on_exit);
  29372. +        if (!on_exit)
  29373. +            kill_pg(tty_pgrp, SIGCONT, on_exit);
  29374. +    }
  29375. +
  29376. +    current->tty_old_pgrp = 0;
  29377. +    tty->session = 0;
  29378. +    tty->pgrp = -1;
  29379. +
  29380. +    for_each_task(p)
  29381. +          if (p->session == current->session)
  29382. +            p->tty = NULL;
  29383. +}
  29384. +
  29385. +void wait_for_keypress(void)
  29386. +{
  29387. +    sleep_on(&keypress_wait);
  29388. +}
  29389. +
  29390. +void stop_tty(struct tty_struct *tty)
  29391. +{
  29392. +    if (tty->stopped)
  29393. +        return;
  29394. +    tty->stopped = 1;
  29395. +    if (tty->link && tty->link->packet) {
  29396. +        tty->ctrl_status &= ~TIOCPKT_START;
  29397. +        tty->ctrl_status |= TIOCPKT_STOP;
  29398. +        wake_up_interruptible(&tty->link->read_wait);
  29399. +    }
  29400. +    if (tty->driver.stop)
  29401. +        (tty->driver.stop)(tty);
  29402. +}
  29403. +
  29404. +void start_tty(struct tty_struct *tty)
  29405. +{
  29406. +    if (!tty->stopped)
  29407. +        return;
  29408. +    tty->stopped = 0;
  29409. +    if (tty->link && tty->link->packet) {
  29410. +        tty->ctrl_status &= ~TIOCPKT_STOP;
  29411. +        tty->ctrl_status |= TIOCPKT_START;
  29412. +        wake_up_interruptible(&tty->link->read_wait);
  29413. +    }
  29414. +    if (tty->driver.start)
  29415. +        (tty->driver.start)(tty);
  29416. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  29417. +        tty->ldisc.write_wakeup)
  29418. +        (tty->ldisc.write_wakeup)(tty);
  29419. +    wake_up_interruptible(&tty->write_wait);
  29420. +}
  29421. +
  29422. +static int tty_read(struct inode * inode, struct file * file, char * buf, int count)
  29423. +{
  29424. +    int i;
  29425. +    struct tty_struct * tty;
  29426. +
  29427. +    tty = (struct tty_struct *)file->private_data;
  29428. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_read"))
  29429. +        return -EIO;
  29430. +    if (!tty || (tty->flags & (1 << TTY_IO_ERROR)))
  29431. +        return -EIO;
  29432. +
  29433. +    /* This check not only needs to be done before reading, but also
  29434. +       whenever read_chan() gets woken up after sleeping, so I've
  29435. +       moved it to there.  This should only be done for the N_TTY
  29436. +       line discipline, anyway.  Same goes for write_chan(). -- jlc. */
  29437. +#if 0
  29438. +    if ((inode->i_rdev != CONSOLE_DEV) && /* don't stop on /dev/console */
  29439. +        (tty->pgrp > 0) &&
  29440. +        (current->tty == tty) &&
  29441. +        (tty->pgrp != current->pgrp))
  29442. +        if (is_ignored(SIGTTIN) || is_orphaned_pgrp(current->pgrp))
  29443. +            return -EIO;
  29444. +        else {
  29445. +            (void) kill_pg(current->pgrp, SIGTTIN, 1);
  29446. +            return -ERESTARTSYS;
  29447. +        }
  29448. +#endif
  29449. +    if (tty->ldisc.read)
  29450. +        /* XXX casts are for what kernel-wide prototypes should be. */
  29451. +        i = (tty->ldisc.read)(tty,file,(unsigned char *)buf,(unsigned int)count);
  29452. +    else
  29453. +        i = -EIO;
  29454. +    if (i > 0)
  29455. +        inode->i_atime = CURRENT_TIME;
  29456. +    return i;
  29457. +}
  29458. +
  29459. +/*
  29460. + * Split writes up in sane blocksizes to avoid
  29461. + * denial-of-service type attacks
  29462. + */
  29463. +static inline int do_tty_write(
  29464. +    int (*write)(struct tty_struct *, struct file *, const unsigned char *, unsigned int),
  29465. +    struct inode *inode,
  29466. +    struct tty_struct *tty,
  29467. +    struct file *file,
  29468. +    const unsigned char *buf,
  29469. +    unsigned int count)
  29470. +{
  29471. +    int ret = 0, written = 0;
  29472. +
  29473. +    for (;;) {
  29474. +        unsigned int size = PAGE_SIZE*2;
  29475. +        if (size > count)
  29476. +            size = count;
  29477. +        ret = write(tty, file, buf, size);
  29478. +        if (ret <= 0)
  29479. +            break;
  29480. +        count -= ret;
  29481. +        written += ret;
  29482. +        if (!count)
  29483. +            break;
  29484. +        ret = -ERESTARTSYS;
  29485. +        if (current->signal & ~current->blocked)
  29486. +            break;
  29487. +        if (need_resched)
  29488. +            schedule();
  29489. +    }
  29490. +    if (written) {
  29491. +        inode->i_mtime = CURRENT_TIME;
  29492. +        ret = written;
  29493. +    }
  29494. +    return ret;
  29495. +}
  29496. +
  29497. +
  29498. +static int tty_write(struct inode * inode, struct file * file, const char * buf, int count)
  29499. +{
  29500. +    int is_console;
  29501. +    struct tty_struct * tty;
  29502. +
  29503. +    is_console = (inode->i_rdev == CONSOLE_DEV);
  29504. +
  29505. +    if (is_console && redirect)
  29506. +        tty = redirect;
  29507. +    else
  29508. +        tty = (struct tty_struct *)file->private_data;
  29509. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_write"))
  29510. +        return -EIO;
  29511. +    if (!tty || !tty->driver.write || (tty->flags & (1 << TTY_IO_ERROR)))
  29512. +        return -EIO;
  29513. +#if 0
  29514. +    if (!is_console && L_TOSTOP(tty) && (tty->pgrp > 0) &&
  29515. +        (current->tty == tty) && (tty->pgrp != current->pgrp)) {
  29516. +        if (is_orphaned_pgrp(current->pgrp))
  29517. +            return -EIO;
  29518. +        if (!is_ignored(SIGTTOU)) {
  29519. +            (void) kill_pg(current->pgrp, SIGTTOU, 1);
  29520. +            return -ERESTARTSYS;
  29521. +        }
  29522. +    }
  29523. +#endif
  29524. +    if (!tty->ldisc.write)
  29525. +        return -EIO;
  29526. +    return do_tty_write(tty->ldisc.write,
  29527. +        inode, tty, file,
  29528. +        (const unsigned char *)buf,
  29529. +        (unsigned int)count);
  29530. +}
  29531. +
  29532. +/*
  29533. + * This is so ripe with races that you should *really* not touch this
  29534. + * unless you know exactly what you are doing. All the changes have to be
  29535. + * made atomically, or there may be incorrect pointers all over the place.
  29536. + */
  29537. +static int init_dev(kdev_t device, struct tty_struct **ret_tty)
  29538. +{
  29539. +    struct tty_struct *tty, **tty_loc, *o_tty, **o_tty_loc;
  29540. +    struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
  29541. +    struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
  29542. +    struct tty_driver *driver;    
  29543. +    int retval;
  29544. +    int idx;
  29545. +
  29546. +    driver = get_tty_driver(device);
  29547. +    if (!driver)
  29548. +        return -ENODEV;
  29549. +
  29550. +    idx = MINOR(device) - driver->minor_start;
  29551. +    tty = o_tty = NULL;
  29552. +    tp = o_tp = NULL;
  29553. +    ltp = o_ltp = NULL;
  29554. +    o_tty_loc = NULL;
  29555. +    o_tp_loc = o_ltp_loc = NULL;
  29556. +
  29557. +    tty_loc = &driver->table[idx];
  29558. +    tp_loc = &driver->termios[idx];
  29559. +    ltp_loc = &driver->termios_locked[idx];
  29560. +
  29561. +repeat:
  29562. +    retval = -EIO;
  29563. +    if (driver->type == TTY_DRIVER_TYPE_PTY &&
  29564. +        driver->subtype == PTY_TYPE_MASTER &&
  29565. +        *tty_loc && (*tty_loc)->count)
  29566. +        goto end_init;
  29567. +    retval = -ENOMEM;
  29568. +    if (!*tty_loc && !tty) {
  29569. +        if (!(tty = (struct tty_struct*) kmalloc(sizeof(struct tty_struct),GFP_KERNEL)))
  29570. +            goto end_init;
  29571. +        initialize_tty_struct(tty);
  29572. +        tty->device = device;
  29573. +        tty->driver = *driver;
  29574. +        goto repeat;
  29575. +    }
  29576. +    if (!*tp_loc && !tp) {
  29577. +        tp = (struct termios *) kmalloc(sizeof(struct termios),
  29578. +                        GFP_KERNEL);
  29579. +        if (!tp)
  29580. +            goto end_init;
  29581. +        *tp = driver->init_termios;
  29582. +        goto repeat;
  29583. +    }
  29584. +    if (!*ltp_loc && !ltp) {
  29585. +        ltp = (struct termios *) kmalloc(sizeof(struct termios),
  29586. +                         GFP_KERNEL);
  29587. +        if (!ltp)
  29588. +            goto end_init;
  29589. +        memset(ltp, 0, sizeof(struct termios));
  29590. +        goto repeat;
  29591. +    }
  29592. +    if (driver->type == TTY_DRIVER_TYPE_PTY) {
  29593. +        o_tty_loc = &driver->other->table[idx];
  29594. +        o_tp_loc = &driver->other->termios[idx];
  29595. +        o_ltp_loc = &driver->other->termios_locked[idx];
  29596. +
  29597. +        if (!*o_tty_loc && !o_tty) {
  29598. +            kdev_t     o_device;
  29599. +            
  29600. +            o_tty = (struct tty_struct *) kmalloc (sizeof(struct tty_struct),
  29601. +                GFP_KERNEL);
  29602. +            if (!o_tty)
  29603. +                goto end_init;
  29604. +            o_device = MKDEV(driver->other->major,
  29605. +                     driver->other->minor_start + idx);
  29606. +            initialize_tty_struct(o_tty);
  29607. +            o_tty->device = o_device;
  29608. +            o_tty->driver = *driver->other;
  29609. +            goto repeat;
  29610. +        }
  29611. +        if (!*o_tp_loc && !o_tp) {
  29612. +            o_tp = (struct termios *)
  29613. +                kmalloc(sizeof(struct termios), GFP_KERNEL);
  29614. +            if (!o_tp)
  29615. +                goto end_init;
  29616. +            *o_tp = driver->other->init_termios;
  29617. +            goto repeat;
  29618. +        }
  29619. +        if (!*o_ltp_loc && !o_ltp) {
  29620. +            o_ltp = (struct termios *)
  29621. +                kmalloc(sizeof(struct termios), GFP_KERNEL);
  29622. +            if (!o_ltp)
  29623. +                goto end_init;
  29624. +            memset(o_ltp, 0, sizeof(struct termios));
  29625. +            goto repeat;
  29626. +        }
  29627. +        
  29628. +    }
  29629. +    /* Now we have allocated all the structures: update all the pointers.. */
  29630. +    if (!*tp_loc) {
  29631. +        *tp_loc = tp;
  29632. +        tp = NULL;
  29633. +    }
  29634. +    if (!*ltp_loc) {
  29635. +        *ltp_loc = ltp;
  29636. +        ltp = NULL;
  29637. +    }
  29638. +    if (!*tty_loc) {
  29639. +        tty->termios = *tp_loc;
  29640. +        tty->termios_locked = *ltp_loc;
  29641. +        *tty_loc = tty;
  29642. +        (*driver->refcount)++;
  29643. +        (*tty_loc)->count++;
  29644. +        if (tty->ldisc.open) {
  29645. +            retval = (tty->ldisc.open)(tty);
  29646. +            if (retval < 0) {
  29647. +                (*tty_loc)->count--;
  29648. +                tty = NULL;
  29649. +                goto end_init;
  29650. +            }
  29651. +        }
  29652. +        tty = NULL;
  29653. +    } else {
  29654. +        if ((*tty_loc)->flags & (1 << TTY_CLOSING)) {
  29655. +            printk("Attempt to open closing tty %s.\n",
  29656. +                   tty_name(*tty_loc));
  29657. +            printk("Ack!!!!  This should never happen!!\n");
  29658. +            return -EINVAL;
  29659. +        }
  29660. +        (*tty_loc)->count++;
  29661. +    }
  29662. +    if (driver->type == TTY_DRIVER_TYPE_PTY) {
  29663. +        if (!*o_tp_loc) {
  29664. +            *o_tp_loc = o_tp;
  29665. +            o_tp = NULL;
  29666. +        }
  29667. +        if (!*o_ltp_loc) {
  29668. +            *o_ltp_loc = o_ltp;
  29669. +            o_ltp = NULL;
  29670. +        }
  29671. +        if (!*o_tty_loc) {
  29672. +            o_tty->termios = *o_tp_loc;
  29673. +            o_tty->termios_locked = *o_ltp_loc;
  29674. +            *o_tty_loc = o_tty;
  29675. +            (*driver->other->refcount)++;
  29676. +            if (o_tty->ldisc.open) {
  29677. +                retval = (o_tty->ldisc.open)(o_tty);
  29678. +                if (retval < 0) {
  29679. +                    (*tty_loc)->count--;
  29680. +                    o_tty = NULL;
  29681. +                    goto end_init;
  29682. +                }
  29683. +            }
  29684. +            o_tty = NULL;
  29685. +        }
  29686. +        (*tty_loc)->link = *o_tty_loc;
  29687. +        (*o_tty_loc)->link = *tty_loc;
  29688. +        if (driver->subtype == PTY_TYPE_MASTER)
  29689. +            (*o_tty_loc)->count++;
  29690. +    }
  29691. +    (*tty_loc)->driver = *driver;
  29692. +    *ret_tty = *tty_loc;
  29693. +    retval = 0;
  29694. +end_init:
  29695. +    if (tty)
  29696. +        kfree_s(tty, sizeof(struct tty_struct));
  29697. +    if (o_tty)
  29698. +        kfree_s(o_tty, sizeof(struct tty_struct));
  29699. +    if (tp)
  29700. +        kfree_s(tp, sizeof(struct termios));
  29701. +    if (o_tp)
  29702. +        kfree_s(o_tp, sizeof(struct termios));
  29703. +    if (ltp)
  29704. +        kfree_s(ltp, sizeof(struct termios));
  29705. +    if (o_ltp)
  29706. +        kfree_s(o_ltp, sizeof(struct termios));
  29707. +    return retval;
  29708. +}
  29709. +
  29710. +/*
  29711. + * Even releasing the tty structures is a tricky business.. We have
  29712. + * to be very careful that the structures are all released at the
  29713. + * same time, as interrupts might otherwise get the wrong pointers.
  29714. + */
  29715. +static void release_dev(struct file * filp)
  29716. +{
  29717. +    struct tty_struct *tty, *o_tty;
  29718. +    struct termios *tp, *o_tp, *ltp, *o_ltp;
  29719. +    struct task_struct **p;
  29720. +    int    idx;
  29721. +    
  29722. +    tty = (struct tty_struct *)filp->private_data;
  29723. +    if (tty_paranoia_check(tty, filp->f_inode->i_rdev, "release_dev"))
  29724. +        return;
  29725. +
  29726. +    check_tty_count(tty, "release_dev");
  29727. +
  29728. +    tty_fasync(filp->f_inode, filp, 0);
  29729. +
  29730. +    tp = tty->termios;
  29731. +    ltp = tty->termios_locked;
  29732. +
  29733. +    idx = MINOR(tty->device) - tty->driver.minor_start;
  29734. +#ifdef TTY_PARANOIA_CHECK
  29735. +    if (idx < 0 || idx >= tty->driver.num) {
  29736. +        printk("release_dev: bad idx when trying to free (%s)\n",
  29737. +               kdevname(tty->device));
  29738. +        return;
  29739. +    }
  29740. +    if (tty != tty->driver.table[idx]) {
  29741. +        printk("release_dev: driver.table[%d] not tty for (%s)\n",
  29742. +               idx, kdevname(tty->device));
  29743. +        return;
  29744. +    }
  29745. +    if (tp != tty->driver.termios[idx]) {
  29746. +        printk("release_dev: driver.termios[%d] not termios for ("
  29747. +               "%s)\n",
  29748. +               idx, kdevname(tty->device));
  29749. +        return;
  29750. +    }
  29751. +    if (ltp != tty->driver.termios_locked[idx]) {
  29752. +        printk("release_dev: driver.termios_locked[%d] not termios_locked for ("
  29753. +               "%s)\n",
  29754. +               idx, kdevname(tty->device));
  29755. +        return;
  29756. +    }
  29757. +#endif
  29758. +
  29759. +#ifdef TTY_DEBUG_HANGUP
  29760. +    printk("release_dev of %s (tty count=%d)...", tty_name(tty),
  29761. +           tty->count);
  29762. +#endif
  29763. +
  29764. +    o_tty = tty->link;
  29765. +    o_tp = (o_tty) ? o_tty->termios : NULL;
  29766. +    o_ltp = (o_tty) ? o_tty->termios_locked : NULL;
  29767. +
  29768. +#ifdef TTY_PARANOIA_CHECK
  29769. +    if (tty->driver.other) {
  29770. +        if (o_tty != tty->driver.other->table[idx]) {
  29771. +            printk("release_dev: other->table[%d] not o_tty for ("
  29772. +                   "%s)\n",
  29773. +                   idx, kdevname(tty->device));
  29774. +            return;
  29775. +        }
  29776. +        if (o_tp != tty->driver.other->termios[idx]) {
  29777. +            printk("release_dev: other->termios[%d] not o_termios for ("
  29778. +                   "%s)\n",
  29779. +                   idx, kdevname(tty->device));
  29780. +            return;
  29781. +        }
  29782. +        if (o_ltp != tty->driver.other->termios_locked[idx]) {
  29783. +            printk("release_dev: other->termios_locked[%d] not o_termios_locked for ("
  29784. +                   "%s)\n",
  29785. +                   idx, kdevname(tty->device));
  29786. +            return;
  29787. +        }
  29788. +
  29789. +        if (o_tty->link != tty) {
  29790. +            printk("release_dev: bad pty pointers\n");
  29791. +            return;
  29792. +        }
  29793. +    }
  29794. +#endif
  29795. +    
  29796. +    if (tty->driver.close)
  29797. +        tty->driver.close(tty, filp);
  29798. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  29799. +        tty->driver.subtype == PTY_TYPE_MASTER) {
  29800. +        if (--tty->link->count < 0) {
  29801. +            printk("release_dev: bad pty slave count (%d) for %s\n",
  29802. +                   tty->count, tty_name(tty));
  29803. +            tty->link->count = 0;
  29804. +        }
  29805. +    }
  29806. +    if (--tty->count < 0) {
  29807. +        printk("release_dev: bad tty->count (%d) for %s\n",
  29808. +               tty->count, tty_name(tty));
  29809. +        tty->count = 0;
  29810. +    }
  29811. +    if (tty->count)
  29812. +        return;
  29813. +
  29814. +    /*
  29815. +     * We're committed; at this point, we must not block!
  29816. +     */
  29817. +    if (o_tty) {
  29818. +        if (o_tty->count)
  29819. +            return;
  29820. +        tty->driver.other->table[idx] = NULL;
  29821. +        tty->driver.other->termios[idx] = NULL;
  29822. +        kfree_s(o_tp, sizeof(struct termios));
  29823. +    }
  29824. +    
  29825. +#ifdef TTY_DEBUG_HANGUP
  29826. +    printk("freeing tty structure...");
  29827. +#endif
  29828. +    tty->flags |= (1 << TTY_CLOSING);
  29829. +
  29830. +    /*
  29831. +     * Make sure there aren't any processes that still think this
  29832. +     * tty is their controlling tty.
  29833. +     */
  29834. +    for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
  29835. +        if (*p == 0)
  29836. +            continue;
  29837. +        if ((*p)->tty == tty)
  29838. +            (*p)->tty = NULL;
  29839. +        if (o_tty && (*p)->tty == o_tty)
  29840. +            (*p)->tty = NULL;
  29841. +    }
  29842. +
  29843. +    /*
  29844. +     * Shutdown the current line discipline, and reset it to
  29845. +     * N_TTY.
  29846. +     */
  29847. +    if (tty->ldisc.close)
  29848. +        (tty->ldisc.close)(tty);
  29849. +    tty->ldisc = ldiscs[N_TTY];
  29850. +    tty->termios->c_line = N_TTY;
  29851. +    if (o_tty) {
  29852. +        if (o_tty->ldisc.close)
  29853. +            (o_tty->ldisc.close)(o_tty);
  29854. +        o_tty->ldisc = ldiscs[N_TTY];
  29855. +    }
  29856. +    
  29857. +    tty->driver.table[idx] = NULL;
  29858. +    if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS) {
  29859. +        tty->driver.termios[idx] = NULL;
  29860. +        kfree_s(tp, sizeof(struct termios));
  29861. +    }
  29862. +    if (tty == redirect || o_tty == redirect)
  29863. +        redirect = NULL;
  29864. +    /*
  29865. +     * Make sure that the tty's task queue isn't activated.  If it
  29866. +     * is, take it out of the linked list.
  29867. +     */
  29868. +    cli();
  29869. +    if (tty->flip.tqueue.sync) {
  29870. +        struct tq_struct *tq, *prev;
  29871. +
  29872. +        for (tq=tq_timer, prev=0; tq; prev=tq, tq=tq->next) {
  29873. +            if (tq == &tty->flip.tqueue) {
  29874. +                if (prev)
  29875. +                    prev->next = tq->next;
  29876. +                else
  29877. +                    tq_timer = tq->next;
  29878. +                break;
  29879. +            }
  29880. +        }
  29881. +    }
  29882. +    sti();
  29883. +    tty->magic = 0;
  29884. +    (*tty->driver.refcount)--;
  29885. +    kfree_s(tty, sizeof(struct tty_struct));
  29886. +    filp->private_data = 0;
  29887. +    if (o_tty) {
  29888. +        o_tty->magic = 0;
  29889. +        (*o_tty->driver.refcount)--;
  29890. +        kfree_s(o_tty, sizeof(struct tty_struct));
  29891. +    }
  29892. +}
  29893. +
  29894. +/*
  29895. + * tty_open and tty_release keep up the tty count that contains the
  29896. + * number of opens done on a tty. We cannot use the inode-count, as
  29897. + * different inodes might point to the same tty.
  29898. + *
  29899. + * Open-counting is needed for pty masters, as well as for keeping
  29900. + * track of serial lines: DTR is dropped when the last close happens.
  29901. + * (This is not done solely through tty->count, now.  - Ted 1/27/92)
  29902. + *
  29903. + * The termios state of a pty is reset on first open so that
  29904. + * settings don't persist across reuse.
  29905. + */
  29906. +static int tty_open(struct inode * inode, struct file * filp)
  29907. +{
  29908. +    struct tty_struct *tty;
  29909. +    int minor;
  29910. +    int noctty, retval;
  29911. +    kdev_t device;
  29912. +
  29913. +retry_open:
  29914. +    noctty = filp->f_flags & O_NOCTTY;
  29915. +    device = inode->i_rdev;
  29916. +    if (device == TTY_DEV) {
  29917. +        if (!current->tty)
  29918. +            return -ENXIO;
  29919. +        device = current->tty->device;
  29920. +        /* noctty = 1; */
  29921. +    }
  29922. +    if (device == CONSOLE_DEV) {
  29923. +        device = MKDEV(TTY_MAJOR, vtdata.fgconsole->num);
  29924. +        noctty = 1;
  29925. +    }
  29926. +    minor = MINOR(device);
  29927. +    
  29928. +    retval = init_dev(device, &tty);
  29929. +    if (retval)
  29930. +        return retval;
  29931. +    filp->private_data = tty;
  29932. +    check_tty_count(tty, "tty_open");
  29933. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  29934. +        tty->driver.subtype == PTY_TYPE_MASTER)
  29935. +        noctty = 1;
  29936. +#ifdef TTY_DEBUG_HANGUP
  29937. +    printk("opening %s...", tty_name(tty));
  29938. +#endif
  29939. +    if (tty->driver.open)
  29940. +        retval = tty->driver.open(tty, filp);
  29941. +    else
  29942. +        retval = -ENODEV;
  29943. +
  29944. +    if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !suser())
  29945. +        retval = -EBUSY;
  29946. +
  29947. +    if (retval) {
  29948. +#ifdef TTY_DEBUG_HANGUP
  29949. +        printk("error %d in opening %s...", retval, tty_name(tty));
  29950. +#endif
  29951. +
  29952. +        release_dev(filp);
  29953. +        if (retval != -ERESTARTSYS)
  29954. +            return retval;
  29955. +        if (current->signal & ~current->blocked)
  29956. +            return retval;
  29957. +        schedule();
  29958. +        /*
  29959. +         * Need to reset f_op in case a hangup happened.
  29960. +         */
  29961. +        filp->f_op = &tty_fops;
  29962. +        goto retry_open;
  29963. +    }
  29964. +    if (!noctty &&
  29965. +        current->leader &&
  29966. +        !current->tty &&
  29967. +        tty->session == 0) {
  29968. +        current->tty = tty;
  29969. +        current->tty_old_pgrp = 0;
  29970. +        tty->session = current->session;
  29971. +        tty->pgrp = current->pgrp;
  29972. +    }
  29973. +    return 0;
  29974. +}
  29975. +
  29976. +/*
  29977. + * Note that releasing a pty master also releases the child, so
  29978. + * we have to make the redirection checks after that and on both
  29979. + * sides of a pty.
  29980. + */
  29981. +static void tty_release(struct inode * inode, struct file * filp)
  29982. +{
  29983. +    release_dev(filp);
  29984. +}
  29985. +
  29986. +static int tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
  29987. +{
  29988. +    struct tty_struct * tty;
  29989. +
  29990. +    tty = (struct tty_struct *)filp->private_data;
  29991. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_select"))
  29992. +        return 0;
  29993. +
  29994. +    if (tty->ldisc.select)
  29995. +        return (tty->ldisc.select)(tty, inode, filp, sel_type, wait);
  29996. +    return 0;
  29997. +}
  29998. +
  29999. +/*
  30000. + * fasync_helper() is used by some character device drivers (mainly mice)
  30001. + * to set up the fasync queue. It returns negative on error, 0 if it did
  30002. + * no changes and positive if it added/deleted the entry.
  30003. + */
  30004. +int fasync_helper(struct inode * inode, struct file * filp, int on, struct fasync_struct **fapp)
  30005. +{
  30006. +    struct fasync_struct *fa, **fp;
  30007. +    unsigned long flags;
  30008. +
  30009. +    for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
  30010. +        if (fa->fa_file == filp)
  30011. +            break;
  30012. +    }
  30013. +
  30014. +    if (on) {
  30015. +        if (fa)
  30016. +            return 0;
  30017. +        fa = (struct fasync_struct *)kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
  30018. +        if (!fa)
  30019. +            return -ENOMEM;
  30020. +        fa->magic = FASYNC_MAGIC;
  30021. +        fa->fa_file = filp;
  30022. +        save_flags_cli (flags);
  30023. +        fa->fa_next = *fapp;
  30024. +        *fapp = fa;
  30025. +        restore_flags(flags);
  30026. +        return 1;
  30027. +    }
  30028. +    if (!fa)
  30029. +        return 0;
  30030. +    save_flags_cli (flags);
  30031. +    *fp = fa->fa_next;
  30032. +    restore_flags(flags);
  30033. +    kfree(fa);
  30034. +    return 1;
  30035. +}
  30036. +
  30037. +static int tty_fasync(struct inode * inode, struct file * filp, int on)
  30038. +{
  30039. +    struct tty_struct * tty;
  30040. +    int retval;
  30041. +
  30042. +    tty = (struct tty_struct *)filp->private_data;
  30043. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_fasync"))
  30044. +        return 0;
  30045. +
  30046. +    retval = fasync_helper(inode, filp, on, &tty->fasync);
  30047. +    if (retval <= 0)
  30048. +        return retval;
  30049. +
  30050. +    if (on) {
  30051. +        if (!waitqueue_active(&tty->read_wait))
  30052. +            tty->minimum_to_wake = 1;
  30053. +        if (filp->f_owner == 0) {
  30054. +            if (tty->pgrp)
  30055. +                filp->f_owner = -tty->pgrp;
  30056. +            else
  30057. +                filp->f_owner = current->pid;
  30058. +        }
  30059. +    } else {
  30060. +        if (!tty->fasync && !waitqueue_active(&tty->read_wait))
  30061. +            tty->minimum_to_wake = N_TTY_BUF_SIZE;
  30062. +    }
  30063. +    return 0;    
  30064. +}
  30065. +
  30066. +#if 0
  30067. +/*
  30068. + * XXX does anyone use this anymore?!?
  30069. + */
  30070. +static int do_get_ps_info(unsigned long arg)
  30071. +{
  30072. +    struct tstruct {
  30073. +        int flag;
  30074. +        int present[NR_TASKS];
  30075. +        struct task_struct tasks[NR_TASKS];
  30076. +    };
  30077. +    struct tstruct *ts = (struct tstruct *)arg;
  30078. +    struct task_struct **p;
  30079. +    char *c, *d;
  30080. +    int i, n = 0;
  30081. +    
  30082. +    i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct tstruct));
  30083. +    if (i)
  30084. +        return i;
  30085. +    for (p = &FIRST_TASK ; p <= &LAST_TASK ; p++, n++)
  30086. +        if (*p)
  30087. +        {
  30088. +            c = (char *)(*p);
  30089. +            d = (char *)(ts->tasks+n);
  30090. +            for (i=0 ; i<sizeof(struct task_struct) ; i++)
  30091. +                put_user(*c++, d++);
  30092. +            put_user(1, ts->present+n);
  30093. +        }
  30094. +        else    
  30095. +            put_user(0, ts->present+n);
  30096. +    return(0);            
  30097. +}
  30098. +#endif
  30099. +
  30100. +static int tty_ioctl(struct inode * inode, struct file * file,
  30101. +             unsigned int cmd, unsigned long arg)
  30102. +{
  30103. +    int    retval;
  30104. +    struct tty_struct * tty;
  30105. +    struct tty_struct * real_tty;
  30106. +    struct winsize tmp_ws;
  30107. +    pid_t pgrp;
  30108. +    unsigned char    ch;
  30109. +    char    mbz = 0;
  30110. +    
  30111. +    tty = (struct tty_struct *)file->private_data;
  30112. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
  30113. +        return -EINVAL;
  30114. +
  30115. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  30116. +        tty->driver.subtype == PTY_TYPE_MASTER)
  30117. +        real_tty = tty->link;
  30118. +    else
  30119. +        real_tty = tty;
  30120. +
  30121. +    switch (cmd) {
  30122. +        case TIOCSTI:
  30123. +            if ((current->tty != tty) && !suser())
  30124. +                return -EPERM;
  30125. +            retval = verify_area(VERIFY_READ, (void *) arg, 1);
  30126. +            if (retval)
  30127. +                return retval;
  30128. +            ch = get_user((char *) arg);
  30129. +            tty->ldisc.receive_buf(tty, &ch, &mbz, 1);
  30130. +            return 0;
  30131. +        case TIOCGWINSZ:
  30132. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  30133. +                         sizeof (struct winsize));
  30134. +            if (retval)
  30135. +                return retval;
  30136. +            memcpy_tofs((struct winsize *) arg, &tty->winsize,
  30137. +                    sizeof (struct winsize));
  30138. +            return 0;
  30139. +        case TIOCSWINSZ:
  30140. +            retval = verify_area(VERIFY_READ, (void *) arg,
  30141. +                         sizeof (struct winsize));
  30142. +            if (retval)
  30143. +                return retval;            
  30144. +            memcpy_fromfs(&tmp_ws, (struct winsize *) arg,
  30145. +                      sizeof (struct winsize));
  30146. +            if (memcmp(&tmp_ws, &tty->winsize,
  30147. +                   sizeof(struct winsize))) {
  30148. +                if (tty->pgrp > 0)
  30149. +                    kill_pg(tty->pgrp, SIGWINCH, 1);
  30150. +                if ((real_tty->pgrp != tty->pgrp) &&
  30151. +                    (real_tty->pgrp > 0))
  30152. +                    kill_pg(real_tty->pgrp, SIGWINCH, 1);
  30153. +            }
  30154. +            tty->winsize = tmp_ws;
  30155. +            real_tty->winsize = tmp_ws;
  30156. +            return 0;
  30157. +        case TIOCCONS:
  30158. +            if (tty->driver.type == TTY_DRIVER_TYPE_CONSOLE) {
  30159. +                if (!suser())
  30160. +                    return -EPERM;
  30161. +                redirect = NULL;
  30162. +                return 0;
  30163. +            }
  30164. +            if (redirect)
  30165. +                return -EBUSY;
  30166. +            redirect = real_tty;
  30167. +            return 0;
  30168. +        case FIONBIO:
  30169. +            retval = verify_area(VERIFY_READ, (void *) arg, sizeof(int));
  30170. +            if (retval)
  30171. +                return retval;
  30172. +            arg = get_user((unsigned int *) arg);
  30173. +            if (arg)
  30174. +                file->f_flags |= O_NONBLOCK;
  30175. +            else
  30176. +                file->f_flags &= ~O_NONBLOCK;
  30177. +            return 0;
  30178. +        case TIOCEXCL:
  30179. +            set_bit(TTY_EXCLUSIVE, &tty->flags);
  30180. +            return 0;
  30181. +        case TIOCNXCL:
  30182. +            clear_bit(TTY_EXCLUSIVE, &tty->flags);
  30183. +            return 0;
  30184. +        case TIOCNOTTY:
  30185. +            if (current->tty != tty)
  30186. +                return -ENOTTY;
  30187. +            if (current->leader)
  30188. +                disassociate_ctty(0);
  30189. +            current->tty = NULL;
  30190. +            return 0;
  30191. +        case TIOCSCTTY:
  30192. +            if (current->leader &&
  30193. +                (current->session == tty->session))
  30194. +                return 0;
  30195. +            /*
  30196. +             * The process must be a session leader and
  30197. +             * not have a controlling tty already.
  30198. +             */
  30199. +            if (!current->leader || current->tty)
  30200. +                return -EPERM;
  30201. +            if (tty->session > 0) {
  30202. +                /*
  30203. +                 * This tty is already the controlling
  30204. +                 * tty for another session group!
  30205. +                 */
  30206. +                if ((arg == 1) && suser()) {
  30207. +                    /*
  30208. +                     * Steal it away
  30209. +                     */
  30210. +                    struct task_struct *p;
  30211. +
  30212. +                    for_each_task(p)
  30213. +                        if (p->tty == tty)
  30214. +                            p->tty = NULL;
  30215. +                } else
  30216. +                    return -EPERM;
  30217. +            }
  30218. +            current->tty = tty;
  30219. +            current->tty_old_pgrp = 0;
  30220. +            tty->session = current->session;
  30221. +            tty->pgrp = current->pgrp;
  30222. +            return 0;
  30223. +        case TIOCGPGRP:
  30224. +            /*
  30225. +             * (tty == real_tty) is a cheap way of
  30226. +             * testing if the tty is NOT a master pty.
  30227. +             */
  30228. +            if (tty == real_tty && current->tty != real_tty)
  30229. +                return -ENOTTY;
  30230. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  30231. +                         sizeof (pid_t));
  30232. +            if (retval)
  30233. +                return retval;
  30234. +            put_user(real_tty->pgrp, (pid_t *) arg);
  30235. +            return 0;
  30236. +        case TIOCSPGRP:
  30237. +            retval = tty_check_change(real_tty);
  30238. +            if (retval == -EIO)
  30239. +                return -ENOTTY;
  30240. +            if (retval)
  30241. +                return retval;
  30242. +            if (!current->tty ||
  30243. +                (current->tty != real_tty) ||
  30244. +                (real_tty->session != current->session))
  30245. +                return -ENOTTY;
  30246. +            pgrp = get_user((pid_t *) arg);
  30247. +            if (pgrp < 0)
  30248. +                return -EINVAL;
  30249. +            if (session_of_pgrp(pgrp) != current->session)
  30250. +                return -EPERM;
  30251. +            real_tty->pgrp = pgrp;
  30252. +            return 0;
  30253. +        case TIOCGETD:
  30254. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  30255. +                         sizeof (int));
  30256. +            if (retval)
  30257. +                return retval;
  30258. +            put_user(tty->ldisc.num, (int *) arg);
  30259. +            return 0;
  30260. +        case TIOCSETD:
  30261. +            retval = tty_check_change(tty);
  30262. +            if (retval)
  30263. +                return retval;
  30264. +            retval = verify_area(VERIFY_READ, (void *) arg,
  30265. +                         sizeof (int));
  30266. +            if (retval)
  30267. +                return retval;
  30268. +            arg = get_user((int *) arg);
  30269. +            return tty_set_ldisc(tty, arg);
  30270. +        case TIOCLINUX:
  30271. +            if (tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)
  30272. +                return -EINVAL;
  30273. +            if (current->tty != tty && !suser())
  30274. +                return -EPERM;
  30275. +            retval = verify_area(VERIFY_READ, (void *) arg, 1);
  30276. +            if (retval)
  30277. +                return retval;
  30278. +            switch (retval = get_user((char *)arg))
  30279. +            {
  30280. +                case 0:
  30281. +                case 8:
  30282. +                case 9:
  30283. +                    printk("TIOCLINUX (0/8/9) ioctl is gone - use /dev/vcs\n");
  30284. +                    return -EINVAL;
  30285. +#if 0
  30286. +                case 1:
  30287. +                    printk("Deprecated TIOCLINUX (1) ioctl\n");
  30288. +                    return do_get_ps_info(arg);
  30289. +#endif
  30290. +                case 2:
  30291. +                    return set_selection(arg, tty);
  30292. +                case 3:
  30293. +                    return paste_selection(tty);
  30294. +                case 4:
  30295. +                    vt_do_unblankscreen ();
  30296. +                    return 0;
  30297. +                case 5:
  30298. +                    return sel_loadlut(arg);
  30299. +                case 6:
  30300. +            /*
  30301. +             * Make it possible to react to Shift+Mousebutton.
  30302. +             * Note that 'shift_state' is an undocumented
  30303. +             * kernel-internal variable; programs not closely
  30304. +             * related to the kernel should not use this.
  30305. +             */
  30306. +                    retval = verify_area(VERIFY_WRITE, (void *) arg, 1);
  30307. +                    if (retval)
  30308. +                        return retval;
  30309. +                    put_user(shift_state,(char *) arg);
  30310. +                    return 0;
  30311. +                case 7:
  30312. +                    retval = verify_area(VERIFY_WRITE, (void *) arg, 1);
  30313. +                    if (retval)
  30314. +                        return retval;
  30315. +                    put_user(mouse_reporting(),(char *) arg);
  30316. +                    return 0;
  30317. +/*                case 10:
  30318. +                    set_vesa_blanking(arg);
  30319. +                    return 0;*/
  30320. +                case 11:    /* set kmsg redirect */
  30321. +                    if (!suser())
  30322. +                        return -EPERM;
  30323. +                    retval = verify_area(VERIFY_READ,
  30324. +                        (void *) arg+1, 1);
  30325. +                    if (retval)
  30326. +                        return retval;
  30327. +                    kmsg_redirect = get_user((char *)arg+1);
  30328. +                    return 0;
  30329. +                case 12:    /* get fg console */
  30330. +                    return vtdata.fgconsole->num;
  30331. +                default: 
  30332. +                    return -EINVAL;
  30333. +            }
  30334. +
  30335. +        case TIOCTTYGSTRUCT:
  30336. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  30337. +                        sizeof(struct tty_struct));
  30338. +            if (retval)
  30339. +                return retval;
  30340. +            memcpy_tofs((struct tty_struct *) arg,
  30341. +                    tty, sizeof(struct tty_struct));
  30342. +            return 0;
  30343. +        default:
  30344. +            if (tty->driver.ioctl) {
  30345. +                retval = (tty->driver.ioctl)(tty, file,
  30346. +                                 cmd, arg);
  30347. +                if (retval != -ENOIOCTLCMD)
  30348. +                    return retval;
  30349. +            }
  30350. +            if (tty->ldisc.ioctl) {
  30351. +                retval = (tty->ldisc.ioctl)(tty, file,
  30352. +                                cmd, arg);
  30353. +                if (retval != -ENOIOCTLCMD)
  30354. +                    return retval;
  30355. +            }
  30356. +            return -EINVAL;
  30357. +        }
  30358. +}
  30359. +
  30360. +
  30361. +/*
  30362. + * This implements the "Secure Attention Key" ---  the idea is to
  30363. + * prevent trojan horses by killing all processes associated with this
  30364. + * tty when the user hits the "Secure Attention Key".  Required for
  30365. + * super-paranoid applications --- see the Orange Book for more details.
  30366. + * 
  30367. + * This code could be nicer; ideally it should send a HUP, wait a few
  30368. + * seconds, then send a INT, and then a KILL signal.  But you then
  30369. + * have to coordinate with the init process, since all processes associated
  30370. + * with the current tty must be dead before the new getty is allowed
  30371. + * to spawn.
  30372. + */
  30373. +void do_SAK( struct tty_struct *tty)
  30374. +{
  30375. +#ifdef TTY_SOFT_SAK
  30376. +    tty_hangup(tty);
  30377. +#else
  30378. +    struct task_struct **p;
  30379. +    int session;
  30380. +    int        i;
  30381. +    struct file    *filp;
  30382. +    
  30383. +    if (!tty)
  30384. +        return;
  30385. +    session  = tty->session;
  30386. +    if (tty->ldisc.flush_buffer)
  30387. +        tty->ldisc.flush_buffer(tty);
  30388. +    if (tty->driver.flush_buffer)
  30389. +        tty->driver.flush_buffer(tty);
  30390. +     for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
  30391. +        if (!(*p))
  30392. +            continue;
  30393. +        if (((*p)->tty == tty) ||
  30394. +            ((session > 0) && ((*p)->session == session)))
  30395. +            send_sig(SIGKILL, *p, 1);
  30396. +        else {
  30397. +            for (i=0; i < NR_OPEN; i++) {
  30398. +                filp = (*p)->files->fd[i];
  30399. +                if (filp && (filp->f_op == &tty_fops) &&
  30400. +                    (filp->private_data == tty)) {
  30401. +                    send_sig(SIGKILL, *p, 1);
  30402. +                    break;
  30403. +                }
  30404. +            }
  30405. +        }
  30406. +    }
  30407. +#endif
  30408. +}
  30409. +
  30410. +/*
  30411. + * This routine is called out of the software interrupt to flush data
  30412. + * from the flip buffer to the line discipline.
  30413. + */
  30414. +static void flush_to_ldisc(void *private_)
  30415. +{
  30416. +    struct tty_struct *tty = (struct tty_struct *) private_;
  30417. +    unsigned char    *cp;
  30418. +    char        *fp;
  30419. +    int        count;
  30420. +
  30421. +    if (tty->flip.buf_num) {
  30422. +        cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
  30423. +        fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
  30424. +        tty->flip.buf_num = 0;
  30425. +
  30426. +        cli();
  30427. +        tty->flip.char_buf_ptr = tty->flip.char_buf;
  30428. +        tty->flip.flag_buf_ptr = tty->flip.flag_buf;
  30429. +    } else {
  30430. +        cp = tty->flip.char_buf;
  30431. +        fp = tty->flip.flag_buf;
  30432. +        tty->flip.buf_num = 1;
  30433. +
  30434. +        cli();
  30435. +        tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
  30436. +        tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
  30437. +    }
  30438. +    count = tty->flip.count;
  30439. +    tty->flip.count = 0;
  30440. +    sti();
  30441. +    
  30442. +#if 0
  30443. +    if (count > tty->max_flip_cnt)
  30444. +        tty->max_flip_cnt = count;
  30445. +#endif
  30446. +    tty->ldisc.receive_buf(tty, cp, fp, count);
  30447. +}
  30448. +
  30449. +/*
  30450. + * This subroutine initializes a tty structure.
  30451. + */
  30452. +static void initialize_tty_struct(struct tty_struct *tty)
  30453. +{
  30454. +    memset(tty, 0, sizeof(struct tty_struct));
  30455. +    tty->magic = TTY_MAGIC;
  30456. +    tty->ldisc = ldiscs[N_TTY];
  30457. +    tty->pgrp = -1;
  30458. +    tty->flip.char_buf_ptr = tty->flip.char_buf;
  30459. +    tty->flip.flag_buf_ptr = tty->flip.flag_buf;
  30460. +    tty->flip.tqueue.routine = flush_to_ldisc;
  30461. +    tty->flip.tqueue.data = tty;
  30462. +}
  30463. +
  30464. +/*
  30465. + * The default put_char routine if the driver did not define one.
  30466. + */
  30467. +void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
  30468. +{
  30469. +    tty->driver.write(tty, 0, &ch, 1);
  30470. +}
  30471. +
  30472. +/*
  30473. + * Called by a tty driver to register itself.
  30474. + */
  30475. +int tty_register_driver(struct tty_driver *driver)
  30476. +{
  30477. +    int error;
  30478. +
  30479. +    if (driver->flags & TTY_DRIVER_INSTALLED)
  30480. +        return 0;
  30481. +
  30482. +    error = register_chrdev(driver->major, driver->name, &tty_fops);
  30483. +    if (error < 0)
  30484. +        return error;
  30485. +    else if(driver->major == 0)
  30486. +        driver->major = error;
  30487. +
  30488. +    if (!driver->put_char)
  30489. +        driver->put_char = tty_default_put_char;
  30490. +    
  30491. +    driver->prev = 0;
  30492. +    driver->next = tty_drivers;
  30493. +    if (tty_drivers) tty_drivers->prev = driver;
  30494. +    tty_drivers = driver;
  30495. +    return error;
  30496. +}
  30497. +
  30498. +/*
  30499. + * Called by a tty driver to unregister itself.
  30500. + */
  30501. +int tty_unregister_driver(struct tty_driver *driver)
  30502. +{
  30503. +    int    retval;
  30504. +    struct tty_driver *p;
  30505. +    int    found = 0;
  30506. +    const char *othername = NULL;
  30507. +    
  30508. +    if (*driver->refcount)
  30509. +        return -EBUSY;
  30510. +
  30511. +    for (p = tty_drivers; p; p = p->next) {
  30512. +        if (p == driver)
  30513. +            found++;
  30514. +        else if (p->major == driver->major)
  30515. +            othername = p->name;
  30516. +    }
  30517. +
  30518. +    if (!found)
  30519. +        return -ENOENT;
  30520. +
  30521. +    if (othername == NULL) {
  30522. +        retval = unregister_chrdev(driver->major, driver->name);
  30523. +        if (retval)
  30524. +            return retval;
  30525. +    } else
  30526. +        register_chrdev(driver->major, othername, &tty_fops);
  30527. +
  30528. +    if (driver->prev)
  30529. +        driver->prev->next = driver->next;
  30530. +    else
  30531. +        tty_drivers = driver->next;
  30532. +    
  30533. +    if (driver->next)
  30534. +        driver->next->prev = driver->prev;
  30535. +
  30536. +    return 0;
  30537. +}
  30538. +
  30539. +
  30540. +/*
  30541. + * Initialize the console device. This is called *early*, so
  30542. + * we can't necessarily depend on lots of kernel help here.
  30543. + * Just do some early initializations, and do the complex setup
  30544. + * later.
  30545. + */
  30546. +long console_init(long kmem_start, long kmem_end)
  30547. +{
  30548. +    /* Setup the default TTY line discipline. */
  30549. +    memset(ldiscs, 0, sizeof(ldiscs));
  30550. +    (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
  30551. +
  30552. +    /*
  30553. +     * Set up the standard termios.  Individual tty drivers may 
  30554. +     * deviate from this; this is used as a template.
  30555. +     */
  30556. +    memset(&tty_std_termios, 0, sizeof(struct termios));
  30557. +    memcpy(tty_std_termios.c_cc, INIT_C_CC, NCCS);
  30558. +    tty_std_termios.c_iflag = ICRNL | IXON;
  30559. +    tty_std_termios.c_oflag = OPOST | ONLCR;
  30560. +    tty_std_termios.c_cflag = B38400 | CS8 | CREAD | HUPCL;
  30561. +    tty_std_termios.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
  30562. +        ECHOCTL | ECHOKE | IEXTEN;
  30563. +
  30564. +    /*
  30565. +     * set up the console device so that later boot sequences can 
  30566. +     * inform about problems etc..
  30567. +     */
  30568. +    return vt_pre_init(kmem_start);
  30569. +}
  30570. +
  30571. +static struct tty_driver dev_tty_driver, dev_console_driver;
  30572. +
  30573. +/*
  30574. + * Ok, now we can initialize the rest of the tty devices and can count
  30575. + * on memory allocations, interrupts etc..
  30576. + */
  30577. +int tty_init(void)
  30578. +{
  30579. +    if (sizeof(struct tty_struct) > PAGE_SIZE)
  30580. +        panic("size of tty structure > PAGE_SIZE!");
  30581. +    vt_post_init ();
  30582. +
  30583. +    /*
  30584. +     * dev_tty_driver and dev_console_driver are actually magic
  30585. +     * devices which get redirected at open time.  Nevertheless,
  30586. +     * we register them so that register_chrdev is called
  30587. +     * appropriately.
  30588. +     */
  30589. +    memset(&dev_tty_driver, 0, sizeof(struct tty_driver));
  30590. +    dev_tty_driver.magic = TTY_DRIVER_MAGIC;
  30591. +    dev_tty_driver.name = "tty";
  30592. +    dev_tty_driver.name_base = 0;
  30593. +    dev_tty_driver.major = TTY_MAJOR;
  30594. +    dev_tty_driver.minor_start = 0;
  30595. +    dev_tty_driver.num = 1;
  30596. +
  30597. +    if (tty_register_driver(&dev_tty_driver))
  30598. +        panic("Couldn't register /dev/tty driver\n");
  30599. +
  30600. +    dev_console_driver = dev_tty_driver;
  30601. +    dev_console_driver.name = "console";
  30602. +    dev_console_driver.major = TTYAUX_MAJOR;
  30603. +
  30604. +    if (tty_register_driver(&dev_console_driver))
  30605. +        panic("Couldn't register /dev/console driver\n");
  30606. +
  30607. +#ifdef CONFIG_SERIAL
  30608. +    rs_init();
  30609. +#endif
  30610. +    pty_init();
  30611. +    vcs_init();
  30612. +    return 0;
  30613. +}
  30614. +
  30615. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/uni_hash.tbl linux/arch/arm/drivers/char/uni_hash.tbl
  30616. --- linux.orig/arch/arm/drivers/char/uni_hash.tbl    Thu Jan  1 01:00:00 1970
  30617. +++ linux/arch/arm/drivers/char/uni_hash.tbl    Thu Jul 18 23:41:22 1996
  30618. @@ -0,0 +1,89 @@
  30619. +/*
  30620. + * uni_hash.tbl
  30621. + *
  30622. + * Do not edit this file; it was automatically generated by
  30623. + *
  30624. + * conmakehash cp437.uni > uni_hash.tbl
  30625. + *
  30626. + */
  30627. +
  30628. +#include <linux/types.h>
  30629. +#include <linux/kd.h>
  30630. +
  30631. +static u8 dfont_unicount[256] = 
  30632. +{
  30633. +      1,   1,   1,   1,   2,   1,   1,   1,
  30634. +      1,   1,   1,   1,   1,   1,   1,   1,
  30635. +      2,   2,   1,   1,   1,   1,   1,   1,
  30636. +      1,   1,   1,   1,   1,   1,   1,   1,
  30637. +      1,   1,   2,   1,   1,   1,   1,   1,
  30638. +      1,   1,   1,   1,   2,   2,   1,   1,
  30639. +      1,   1,   1,   1,   1,   1,   1,   1,
  30640. +      1,   1,   1,   1,   1,   1,   1,   1,
  30641. +      1,   5,   1,   2,   1,   4,   1,   1,
  30642. +      1,   5,   1,   2,   1,   1,   1,   5,
  30643. +      1,   1,   2,   1,   1,   4,   1,   1,
  30644. +      1,   2,   1,   1,   1,   1,   1,   2,
  30645. +      1,   2,   1,   1,   1,   1,   1,   1,
  30646. +      1,   1,   1,   1,   1,   1,   1,   2,
  30647. +      1,   1,   1,   1,   1,   1,   1,   1,
  30648. +      2,   2,   1,   1,   2,   1,   1,   1,
  30649. +      1,   1,   1,   1,   1,   1,   1,   1,
  30650. +      1,   1,   1,   1,   1,   1,   1,   2,
  30651. +      1,   1,   1,   1,   1,   1,   1,   1,
  30652. +      1,   1,   1,   1,   1,   1,   1,   1,
  30653. +      1,   1,   1,   1,   1,   1,   1,   1,
  30654. +      1,   1,   1,   1,   1,   1,   1,   1,
  30655. +      1,   1,   1,   1,   1,   1,   1,   1,
  30656. +      1,   1,   1,   1,   1,   1,   1,   1,
  30657. +      1,   1,   1,   1,   1,   1,   1,   1,
  30658. +      1,   1,   1,   1,   1,   1,   1,   1,
  30659. +      1,   1,   1,   1,   1,   1,   1,   1,
  30660. +      1,   1,   1,   1,   1,   1,   1,   1,
  30661. +      1,   2,   1,   1,   1,   1,   2,   1,
  30662. +      2,   1,   2,   1,   1,   2,   1,   1,
  30663. +      1,   1,   1,   1,   1,   1,   1,   1,
  30664. +      1,   1,   1,   1,   1,   1,   2,   1
  30665. +};
  30666. +
  30667. +static u16 dfont_unitable[297] = 
  30668. +{
  30669. +    0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x25c6, 0x2663, 0x2660,
  30670. +    0x2022, 0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b,
  30671. +    0x263c, 0x25b6, 0x25ba, 0x25c0, 0x25c4, 0x2195, 0x203c, 0x00b6,
  30672. +    0x00a7, 0x25ac, 0x21a8, 0x2191, 0x2193, 0x2192, 0x2190, 0x221f,
  30673. +    0x2194, 0x25b2, 0x25bc, 0x0020, 0x0021, 0x0022, 0x00a8, 0x0023,
  30674. +    0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b,
  30675. +    0x002c, 0x00b8, 0x002d, 0x00ad, 0x002e, 0x002f, 0x0030, 0x0031,
  30676. +    0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039,
  30677. +    0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 0x0040, 0x0041,
  30678. +    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x0042, 0x0043, 0x00a9, 0x0044,
  30679. +    0x0045, 0x00c8, 0x00ca, 0x00cb, 0x0046, 0x0047, 0x0048, 0x0049,
  30680. +    0x00cc, 0x00cd, 0x00ce, 0x00cf, 0x004a, 0x004b, 0x212a, 0x004c,
  30681. +    0x004d, 0x004e, 0x004f, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x0050,
  30682. +    0x0051, 0x0052, 0x00ae, 0x0053, 0x0054, 0x0055, 0x00d9, 0x00da,
  30683. +    0x00db, 0x0056, 0x0057, 0x0058, 0x0059, 0x00dd, 0x005a, 0x005b,
  30684. +    0x005c, 0x005d, 0x005e, 0x005f, 0xf804, 0x0060, 0x0061, 0x00e3,
  30685. +    0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069,
  30686. +    0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 0x00f5, 0x0070,
  30687. +    0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078,
  30688. +    0x00d7, 0x0079, 0x00fd, 0x007a, 0x007b, 0x007c, 0x00a5, 0x007d,
  30689. +    0x007e, 0x2302, 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0,
  30690. +    0x00e5, 0x00e7, 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec,
  30691. +    0x00c4, 0x00c5, 0x212b, 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6,
  30692. +    0x00f2, 0x00fb, 0x00f9, 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3,
  30693. +    0x00a5, 0x20a7, 0x0192, 0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1,
  30694. +    0x00d1, 0x00aa, 0x00ba, 0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc,
  30695. +    0x00a1, 0x00ab, 0x00bb, 0x2591, 0x2592, 0x2593, 0x2502, 0x2524,
  30696. +    0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255d,
  30697. +    0x255c, 0x255b, 0x2510, 0x2514, 0x2534, 0x252c, 0x251c, 0x2500,
  30698. +    0x253c, 0x255e, 0x255f, 0x255a, 0x2554, 0x2569, 0x2566, 0x2560,
  30699. +    0x2550, 0x256c, 0x2567, 0x2568, 0x2564, 0x2565, 0x2559, 0x2558,
  30700. +    0x2552, 0x2553, 0x256b, 0x256a, 0x2518, 0x250c, 0x2588, 0x2584,
  30701. +    0x258c, 0x2590, 0x2580, 0x03b1, 0x03b2, 0x00df, 0x0393, 0x03c0,
  30702. +    0x03a3, 0x03c3, 0x00b5, 0x03bc, 0x03c4, 0x03a6, 0x00d8, 0x0398,
  30703. +    0x03a9, 0x2126, 0x03b4, 0x221e, 0x03c6, 0x00f8, 0x03b5, 0x2229,
  30704. +    0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248,
  30705. +    0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0xfffd,
  30706. +    0x00a0
  30707. +};
  30708. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/vc_screen.c linux/arch/arm/drivers/char/vc_screen.c
  30709. --- linux.orig/arch/arm/drivers/char/vc_screen.c    Thu Jan  1 01:00:00 1970
  30710. +++ linux/arch/arm/drivers/char/vc_screen.c    Fri May 10 23:47:14 1996
  30711. @@ -0,0 +1,268 @@
  30712. +/*
  30713. + * linux/arch/arm/drivers/char/vc_screen.c
  30714. + *
  30715. + * Provide access to virtual console memory.
  30716. + * /dev/vcs0: the screen as it is being viewed right now (possibly scrolled)
  30717. + * /dev/vcsN: the screen of /dev/ttyN (1 <= N <= 63)
  30718. + *            [minor: N]
  30719. + *
  30720. + * /dev/vcsaN: idem, but including attributes, and prefixed with
  30721. + *    the 4 bytes lines,columns,x,y (as screendump used to give)
  30722. + *            [minor: N+128]
  30723. + *
  30724. + * This replaces screendump and part of selection, so that the system
  30725. + * administrator can control access using file system permissions.
  30726. + *
  30727. + * aeb@cwi.nl - efter Friedas begravelse - 950211
  30728. + *
  30729. + * Modified by Russell King (01/01/96) [experimental + in development]
  30730. + */
  30731. +
  30732. +#include <linux/kernel.h>
  30733. +#include <linux/major.h>
  30734. +#include <linux/errno.h>
  30735. +#include <linux/tty.h>
  30736. +#include <linux/fs.h>
  30737. +#include <asm/segment.h>
  30738. +
  30739. +#include "vt_kern.h"
  30740. +#include "selection.h"
  30741. +
  30742. +#define HEADER_SIZE    4
  30743. +
  30744. +static inline int vcs_size (struct inode *inode)
  30745. +{
  30746. +    int size = vtdata.numrows * vtdata.numcolumns;
  30747. +
  30748. +    if (MINOR(inode->i_rdev) & 128)
  30749. +    size = sizeof (unsigned long) * size + HEADER_SIZE;
  30750. +    return size;
  30751. +}
  30752. +
  30753. +static int vcs_lseek (struct inode *inode, struct file *file, off_t offset, int orig)
  30754. +{
  30755. +    int size = vcs_size(inode);
  30756. +
  30757. +    switch (orig) {
  30758. +    case 0:
  30759. +    file->f_pos = offset;
  30760. +    break;
  30761. +    case 1:
  30762. +    file->f_pos += offset;
  30763. +    break;
  30764. +    case 2:
  30765. +    file->f_pos = size + offset;
  30766. +    break;
  30767. +    default:
  30768. +    return -EINVAL;
  30769. +    }
  30770. +    if (file->f_pos < 0 || file->f_pos > size)
  30771. +    return -EINVAL;
  30772. +    return file->f_pos;
  30773. +}
  30774. +
  30775. +static int vcs_read (struct inode *inode, struct file *file, char *buf, int count)
  30776. +{
  30777. +    struct vt *vt;
  30778. +    unsigned long p = file->f_pos;
  30779. +    unsigned int cons = MINOR(inode->i_rdev);
  30780. +    int attr, size, read;
  30781. +    char *buf0;
  30782. +    unsigned long *org, d;
  30783. +
  30784. +    attr = (cons & 128);
  30785. +    cons = (cons & 127);
  30786. +
  30787. +    if (cons == 0)
  30788. +    vt = vtdata.fgconsole;
  30789. +    else
  30790. +    vt = vt_con_data + (cons - 1);
  30791. +
  30792. +    if (!vt_allocated (vt))
  30793. +    return -ENXIO;
  30794. +
  30795. +    size = vcs_size(inode);
  30796. +    if (count < 0 || p > size)
  30797. +    return -EINVAL;
  30798. +
  30799. +    if (count > size - p)
  30800. +    count = size - p;
  30801. +
  30802. +    buf0 = buf;
  30803. +    if (!attr) {
  30804. +    org = screen_pos (vt, p);
  30805. +    while (count-- > 0)
  30806. +        put_user (*org++ & 0xff, buf++);
  30807. +    } else {
  30808. +    if (p < HEADER_SIZE) {
  30809. +        char header[HEADER_SIZE];
  30810. +        header[0] = (char) vtdata.numrows;
  30811. +        header[1] = (char) vtdata.numcolumns;
  30812. +        getconsxy (vt, header + 2);
  30813. +        while (p < HEADER_SIZE && count-- > 0)
  30814. +        put_user (header[p++], buf++);
  30815. +    }
  30816. +    p -= HEADER_SIZE;
  30817. +    org = screen_pos (vt, p >> 2);
  30818. +
  30819. +    if (p & 3) {
  30820. +        unsigned long d = *org++;
  30821. +
  30822. +        switch (p & 3) {
  30823. +        case 1:
  30824. +        if (count-- > 0)
  30825. +            put_user ((d >> 8) & 255, buf++);
  30826. +        case 2:
  30827. +        if (count-- > 0)
  30828. +            put_user ((d >> 16) & 255, buf++);
  30829. +        case 3:
  30830. +        if (count-- > 0)
  30831. +            put_user (d >> 24, buf++);
  30832. +        }
  30833. +    }
  30834. +
  30835. +    while (count > 3) {
  30836. +        put_user (*org++, (unsigned long *) buf);
  30837. +        buf += 4;
  30838. +        count -= 4;
  30839. +    }
  30840. +
  30841. +    if (count > 0) {
  30842. +        d = *org;
  30843. +        put_user (d & 0xff, buf++);
  30844. +        if (count > 1)
  30845. +        put_user ((d >> 8) & 0xff, buf++);
  30846. +        if (count > 2)
  30847. +        put_user ((d >> 16) & 0xff, buf++);
  30848. +    }
  30849. +    }
  30850. +    read = buf - buf0;
  30851. +    file->f_pos += read;
  30852. +    return read;
  30853. +}
  30854. +
  30855. +static int vcs_write (struct inode *inode, struct file *file, const char *buf, int count)
  30856. +{
  30857. +    struct vt *vt;
  30858. +    unsigned long p = file->f_pos;
  30859. +    unsigned int cons = MINOR(inode->i_rdev);
  30860. +    int viewed, attr, size, written;
  30861. +    const char *buf0;
  30862. +    unsigned long *org;
  30863. +
  30864. +    attr = (cons & 128);
  30865. +    cons = (cons & 127);
  30866. +
  30867. +    if (cons == 0) {
  30868. +    vt = vtdata.fgconsole;
  30869. +    viewed = 1;
  30870. +    } else {
  30871. +    vt = vt_con_data + (cons - 1);
  30872. +    viewed = 0;
  30873. +    }
  30874. +
  30875. +    if (!vt_allocated (vt))
  30876. +    return -ENXIO;
  30877. +
  30878. +    size = vcs_size(inode);
  30879. +
  30880. +    if (count < 0 || p > size)
  30881. +    return -EINVAL;
  30882. +
  30883. +    if (count > size - p)
  30884. +    count = size - p;
  30885. +
  30886. +    buf0 = buf;
  30887. +    if (!attr) {
  30888. +    org = screen_pos (vt, p);
  30889. +    while (count-- > 0) {
  30890. +        *org = (*org & 0xffffff00) | get_user (buf++);
  30891. +        org++;
  30892. +    }
  30893. +    } else {
  30894. +    if (p < HEADER_SIZE) {
  30895. +        char header[HEADER_SIZE];
  30896. +        getconsxy (vt, header+2);
  30897. +
  30898. +        while (p < HEADER_SIZE && count-- > 0)
  30899. +        header[p++] = get_user (buf++);
  30900. +        if (!viewed)
  30901. +        putconsxy (vt, header + 2);
  30902. +    }
  30903. +    p -= HEADER_SIZE;
  30904. +    org = screen_pos (vt, p >> 2);
  30905. +
  30906. +    if (p & 3) {
  30907. +        unsigned long d = *org;
  30908. +
  30909. +        switch (p & 3) {
  30910. +        case 1:
  30911. +        if (count-- > 0)
  30912. +                d = (d & 0xffff00ff) | (get_user (buf++) << 8);
  30913. +        case 2:
  30914. +        if (count-- > 0)
  30915. +                d = (d & 0xff00ffff) | (get_user (buf++) << 16);
  30916. +        case 3:
  30917. +        if (count-- > 0)
  30918. +                d = (d & 0x00ffffff) | (get_user (buf++) << 24);
  30919. +        }
  30920. +        *org ++ = d;
  30921. +    }
  30922. +
  30923. +    while (count > 3) {
  30924. +        *org ++ = get_user ((const unsigned long *)buf);
  30925. +        buf += 4;
  30926. +        count -= 4;
  30927. +    }
  30928. +
  30929. +    if (count > 0) {
  30930. +        unsigned long d;
  30931. +
  30932. +        d = (*org >> (count * 8)) << (count * 8);
  30933. +        d |= get_user (buf ++);
  30934. +
  30935. +        if (count > 1)
  30936. +        d |= get_user (buf ++) << 8;
  30937. +
  30938. +        if (count > 2)
  30939. +        d |= get_user (buf ++) << 16;
  30940. +        *org = d;
  30941. +    }
  30942. +    }
  30943. +    written = buf - buf0;
  30944. +    update_scrmem (vt, file->f_pos >> 2, (written + 3) >> 2);
  30945. +    file->f_pos += written;
  30946. +    return written;
  30947. +}
  30948. +
  30949. +static int vcs_open (struct inode *inode, struct file *filp)
  30950. +{
  30951. +    unsigned int cons = (MINOR(inode->i_rdev) & 127);
  30952. +
  30953. +    if (cons && !vt_allocated (vt_con_data + cons - 1))
  30954. +    return -ENXIO;
  30955. +    return 0;
  30956. +}
  30957. +
  30958. +static struct file_operations vcs_fops = {
  30959. +    vcs_lseek,    /* lseek */
  30960. +    vcs_read,    /* read */
  30961. +    vcs_write,    /* write */
  30962. +    NULL,        /* readdir */
  30963. +    NULL,        /* select */
  30964. +    NULL,        /* ioctl */
  30965. +    NULL,        /* mmap */
  30966. +    vcs_open,    /* open */
  30967. +    NULL,        /* release */
  30968. +    NULL        /* fsync */
  30969. +};
  30970. +
  30971. +int vcs_init(void)
  30972. +{
  30973. +    int error;
  30974. +
  30975. +    error = register_chrdev(VCS_MAJOR, "vcs", &vcs_fops);
  30976. +    if (error)
  30977. +    printk("unable to get major %d for vcs device", VCS_MAJOR);
  30978. +    return error;
  30979. +}
  30980. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/vt.c linux/arch/arm/drivers/char/vt.c
  30981. --- linux.orig/arch/arm/drivers/char/vt.c    Thu Jan  1 01:00:00 1970
  30982. +++ linux/arch/arm/drivers/char/vt.c    Sat Sep  7 13:41:49 1996
  30983. @@ -0,0 +1,1029 @@
  30984. +/*
  30985. + * linux/arch/arm/drivers/char/vt.c
  30986. + *
  30987. + * VT routines
  30988. + *
  30989. + * Changelog:
  30990. + *  05-Sep-1996    RMK    Fixed race condition between VT switch & initialisation
  30991. + */
  30992. +
  30993. +#include <linux/config.h>
  30994. +#include <linux/sched.h>
  30995. +#include <linux/tty.h>
  30996. +#include <linux/kd.h>
  30997. +#include <linux/errno.h>
  30998. +#include <linux/malloc.h>
  30999. +#include <linux/mm.h>
  31000. +#include <linux/tty.h>
  31001. +#include <linux/major.h>
  31002. +
  31003. +#include <asm/segment.h>
  31004. +
  31005. +#include "kbd_kern.h"
  31006. +#include "vt_kern.h"
  31007. +
  31008. +#define CON_XMIT_SIZE    2048
  31009. +
  31010. +#ifndef MIN
  31011. +#define MIN(a,b)        ((a) < (b) ? (a) : (b))
  31012. +#endif
  31013. +
  31014. +/*
  31015. + * VCD functions
  31016. + */
  31017. +extern void        vcd_blankscreen (int nopowersave);
  31018. +extern void        vcd_disallocate (struct vt *);
  31019. +extern int        vcd_init (struct vt *, int kmallocok, unsigned long *kmem);
  31020. +extern int        vcd_ioctl (struct vt *, int cmd, unsigned long arg);
  31021. +extern unsigned long    vcd_pre_init (unsigned long kmem, struct vt *);
  31022. +extern int        vcd_resize (int rows, int columns);
  31023. +extern void        vcd_restorestate (const struct vt *);
  31024. +extern void        vcd_savestate (const struct vt *, int blanked);
  31025. +extern void        vcd_unblankscreen (void);
  31026. +extern int        vcd_write (const struct vt *, int from_user, const unsigned char *buf, int count);
  31027. +extern void        vcd_setup_graphics (const struct vt *);
  31028. +
  31029. +extern void con_reset_palette (const struct vt *vt);
  31030. +extern void con_set_palette (const struct vt *vt);
  31031. +extern int con_init (void);
  31032. +
  31033. +static int vt_refcount;
  31034. +static struct tty_driver vt_driver;
  31035. +static struct tty_struct *vt_table[MAX_NR_CONSOLES];
  31036. +static struct termios *vt_termios[MAX_NR_CONSOLES];
  31037. +static struct termios *vt_termios_locked[MAX_NR_CONSOLES];
  31038. +
  31039. +extern void vt_do_blankscreen (int nopowersave);
  31040. +extern void vt_do_unblankscreen (void);
  31041. +
  31042. +struct vt_data vtdata;
  31043. +struct vt vt_con_data[MAX_NR_CONSOLES];
  31044. +
  31045. +/*
  31046. + * last_console is the last used console
  31047. + */
  31048. +struct vt *last_console;
  31049. +
  31050. +/*
  31051. + * Sometimes we want to wait until a particular VT has been activated. We
  31052. + * do it in a very simple manner. Everybody waits on a single queue and
  31053. + * get woken up at once. Those that are satisfied go on with their business,
  31054. + * while those not ready go back to sleep. Seems overkill to add a wait
  31055. + * to each vt just for this - usually this does nothing!
  31056. + */
  31057. +static struct wait_queue *vt_activate_queue = NULL;
  31058. +
  31059. +/*
  31060. + * Sleeps until a vt is activated, or the task is interrupted. Returns
  31061. + * 0 if activation, -1 if interrupted.
  31062. + */
  31063. +static int vt_waitonactivate (void)
  31064. +{
  31065. +    interruptible_sleep_on (&vt_activate_queue);
  31066. +    return (current->signal & ~current->blocked) ? -1 : 0;
  31067. +}
  31068. +
  31069. +#define vt_wake_waitactive() wake_up(&vt_activate_queue)
  31070. +
  31071. +void vt_reset (const struct vt *vt)
  31072. +{
  31073. +    vt->kbd->kbdmode        = VC_XLATE;
  31074. +    vt->vtd->vc_mode        = KD_TEXT;
  31075. +    vt->vtd->vt_mode.mode    = VT_AUTO;
  31076. +    vt->vtd->vt_mode.waitv    = 0;
  31077. +    vt->vtd->vt_mode.relsig    = 0;
  31078. +    vt->vtd->vt_mode.acqsig    = 0;
  31079. +    vt->vtd->vt_mode.frsig    = 0;
  31080. +    vt->vtd->vt_pid        = -1;
  31081. +    vt->vtd->vt_newvt        = NULL;
  31082. +    con_reset_palette (vt);
  31083. +}
  31084. +
  31085. +static int vt_allocate (struct vt *vt)
  31086. +{
  31087. +    if (!vt_allocated(vt)) {
  31088. +    void *data, *p;
  31089. +    int r;
  31090. +
  31091. +    data = kmalloc (sizeof (*vt->vcd) +
  31092. +            sizeof (*vt->kbd) +
  31093. +            sizeof (*vt->vtd) + CON_XMIT_SIZE, GFP_KERNEL);
  31094. +    if (!data)
  31095. +        return -ENOMEM;
  31096. +
  31097. +    vt->vcd = data;  p = ((struct con_struct *)data + 1);
  31098. +    vt->kbd = p;     p = ((struct kbd_struct *)p + 1);
  31099. +    vt->vtd = p;     p = ((struct vt_struct *)p + 1);
  31100. +    vt->vtd->xmit_buf = p;
  31101. +
  31102. +    if ((r = kbd_struct_init (vt, 1)) < 0) {
  31103. +        vt->vcd = NULL;
  31104. +        vt->kbd = NULL;
  31105. +        vt->vtd = NULL;
  31106. +        kfree (data);
  31107. +        return r;
  31108. +    }
  31109. +
  31110. +    if ((r = vcd_init (vt, 1, NULL)) < 0) {
  31111. +        vt->vcd = NULL;
  31112. +        vt->kbd = NULL;
  31113. +        vt->vtd = NULL;
  31114. +        kfree (data);
  31115. +        return r;
  31116. +    }
  31117. +    vt_reset (vt);
  31118. +    vt->vtd->xmitting = vt->vtd->xmit_cnt =
  31119. +    vt->vtd->xmit_out = vt->vtd->xmit_in = 0;
  31120. +    vt->allocinit = 1;
  31121. +    }
  31122. +    return 0;
  31123. +}
  31124. +
  31125. +static int vt_disallocate (struct vt *vt)
  31126. +{
  31127. +    if (vt_allocated (vt)) {
  31128. +    void *data = vt->vcd;
  31129. +
  31130. +    vt->allocinit = 0;
  31131. +    vcd_disallocate (vt);
  31132. +    vt->vcd = NULL;
  31133. +    vt->kbd = NULL;
  31134. +    vt->vtd = NULL;
  31135. +
  31136. +    kfree (data);
  31137. +    }
  31138. +    return 0;
  31139. +}
  31140. +
  31141. +static void vt_updatescreen (const struct vt *newvt)
  31142. +{
  31143. +    static int lock = 0;
  31144. +
  31145. +    if (newvt == vtdata.fgconsole || lock)
  31146. +    return;
  31147. +
  31148. +    if (!vt_allocated (newvt)) {
  31149. +    printk ("updatescreen: tty %d not allocated ??\n", newvt->num);
  31150. +    return;
  31151. +    }
  31152. +
  31153. +    lock = 1;
  31154. +
  31155. +    vcd_savestate (vtdata.fgconsole, vtdata.blanked != NULL);
  31156. +
  31157. +    vtdata.fgconsole = (struct vt *)newvt;
  31158. +
  31159. +    vcd_restorestate (vtdata.fgconsole);
  31160. +    compute_shiftstate ();
  31161. +
  31162. +    lock = 0;
  31163. +}
  31164. +
  31165. +/*
  31166. + * Performs the back end of a vt switch
  31167. + */
  31168. +void vt_completechangeconsole (const struct vt *new_console)
  31169. +{
  31170. +    unsigned char old_vt_mode;
  31171. +    struct vt *old_vt = vtdata.fgconsole;
  31172. +
  31173. +    if (new_console == old_vt)
  31174. +    return;
  31175. +    if (!vt_allocated (new_console))
  31176. +    return;
  31177. +    last_console = old_vt;
  31178. +
  31179. +    /*
  31180. +     * If we're switching, we could be going from KD_GRAPHICS to
  31181. +     * KD_TEXT mode or vice versa, which means we need to blank or
  31182. +     * unblank the screen later.
  31183. +     */
  31184. +    old_vt_mode = old_vt->vtd->vc_mode;
  31185. +    vt_updatescreen (new_console);
  31186. +
  31187. +    /*
  31188. +     * If this new console is under process control, send it a signal
  31189. +     * telling it that it has acquired. Also check if it has died and
  31190. +     * clean up (similar to logic employed in vt_changeconsole())
  31191. +     */
  31192. +    if (new_console->vtd->vt_mode.mode == VT_PROCESS) {
  31193. +    /*
  31194. +     * Send the signal as privileged - kill_proc() will
  31195. +     * tell us if the process has gone or something else
  31196. +     * is awry
  31197. +     */
  31198. +    if (kill_proc(new_console->vtd->vt_pid,
  31199. +                  new_console->vtd->vt_mode.acqsig,
  31200. +                  1) != 0) {
  31201. +        /*
  31202. +         * The controlling process has died, so we revert back to
  31203. +         * normal operation. In this case, we'll also change back
  31204. +         * to KD_TEXT mode. I'm not sure if this is strictly correct
  31205. +         * but it saves the agony when the X server dies and the screen
  31206. +         * remains blanked due to KD_GRAPHICS! It would be nice to do
  31207. +         * this outside of VT_PROCESS but there is no single process
  31208. +         * to account for and tracking tty count may be undesirable.
  31209. +         */
  31210. +        vt_reset (new_console);
  31211. +    }
  31212. +    }
  31213. +
  31214. +    /*
  31215. +     * We do this here because the controlling process above may have
  31216. +     * gone, and so there is now a new vc_mode
  31217. +     */
  31218. +    if (old_vt_mode != new_console->vtd->vc_mode) {
  31219. +    if (new_console->vtd->vc_mode == KD_TEXT)
  31220. +        vt_do_unblankscreen ();
  31221. +    else {
  31222. +        vt_do_blankscreen (1);
  31223. +        vcd_setup_graphics (new_console);
  31224. +    }
  31225. +    }
  31226. +
  31227. +    /* Set the colour palette for this VT */
  31228. +    if (new_console->vtd->vc_mode == KD_TEXT)
  31229. +    con_set_palette (new_console);
  31230. +    
  31231. +    /*
  31232. +     * Wake anyone waiting for their VT to activate
  31233. +     */
  31234. +    vt_wake_waitactive();
  31235. +    return;
  31236. +}
  31237. +
  31238. +/*
  31239. + * Performs the front-end of a vt switch
  31240. + */
  31241. +void vt_changeconsole (struct vt *new_console)
  31242. +{
  31243. +    struct vt *old_vt = vtdata.fgconsole;
  31244. +
  31245. +    if (new_console == old_vt)
  31246. +    return;
  31247. +    if (!vt_allocated (new_console))
  31248. +    return;
  31249. +
  31250. +    /*
  31251. +     * If this vt is in process mode, then we need to handshake with
  31252. +     * that process before switching. Essentially, we store where that
  31253. +     * vt wants to switch to and wait for it to tell us when it's done
  31254. +     * (via VT_RELDISP ioctl).
  31255. +     *
  31256. +     * We also check to see if the controlling process still exists.
  31257. +     * If it doesn't, we reset this vt to auto mode and continue.
  31258. +     * This is a cheap way to track process control. The worst thing
  31259. +     * that can happen is: we send a signal to a process, it dies, and
  31260. +     * the switch gets "lost" waiting for a response; hopefully, the
  31261. +     * user will try again, we'll detect the process is gone (unless
  31262. +     * the user waits just the right amount of time :-) and revert the
  31263. +     * vt to auto control.
  31264. +     */
  31265. +    if (old_vt->vtd->vt_mode.mode == VT_PROCESS) {
  31266. +    /*
  31267. +     * Send the signal as privileged - kill_proc() will
  31268. +     * tell us if the process has gone or something else
  31269. +     * is awry
  31270. +     */
  31271. +    if (kill_proc(old_vt->vtd->vt_pid, old_vt->vtd->vt_mode.relsig, 1) == 0) {
  31272. +        /*
  31273. +         * It worked. Mark the vt to switch to and
  31274. +         * return. The process needs to send us a
  31275. +         * VT_RELDISP ioctl to complete the switch.
  31276. +         */
  31277. +        old_vt->vtd->vt_newvt = new_console;
  31278. +        return;
  31279. +    }
  31280. +
  31281. +    /*
  31282. +     * The controlling process has died, so we revert back to
  31283. +     * normal operation. In this case, we'll also change back
  31284. +     * to KD_TEXT mode. I'm not sure if this is strictly correct
  31285. +     * but it saves the agony when the X server dies and the screen
  31286. +     * remains blanked due to KD_GRAPHICS! It would be nice to do
  31287. +     * this outside of VT_PROCESS but there is no single process
  31288. +     * to account for and tracking tty count may be undesirable.
  31289. +     */
  31290. +    vt_reset (old_vt);
  31291. +
  31292. +    /*
  31293. +     * Fall through to normal (VT_AUTO) handling of the switch...
  31294. +     */
  31295. +    }
  31296. +
  31297. +    /*
  31298. +     * Ignore all switches in KD_GRAPHICS+VT_AUTO mode
  31299. +     */
  31300. +    if (old_vt->vtd->vc_mode == KD_GRAPHICS)
  31301. +    return;
  31302. +
  31303. +    vt_completechangeconsole (new_console);
  31304. +}
  31305. +
  31306. +/*
  31307. + * If a vt is under process control, the kernel will not switch to it
  31308. + * immediately, but postpone the operation until the process calls this
  31309. + * ioctl, allowing the switch to complete.
  31310. + *
  31311. + * According to the X sources this is the behavior:
  31312. + *      0:      pending switch-from not OK
  31313. + *      1:      pending switch-from OK
  31314. + *      2:      completed switch-to OK
  31315. + */
  31316. +static inline int vt_reldisp (const struct vt *old_vt, int arg)
  31317. +{
  31318. +    int i;
  31319. +
  31320. +    if (old_vt->vtd->vt_mode.mode != VT_PROCESS)
  31321. +    return -EINVAL;
  31322. +
  31323. +    if (old_vt->vtd->vt_newvt) {
  31324. +    /*
  31325. +     * Switching-from response
  31326. +     */
  31327. +    if (arg == 0)
  31328. +        /*
  31329. +         * Switch disallowed, so forget we were trying
  31330. +         * to do it.
  31331. +         */
  31332. +        old_vt->vtd->vt_newvt = NULL;
  31333. +    else {
  31334. +        /*
  31335. +         * The current vt has been released, so complete the
  31336. +         * switch.
  31337. +         */
  31338. +        struct vt *new_vt = old_vt->vtd->vt_newvt;
  31339. +        old_vt->vtd->vt_newvt = NULL;
  31340. +        i = vt_allocate (new_vt);
  31341. +        if (i)
  31342. +        return i;
  31343. +        vt_completechangeconsole (new_vt);
  31344. +    }
  31345. +    } else {
  31346. +    /*
  31347. +     * Switched-to response
  31348. +     */
  31349. +    if (arg != VT_ACKACQ)
  31350. +        return -EINVAL;
  31351. +    }
  31352. +    return 0;
  31353. +}
  31354. +
  31355. +/*
  31356. + * Set the mode of a VT.
  31357. + */
  31358. +static inline int vt_kdsetmode (const struct vt *vt, int mode)
  31359. +{
  31360. +    /*
  31361. +     * Currently, setting the mode from KD_TEXT to KD_GRAPHICS
  31362. +     * doesn't do a whole lot. I'm not sure if it should do any
  31363. +     * restoration of modes or what...
  31364. +     */
  31365. +    switch (mode) {
  31366. +    case KD_TEXT0:
  31367. +    case KD_TEXT1:
  31368. +    mode = KD_TEXT;
  31369. +    case KD_GRAPHICS:
  31370. +    case KD_TEXT:
  31371. +    break;
  31372. +    default:
  31373. +    return -EINVAL;
  31374. +    }
  31375. +
  31376. +    if (vt->vtd->vc_mode == mode)
  31377. +    return 0;
  31378. +
  31379. +    vt->vtd->vc_mode = mode;
  31380. +    if (vt != vtdata.fgconsole)
  31381. +    return 0;
  31382. +
  31383. +    /*
  31384. +     * explicitly blank/unblank the screen if switching modes
  31385. +     */
  31386. +    if (mode == KD_TEXT) {
  31387. +    vt_do_unblankscreen ();
  31388. +        vcd_restorestate (vt);
  31389. +    } else {
  31390. +    vt_do_blankscreen (1);
  31391. +    vcd_setup_graphics (vt);
  31392. +    }
  31393. +    return 0;
  31394. +}
  31395. +
  31396. +static inline int vt_setmode (const struct vt *vt, struct vt_mode *vtmode)
  31397. +{
  31398. +    if (vtmode->mode != VT_AUTO && vtmode->mode != VT_PROCESS)
  31399. +    return -EINVAL;
  31400. +
  31401. +    vt->vtd->vt_mode = *vtmode;
  31402. +    vt->vtd->vt_mode.frsig = 0;
  31403. +    vt->vtd->vt_pid = current->pid;
  31404. +    vt->vtd->vt_newvt = NULL;
  31405. +    return 0;
  31406. +}
  31407. +
  31408. +void vt_mksound (unsigned int count, unsigned int vol, unsigned int ticks)
  31409. +{
  31410. +    extern void mk_beep (unsigned int, unsigned int, unsigned int);
  31411. +#ifdef CONFIG_SOUND
  31412. +    mk_beep (count, vol, ticks);
  31413. +#endif
  31414. +}
  31415. +
  31416. +/*
  31417. + * Deallocate memory associated to VT (but leave VT1)
  31418. + */
  31419. +int vt_deallocate (int arg)
  31420. +{
  31421. +    int i;
  31422. +
  31423. +    if (arg == 0) {
  31424. +    /*
  31425. +     * deallocate all unused consoles, but leave 0
  31426. +     */
  31427. +    for (i = 1; i < MAX_NR_CONSOLES; i++)
  31428. +        if (!VT_BUSY (i))
  31429. +        vt_disallocate (vt_con_data + i);
  31430. +    } else {
  31431. +    arg -= 1;
  31432. +    if (VT_BUSY (arg))
  31433. +        return -EBUSY;
  31434. +    if (arg)
  31435. +        vt_disallocate (vt_con_data + arg);
  31436. +    }
  31437. +    return 0;
  31438. +}
  31439. +
  31440. +int vt_resize (int columns, int rows)
  31441. +{
  31442. +    return vcd_resize (rows, columns);
  31443. +}
  31444. +
  31445. +void vt_pokeblankedconsole (void)
  31446. +{
  31447. +    timer_active &= ~(1 << BLANK_TIMER);
  31448. +    if (vtdata.fgconsole->vtd->vc_mode == KD_GRAPHICS)
  31449. +    return;
  31450. +    if (vtdata.blanked) {
  31451. +    timer_table[BLANK_TIMER].expires = 0;
  31452. +    timer_active |= 1 << BLANK_TIMER;
  31453. +    } else
  31454. +    if (vtdata.screen.blankinterval) {
  31455. +    timer_table[BLANK_TIMER].expires = jiffies + vtdata.screen.blankinterval;
  31456. +    timer_active |= 1 << BLANK_TIMER;
  31457. +    }
  31458. +}
  31459. +
  31460. +static void vt_blankscreen (void);
  31461. +
  31462. +void vt_do_unblankscreen (void)
  31463. +{
  31464. +    if (!vtdata.blanked)
  31465. +    return;
  31466. +
  31467. +    if (!vt_allocated (vtdata.fgconsole)) {
  31468. +    /* impossible... */
  31469. +    printk ("unblank_screen: tty %d not allocated ??\n", vtdata.fgconsole->num);
  31470. +    return;
  31471. +    }
  31472. +
  31473. +    timer_table[BLANK_TIMER].fn = vt_blankscreen;
  31474. +
  31475. +    if (vtdata.screen.blankinterval) {
  31476. +    timer_table[BLANK_TIMER].expires = jiffies + vtdata.screen.blankinterval;
  31477. +    timer_active |= 1 << BLANK_TIMER;
  31478. +    }
  31479. +
  31480. +    vtdata.blanked = NULL;
  31481. +
  31482. +    vcd_unblankscreen ();
  31483. +}
  31484. +
  31485. +/*
  31486. + * for panic.c
  31487. + */
  31488. +void do_unblank_screen (void)
  31489. +{
  31490. +    vt_do_unblankscreen ();
  31491. +}
  31492. +
  31493. +void vt_do_blankscreen (int nopowersave)
  31494. +{
  31495. +    if (vtdata.blanked)
  31496. +    return;
  31497. +
  31498. +    timer_active &= ~(1 << BLANK_TIMER);
  31499. +    timer_table[BLANK_TIMER].fn = do_unblank_screen;
  31500. +
  31501. +    vtdata.blanked = vtdata.fgconsole;
  31502. +
  31503. +    vcd_blankscreen (nopowersave);
  31504. +}
  31505. +
  31506. +static void vt_blankscreen (void)
  31507. +{
  31508. +    vt_do_blankscreen (0);
  31509. +}
  31510. +
  31511. +static int vt_open (struct tty_struct *tty, struct file *filp)
  31512. +{
  31513. +    struct vt *vt;
  31514. +    unsigned int idx;
  31515. +    int i;
  31516. +
  31517. +    idx = MINOR(tty->device) - tty->driver.minor_start;
  31518. +
  31519. +    vt = vt_con_data + idx;
  31520. +
  31521. +    if ((i = vt_allocate (vt)) < 0)
  31522. +    return i;
  31523. +
  31524. +    tty->driver_data = vt;
  31525. +
  31526. +    if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
  31527. +    tty->winsize.ws_row = vtdata.numrows;
  31528. +    tty->winsize.ws_col = vtdata.numcolumns;
  31529. +    }
  31530. +    return 0;
  31531. +}
  31532. +
  31533. +static void vt_vtd_flush_chars (const struct vt *vt, struct vt_struct *vtd)
  31534. +{
  31535. +    unsigned long flags;
  31536. +
  31537. +    save_flags (flags);
  31538. +    if (vtd->xmitting)
  31539. +    return;
  31540. +
  31541. +    vtd->xmitting = 1;
  31542. +
  31543. +    while (1) {
  31544. +    int c;
  31545. +
  31546. +    cli ();
  31547. +    c = MIN(vtd->xmit_cnt, CON_XMIT_SIZE - vtd->xmit_out);
  31548. +
  31549. +    if (c <= 0)
  31550. +        break;
  31551. +
  31552. +    restore_flags (flags);
  31553. +
  31554. +    c = vcd_write (vt, 0, vtd->xmit_buf + vtd->xmit_out, c);
  31555. +
  31556. +    cli ();
  31557. +
  31558. +    if (c <= 0)
  31559. +        break;
  31560. +    vtd->xmit_out = (vtd->xmit_out + c) & (CON_XMIT_SIZE - 1);
  31561. +    vtd->xmit_cnt -= c;
  31562. +    }
  31563. +
  31564. +    vtd->xmitting = 0;
  31565. +    restore_flags (flags);
  31566. +    if (*vt->tty)
  31567. +    wake_up_interruptible (&(*vt->tty)->write_wait);
  31568. +}
  31569. +
  31570. +static int vt_write (struct tty_struct *tty, int from_user,
  31571. +            const unsigned char *buf, int count)
  31572. +{
  31573. +    static unsigned long last_error = 0;
  31574. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31575. +
  31576. +    if (vt_allocated (vt)) {
  31577. +    if (vt->vtd->xmit_cnt)
  31578. +        vt_vtd_flush_chars (vt, vt->vtd);
  31579. +    return vcd_write (vt, from_user, buf, count);
  31580. +    }
  31581. +
  31582. +    if (jiffies > last_error + 10*HZ) {
  31583. +    printk ("vt_write: tty %d not allocated\n", vt->num);
  31584. +    last_error = jiffies;
  31585. +    }
  31586. +    return 0;
  31587. +}
  31588. +
  31589. +static void vt_put_char (struct tty_struct *tty, unsigned char ch)
  31590. +{
  31591. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31592. +    unsigned long flags;
  31593. +
  31594. +    if (!vt_allocated (vt))
  31595. +    return;
  31596. +
  31597. +    save_flags_cli (flags);
  31598. +    if (vt->vtd->xmit_cnt < CON_XMIT_SIZE - 1) {
  31599. +    vt->vtd->xmit_buf[vt->vtd->xmit_in++] = ch;
  31600. +    vt->vtd->xmit_in &= CON_XMIT_SIZE - 1;
  31601. +    vt->vtd->xmit_cnt ++;
  31602. +    }
  31603. +    restore_flags (flags);
  31604. +}
  31605. +
  31606. +static void vt_flush_chars (struct tty_struct *tty)
  31607. +{
  31608. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31609. +
  31610. +    if (!vt_allocated (vt) || !vt->vtd->xmit_cnt || tty->stopped)
  31611. +    return;
  31612. +
  31613. +    vt_vtd_flush_chars (vt, vt->vtd);
  31614. +}
  31615. +
  31616. +static int vt_write_room (struct tty_struct *tty)
  31617. +{
  31618. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31619. +    int r;
  31620. +
  31621. +    if (!vt_allocated (vt))
  31622. +    return 0;
  31623. +
  31624. +    r = CON_XMIT_SIZE - vt->vtd->xmit_cnt - 8; /* allow 8 char overflow */
  31625. +    if (r < 0)
  31626. +    return 0;
  31627. +    else
  31628. +    return r;
  31629. +}
  31630. +
  31631. +static int vt_chars_in_buffer (struct tty_struct *tty)
  31632. +{
  31633. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31634. +
  31635. +    if (!vt_allocated (vt))
  31636. +    return CON_XMIT_SIZE;
  31637. +    return vt->vtd->xmit_cnt;
  31638. +}
  31639. +#if 0
  31640. +static void vt_flush_buffer (struct tty_struct *tty)
  31641. +{
  31642. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31643. +
  31644. +    if (!vt_allocated (vt))
  31645. +    return;
  31646. +
  31647. +    cli ();
  31648. +    vt->vtd->xmit_cnt = vt->vtd->xmit_out = vt->vtd->xmit_in = 0;
  31649. +    sti ();
  31650. +}
  31651. +#endif
  31652. +static int vt_ioctl (struct tty_struct *tty, struct file *filp,
  31653. +            unsigned int cmd, unsigned long arg)
  31654. +{
  31655. +    struct vt *vt = tty->driver_data;
  31656. +    int perm, i;
  31657. +
  31658. +    if (!vt_allocated (vt))    /* impossible ? */
  31659. +    return -ENOIOCTLCMD;
  31660. +    /*
  31661. +     * To have permissions to do most of the vt ioctls, we either
  31662. +     * have to be the owner of the tty, or super-user.
  31663. +     */
  31664. +    perm = 0;
  31665. +    if (current->tty == tty || suser ())
  31666. +    perm = 1;
  31667. +
  31668. +    switch (cmd) {
  31669. +    case KDGETMODE:
  31670. +    i = verify_area (VERIFY_WRITE, (void *)arg, sizeof (unsigned long));
  31671. +    if (!i)
  31672. +        put_user (vt->vtd->vc_mode, (unsigned long *)arg);
  31673. +    return i;
  31674. +
  31675. +    case VT_GETMODE:
  31676. +    i = verify_area (VERIFY_WRITE, (void *)arg, sizeof (struct vt_mode));
  31677. +    if (i)
  31678. +        return i;
  31679. +    memcpy_tofs ((void *)arg, &vt->vtd->vt_mode, sizeof (struct vt_mode));
  31680. +    return 0;
  31681. +
  31682. +    case VT_GETSTATE: {
  31683. +    /*
  31684. +     * Returns global VT state.  Note that VT 0 is always open, since
  31685. +     * it's an alias for the current VT, and people can't use it here.
  31686. +     * We cannot return state for more than 16 VTs, since v_state is short.
  31687. +     */
  31688. +    struct vt_stat *vtstat = (struct vt_stat *)arg;
  31689. +    unsigned short state = 1, mask = 2;
  31690. +
  31691. +    i = verify_area (VERIFY_WRITE, vtstat, sizeof (struct vt_stat));
  31692. +    if (i)
  31693. +        return i;
  31694. +
  31695. +    for (i = 0; i < MAX_NR_CONSOLES && mask; ++i, mask <<= 1)
  31696. +        if (VT_IS_IN_USE(i))
  31697. +        state |= mask;
  31698. +
  31699. +    put_user (vtdata.fgconsole->num, &vtstat->v_active);
  31700. +    put_user (state, &vtstat->v_state);
  31701. +    return 0;
  31702. +    }
  31703. +
  31704. +    case VT_OPENQRY:
  31705. +    /*
  31706. +     * Returns the first available (non-open) console
  31707. +     */
  31708. +    i = verify_area (VERIFY_WRITE, (void *)arg, sizeof (unsigned long));
  31709. +    if (i)
  31710. +        return i;
  31711. +
  31712. +    for (i = 0; i < MAX_NR_CONSOLES; i++)
  31713. +        if (!VT_IS_IN_USE(i))
  31714. +        break;
  31715. +    if (i < MAX_NR_CONSOLES)
  31716. +        put_user (i + 1, (unsigned long *)arg);
  31717. +    else
  31718. +        put_user (-1, (unsigned long *)arg);
  31719. +    return 0;
  31720. +
  31721. +    case VT_DISALLOCATE:
  31722. +    if (arg > MAX_NR_CONSOLES)
  31723. +        return -ENXIO;
  31724. +    return vt_deallocate (arg);
  31725. +
  31726. +    case VT_GETSCRINFO:
  31727. +    /*
  31728. +     * Get screen dimentions
  31729. +     */
  31730. +    i = verify_area (VERIFY_WRITE, (void *)arg, 5 * sizeof (unsigned long));
  31731. +    if (!i) {
  31732. +        put_user (0, (unsigned long *)arg);
  31733. +        put_user (vtdata.numcolumns * 8, (unsigned long *)(arg + 4));
  31734. +        put_user (vtdata.numrows * 8, (unsigned long *)(arg + 8));
  31735. +        put_user (vtdata.screen.bitsperpix, (unsigned long *)(arg + 12)); /* bpp */
  31736. +        put_user (4, (unsigned long *)(arg + 16)); /* depth */
  31737. +    }
  31738. +    return i;
  31739. +
  31740. +    case KDGKBTYPE:
  31741. +    case KDADDIO:
  31742. +    case KDDELIO:
  31743. +    case KDENABIO:
  31744. +    case KDDISABIO:
  31745. +    case KDGKBMODE:
  31746. +    case KDGKBMETA:
  31747. +    case KDGETKEYCODE:
  31748. +    case KDGKBENT:
  31749. +    case KDGKBSENT:
  31750. +    case KDGKBDIACR:
  31751. +    case KDGKBLED:
  31752. +    case KDGETLED:
  31753. +    return kbd_ioctl (vt, cmd, arg);
  31754. +
  31755. +    case VT_GETPALETTE:
  31756. +    case GIO_FONT:
  31757. +    case GIO_SCRNMAP:
  31758. +    case GIO_UNISCRNMAP:
  31759. +    case GIO_UNIMAP:
  31760. +    return vcd_ioctl (vt, cmd, arg);
  31761. +    }
  31762. +
  31763. +    if (!perm)
  31764. +    return -EPERM;
  31765. +
  31766. +    switch (cmd) {
  31767. +    case KDSETMODE:
  31768. +    return vt_kdsetmode (vt, arg);
  31769. +
  31770. +    case VT_SETMODE: {
  31771. +    struct vt_mode vtmode;
  31772. +
  31773. +    if (!perm)
  31774. +        return -EPERM;
  31775. +    i = verify_area (VERIFY_READ, (void *)arg, sizeof (struct vt_mode));
  31776. +    if (i)
  31777. +        return i;
  31778. +    memcpy_fromfs (&vtmode, (void *)arg, sizeof (struct vt_mode));
  31779. +    return vt_setmode (vt, &vtmode);
  31780. +    }
  31781. +
  31782. +    case VT_ACTIVATE:
  31783. +    /*
  31784. +     * VT activate will cause us to switch to vt #num with num >= 1
  31785. +     * (switches to vt0, our console, are not allowed, just to preserve
  31786. +     * sanity)
  31787. +     */
  31788. +    if (arg == 0 || arg > MAX_NR_CONSOLES)
  31789. +        return -ENXIO;
  31790. +    vt = vt_con_data + (arg - 1);
  31791. +    i = vt_allocate (vt);
  31792. +    if (i)
  31793. +        return i;
  31794. +
  31795. +    vt_changeconsole (vt);
  31796. +    return 0;
  31797. +
  31798. +    case VT_WAITACTIVE:
  31799. +    /*
  31800. +     * wait until the specified VT has been activated
  31801. +     */
  31802. +    if (arg == 0 || arg > MAX_NR_CONSOLES)
  31803. +        return -ENXIO;
  31804. +    vt = vt_con_data + (arg - 1);
  31805. +    while (vt != vtdata.fgconsole) {
  31806. +        if (vt_waitonactivate () < 0)
  31807. +        return -EINTR;
  31808. +        }
  31809. +    return 0;
  31810. +
  31811. +    case VT_RELDISP:
  31812. +    return vt_reldisp (vt, arg);
  31813. +
  31814. +    case VT_RESIZE: {
  31815. +    struct vt_sizes *vtsizes = (struct vt_sizes *)arg;
  31816. +    ushort ll, cc;
  31817. +    i = verify_area (VERIFY_READ, (void *)vtsizes, sizeof (struct vt_sizes));
  31818. +    if (i)
  31819. +        return i;
  31820. +    ll = get_user (&vtsizes->v_rows);
  31821. +    cc = get_user (&vtsizes->v_cols);
  31822. +    return vt_resize (cc, ll);
  31823. +    }
  31824. +
  31825. +    case KIOCSOUND:
  31826. +    vt_mksound (arg, 72, 5);
  31827. +    return 0;
  31828. +
  31829. +    case KDMKTONE: {
  31830. +    unsigned int freq  = get_user ((unsigned long *)arg);
  31831. +    unsigned int vol   = get_user ((unsigned long *)(arg + 4));
  31832. +    unsigned int ticks = get_user ((unsigned long *)(arg + 8));
  31833. +
  31834. +    /*
  31835. +     * Generate the tone for the apropriate number of ticks.
  31836. +     * If time is zero, turn off sound ourselves.
  31837. +     */
  31838. +    vt_mksound (freq, vol, ticks);
  31839. +    return 0;
  31840. +    }
  31841. +
  31842. +    case KDMAPDISP:
  31843. +    case KDUNMAPDISP:
  31844. +    case KDSKBMODE:
  31845. +    case KDSKBMETA:
  31846. +    case KDSETKEYCODE:
  31847. +    case KDSKBENT:
  31848. +    case KDSKBSENT:
  31849. +    case KDSKBDIACR:
  31850. +    case KDSKBLED:
  31851. +    case KDSETLED:
  31852. +    case KDSIGACCEPT:
  31853. +    return kbd_ioctl (vt, cmd, arg);
  31854. +
  31855. +    case VT_SETPALETTE:
  31856. +    case PIO_FONT:
  31857. +    case PIO_SCRNMAP:
  31858. +    case PIO_UNISCRNMAP:
  31859. +    case PIO_UNIMAPCLR:
  31860. +    case PIO_UNIMAP:
  31861. +    return vcd_ioctl (vt, cmd, arg);
  31862. +    }
  31863. +    return -ENOIOCTLCMD;
  31864. +}
  31865. +/*
  31866. + * Turn the Scroll-Lock LED on when the tty is stopped
  31867. + */
  31868. +static void vt_stop (struct tty_struct *tty)
  31869. +{
  31870. +    if (tty) {
  31871. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31872. +    if (vt_allocated (vt)) {
  31873. +        set_vc_kbd_led (vt->kbd, VC_SCROLLOCK);
  31874. +        set_leds ();
  31875. +    }
  31876. +    }
  31877. +}
  31878. +
  31879. +/*
  31880. + * Turn the Scroll-Lock LED off when the tty is started
  31881. + */
  31882. +static void vt_start (struct tty_struct *tty)
  31883. +{
  31884. +    if (tty) {
  31885. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31886. +    if (vt_allocated (vt)) {
  31887. +        clr_vc_kbd_led (vt->kbd, VC_SCROLLOCK);
  31888. +        set_leds ();
  31889. +    }
  31890. +    if (vt->vtd->xmit_cnt)
  31891. +        vt_vtd_flush_chars (vt, vt->vtd);
  31892. +    }
  31893. +}
  31894. +
  31895. +/*
  31896. + * vt_throttle and vt_unthrottle are only used for
  31897. + * paste_selection(), which has to stuff in a large number
  31898. + * of characters...
  31899. + */
  31900. +static void vt_throttle (struct tty_struct *tty)
  31901. +{
  31902. +}
  31903. +
  31904. +static void vt_unthrottle (struct tty_struct *tty)
  31905. +{
  31906. +    const struct vt *vt = (struct vt *)tty->driver_data;
  31907. +
  31908. +    if (vt_allocated (vt))
  31909. +    wake_up_interruptible (&vt->vtd->paste_wait);
  31910. +}
  31911. +
  31912. +/*
  31913. + * We don't have kmalloc setup yet.  We just want to get enough up so that printk
  31914. + * can work.
  31915. + *
  31916. + * Basically, we setup the VT structures for tty1.
  31917. + */
  31918. +unsigned long vt_pre_init (unsigned long kmem)
  31919. +{
  31920. +    struct vt *vt = vt_con_data;
  31921. +
  31922. +    memset (vt_con_data, 0, sizeof (vt_con_data));
  31923. +
  31924. +    vtdata.numcolumns    = ORIG_VIDEO_COLS;
  31925. +    vtdata.numrows    = ORIG_VIDEO_LINES;
  31926. +    vtdata.blanked    = NULL;
  31927. +    vtdata.fgconsole    = vt_con_data;
  31928. +    vtdata.screen.blankinterval = 10*60*HZ;
  31929. +    vtdata.select.vt    = NULL;
  31930. +    vtdata.select.start = -1;
  31931. +    vtdata.select.end    = 0;
  31932. +    vtdata.select.buffer= NULL;
  31933. +
  31934. +    vt->vcd = (struct con_struct *)kmem;    kmem += sizeof (struct con_struct);
  31935. +    vt->kbd = (struct kbd_struct *)kmem;    kmem += sizeof (struct kbd_struct);
  31936. +    vt->vtd = (struct vt_struct *)kmem;        kmem += sizeof (struct vt_struct);
  31937. +    vt->vtd->xmit_buf = (unsigned char *)kmem;    kmem += CON_XMIT_SIZE;
  31938. +    vt->vtd->xmitting = vt->vtd->xmit_cnt =
  31939. +    vt->vtd->xmit_out = vt->vtd->xmit_in = 0;
  31940. +    vt->tty = &vt_table[0];
  31941. +    vt->num = 1;
  31942. +
  31943. +    /*
  31944. +     * vcd_init is called inside vcd_pre_init
  31945. +     */
  31946. +    kbd_struct_init (vt, 0);
  31947. +    vt_reset (vt);
  31948. +    vt->allocinit = 1;
  31949. +
  31950. +    kmem = vcd_pre_init (kmem, vt);
  31951. +
  31952. +    return kmem;
  31953. +}
  31954. +
  31955. +/*
  31956. + * This is the post initialisation.  We have kmalloc setup so we can use it...
  31957. + */
  31958. +void vt_post_init (void)
  31959. +{
  31960. +    int i;
  31961. +
  31962. +    memset (&vt_driver, 0, sizeof (struct tty_driver));
  31963. +    vt_driver.magic        = TTY_DRIVER_MAGIC;
  31964. +    vt_driver.name        = "tty";
  31965. +    vt_driver.name_base        = 1;
  31966. +    vt_driver.major        = TTY_MAJOR;
  31967. +    vt_driver.minor_start    = 1;
  31968. +    vt_driver.num        = MAX_NR_CONSOLES;
  31969. +    vt_driver.type        = TTY_DRIVER_TYPE_CONSOLE;
  31970. +    vt_driver.init_termios    = tty_std_termios;
  31971. +    vt_driver.flags        = TTY_DRIVER_REAL_RAW;
  31972. +    vt_driver.refcount        = &vt_refcount;
  31973. +    vt_driver.table        = vt_table;
  31974. +    vt_driver.termios        = vt_termios;
  31975. +    vt_driver.termios_locked    = vt_termios_locked;
  31976. +    vt_driver.open        = vt_open;
  31977. +    vt_driver.write        = vt_write;
  31978. +    vt_driver.put_char        = vt_put_char;
  31979. +    vt_driver.flush_chars    = vt_flush_chars;
  31980. +    vt_driver.write_room    = vt_write_room;
  31981. +    vt_driver.chars_in_buffer    = vt_chars_in_buffer;
  31982. +#if 0
  31983. +    vt_driver.flush_buffer    = vt_flush_buffer;
  31984. +#endif
  31985. +    vt_driver.ioctl        = vt_ioctl;
  31986. +    vt_driver.stop        = vt_stop;
  31987. +    vt_driver.start        = vt_start;
  31988. +    vt_driver.throttle        = vt_throttle;
  31989. +    vt_driver.unthrottle    = vt_unthrottle;
  31990. +
  31991. +    for (i = 1; i < MAX_NR_CONSOLES; i++) {
  31992. +    struct vt *vt = vt_con_data + i;
  31993. +    vt->tty = &vt_table[i];
  31994. +    vt->num = i + 1;
  31995. +    vt->allocinit = 0;
  31996. +    if (i < MIN_NR_CONSOLES)
  31997. +        vt_allocate (vt);
  31998. +    }
  31999. +
  32000. +    if (tty_register_driver (&vt_driver))
  32001. +    panic ("Couldn't register console driver");
  32002. +
  32003. +    timer_table[BLANK_TIMER].fn    = vt_blankscreen;
  32004. +    if (vtdata.screen.blankinterval) {
  32005. +    timer_table[BLANK_TIMER].expires = jiffies + vtdata.screen.blankinterval;
  32006. +    timer_active |= 1 << BLANK_TIMER;
  32007. +    } else
  32008. +    timer_table[BLANK_TIMER].expires = 0;
  32009. +
  32010. +    kbd_init ();
  32011. +    vcs_init ();
  32012. +}
  32013. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/char/vt_kern.h linux/arch/arm/drivers/char/vt_kern.h
  32014. --- linux.orig/arch/arm/drivers/char/vt_kern.h    Thu Jan  1 01:00:00 1970
  32015. +++ linux/arch/arm/drivers/char/vt_kern.h    Fri Sep  6 22:23:13 1996
  32016. @@ -0,0 +1,201 @@
  32017. +/*
  32018. + * linux/arch/arm/drivers/char/vt.h
  32019. + *
  32020. + * Virtual Terminal bits...
  32021. + */
  32022. +
  32023. +#ifndef _VT_KERN_H
  32024. +#define _VT_KERN_H
  32025. +
  32026. +#include <linux/vt.h>
  32027. + 
  32028. +#define NPAR 16
  32029. +#define SEL_BUFFER_SIZE 4096
  32030. +
  32031. +struct vc_state {
  32032. +    unsigned char    forecol;        /* foreground            */
  32033. +    unsigned char    backcol;        /* background            */
  32034. +    unsigned char    x;            /* x position            */
  32035. +    unsigned char    y;            /* y position            */
  32036. +#define FLG_BOLD    0x01
  32037. +#define FLG_ITALIC    0x02
  32038. +#define FLG_UNDERLINE    0x04
  32039. +#define FLG_FLASH    0x08
  32040. +#define FLG_INVERSE    0x10
  32041. +#define FLG_CHRSET    0x20
  32042. +    unsigned char    flags;            /* special flags        */
  32043. +    unsigned char    G0_charset;        /* G0 character set        */
  32044. +    unsigned char    G1_charset;        /* G1 character set        */
  32045. +    unsigned char    __unused;        /* unused            */
  32046. +};
  32047. +
  32048. +struct con_struct {
  32049. +    struct {
  32050. +    unsigned int    origin;            /* address of top-left        */
  32051. +    unsigned int    pos;            /* current position into screen    */
  32052. +    unsigned long    *palette_entries;    /* Current palette        */
  32053. +    unsigned int    cursoron;        /* Cursor on count        */
  32054. +    } screen;
  32055. +
  32056. +    struct {
  32057. +    unsigned long    *buffer;        /* pointer to actual buffer    */
  32058. +    unsigned int    size;            /* size of buffer        */
  32059. +    unsigned int    pos;            /* current position into buffer */
  32060. +    unsigned char    kmalloced    : 1;    /* buffer kmalloced        */
  32061. +    } buffer;
  32062. +
  32063. +    /*
  32064. +     * State
  32065. +     */
  32066. +    struct vc_state    curstate;        /* current state        */
  32067. +    struct vc_state    savedstate;        /* saved state            */
  32068. +    unsigned long    combined_state;        /* combined state        */
  32069. +    unsigned long    cached_backcolwrd;    /* cached background colour    */
  32070. +    unsigned long    tab_stop[5];        /* tab stops            */
  32071. +    unsigned short    *translate;        /* translation table        */
  32072. +
  32073. +    unsigned char    top;            /* top of scrollable region    */
  32074. +    unsigned char    bottom;            /* bottom of scrollable region    */
  32075. +    unsigned char    def_forecol;        /* default foreground        */
  32076. +    unsigned char    def_backcol;        /* default background        */
  32077. +
  32078. +     unsigned char    cursor_count;        /* on/off cursor count (int)    */
  32079. +
  32080. +      unsigned char    disp_ctrl    : 1;    /* display control characters    */
  32081. +      unsigned char    toggle_meta    : 1;    /* toggle high bit        */
  32082. +      unsigned char    decscnm        : 1;    /* screen mode            */
  32083. +      unsigned char    decom        : 1;    /* origin mode            */
  32084. +      unsigned char    decawm        : 1;    /* autowrap mode        */
  32085. +      unsigned char    deccm        : 1;    /* cursor visible        */
  32086. +      unsigned char    decim        : 1;    /* insert mode            */
  32087. +      unsigned char    deccolm        : 1;    /* 80/132 col mode        */
  32088. +
  32089. +      unsigned char    report_mouse    : 2;    /* mouse reporting?        */
  32090. +      unsigned char    need_wrap    : 1;    /* need to wrap            */
  32091. +      unsigned char    ques        : 1;
  32092. +    /*
  32093. +     * UTF
  32094. +     */
  32095. +      unsigned char    utf        : 1;    /* Unicode UTF-8 encoding    */
  32096. +
  32097. +     unsigned char    utf_count;        /* UTF character count        */
  32098. +    unsigned long    utf_char;        /* UTF character built        */
  32099. +    unsigned long    npar;            /* number of params        */
  32100. +    unsigned long    par[NPAR];        /* params            */
  32101. +    unsigned char    state;            /* Current escape state        */
  32102. +
  32103. +};
  32104. +
  32105. +struct vt_data {
  32106. +    unsigned char    numcolumns;        /* number of columns        */
  32107. +    unsigned char    numrows;        /* number of rows        */
  32108. +    unsigned char    __unused[2];
  32109. +    struct vt        *fgconsole;        /* displayed VC            */
  32110. +    struct vt        *blanked;        /* blanked VC            */
  32111. +    struct {
  32112. +        unsigned char    bitsperpix;        /* bits per pixel        */
  32113. +    unsigned char    bytespercharh;        /* horiz. bytes a char takes    */
  32114. +    unsigned char    bytespercharv;        /* vert. bytes a char takes    */
  32115. +    unsigned char    __unused[1];
  32116. +    unsigned long    sizerow;        /* size of a row of chars    */
  32117. +    unsigned long    totsize;        /* total size            */
  32118. +    unsigned long    memstart;        /* video mem start        */
  32119. +    unsigned long    memmask;        /* video mem mask        */
  32120. +    unsigned long    memend;            /* video mem end        */
  32121. +    unsigned long    blankinterval;        /* blank interval        */
  32122. +    } screen;
  32123. +    struct {
  32124. +    unsigned long    totsize;        /* total buffer size        */
  32125. +    unsigned long    sizerow;        /* size of a row of chars    */
  32126. +    } buffer;
  32127. +    struct {
  32128. +    struct vt    *vt;            /* selected VC            */
  32129. +    int        start;            /* start offset            */
  32130. +    int        end;            /* end offset            */
  32131. +    int        length;            /* buffer length        */
  32132. +    char        *buffer;        /* buffer            */
  32133. +    } select;
  32134. +};
  32135. +
  32136. +extern struct vt_data vtdata;
  32137. +extern struct tty_driver console_driver;
  32138. +
  32139. +struct vt_struct {
  32140. +    unsigned char    vc_mode;        /* hmm...            */
  32141. +    unsigned char    vc_kbdraw;
  32142. +    unsigned char    vc_kbde0;
  32143. +    unsigned char    vc_kbdleds;
  32144. +    struct vt_mode    vt_mode;
  32145. +    pid_t        vt_pid;
  32146. +    struct vt        *vt_newvt;        /* VT to switch to..        */
  32147. +    struct wait_queue    *paste_wait;
  32148. +    unsigned char *    xmit_buf;
  32149. +    unsigned int    xmit_cnt;
  32150. +    unsigned int    xmit_out;
  32151. +    unsigned int    xmit_in;
  32152. +    unsigned int    xmitting;
  32153. +};
  32154. +
  32155. +struct vt {
  32156. +    /*
  32157. +     * Per-console data
  32158. +     */
  32159. +    struct con_struct *vcd;
  32160. +    /*
  32161. +     * Keyboard stuff
  32162. +     */
  32163. +    struct kbd_struct *kbd;
  32164. +    /*
  32165. +     * VT stuff
  32166. +     */
  32167. +    struct vt_struct *vtd;
  32168. +    /*
  32169. +     * tty that this VT is connected to
  32170. +     */
  32171. +    struct tty_struct **tty;
  32172. +    /*
  32173. +     * tty number of this vt struct
  32174. +     */
  32175. +    unsigned char num;
  32176. +    /*
  32177. +     * is this vt allocated and initialised?
  32178. +     */
  32179. +    unsigned char allocinit;
  32180. +    /*
  32181. +     * might add  scrmem at some time, to have everything
  32182. +     * in one place - the disadvantage would be that
  32183. +     * vc_cons etc can no longer be static
  32184. +     */
  32185. +};
  32186. +
  32187. +extern struct vt vt_con_data[];
  32188. +
  32189. +#define VT_IS_IN_USE(i) (vt_driver.table[i] && vt_driver.table[i]->count)
  32190. +#define VT_BUSY(i) (VT_IS_IN_USE(i) || vt_con_data + i == vtdata.fgconsole || vt_con_data + i == vtdata.select.vt)
  32191. +
  32192. +extern inline int vt_allocated (const struct vt * const vt)
  32193. +{
  32194. +    return vt->allocinit != 0;
  32195. +}
  32196. +
  32197. +extern void        vt_reset (const struct vt *vt);
  32198. +extern void        vt_completechangeconsole (const struct vt *vt);
  32199. +extern void        vt_changeconsole (struct vt *newvt);
  32200. +extern void        vt_mksound (unsigned int count, unsigned int vol, unsigned int ticks);
  32201. +extern int         vt_deallocate (int arg);
  32202. +extern int        vt_resize (int cols, int rows);
  32203. +
  32204. +/*
  32205. + * Blanking ...
  32206. + */
  32207. +extern void        vt_pokeblankedconsole (void);
  32208. +extern void        vt_do_unblankscreen (void);
  32209. +extern void        vt_do_blankscreen (int nopowersave);
  32210. +
  32211. +/*
  32212. + * Initialisation ...
  32213. + */
  32214. +extern unsigned long    vt_pre_init (unsigned long kmem);
  32215. +extern void        vt_post_init (void);
  32216. +
  32217. +#endif /* _VT_KERN_H */
  32218. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/Config.in linux/arch/arm/drivers/net/Config.in
  32219. --- linux.orig/arch/arm/drivers/net/Config.in    Thu Jan  1 01:00:00 1970
  32220. +++ linux/arch/arm/drivers/net/Config.in    Thu Jun 27 20:09:55 1996
  32221. @@ -0,0 +1,21 @@
  32222. +#
  32223. +# Network device configuration
  32224. +#
  32225. +tristate 'Dummy net driver support' CONFIG_DUMMY
  32226. +tristate 'EQL (serial line load balancing) support' CONFIG_EQUALIZER
  32227. +tristate 'PPP (point-to-point) support' CONFIG_PPP
  32228. +if [ ! "$CONFIG_PPP" = "n" ]; then
  32229. +  comment 'CCP compressors for PPP are only built as modules.'
  32230. +fi
  32231. +tristate 'SLIP (serial line) support' CONFIG_SLIP
  32232. +if [ "$CONFIG_SLIP" != "n" ]; then
  32233. +  bool ' CSLIP compressed headers' CONFIG_SLIP_COMPRESSED
  32234. +  bool ' Keepalive and linefill' CONFIG_SLIP_SMART
  32235. +  bool ' Six bit SLIP encapsulation' CONFIG_SLIP_MODE_SLIP6
  32236. +fi
  32237. +#tristate 'PLIP (parallel port) support' CONFIG_PLIP
  32238. +#
  32239. +#    Ethernet
  32240. +#
  32241. +tristate 'Ether1 (82586) support' CONFIG_ETHER1
  32242. +tristate 'Ether3 (NQ8005) support' CONFIG_ETHER3
  32243. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/Makefile linux/arch/arm/drivers/net/Makefile
  32244. --- linux.orig/arch/arm/drivers/net/Makefile    Thu Jan  1 01:00:00 1970
  32245. +++ linux/arch/arm/drivers/net/Makefile    Sun Aug 25 15:39:47 1996
  32246. @@ -0,0 +1,129 @@
  32247. +# File: drivers/net/Makefile
  32248. +#
  32249. +# Makefile for the Linux network (ethercard) device drivers.
  32250. +#
  32251. +
  32252. +all: links first_rule
  32253. +
  32254. +LK    = README.eql README.multicast README.tunnel README1.PLIP README2.PLIP \
  32255. +      bsd_comp.c dummy.c eql.c loopback.c net_init.c slhc.c slip.c slip.h
  32256. +
  32257. +L_TARGET := net.a
  32258. +L_OBJS   := Space.o auto_irq.o net_init.o loopback.o
  32259. +M_OBJS   :=
  32260. +MOD_LIST_NAME := NET_MODULES
  32261. +
  32262. +# Need these to keep track of whether the SLHC module should
  32263. +# really go in the kernel or a module
  32264. +CONFIG_SLHC_BUILTIN :=
  32265. +CONFIG_SLHC_MODULE  :=
  32266. +
  32267. +ifeq ($(CONFIG_ETHER1),y)
  32268. +L_OBJS += ether1.o
  32269. +else
  32270. +  ifeq ($(CONFIG_ETHER1),m)
  32271. +  M_OBJS += ether1.o
  32272. +  endif
  32273. +endif
  32274. +
  32275. +ifeq ($(CONFIG_ETHER3),y)
  32276. +L_OBJS += ether3.o
  32277. +else
  32278. +  ifeq ($(CONFIG_ETHER3),m)
  32279. +  M_OBJS += ether3.o
  32280. +  endif
  32281. +endif
  32282. +
  32283. +ifeq ($(CONFIG_IPIP),y)
  32284. +L_OBJS += tunnel.o
  32285. +else
  32286. +  ifeq ($(CONFIG_IPIP),m)
  32287. +  M_OBJS += tunnel.o
  32288. +  endif
  32289. +endif
  32290. +
  32291. +ifeq ($(CONFIG_PLIP),y)
  32292. +L_OBJS += plip.o
  32293. +else
  32294. +  ifeq ($(CONFIG_PLIP),m)
  32295. +  M_OBJS += plip.o
  32296. +  endif
  32297. +endif
  32298. +
  32299. +ifeq ($(CONFIG_PPP),y)
  32300. +LX_OBJS += ppp.o
  32301. +CONFIG_SLHC_BUILTIN = y
  32302. +else
  32303. +  ifeq ($(CONFIG_PPP),m)
  32304. +  MX_OBJS += ppp.o
  32305. +  CONFIG_SLHC_MODULE = y
  32306. +  endif
  32307. +endif
  32308. +
  32309. +ifneq ($(CONFIG_PPP),n)
  32310. +  M_OBJS += bsd_comp.o
  32311. +endif
  32312. +
  32313. +ifeq ($(CONFIG_SLIP),y)
  32314. +L_OBJS += slip.o
  32315. +CONFIG_SLHC_BUILTIN = y
  32316. +else
  32317. +  ifeq ($(CONFIG_SLIP),m)
  32318. +  M_OBJS += slip.o
  32319. +  CONFIG_SLHC_MODULE = y
  32320. +  endif
  32321. +endif
  32322. +
  32323. +ifeq ($(CONFIG_DUMMY),y)
  32324. +L_OBJS += dummy.o
  32325. +else
  32326. +  ifeq ($(CONFIG_DUMMY),m)
  32327. +  L_OBJS += dummy.o
  32328. +  endif
  32329. +endif
  32330. +
  32331. +# If anything built-in uses slhc, then build it into the kernel also.
  32332. +# If not, but a module uses it, build as a module.
  32333. +ifdef CONFIG_SLHC_BUILTIN
  32334. +L_OBJS += slhc.o
  32335. +else
  32336. +  ifdef CONFIG_SLHC_MODULE
  32337. +  M_OBJS += slhc.o
  32338. +  endif
  32339. +endif
  32340. +
  32341. +ifeq ($(CONFIG_EQUALIZER),y)
  32342. +L_OBJS += eql.o
  32343. +else
  32344. +  ifeq ($(CONFIG_EQUALIZER),m)
  32345. +  M_OBJS += eql.o
  32346. +  endif
  32347. +endif
  32348. +
  32349. +fastdep: links
  32350. +
  32351. +include $(TOPDIR)/Rules.make
  32352. +
  32353. +clean:
  32354. +    rm -f core *.o *.a *.s
  32355. +
  32356. +net_init.o: ../../../../include/linux/autoconf.h
  32357. +
  32358. +.PHONY: links
  32359. +links:
  32360. +    -@for f in $(LK); do \
  32361. +        if [ ! -e $$f ]; then \
  32362. +            echo "ln -s ../../../../drivers/net/$$f .";\
  32363. +            ln -s ../../../../drivers/net/$$f .; \
  32364. +        fi \
  32365. +    done
  32366. +
  32367. +mrproper:
  32368. +    -@for f in $(LK); do \
  32369. +        if [ -L $$f ]; then \
  32370. +            echo $(RM) $$f; \
  32371. +            $(RM) $$f; \
  32372. +        fi; \
  32373. +    done
  32374. +    $(RM) ppp.ver
  32375. +
  32376. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/Space.c linux/arch/arm/drivers/net/Space.c
  32377. --- linux.orig/arch/arm/drivers/net/Space.c    Thu Jan  1 01:00:00 1970
  32378. +++ linux/arch/arm/drivers/net/Space.c    Sun Jul  7 13:12:08 1996
  32379. @@ -0,0 +1,173 @@
  32380. +/*
  32381. + * INET        An implementation of the TCP/IP protocol suite for the LINUX
  32382. + *        operating system.  INET is implemented using the  BSD Socket
  32383. + *        interface as the means of communication with the user level.
  32384. + *
  32385. + *        Holds initial configuration information for devices.
  32386. + *
  32387. + * NOTE:    This file is a nice idea, but its current format does not work
  32388. + *        well for drivers that support multiple units, like the SLIP
  32389. + *        driver.  We should actually have only one pointer to a driver
  32390. + *        here, with the driver knowing how many units it supports.
  32391. + *        Currently, the SLIP driver abuses the "base_addr" integer
  32392. + *        field of the 'device' structure to store the unit number...
  32393. + *        -FvK
  32394. + *
  32395. + * Version:    @(#)Space.c    1.0.7    08/12/93
  32396. + *
  32397. + * Authors:    Ross Biro, <bir7@leland.Stanford.Edu>
  32398. + *        Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  32399. + *        Donald J. Becker, <becker@super.org>
  32400. + *
  32401. + *    FIXME:
  32402. + *        Sort the device chain fastest first.
  32403. + *
  32404. + *        This program is free software; you can redistribute it and/or
  32405. + *        modify it under the terms of the GNU General Public License
  32406. + *        as published by the Free Software Foundation; either version
  32407. + *        2 of the License, or (at your option) any later version.
  32408. + */
  32409. +#include <linux/config.h>
  32410. +#include <linux/netdevice.h>
  32411. +#include <linux/errno.h>
  32412. +
  32413. +#define    NEXT_DEV    NULL
  32414. +
  32415. +
  32416. +/* A unified ethernet device probe.  This is the easiest way to have every
  32417. +   ethernet adaptor have the name "eth[0123...]".
  32418. +   */
  32419. +extern int ether1_probe (struct device *dev);
  32420. +extern int ether3_probe (struct device *dev);
  32421. +
  32422. +static int
  32423. +ethif_probe(struct device *dev)
  32424. +{
  32425. +    u_long base_addr = dev->base_addr;
  32426. +
  32427. +    if ((base_addr == 0xffe0)  ||  (base_addr == 1))
  32428. +    return 1;        /* ENXIO */
  32429. +
  32430. +    if (1
  32431. +#ifdef CONFIG_ETHER3
  32432. +        && ether3_probe (dev)
  32433. +#endif
  32434. +#ifdef CONFIG_ETHER1
  32435. +    && ether1_probe (dev)
  32436. +#endif
  32437. +    && 1 ) {
  32438. +    return 1;    /* -ENODEV or -EAGAIN would be more accurate. */
  32439. +    }
  32440. +    return 0;
  32441. +}
  32442. +
  32443. +/* The first device defaults to I/O base '0', which means autoprobe. */
  32444. +#ifndef ETH0_ADDR
  32445. +# define ETH0_ADDR 0
  32446. +#endif
  32447. +#ifndef ETH0_IRQ
  32448. +# define ETH0_IRQ 0
  32449. +#endif
  32450. +/* The first device defaults to I/O base '0', which means autoprobe. */
  32451. +#ifndef ETH1_ADDR
  32452. +# define ETH1_ADDR 0
  32453. +#endif
  32454. +#ifndef ETH1_IRQ
  32455. +# define ETH1_IRQ 0
  32456. +#endif
  32457. +/* "eth0" defaults to autoprobe (== 0), other use a base of 0xffe0 (== -0x20),
  32458. +   which means "don't probe".  These entries exist to only to provide empty
  32459. +   slots which may be enabled at boot-time. */
  32460. +
  32461. +static struct device eth3_dev = {
  32462. +"eth3"        , 0x0, 0x0, 0x0, 0x0, 0xffe0   , 0       , 0, 0, 0, NEXT_DEV  , ethif_probe };
  32463. +
  32464. +static struct device eth2_dev = {
  32465. +"eth2"        , 0x0, 0x0, 0x0, 0x0, 0xffe0   , 0       , 0, 0, 0, ð3_dev , ethif_probe };
  32466. +    
  32467. +static struct device eth1_dev = {
  32468. +"eth1"        , 0x0, 0x0, 0x0, 0x0, ETH1_ADDR, ETH1_IRQ, 0, 0, 0, ð2_dev , ethif_probe };
  32469. +
  32470. +static struct device eth0_dev = {
  32471. +"eth0"        , 0x0, 0x0, 0x0, 0x0, ETH0_ADDR, ETH0_IRQ, 0, 0, 0, ð1_dev , ethif_probe };
  32472. +
  32473. +#undef  NEXT_DEV
  32474. +#define NEXT_DEV (ð0_dev)
  32475. +
  32476. +#if defined(PLIP) || defined(CONFIG_PLIP)
  32477. +extern int plip_init(struct device *);
  32478. +static struct device plip2_dev = {
  32479. +"plip2"        , 0x0, 0x0, 0x0, 0x0, 0x278    , 2       , 0, 0, 0, NEXT_DEV  , plip_init };
  32480. +
  32481. +static struct device plip1_dev = {
  32482. +"plip1"        , 0x0, 0x0, 0x0, 0x0, 0x378    , 7       , 0, 0, 0, &plip2_dev, plip_init };
  32483. +
  32484. +static struct device plip0_dev = {
  32485. +"plip0"        , 0x0, 0x0, 0x0, 0x0, 0x3BC    , 5       , 0, 0, 0, &plip1_dev, plip_init };
  32486. +
  32487. +#undef  NEXT_DEV
  32488. +#define NEXT_DEV (&plip0_dev)
  32489. +#endif  /* PLIP */
  32490. +
  32491. +#if defined(SLIP) || defined(CONFIG_SLIP)
  32492. +    /* To be exact, this node just hooks the initialization
  32493. +       routines to the device structures.            */
  32494. +extern int slip_init_ctrl_dev(struct device *);
  32495. +
  32496. +static struct device slip_bootstrap = {
  32497. +"slip_proto"    , 0x0, 0x0, 0x0, 0x0, 0        , 0       , 0, 0, 0, NEXT_DEV  , slip_init_ctrl_dev };
  32498. +
  32499. +#undef  NEXT_DEV
  32500. +#define NEXT_DEV (&slip_bootstrap)
  32501. +#endif /* SLIP */
  32502. +  
  32503. +#if defined(CONFIG_PPP)
  32504. +extern int ppp_init(struct device *);
  32505. +
  32506. +static struct device ppp_bootstrap = {
  32507. +"ppp_proto"    , 0x0, 0x0, 0x0, 0x0, 0        , 0       , 0, 0, 0, NEXT_DEV  , ppp_init };
  32508. +
  32509. +#undef  NEXT_DEV
  32510. +#define NEXT_DEV (&ppp_bootstrap)
  32511. +#endif   /* PPP */
  32512. +
  32513. +#ifdef CONFIG_DUMMY
  32514. +extern int dummy_init(struct device *dev);
  32515. +
  32516. +static struct device dummy_dev = {
  32517. +"dummy"        , 0x0, 0x0, 0x0, 0x0, 0        , 0       , 0, 0, 0, NEXT_DEV  , dummy_init };
  32518. +    
  32519. +#undef    NEXT_DEV
  32520. +#define    NEXT_DEV    (&dummy_dev)
  32521. +#endif
  32522. +
  32523. +#ifdef CONFIG_EQUALIZER
  32524. +extern int eql_init(struct device *dev);
  32525. +
  32526. +static struct device eql_dev = {
  32527. +"eql"        , 0x0, 0x0, 0x0, 0x0, 0        , 0       , 0, 0, 0, NEXT_DEV  , eql_init };
  32528. +
  32529. +#undef  NEXT_DEV
  32530. +#define NEXT_DEV (&eql_dev)
  32531. +#endif
  32532. +
  32533. +#ifdef CONFIG_NET_IPIP
  32534. +#ifdef CONFIG_IP_FORWARD
  32535. +extern int tunnel_init (struct device *dev);
  32536. +
  32537. +static struct device tunnel_dev1 = {
  32538. +"tunl1"        , 0x0, 0x0, 0x0, 0x0, 0        , 0       , 0, 0, 0, NEXT_DEV  , tunnel_init };
  32539. +
  32540. +static struct device tunnel_dev0 = {
  32541. +"tunl0"        , 0x0, 0x0, 0x0, 0x0, 0        , 0       , 0, 0, 0, &tunnel_dev1, tunnel_init };
  32542. +
  32543. +#undef  NEXT_DEV
  32544. +#define NEXT_DEV (&tunnel_dev0)
  32545. +#endif
  32546. +#endif
  32547. +
  32548. +extern int loopback_init(struct device *dev);
  32549. +struct device loopback_dev = {
  32550. +"lo"        , 0x0, 0x0, 0x0, 0x0, 0        , 0       , 0, 0, 0, NEXT_DEV  ,    loopback_init };
  32551. +
  32552. +struct device *dev_base = &loopback_dev;
  32553. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/auto_irq.c linux/arch/arm/drivers/net/auto_irq.c
  32554. --- linux.orig/arch/arm/drivers/net/auto_irq.c    Thu Jan  1 01:00:00 1970
  32555. +++ linux/arch/arm/drivers/net/auto_irq.c    Fri Jun 28 21:23:06 1996
  32556. @@ -0,0 +1,122 @@
  32557. +/* auto_irq.c: Auto-configure IRQ lines for linux. */
  32558. +/*
  32559. +    Written 1994 by Donald Becker.
  32560. +
  32561. +    The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
  32562. +    Center of Excellence in Space Data and Information Sciences
  32563. +      Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  32564. +
  32565. +    This code is a general-purpose IRQ line detector for devices with
  32566. +    jumpered IRQ lines.  If you can make the device raise an IRQ (and
  32567. +    that IRQ line isn't already being used), these routines will tell
  32568. +    you what IRQ line it's using -- perfect for those oh-so-cool boot-time
  32569. +    device probes!
  32570. +
  32571. +    To use this, first call autoirq_setup(timeout). TIMEOUT is how many
  32572. +    'jiffies' (1/100 sec.) to detect other devices that have active IRQ lines,
  32573. +    and can usually be zero at boot.  'autoirq_setup()' returns the bit
  32574. +    vector of nominally-available IRQ lines (lines may be physically in-use,
  32575. +    but not yet registered to a device).
  32576. +    Next, set up your device to trigger an interrupt.
  32577. +    Finally call autoirq_report(TIMEOUT) to find out which IRQ line was
  32578. +    most recently active.  The TIMEOUT should usually be zero, but may
  32579. +    be set to the number of jiffies to wait for a slow device to raise an IRQ.
  32580. +
  32581. +    The idea of using the setup timeout to filter out bogus IRQs came from
  32582. +    the serial driver.
  32583. +*/
  32584. +
  32585. +
  32586. +#ifdef version
  32587. +static const char *version=
  32588. +"auto_irq.c:v1.11 Donald Becker (becker@cesdis.gsfc.nasa.gov)";
  32589. +#endif
  32590. +
  32591. +#include <linux/sched.h>
  32592. +#include <linux/delay.h>
  32593. +#include <asm/bitops.h>
  32594. +#include <asm/io.h>
  32595. +#include <asm/irq.h>
  32596. +#include <linux/netdevice.h>
  32597. +
  32598. +struct device *irq2dev_map[32];
  32599. +
  32600. +unsigned long irqs_busy = 0x2147;        /* The set of fixed IRQs (keyboard, timer, etc) */
  32601. +unsigned long irqs_used = 0x0001;        /* The set of fixed IRQs sometimes enabled. */
  32602. +unsigned long irqs_reserved;            /* An advisory "reserved" table. */
  32603. +unsigned long irqs_shared;            /* IRQ lines "shared" among conforming cards.*/
  32604. +
  32605. +static volatile unsigned long irq_bitmap;    /* The irqs we actually found. */
  32606. +static unsigned long irq_handled;        /* The irq lines we have a handler on. */
  32607. +static volatile int irq_number;            /* The latest irq number we actually found. */
  32608. +
  32609. +static void autoirq_probe(int irq, void *dev_id, struct pt_regs * regs)
  32610. +{
  32611. +    irq_number = irq;
  32612. +    set_bit(irq, (void *)&irq_bitmap);    /* irq_bitmap |= 1 << irq; */
  32613. +    disable_irq(irq);
  32614. +    return;
  32615. +}
  32616. +
  32617. +int autoirq_setup(int waittime)
  32618. +{
  32619. +    int i, mask;
  32620. +    int timeout = jiffies + waittime;
  32621. +    int boguscount = (waittime*loops_per_sec) / 100;
  32622. +
  32623. +    irq_handled = 0;
  32624. +    for (i = 0; i < 16; i++) {
  32625. +        if (test_bit(i, &irqs_busy) == 0
  32626. +            && request_irq(i, autoirq_probe, SA_INTERRUPT, "irq probe", NULL) == 0)
  32627. +            set_bit(i, (void *)&irq_handled);    /* irq_handled |= 1 << i;*/
  32628. +    }
  32629. +    /* Update our USED lists. */
  32630. +    irqs_used |= ~irq_handled;
  32631. +    irq_number = 0;
  32632. +    irq_bitmap = 0;
  32633. +
  32634. +    /* Hang out at least <waittime> jiffies waiting for bogus IRQ hits. */
  32635. +    while (timeout > jiffies  &&  --boguscount > 0)
  32636. +        ;
  32637. +
  32638. +    for (i = 0, mask = 0x01; i < 16; i++, mask <<= 1) {
  32639. +        if (irq_bitmap & irq_handled & mask) {
  32640. +            irq_handled &= ~mask;
  32641. +#ifdef notdef
  32642. +            printk(" Spurious interrupt on IRQ %d\n", i);
  32643. +#endif
  32644. +            free_irq(i, NULL);
  32645. +        }
  32646. +    }
  32647. +    return irq_handled;
  32648. +}
  32649. +
  32650. +int autoirq_report(int waittime)
  32651. +{
  32652. +    int i;
  32653. +    int timeout = jiffies+waittime;
  32654. +    int boguscount = (waittime*loops_per_sec) / 100;
  32655. +
  32656. +    /* Hang out at least <waittime> jiffies waiting for the IRQ. */
  32657. +
  32658. +    while (timeout > jiffies  &&  --boguscount > 0)
  32659. +        if (irq_number)
  32660. +            break;
  32661. +
  32662. +    /* Retract the irq handlers that we installed. */
  32663. +    for (i = 0; i < 16; i++) {
  32664. +        if (test_bit(i, (void *)&irq_handled))
  32665. +            free_irq(i, NULL);
  32666. +    }
  32667. +    return irq_number;
  32668. +}
  32669. +
  32670. +/*
  32671. + * Local variables:
  32672. + *  compile-command: "gcc -DKERNEL -Wall -O6 -fomit-frame-pointer -I/usr/src/linux/net/tcp -c auto_irq.c"
  32673. + *  version-control: t
  32674. + *  kept-new-versions: 5
  32675. + *  c-indent-level: 4
  32676. + *  tab-width: 4
  32677. + * End:
  32678. + */
  32679. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/ether1.c linux/arch/arm/drivers/net/ether1.c
  32680. --- linux.orig/arch/arm/drivers/net/ether1.c    Thu Jan  1 01:00:00 1970
  32681. +++ linux/arch/arm/drivers/net/ether1.c    Mon Jul 29 20:27:07 1996
  32682. @@ -0,0 +1,1132 @@
  32683. +/*
  32684. + * linux/arch/arm/drivers/net/ether1.c
  32685. + *
  32686. + * Acorn ether1 driver (82586 chip)
  32687. + *
  32688. + * (c) 1996 Russell King
  32689. + */
  32690. +
  32691. +/*
  32692. + * We basically keep two queues in the cards memory - one for transmit
  32693. + * and one for receive.  Each has a head and a tail.  The head is where
  32694. + * we/the chip adds packets to be transmitted/received, and the tail
  32695. + * is where the transmitter has got to/where the receiver will stop.
  32696. + * Both of these queues are circular, and since the chip is running
  32697. + * all the time, we have to be careful when we modify the pointers etc
  32698. + * so that the buffer memory is valid all the time.
  32699. + */
  32700. +
  32701. +/*
  32702. + * Change log:
  32703. + * 1.00    RMK            Released
  32704. + * 1.01    RMK       19/03/96    Transfers the last odd byte onto/off of the card now.
  32705. + */
  32706. +
  32707. +#include <linux/module.h>
  32708. +#include <linux/kernel.h>
  32709. +#include <linux/sched.h>
  32710. +#include <linux/types.h>
  32711. +#include <linux/fcntl.h>
  32712. +#include <linux/interrupt.h>
  32713. +#include <linux/ptrace.h>
  32714. +#include <linux/ioport.h>
  32715. +#include <linux/in.h>
  32716. +#include <linux/malloc.h>
  32717. +#include <linux/string.h>
  32718. +#include <asm/system.h>
  32719. +#include <asm/bitops.h>
  32720. +#include <asm/io.h>
  32721. +#include <asm/dma.h>
  32722. +#include <linux/errno.h>
  32723. +
  32724. +#include <linux/netdevice.h>
  32725. +#include <linux/etherdevice.h>
  32726. +#include <linux/skbuff.h>
  32727. +
  32728. +#include <asm/ecard.h>
  32729. +
  32730. +#define __ETHER1_C
  32731. +#include "ether1.h"
  32732. +
  32733. +static unsigned int net_debug = NET_DEBUG;
  32734. +
  32735. +#define FUNC_PROLOGUE \
  32736. +    struct ether1_priv *priv = (struct ether1_priv *)dev->priv
  32737. +
  32738. +#define BUFFER_SIZE    0x10000
  32739. +#define TX_AREA_START    0x00100
  32740. +#define TX_AREA_END    0x05000
  32741. +#define RX_AREA_START    0x05000
  32742. +#define RX_AREA_END    0x0fc00
  32743. +
  32744. +#define tx_done(dev) 0
  32745. +/* ------------------------------------------------------------------------- */
  32746. +static char *version = "ether1 ethernet driver (c) 1995 Russell King v1.01\n";
  32747. +
  32748. +#define BUS_16 16
  32749. +#define BUS_8  8
  32750. +
  32751. +static const int ether1_prods[] = { 0x0003 };
  32752. +static const int ether1_manus[] = { 0x0000 };
  32753. +
  32754. +/* ------------------------------------------------------------------------- */
  32755. +
  32756. +#define DISABLEIRQS 1
  32757. +#define NORMALIRQS  0
  32758. +
  32759. +#define ether1_inw(dev, addr, type, offset, svflgs) ether1_inw_p (dev, addr + (int)(&((type *)0)->offset), svflgs)
  32760. +#define ether1_outw(dev, val, addr, type, offset, svflgs) ether1_outw_p (dev, val, addr + (int)(&((type *)0)->offset), svflgs)
  32761. +
  32762. +static inline unsigned short
  32763. +ether1_inw_p (struct device *dev, int addr, int svflgs)
  32764. +{
  32765. +    unsigned long flags;
  32766. +    unsigned short ret;
  32767. +
  32768. +    if (svflgs) {
  32769. +    save_flags_cli (flags);
  32770. +    }
  32771. +    outb (addr >> 12, REG_PAGE);
  32772. +    ret = inw (ETHER1_RAM + ((addr & 4095) >> 1));
  32773. +    if (svflgs)
  32774. +    restore_flags (flags);
  32775. +    return ret;
  32776. +}
  32777. +
  32778. +static inline void
  32779. +ether1_outw_p (struct device *dev, unsigned short val, int addr, int svflgs)
  32780. +{
  32781. +    unsigned long flags;
  32782. +
  32783. +    if (svflgs) {
  32784. +    save_flags_cli (flags);
  32785. +    }
  32786. +    outb (addr >> 12, REG_PAGE);
  32787. +    outw (val, ETHER1_RAM + ((addr & 4095) >> 1));
  32788. +    if (svflgs)
  32789. +    restore_flags (flags);
  32790. +}
  32791. +
  32792. +static inline void *
  32793. +ether1_inswb (int addr, void *data, unsigned int len)
  32794. +{
  32795. +    int used;
  32796. +
  32797. +    __asm__ __volatile__(
  32798. +    "    subs    %3, %3, #2\n"
  32799. +    "    bmi    2f\n"
  32800. +    "1:    ldr    %0, [%1], #4\n"
  32801. +    "    strb    %0, [%2], #1\n"
  32802. +    "    mov    %0, %0, lsr #8\n"
  32803. +    "    strb    %0, [%2], #1\n"
  32804. +    "    subs    %3, %3, #2\n"
  32805. +    "    bmi    2f\n"
  32806. +    "    ldr    %0, [%1], #4\n"
  32807. +    "    strb    %0, [%2], #1\n"
  32808. +    "    mov    %0, %0, lsr #8\n"
  32809. +    "    strb    %0, [%2], #1\n"
  32810. +    "    subs    %3, %3, #2\n"
  32811. +    "    bmi    2f\n"
  32812. +    "    ldr    %0, [%1], #4\n"
  32813. +    "    strb    %0, [%2], #1\n"
  32814. +    "    mov    %0, %0, lsr #8\n"
  32815. +    "    strb    %0, [%2], #1\n"
  32816. +    "    subs    %3, %3, #2\n"
  32817. +    "    bmi    2f\n"
  32818. +    "    ldr    %0, [%1], #4\n"
  32819. +    "    strb    %0, [%2], #1\n"
  32820. +    "    mov    %0, %0, lsr #8\n"
  32821. +    "    strb    %0, [%2], #1\n"
  32822. +    "    subs    %3, %3, #2\n"
  32823. +    "    bpl    1b\n"
  32824. +    "2:    adds    %3, %3, #1\n"
  32825. +    "    ldreqb    %0, [%1]\n"
  32826. +    "    streqb    %0, [%2]\n"
  32827. +    : "=&r" (used), "=&r" (addr), "=&r" (data), "=&r" (len)
  32828. +    : "1" (addr << 2), "2" (data), "3" (len));
  32829. +
  32830. +    return data;
  32831. +}
  32832. +
  32833. +static inline void *
  32834. +ether1_outswb (int addr, void *data, unsigned int len)
  32835. +{
  32836. +    int used;
  32837. +
  32838. +    __asm__ __volatile__(
  32839. +    "    subs    %3, %3, #2\n"
  32840. +    "    bmi    2f\n"
  32841. +    "1:    ldr    %0, [%2], #2\n"
  32842. +    "    mov    %0, %0, lsl #16\n"
  32843. +    "    orr    %0, %0, %0, lsr #16\n"
  32844. +    "    str    %0, [%1], #4\n"
  32845. +    "    subs    %3, %3, #2\n"
  32846. +    "    bmi    2f\n"
  32847. +    "    ldr    %0, [%2], #2\n"
  32848. +    "    mov    %0, %0, lsl #16\n"
  32849. +    "    orr    %0, %0, %0, lsr #16\n"
  32850. +    "    str    %0, [%1], #4\n"
  32851. +    "    subs    %3, %3, #2\n"
  32852. +    "    bmi    2f\n"
  32853. +    "    ldr    %0, [%2], #2\n"
  32854. +    "    mov    %0, %0, lsl #16\n"
  32855. +    "    orr    %0, %0, %0, lsr #16\n"
  32856. +    "    str    %0, [%1], #4\n"
  32857. +    "    subs    %3, %3, #2\n"
  32858. +    "    bmi    2f\n"
  32859. +    "    ldr    %0, [%2], #2\n"
  32860. +    "    mov    %0, %0, lsl #16\n"
  32861. +    "    orr    %0, %0, %0, lsr #16\n"
  32862. +    "    str    %0, [%1], #4\n"
  32863. +    "    subs    %3, %3, #2\n"
  32864. +    "    bpl    1b\n"
  32865. +    "2:    adds    %3, %3, #1\n"
  32866. +    "    ldreqb    %0, [%2]\n"
  32867. +    "    streqb    %0, [%1]\n"
  32868. +    : "=&r" (used), "=&r" (addr), "=&r" (data), "=&r" (len)
  32869. +    : "1" (addr << 2), "2" (data), "3" (len));
  32870. +
  32871. +    return data;
  32872. +}
  32873. +
  32874. +
  32875. +static void
  32876. +ether1_writebuffer (struct device *dev, void *data, unsigned int start, unsigned int length)
  32877. +{
  32878. +    unsigned int page, thislen, offset;
  32879. +
  32880. +    offset = start & 4095;
  32881. +
  32882. +    for (page = start >> 12; length; page++) {
  32883. +    outb (page, REG_PAGE);
  32884. +    if (offset + length > 4096) {
  32885. +        length -= 4096 - offset;
  32886. +        thislen = 4096 - offset;
  32887. +    } else {
  32888. +        thislen = length;
  32889. +        length = 0;
  32890. +    }
  32891. +
  32892. +    data = ether1_outswb (ETHER1_RAM + (offset >> 1), data, thislen);
  32893. +    offset = 0;
  32894. +    }
  32895. +}
  32896. +
  32897. +static void
  32898. +ether1_readbuffer (struct device *dev, void *data, unsigned int start, unsigned int length)
  32899. +{
  32900. +    unsigned int page, thislen, offset;
  32901. +
  32902. +    offset = start & 4095;
  32903. +
  32904. +    for (page = start >> 12; length; page++) {
  32905. +    outb (page, REG_PAGE);
  32906. +    if (offset + length > 4096) {
  32907. +        length -= 4096 - offset;
  32908. +        thislen = 4096 - offset;
  32909. +    } else {
  32910. +        thislen = length;
  32911. +        length = 0;
  32912. +    }
  32913. +
  32914. +    data = ether1_inswb (ETHER1_RAM + (offset >> 1), data, thislen);
  32915. +    offset = 0;
  32916. +    }
  32917. +}
  32918. +
  32919. +static int
  32920. +ether1_ramtest (struct device *dev, unsigned char byte)
  32921. +{
  32922. +    unsigned char *buffer = kmalloc (BUFFER_SIZE, GFP_KERNEL);
  32923. +    int i, ret = BUFFER_SIZE;
  32924. +    int max_errors = 15;
  32925. +    int bad = -1;
  32926. +    int bad_start = 0;
  32927. +
  32928. +    if (!buffer)
  32929. +    return 1;
  32930. +
  32931. +    memset (buffer, byte, BUFFER_SIZE);
  32932. +    ether1_writebuffer (dev, buffer, 0, BUFFER_SIZE);
  32933. +    memset (buffer, byte ^ 0xff, BUFFER_SIZE);
  32934. +    ether1_readbuffer (dev, buffer, 0, BUFFER_SIZE);
  32935. +
  32936. +    for (i = 0; i < BUFFER_SIZE; i++) {
  32937. +    if (buffer[i] != byte) {
  32938. +        if (max_errors >= 0 && bad != buffer[i]) {
  32939. +        if (bad != -1)
  32940. +            printk ("\n");
  32941. +        printk (KERN_CRIT "%s: RAM failed with (%02X instead of %02X) at 0x%04X",
  32942. +            dev->name, buffer[i], byte, i);
  32943. +        ret = -ENODEV;
  32944. +        max_errors --;
  32945. +        bad = buffer[i];
  32946. +        bad_start = i;
  32947. +        }
  32948. +    } else {
  32949. +        if (bad != -1) {
  32950. +            if (bad_start == i - 1)
  32951. +            printk ("\n");
  32952. +        else
  32953. +            printk (" - 0x%04X\n", i - 1);
  32954. +        bad = -1;
  32955. +        }
  32956. +    }
  32957. +    }
  32958. +
  32959. +    if (bad != -1)
  32960. +    printk (" - 0x%04X\n", BUFFER_SIZE);
  32961. +    kfree (buffer);
  32962. +
  32963. +    return ret;
  32964. +}
  32965. +
  32966. +static int
  32967. +ether1_reset (struct device *dev)
  32968. +{
  32969. +    outb (CTRL_RST|CTRL_ACK, REG_CONTROL);
  32970. +    return BUS_16;
  32971. +}
  32972. +
  32973. +static int
  32974. +ether1_init_2 (struct device *dev)
  32975. +{
  32976. +    int i;
  32977. +    dev->mem_start = 0;
  32978. +    
  32979. +    i = ether1_ramtest (dev, 0x5a);
  32980. +
  32981. +    if (i > 0)
  32982. +    i = ether1_ramtest (dev, 0x1e);
  32983. +
  32984. +    if (i <= 0)
  32985. +        return -ENODEV;
  32986. +
  32987. +    dev->mem_end = i;
  32988. +    
  32989. +    return 0;
  32990. +}
  32991. +
  32992. +/*
  32993. + * These are the structures that are loaded into the ether RAM card to
  32994. + * initialise the 82586
  32995. + */
  32996. +
  32997. +/* at 0x0100 */
  32998. +#define NOP_ADDR    (TX_AREA_START)
  32999. +#define NOP_SIZE    (0x06)
  33000. +static nop_t  init_nop  = {
  33001. +    0,
  33002. +    CMD_NOP,
  33003. +    NOP_ADDR
  33004. +};
  33005. +
  33006. +/* at 0x003a */
  33007. +#define TDR_ADDR    (0x003a)
  33008. +#define TDR_SIZE    (0x08)
  33009. +static tdr_t  init_tdr    = {
  33010. +    0,
  33011. +    CMD_TDR | CMD_INTR,
  33012. +    NOP_ADDR,
  33013. +    0
  33014. +};
  33015. +
  33016. +/* at 0x002e */
  33017. +#define MC_ADDR        (0x002e)
  33018. +#define MC_SIZE        (0x0c)
  33019. +static mc_t   init_mc   = {
  33020. +    0,
  33021. +    CMD_SETMULTICAST,
  33022. +    TDR_ADDR,
  33023. +    0,
  33024. +    { { 0, } }
  33025. +};
  33026. +
  33027. +/* at 0x0022 */
  33028. +#define SA_ADDR        (0x0022)
  33029. +#define SA_SIZE        (0x0c)
  33030. +static sa_t   init_sa   = {
  33031. +    0,
  33032. +    CMD_SETADDRESS,
  33033. +    MC_ADDR,
  33034. +    { 0, }
  33035. +};
  33036. +
  33037. +/* at 0x0010 */
  33038. +#define CFG_ADDR    (0x0010)
  33039. +#define CFG_SIZE    (0x12)
  33040. +static cfg_t  init_cfg  = {
  33041. +    0,
  33042. +    CMD_CONFIG,
  33043. +    SA_ADDR,
  33044. +    4,
  33045. +    8,
  33046. +    CFG8_SRDY,
  33047. +    CFG9_PREAMB8 | CFG9_ADDRLENBUF | CFG9_ADDRLEN(6),
  33048. +    0,
  33049. +};
  33050. +
  33051. +/* at 0x0000 */
  33052. +#define SCB_ADDR    (0x0000)
  33053. +#define SCB_SIZE    (0x10)
  33054. +static scb_t  init_scb  = {
  33055. +    0,
  33056. +    0,
  33057. +    CFG_ADDR,
  33058. +    RX_AREA_START,
  33059. +    0,
  33060. +    0,
  33061. +    0,
  33062. +    0
  33063. +};
  33064. +
  33065. +/* at 0xffee */
  33066. +#define ISCP_ADDR    (0xffee)
  33067. +#define ISCP_SIZE    (0x08)
  33068. +static iscp_t init_iscp = {
  33069. +    1,
  33070. +    SCB_ADDR,
  33071. +    0x0000,
  33072. +    0x0000
  33073. +};
  33074. +
  33075. +/* at 0xfff6 */
  33076. +#define SCP_ADDR    (0xfff6)
  33077. +#define SCP_SIZE    (0x0a)
  33078. +static scp_t  init_scp  = {
  33079. +    SCP_SY_16BBUS,
  33080. +    { 0, 0 },
  33081. +    ISCP_ADDR,
  33082. +    0
  33083. +};
  33084. +
  33085. +#define RFD_SIZE    (0x16)
  33086. +static rfd_t  init_rfd    = {
  33087. +    0,
  33088. +    0,
  33089. +    0,
  33090. +    0,
  33091. +    { 0, },
  33092. +    { 0, },
  33093. +    0
  33094. +};
  33095. +
  33096. +#define RBD_SIZE    (0x0a)
  33097. +static rbd_t  init_rbd    = {
  33098. +    0,
  33099. +    0,
  33100. +    0,
  33101. +    0,
  33102. +    ETH_FRAME_LEN + 8
  33103. +};
  33104. +
  33105. +#define TX_SIZE        (0x08)
  33106. +#define TBD_SIZE    (0x08)
  33107. +
  33108. +static int
  33109. +ether1_init_for_open (struct device *dev)
  33110. +{
  33111. +    FUNC_PROLOGUE;
  33112. +    int i, status, addr, next, next2;
  33113. +
  33114. +    outb (CTRL_RST|CTRL_ACK, REG_CONTROL);
  33115. +
  33116. +    for (i = 0; i < 6; i++)
  33117. +    init_sa.sa_addr[i] = dev->dev_addr[i];
  33118. +
  33119. +    /* load data structures into ether1 RAM */
  33120. +    ether1_writebuffer (dev, &init_scp,  SCP_ADDR,  SCP_SIZE);
  33121. +    ether1_writebuffer (dev, &init_iscp, ISCP_ADDR, ISCP_SIZE);
  33122. +    ether1_writebuffer (dev, &init_scb,  SCB_ADDR,  SCB_SIZE);
  33123. +    ether1_writebuffer (dev, &init_cfg,  CFG_ADDR,  CFG_SIZE);
  33124. +    ether1_writebuffer (dev, &init_sa,   SA_ADDR,   SA_SIZE);
  33125. +    ether1_writebuffer (dev, &init_mc,   MC_ADDR,   MC_SIZE);
  33126. +    ether1_writebuffer (dev, &init_tdr,  TDR_ADDR,  TDR_SIZE);
  33127. +    ether1_writebuffer (dev, &init_nop,  NOP_ADDR,  NOP_SIZE);
  33128. +
  33129. +    /*
  33130. +     * setup circularly linked list of { rfd, rbd, buffer }, with
  33131. +     * all rfds circularly linked, rbds circularly linked.
  33132. +     * First rfd is linked to scp, first rbd is linked to first
  33133. +     * rfd.  Last rbd has a suspend command.
  33134. +     */
  33135. +    addr = RX_AREA_START;
  33136. +    do {
  33137. +    next = addr + RFD_SIZE + RBD_SIZE + ETH_FRAME_LEN + 10;
  33138. +    next2 = next + RFD_SIZE + RBD_SIZE + ETH_FRAME_LEN + 10;
  33139. +
  33140. +    if (next2 >= RX_AREA_END) {
  33141. +        next = RX_AREA_START;
  33142. +        init_rfd.rfd_command = RFD_CMDEL | RFD_CMDSUSPEND;
  33143. +        priv->rx_tail = addr;
  33144. +    } else
  33145. +        init_rfd.rfd_command = 0;
  33146. +    if (addr == RX_AREA_START)
  33147. +        init_rfd.rfd_rbdoffset = addr + RFD_SIZE;
  33148. +    else
  33149. +        init_rfd.rfd_rbdoffset = 0;
  33150. +    init_rfd.rfd_link = next;
  33151. +    init_rbd.rbd_link = next + RFD_SIZE;
  33152. +    init_rbd.rbd_bufl = addr + RFD_SIZE + RBD_SIZE;
  33153. +
  33154. +    ether1_writebuffer (dev, &init_rfd, addr, RFD_SIZE);
  33155. +    ether1_writebuffer (dev, &init_rbd, addr + RFD_SIZE, RBD_SIZE);
  33156. +    addr = next;
  33157. +    } while (next2 < RX_AREA_END);
  33158. +
  33159. +    priv->tx_link = NOP_ADDR;
  33160. +    priv->tx_head = NOP_ADDR + NOP_SIZE;
  33161. +    priv->tx_tail = TDR_ADDR;
  33162. +    priv->rx_head = RX_AREA_START;
  33163. +
  33164. +    /* release reset & give 586 a prod */
  33165. +    priv->resetting = 1;
  33166. +    priv->initialising = 1;
  33167. +    outb (CTRL_RST, REG_CONTROL);
  33168. +    outb (0, REG_CONTROL);
  33169. +    outb (CTRL_CA, REG_CONTROL);
  33170. +
  33171. +    /* 586 should now unset iscp.busy */
  33172. +    i = jiffies + HZ/2;
  33173. +    while (ether1_inw (dev, ISCP_ADDR, iscp_t, iscp_busy, DISABLEIRQS) == 1) {
  33174. +    if (jiffies > i) {
  33175. +        printk (KERN_WARNING "%s: can't initialise 82586: iscp is busy\n", dev->name);
  33176. +        return 1;
  33177. +    }
  33178. +    }
  33179. +
  33180. +    /* check status of commands that we issued */
  33181. +    i += HZ/10;
  33182. +    while (((status = ether1_inw (dev, CFG_ADDR, cfg_t, cfg_status, DISABLEIRQS))
  33183. +        & STAT_COMPLETE) == 0) {
  33184. +    if (jiffies > i)
  33185. +        break;
  33186. +    }
  33187. +
  33188. +    if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) {
  33189. +    printk (KERN_WARNING "%s: can't initialise 82586: config status %04X\n", dev->name, status);
  33190. +    ether1_reset (dev);
  33191. +    return 1;
  33192. +    }
  33193. +
  33194. +    i += HZ/10;
  33195. +    while (((status = ether1_inw (dev, SA_ADDR, sa_t, sa_status, DISABLEIRQS))
  33196. +        & STAT_COMPLETE) == 0) {
  33197. +    if (jiffies > i)
  33198. +        break;
  33199. +    }
  33200. +
  33201. +    if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) {
  33202. +    printk (KERN_WARNING "%s: can't initialise 82586: set address status %04X\n", dev->name, status);
  33203. +    ether1_reset (dev);
  33204. +    return 1;
  33205. +    }
  33206. +
  33207. +    i += HZ/10;
  33208. +    while (((status = ether1_inw (dev, MC_ADDR, mc_t, mc_status, DISABLEIRQS))
  33209. +        & STAT_COMPLETE) == 0) {
  33210. +    if (jiffies > i)
  33211. +        break;
  33212. +    }
  33213. +
  33214. +    if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) {
  33215. +    printk (KERN_WARNING "%s: can't initialise 82586: set multicast status %04X\n", dev->name, status);
  33216. +    ether1_reset (dev);
  33217. +    return 1;
  33218. +    }
  33219. +
  33220. +    i += HZ;
  33221. +    while (((status = ether1_inw (dev, TDR_ADDR, tdr_t, tdr_status, DISABLEIRQS))
  33222. +        & STAT_COMPLETE) == 0) {
  33223. +    if (jiffies > i)
  33224. +        break;
  33225. +    }
  33226. +
  33227. +    if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) {
  33228. +    printk (KERN_WARNING "%s: can't tdr (ignored)\n", dev->name);
  33229. +    return 0;
  33230. +    }
  33231. +
  33232. +    status = ether1_inw (dev, TDR_ADDR, tdr_t, tdr_result, DISABLEIRQS);
  33233. +    if (status & TDR_XCVRPROB)
  33234. +    printk (KERN_WARNING "%s: i/f failed tdr: transceiver problem\n", dev->name);
  33235. +    else
  33236. +    if (status & (TDR_SHORT|TDR_OPEN)) {
  33237. +#ifdef FANCY
  33238. +    printk (KERN_WARNING "%s: i/f failed tdr: cable %s %d.%d us away\n", dev->name,
  33239. +        status & TDR_SHORT ? "short" : "open", (status & TDR_TIME) / 10,
  33240. +        (status & TDR_TIME) % 10);
  33241. +#else
  33242. +    printk (KERN_WARNING "%s: i/f failed tdr: cable %s %d clks away\n", dev->name,
  33243. +        status & TDR_SHORT ? "short" : "open", (status & TDR_TIME));
  33244. +#endif
  33245. +    }
  33246. +
  33247. +    return 0;
  33248. +}
  33249. +
  33250. +static int
  33251. +ether1_probe1 (struct device *dev)
  33252. +{
  33253. +    static unsigned int version_printed = 0;
  33254. +    struct ether1_priv *priv;
  33255. +    int i;
  33256. +
  33257. +    if (!dev->priv)
  33258. +    dev->priv = kmalloc (sizeof (struct ether1_priv), GFP_KERNEL);
  33259. +
  33260. +    if (!dev->priv)
  33261. +        return 1;
  33262. +
  33263. +    priv = (struct ether1_priv *)dev->priv;
  33264. +    memset (priv, 0, sizeof (struct ether1_priv));
  33265. +
  33266. +    if ((priv->bus_type = ether1_reset (dev)) == 0) {
  33267. +    kfree (dev->priv);
  33268. +    return 1;
  33269. +    }
  33270. +
  33271. +    if (net_debug && version_printed++ == 0)
  33272. +    printk (KERN_INFO "%s", version);
  33273. +
  33274. +    printk (KERN_INFO "%s: ether1 found [%d, %04lx, %d]", dev->name, priv->bus_type,
  33275. +        dev->base_addr, dev->irq);
  33276. +
  33277. +    request_region (dev->base_addr, 16, "ether1");
  33278. +    request_region (dev->base_addr + 0x800, 4096, "ether1(ram)");
  33279. +
  33280. +    for (i = 0; i < 6; i++)
  33281. +    printk (i==0?" %02x":i==5?":%02x\n":":%02x", dev->dev_addr[i]);
  33282. +
  33283. +    if (ether1_init_2 (dev)) {
  33284. +    kfree (dev->priv);
  33285. +    return 1;
  33286. +    }
  33287. +
  33288. +    dev->open            = ether1_open;
  33289. +    dev->stop            = ether1_close;
  33290. +    dev->hard_start_xmit    = ether1_sendpacket;
  33291. +    dev->get_stats        = ether1_getstats;
  33292. +    dev->set_multicast_list = ether1_setmulticastlist;
  33293. +
  33294. +    /* Fill in the fields of the device structure with ethernet values */
  33295. +    ether_setup (dev);
  33296. +
  33297. +#ifndef CLAIM_IRQ_AT_OPEN
  33298. +    if (request_irq (dev->irq, ether1_interrupt, 0, "ether1", dev)) {
  33299. +    kfree (dev->priv);
  33300. +    return -EAGAIN;
  33301. +    }
  33302. +#endif
  33303. +    return 0;
  33304. +}    
  33305. +    
  33306. +/* ------------------------------------------------------------------------- */
  33307. +
  33308. +static void
  33309. +ether1_addr (struct device *dev)
  33310. +{
  33311. +    int i;
  33312. +    
  33313. +    for (i = 0; i < 6; i++)
  33314. +    dev->dev_addr[i] = inb (IDPROM_ADDRESS + i);
  33315. +}
  33316. +
  33317. +int
  33318. +ether1_probe (struct device *dev)
  33319. +{
  33320. +#ifndef MODULE
  33321. +    struct expansion_card *ec;
  33322. +
  33323. +    if (!dev)
  33324. +    return ENODEV;
  33325. +
  33326. +    if ((ec = ecard_find (0, sizeof (ether1_prods) / sizeof (int), ether1_prods, ether1_manus)) == NULL)
  33327. +    return ENODEV;
  33328. +
  33329. +    dev->base_addr = ((unsigned long)ecard_address (ec->slot_no, ECARD_IOC, ECARD_FAST)) >> 2;
  33330. +    dev->irq       = ec->irq;
  33331. +
  33332. +    ecard_claim (ec);
  33333. +
  33334. +#endif
  33335. +    ether1_addr (dev);
  33336. +
  33337. +    if (ether1_probe1 (dev) == 0)
  33338. +    return 0;
  33339. +    return ENODEV;
  33340. +}
  33341. +
  33342. +/* ------------------------------------------------------------------------- */
  33343. +
  33344. +static int
  33345. +ether1_txalloc (struct device *dev, int size)
  33346. +{
  33347. +    FUNC_PROLOGUE;
  33348. +    int start, tail;
  33349. +
  33350. +    size = (size + 1) & ~1;
  33351. +    tail = priv->tx_tail;
  33352. +
  33353. +    if (priv->tx_head + size > TX_AREA_END) {
  33354. +    if (tail > priv->tx_head)
  33355. +        return -1;
  33356. +    start = TX_AREA_START;
  33357. +    if (start + size > tail)
  33358. +        return -1;
  33359. +    priv->tx_head = start + size;
  33360. +    } else {
  33361. +    if (priv->tx_head < tail && (priv->tx_head + size) > tail)
  33362. +        return -1;
  33363. +    start = priv->tx_head;
  33364. +    priv->tx_head += size;
  33365. +    }
  33366. +
  33367. +    return start;
  33368. +}
  33369. +
  33370. +static void
  33371. +ether1_restart (struct device *dev, char *reason)
  33372. +{
  33373. +    FUNC_PROLOGUE;
  33374. +    priv->stats.tx_errors ++;
  33375. +
  33376. +    if (reason)
  33377. +    printk (KERN_WARNING "%s: %s - resetting device\n", dev->name, reason);
  33378. +    else
  33379. +    printk (" - resetting device\n");
  33380. +
  33381. +    ether1_reset (dev);
  33382. +
  33383. +    dev->start = 0;
  33384. +    dev->tbusy = 0;
  33385. +
  33386. +    if (ether1_init_for_open (dev))
  33387. +    printk (KERN_ERR "%s: unable to restart interface\n", dev->name);
  33388. +
  33389. +    dev->start = 1;
  33390. +}
  33391. +
  33392. +static int
  33393. +ether1_open (struct device *dev)
  33394. +{
  33395. +    FUNC_PROLOGUE;
  33396. +#ifdef CLAIM_IRQ_AT_OPEN
  33397. +    if (request_irq (dev->irq, ether1_interrupt, 0, "ether1", dev))
  33398. +    return -EAGAIN;
  33399. +#endif
  33400. +    MOD_INC_USE_COUNT;
  33401. +
  33402. +    memset (&priv->stats, 0, sizeof (struct enet_statistics));
  33403. +
  33404. +    if (ether1_init_for_open (dev)) {
  33405. +#ifdef CLAIM_IRQ_AT_OPEN
  33406. +    free_irq (dev->irq, dev);
  33407. +#endif
  33408. +    MOD_DEC_USE_COUNT;
  33409. +    return -EAGAIN;
  33410. +    }
  33411. +
  33412. +    dev->tbusy = 0;
  33413. +    dev->interrupt = 0;
  33414. +    dev->start = 1;
  33415. +
  33416. +    return 0;
  33417. +}
  33418. +
  33419. +static int
  33420. +ether1_sendpacket (struct sk_buff *skb, struct device *dev)
  33421. +{
  33422. +    FUNC_PROLOGUE;
  33423. +
  33424. +    if (dev->tbusy) {
  33425. +    /*
  33426. +     * If we get here, some higher level has decided that we are broken.
  33427. +     * There should really be a "kick me" function call instead.
  33428. +     */
  33429. +    int tickssofar = jiffies - dev->trans_start;
  33430. +
  33431. +    if (tickssofar < 5)
  33432. +        return 1;
  33433. +
  33434. +    /* Try to restart the adapter. */
  33435. +    ether1_restart (dev, "transmit timeout, network cable problem?");
  33436. +    dev->trans_start = jiffies;
  33437. +    }
  33438. +
  33439. +    /*
  33440. +     * If some higher layer thinks we've missed a tx-done interrupt
  33441. +     * we are passed NULL.  Caution: dev_tint() handles the cli()/sti()
  33442. +     * itself.
  33443. +     */
  33444. +    if (skb == NULL) {
  33445. +    dev_tint (dev);
  33446. +    return 0;
  33447. +    }
  33448. +
  33449. +    /*
  33450. +     * Block a timer-based transmit from overlapping.  This could better be
  33451. +     * done with atomic_swap(1, dev->tbusy), but set_bit() works as well.
  33452. +     */
  33453. +    if (set_bit (0, (void *)&dev->tbusy) != 0)
  33454. +    printk (KERN_WARNING "%s: transmitter access conflict.\n", dev->name);
  33455. +    else {
  33456. +    int len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
  33457. +    int tmp, tst, nopaddr, txaddr, tbdaddr, dataddr;
  33458. +    unsigned long flags;
  33459. +    tx_t tx;
  33460. +    tbd_t tbd;
  33461. +    nop_t nop;
  33462. +    /*
  33463. +     * insert packet followed by a nop
  33464. +     */
  33465. +    txaddr = ether1_txalloc (dev, TX_SIZE);
  33466. +    tbdaddr = ether1_txalloc (dev, TBD_SIZE);
  33467. +    dataddr = ether1_txalloc (dev, len);
  33468. +    nopaddr = ether1_txalloc (dev, NOP_SIZE);
  33469. +
  33470. +    tx.tx_status = 0;
  33471. +    tx.tx_command = CMD_TX | CMD_INTR;
  33472. +    tx.tx_link = nopaddr;
  33473. +    tx.tx_tbdoffset = tbdaddr;
  33474. +    tbd.tbd_opts = TBD_EOL | len;
  33475. +    tbd.tbd_link = I82586_NULL;
  33476. +    tbd.tbd_bufl = dataddr;
  33477. +    tbd.tbd_bufh = 0;
  33478. +    nop.nop_status = 0;
  33479. +    nop.nop_command = CMD_NOP;
  33480. +    nop.nop_link = nopaddr;
  33481. +
  33482. +    save_flags_cli (flags);
  33483. +    ether1_writebuffer (dev, &tx, txaddr, TX_SIZE);
  33484. +    ether1_writebuffer (dev, &tbd, tbdaddr, TBD_SIZE);
  33485. +    ether1_writebuffer (dev, skb->data, dataddr, len);
  33486. +    ether1_writebuffer (dev, &nop, nopaddr, NOP_SIZE);
  33487. +    tmp = priv->tx_link;
  33488. +    priv->tx_link = nopaddr;
  33489. +
  33490. +    /* now reset the previous nop pointer */
  33491. +    ether1_outw (dev, txaddr, tmp, nop_t, nop_link, NORMALIRQS);
  33492. +
  33493. +    restore_flags (flags);
  33494. +
  33495. +    /* handle transmit */
  33496. +    dev->trans_start = jiffies;
  33497. +
  33498. +    /* check to see if we have room for a full sized ether frame */
  33499. +    tmp = priv->tx_head;
  33500. +    tst = ether1_txalloc (dev, TX_SIZE + TBD_SIZE + NOP_SIZE + ETH_FRAME_LEN);
  33501. +    priv->tx_head = tmp;
  33502. +    if (tst != -1)
  33503. +        dev->tbusy = 0;
  33504. +    }
  33505. +    dev_kfree_skb (skb, FREE_WRITE);
  33506. +
  33507. +    return 0;
  33508. +}
  33509. +
  33510. +static void
  33511. +ether1_xmit_done (struct device *dev)
  33512. +{
  33513. +    FUNC_PROLOGUE;
  33514. +    nop_t nop;
  33515. +    int caddr, tst;
  33516. +
  33517. +    caddr = priv->tx_tail;
  33518. +
  33519. +again:
  33520. +    ether1_readbuffer (dev, &nop, caddr, NOP_SIZE);
  33521. +
  33522. +    switch (nop.nop_command & CMD_MASK) {
  33523. +    case CMD_TDR:
  33524. +    /* special case */
  33525. +    if (ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS)
  33526. +                != (unsigned short)I82586_NULL) {
  33527. +        ether1_outw (dev, SCB_CMDCUCSTART | SCB_CMDRXSTART, SCB_ADDR, scb_t,
  33528. +        scb_command, NORMALIRQS);
  33529. +        outb (CTRL_CA, REG_CONTROL);
  33530. +    }
  33531. +    priv->tx_tail = NOP_ADDR;
  33532. +    return;
  33533. +
  33534. +    case CMD_NOP:
  33535. +    if (nop.nop_link == caddr) {
  33536. +        if (priv->initialising == 0)
  33537. +        printk (KERN_WARNING "%s: strange command complete with no tx command!\n", dev->name);
  33538. +        else
  33539. +            priv->initialising = 0;
  33540. +        return;
  33541. +    }
  33542. +    caddr = nop.nop_link;
  33543. +    goto again;
  33544. +
  33545. +    case CMD_TX:
  33546. +    if (nop.nop_status & STAT_COMPLETE)
  33547. +        break;
  33548. +    ether1_restart (dev, "strange command complete without completed command!");
  33549. +    return;
  33550. +
  33551. +    default:
  33552. +    printk (KERN_WARNING "%s: strange command %d complete! (offset %04X)", dev->name,
  33553. +        nop.nop_command & CMD_MASK, caddr);
  33554. +    ether1_restart (dev, NULL);
  33555. +    return;
  33556. +    }
  33557. +
  33558. +    while (nop.nop_status & STAT_COMPLETE) {
  33559. +    if (nop.nop_status & STAT_OK) {
  33560. +        priv->stats.tx_packets ++;
  33561. +        priv->stats.collisions += (nop.nop_status & STAT_COLLISIONS);
  33562. +    } else {
  33563. +        priv->stats.tx_errors ++;
  33564. +
  33565. +        if (nop.nop_status & STAT_COLLAFTERTX)
  33566. +        priv->stats.collisions ++;
  33567. +        if (nop.nop_status & STAT_NOCARRIER)
  33568. +        priv->stats.tx_carrier_errors ++;
  33569. +        if (nop.nop_status & STAT_TXLOSTCTS)
  33570. +        printk (KERN_WARNING "%s: cts lost\n", dev->name);
  33571. +        if (nop.nop_status & STAT_TXSLOWDMA)
  33572. +        priv->stats.tx_fifo_errors ++;
  33573. +        if (nop.nop_status & STAT_COLLEXCESSIVE)
  33574. +        priv->stats.collisions += 16;
  33575. +    }
  33576. +
  33577. +    if (nop.nop_link == caddr) {
  33578. +        printk (KERN_ERR "%s: tx buffer chaining error: tx command points to itself\n", dev->name);
  33579. +        break;
  33580. +    }
  33581. +
  33582. +    caddr = nop.nop_link;
  33583. +    ether1_readbuffer (dev, &nop, caddr, NOP_SIZE);
  33584. +    if ((nop.nop_command & CMD_MASK) != CMD_NOP) {
  33585. +        printk (KERN_ERR "%s: tx buffer chaining error: no nop after tx command\n", dev->name);
  33586. +        break;
  33587. +    }
  33588. +
  33589. +    if (caddr == nop.nop_link)
  33590. +        break;
  33591. +
  33592. +    caddr = nop.nop_link;
  33593. +    ether1_readbuffer (dev, &nop, caddr, NOP_SIZE);
  33594. +    if ((nop.nop_command & CMD_MASK) != CMD_TX) {
  33595. +        printk (KERN_ERR "%s: tx buffer chaining error: no tx command after nop\n", dev->name);
  33596. +        break;
  33597. +    }
  33598. +    }
  33599. +    priv->tx_tail = caddr;
  33600. +
  33601. +    caddr = priv->tx_head;
  33602. +    tst = ether1_txalloc (dev, TX_SIZE + TBD_SIZE + NOP_SIZE + ETH_FRAME_LEN);
  33603. +    priv->tx_head = caddr;
  33604. +    if (tst != -1)
  33605. +    dev->tbusy = 0;
  33606. +    
  33607. +    mark_bh (NET_BH);
  33608. +}
  33609. +
  33610. +static void
  33611. +ether1_recv_done (struct device *dev)
  33612. +{
  33613. +    FUNC_PROLOGUE;
  33614. +    int status;
  33615. +    int nexttail, rbdaddr;
  33616. +    rbd_t rbd;
  33617. +
  33618. +    do {
  33619. +    status = ether1_inw (dev, priv->rx_head, rfd_t, rfd_status, NORMALIRQS);
  33620. +    if ((status & RFD_COMPLETE) == 0)
  33621. +        break;
  33622. +
  33623. +    rbdaddr = ether1_inw (dev, priv->rx_head, rfd_t, rfd_rbdoffset, NORMALIRQS);
  33624. +    ether1_readbuffer (dev, &rbd, rbdaddr, RBD_SIZE);
  33625. +
  33626. +    if ((rbd.rbd_status & (RBD_EOF | RBD_ACNTVALID)) == (RBD_EOF | RBD_ACNTVALID)) {
  33627. +        int length = rbd.rbd_status & RBD_ACNT;
  33628. +        struct sk_buff *skb;
  33629. +
  33630. +        length = (length + 1) & ~1;
  33631. +        skb = dev_alloc_skb (length + 2);
  33632. +
  33633. +        if (skb) {
  33634. +        skb->dev = dev;
  33635. +        skb_reserve (skb, 2);
  33636. +
  33637. +        ether1_readbuffer (dev, skb_put (skb, length), rbd.rbd_bufl, length);
  33638. +
  33639. +        skb->protocol = eth_type_trans (skb, dev);
  33640. +        netif_rx (skb);
  33641. +        priv->stats.rx_packets ++;
  33642. +        } else
  33643. +        priv->stats.rx_dropped ++;
  33644. +    } else {
  33645. +        printk (KERN_WARNING "%s: %s\n", dev->name,
  33646. +            (rbd.rbd_status & RBD_EOF) ? "oversized packet" : "acnt not valid");
  33647. +        priv->stats.rx_dropped ++;
  33648. +    }
  33649. +
  33650. +    nexttail = ether1_inw (dev, priv->rx_tail, rfd_t, rfd_link, NORMALIRQS);
  33651. +    /* nexttail should be rx_head */
  33652. +    if (nexttail != priv->rx_head)
  33653. +        printk (KERN_ERR "%s: receiver buffer chaining error (%04X != %04X)\n",
  33654. +            dev->name, nexttail, priv->rx_head);
  33655. +    ether1_outw (dev, RFD_CMDEL | RFD_CMDSUSPEND, nexttail, rfd_t, rfd_command, NORMALIRQS);
  33656. +    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_command, NORMALIRQS);
  33657. +    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_status, NORMALIRQS);
  33658. +    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_rbdoffset, NORMALIRQS);
  33659. +    
  33660. +    priv->rx_tail = nexttail;
  33661. +    priv->rx_head = ether1_inw (dev, priv->rx_head, rfd_t, rfd_link, NORMALIRQS);
  33662. +    } while (1);
  33663. +}
  33664. +
  33665. +static void
  33666. +ether1_interrupt (int irq, void *dev_id, struct pt_regs *regs)
  33667. +{
  33668. +    struct device *dev = (struct device *)dev_id;
  33669. +    FUNC_PROLOGUE;
  33670. +    int status;
  33671. +
  33672. +    dev->interrupt = 1;
  33673. +
  33674. +    status = ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS);
  33675. +    if (status ) {
  33676. +    ether1_outw (dev, status & (SCB_STRNR | SCB_STCNA | SCB_STFR | SCB_STCX),
  33677. +            SCB_ADDR, scb_t, scb_command, NORMALIRQS);
  33678. +    outb (CTRL_CA | CTRL_ACK, REG_CONTROL);
  33679. +    if (status & SCB_STCX) {
  33680. +        ether1_xmit_done (dev);
  33681. +    }
  33682. +    if (status & SCB_STCNA) {
  33683. +        if (priv->resetting == 0)
  33684. +        printk (KERN_WARNING "%s: CU went not ready ???\n", dev->name);
  33685. +        if (ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS)
  33686. +                != (unsigned short)I82586_NULL) {
  33687. +        ether1_outw (dev, SCB_CMDCUCSTART, SCB_ADDR, scb_t, scb_command, NORMALIRQS);
  33688. +        outb (CTRL_CA, REG_CONTROL);
  33689. +        }
  33690. +        if (priv->resetting == 2)
  33691. +        priv->resetting = 0;
  33692. +    }
  33693. +    if (status & SCB_STFR) {
  33694. +        ether1_recv_done (dev);
  33695. +    }
  33696. +    if (status & SCB_STRNR) {
  33697. +        printk (KERN_WARNING "%s: RU went not ready\n", dev->name);
  33698. +        printk (KERN_WARNING "RU ptr = %04X\n", ether1_inw (dev, SCB_ADDR, scb_t, scb_rfa_offset,
  33699. +                    NORMALIRQS));
  33700. +    }
  33701. +    } else
  33702. +        outb (CTRL_ACK, REG_CONTROL);
  33703. +
  33704. +    dev->interrupt = 0;
  33705. +}
  33706. +
  33707. +static int
  33708. +ether1_close (struct device *dev)
  33709. +{
  33710. +#ifdef CLAIM_IRQ_AT_OPEN
  33711. +    free_irq (dev->irq, dev);
  33712. +#endif
  33713. +
  33714. +    ether1_reset (dev);
  33715. +
  33716. +    dev->start = 0;
  33717. +    dev->tbusy = 0;
  33718. +
  33719. +    MOD_DEC_USE_COUNT;
  33720. +
  33721. +    return 0;
  33722. +}
  33723. +
  33724. +static struct enet_statistics *
  33725. +ether1_getstats (struct device *dev)
  33726. +{
  33727. +    FUNC_PROLOGUE;
  33728. +    return &priv->stats;
  33729. +}
  33730. +
  33731. +/*
  33732. + * Set or clear the multicast filter for this adaptor.
  33733. + * num_addrs == -1    Promiscuous mode, receive all packets.
  33734. + * num_addrs == 0    Normal mode, clear multicast list.
  33735. + * num_addrs > 0    Multicast mode, receive normal and MC packets, and do
  33736. + *            best-effort filtering.
  33737. + */
  33738. +static void
  33739. +ether1_setmulticastlist (struct device *dev)
  33740. +{
  33741. +}
  33742. +
  33743. +/* ------------------------------------------------------------------------- */
  33744. +
  33745. +#ifdef MODULE
  33746. +
  33747. +static char ethernames[MAX_ECARDS][9];
  33748. +static struct device *my_ethers[MAX_ECARDS];
  33749. +static struct expansion_card *ec[MAX_ECARDS];
  33750. +
  33751. +int
  33752. +init_module (void)
  33753. +{
  33754. +    int i;
  33755. +
  33756. +    for (i = 0; i < MAX_ECARDS; i++) {
  33757. +    my_ethers[i] = NULL;
  33758. +    ec[i] = NULL;
  33759. +    strcpy (ethernames[i], "        ");
  33760. +    }
  33761. +
  33762. +    i = 0;
  33763. +
  33764. +    do {
  33765. +    if ((ec[i] = ecard_find(0, sizeof(ether1_prods) / sizeof(int), ether1_prods, ether1_manus))
  33766. +        == NULL)
  33767. +        break;
  33768. +
  33769. +    my_ethers[i] = (struct device *)kmalloc (sizeof (struct device), GFP_KERNEL);
  33770. +    memset (my_ethers[i], 0, sizeof (struct device));
  33771. +
  33772. +    my_ethers[i]->irq = ec[i]->irq;
  33773. +    my_ethers[i]->base_addr = ((unsigned long)ecard_address (ec[i]->slot_no, ECARD_IOC, ECARD_FAST)) >> 2;
  33774. +    my_ethers[i]->init = ether1_probe;
  33775. +    my_ethers[i]->name = ethernames[i];
  33776. +
  33777. +    ecard_claim (ec[i]);
  33778. +
  33779. +    if (register_netdev (my_ethers[i]) != 0) {
  33780. +        for (i = 0; i < 4; i++) {
  33781. +        if (my_ethers[i]) {
  33782. +            kfree (my_ethers[i]);
  33783. +            my_ethers[i] = NULL;
  33784. +        }
  33785. +        if (ec[i]) {
  33786. +            ecard_release (ec[i]);
  33787. +            ec[i] = NULL;
  33788. +        }
  33789. +        }
  33790. +        return -EIO;
  33791. +    }
  33792. +    i++;
  33793. +    } while (i < MAX_ECARDS);
  33794. +
  33795. +    return i != 0 ? 0 : -ENODEV;
  33796. +}
  33797. +
  33798. +void
  33799. +cleanup_module (void)
  33800. +{
  33801. +    int i;
  33802. +
  33803. +    for (i = 0; i < MAX_ECARDS; i++) {
  33804. +    if (my_ethers[i]) {
  33805. +        unregister_netdev (my_ethers[i]);
  33806. +        my_ethers[i] = NULL;
  33807. +    }
  33808. +    if (ec[i]) {
  33809. +        ecard_release (ec[i]);
  33810. +        ec[i] = NULL;
  33811. +    }
  33812. +    }
  33813. +}
  33814. +#endif /* MODULE */
  33815. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/ether1.h linux/arch/arm/drivers/net/ether1.h
  33816. --- linux.orig/arch/arm/drivers/net/ether1.h    Thu Jan  1 01:00:00 1970
  33817. +++ linux/arch/arm/drivers/net/ether1.h    Fri Jul 19 20:44:22 1996
  33818. @@ -0,0 +1,281 @@
  33819. +/*
  33820. + * linux/arch/arm/drivers/net/ether1.h
  33821. + *
  33822. + * network driver for Acorn Ether1 cards.
  33823. + *
  33824. + * (c) 1996 Russell King
  33825. + */
  33826. +
  33827. +#ifndef _LINUX_ether1_H
  33828. +#define _LINUX_ether1_H
  33829. +
  33830. +#ifdef __ETHER1_C
  33831. +/* use 0 for production, 1 for verification, >2 for debug */
  33832. +#ifndef NET_DEBUG
  33833. +#define NET_DEBUG 0
  33834. +#endif
  33835. +
  33836. +/* Page register */
  33837. +#define REG_PAGE    (dev->base_addr + 0x00)
  33838. +
  33839. +/* Control register */
  33840. +#define REG_CONTROL    (dev->base_addr + 0x01)
  33841. +#define CTRL_RST    0x01
  33842. +#define CTRL_LOOPBACK    0x02
  33843. +#define CTRL_CA        0x04
  33844. +#define CTRL_ACK    0x08
  33845. +
  33846. +#define ETHER1_RAM    (dev->base_addr + 0x800)
  33847. +
  33848. +/* HW address */
  33849. +#define IDPROM_ADDRESS    (dev->base_addr + 0x09)
  33850. +
  33851. +struct ether1_priv {
  33852. +    struct enet_statistics stats;
  33853. +    int tx_link;
  33854. +    int tx_head;
  33855. +    volatile int tx_tail;
  33856. +    volatile int rx_head;
  33857. +    volatile int rx_tail;
  33858. +    char bus_type;
  33859. +    char resetting;
  33860. +    char initialising;
  33861. +};
  33862. +
  33863. +static int ether1_open (struct device *dev);
  33864. +static int ether1_sendpacket (struct sk_buff *skb, struct device *dev);
  33865. +static void ether1_interrupt (int irq, void *dev_id, struct pt_regs *regs);
  33866. +static int ether1_close (struct device *dev);
  33867. +static struct enet_statistics *ether1_getstats (struct device *dev);
  33868. +static void ether1_setmulticastlist (struct device *dev);
  33869. +
  33870. +#define I82586_NULL (-1)
  33871. +
  33872. +typedef struct { /* tdr */
  33873. +    unsigned short tdr_status;
  33874. +    unsigned short tdr_command;
  33875. +    unsigned short tdr_link;
  33876. +    unsigned short tdr_result;
  33877. +#define TDR_TIME    (0x7ff)
  33878. +#define TDR_SHORT    (1 << 12)
  33879. +#define TDR_OPEN    (1 << 13)
  33880. +#define TDR_XCVRPROB    (1 << 14)
  33881. +#define TDR_LNKOK    (1 << 15)
  33882. +} tdr_t;
  33883. +
  33884. +typedef struct { /* transmit */
  33885. +    unsigned short tx_status;
  33886. +    unsigned short tx_command;
  33887. +    unsigned short tx_link;
  33888. +    unsigned short tx_tbdoffset;
  33889. +} tx_t;
  33890. +
  33891. +typedef struct { /* tbd */
  33892. +    unsigned short tbd_opts;
  33893. +#define TBD_CNT        (0x3fff)
  33894. +#define TBD_EOL        (1 << 15)
  33895. +    unsigned short tbd_link;
  33896. +    unsigned short tbd_bufl;
  33897. +    unsigned short tbd_bufh;
  33898. +} tbd_t;
  33899. +
  33900. +typedef struct { /* rfd */
  33901. +    unsigned short rfd_status;
  33902. +#define RFD_NOEOF    (1 << 6)
  33903. +#define RFD_FRAMESHORT    (1 << 7)
  33904. +#define RFD_DMAOVRN    (1 << 8)
  33905. +#define RFD_NORESOURCES    (1 << 9)
  33906. +#define RFD_ALIGNERROR    (1 << 10)
  33907. +#define RFD_CRCERROR    (1 << 11)
  33908. +#define RFD_OK        (1 << 13)
  33909. +#define RFD_FDCONSUMED    (1 << 14)
  33910. +#define RFD_COMPLETE    (1 << 15)
  33911. +    unsigned short rfd_command;
  33912. +#define RFD_CMDSUSPEND    (1 << 14)
  33913. +#define RFD_CMDEL    (1 << 15)
  33914. +    unsigned short rfd_link;
  33915. +    unsigned short rfd_rbdoffset;
  33916. +    unsigned char  rfd_dest[6];
  33917. +    unsigned char  rfd_src[6];
  33918. +    unsigned short rfd_len;
  33919. +} rfd_t;
  33920. +
  33921. +typedef struct { /* rbd */
  33922. +    unsigned short rbd_status;
  33923. +#define RBD_ACNT    (0x3fff)
  33924. +#define RBD_ACNTVALID    (1 << 14)
  33925. +#define RBD_EOF        (1 << 15)
  33926. +    unsigned short rbd_link;
  33927. +    unsigned short rbd_bufl;
  33928. +    unsigned short rbd_bufh;
  33929. +    unsigned short rbd_len;
  33930. +} rbd_t;
  33931. +
  33932. +typedef struct { /* nop */
  33933. +    unsigned short nop_status;
  33934. +    unsigned short nop_command;
  33935. +    unsigned short nop_link;
  33936. +} nop_t;
  33937. +
  33938. +typedef struct { /* set multicast */
  33939. +    unsigned short mc_status;
  33940. +    unsigned short mc_command;
  33941. +    unsigned short mc_link;
  33942. +    unsigned short mc_cnt;
  33943. +    unsigned char  mc_addrs[1][6];
  33944. +} mc_t;
  33945. +
  33946. +typedef struct { /* set address */
  33947. +    unsigned short sa_status;
  33948. +    unsigned short sa_command;
  33949. +    unsigned short sa_link;
  33950. +    unsigned char  sa_addr[6];
  33951. +} sa_t;
  33952. +
  33953. +typedef struct { /* config command */
  33954. +    unsigned short cfg_status;
  33955. +    unsigned short cfg_command;
  33956. +    unsigned short cfg_link;
  33957. +    unsigned char  cfg_bytecnt;    /* size foll data: 4 - 12         */
  33958. +    unsigned char  cfg_fifolim;    /* FIFO threshold             */
  33959. +    unsigned char  cfg_byte8;
  33960. +#define CFG8_SRDY    (1 << 6)
  33961. +#define CFG8_SAVEBADF    (1 << 7)
  33962. +    unsigned char  cfg_byte9;
  33963. +#define CFG9_ADDRLEN(x)    (x)
  33964. +#define CFG9_ADDRLENBUF    (1 << 3)
  33965. +#define CFG9_PREAMB2    (0 << 4)
  33966. +#define CFG9_PREAMB4    (1 << 4)
  33967. +#define CFG9_PREAMB8    (2 << 4)
  33968. +#define CFG9_PREAMB16    (3 << 4)
  33969. +#define CFG9_ILOOPBACK    (1 << 6)
  33970. +#define CFG9_ELOOPBACK    (1 << 7)
  33971. +    unsigned char  cfg_byte10;
  33972. +#define CFG10_LINPRI(x)    (x)
  33973. +#define CFG10_ACR(x)    (x << 4)
  33974. +#define CFG10_BOFMET    (1 << 7)
  33975. +    unsigned char  cfg_ifs;
  33976. +    unsigned char  cfg_slotl;
  33977. +    unsigned char  cfg_byte13;
  33978. +#define CFG13_SLOTH(x)    (x)
  33979. +#define CFG13_RETRY(x)    (x << 4)
  33980. +    unsigned char  cfg_byte14;
  33981. +#define CFG14_PROMISC    (1 << 0)
  33982. +#define CFG14_DISBRD    (1 << 1)
  33983. +#define CFG14_MANCH    (1 << 2)
  33984. +#define CFG14_TNCRS    (1 << 3)
  33985. +#define CFG14_NOCRC    (1 << 4)
  33986. +#define CFG14_CRC16    (1 << 5)
  33987. +#define CFG14_BTSTF    (1 << 6)
  33988. +#define CFG14_FLGPAD    (1 << 7)
  33989. +    unsigned char  cfg_byte15;
  33990. +#define CFG15_CSTF(x)    (x)
  33991. +#define CFG15_ICSS    (1 << 3)
  33992. +#define CFG15_CDTF(x)    (x << 4)
  33993. +#define CFG15_ICDS    (1 << 7)
  33994. +    unsigned short cfg_minfrmlen;
  33995. +} cfg_t;
  33996. +
  33997. +typedef struct { /* scb */
  33998. +    unsigned short scb_status;    /* status of 82586             */
  33999. +#define SCB_STRXMASK        (7 << 4)
  34000. +#define SCB_STRXIDLE        (0 << 4)
  34001. +#define SCB_STRXSUSP        (1 << 4)
  34002. +#define SCB_STRXNRES        (2 << 4)
  34003. +#define SCB_STRXRDY        (4 << 4)
  34004. +#define SCB_STCUMASK        (7 << 8)
  34005. +#define SCB_STCUIDLE        (0 << 8)
  34006. +#define SCB_STCUSUSP        (1 << 8)
  34007. +#define SCB_STCUACTV        (2 << 8)
  34008. +#define SCB_STRNR        (1 << 12)
  34009. +#define SCB_STCNA        (1 << 13)
  34010. +#define SCB_STFR        (1 << 14)
  34011. +#define SCB_STCX        (1 << 15)
  34012. +    unsigned short scb_command;    /* Next command                 */
  34013. +#define SCB_CMDRXSTART        (1 << 4)
  34014. +#define SCB_CMDRXRESUME        (2 << 4)
  34015. +#define SCB_CMDRXSUSPEND    (3 << 4)
  34016. +#define SCB_CMDRXABORT        (4 << 4)
  34017. +#define SCB_CMDCUCSTART        (1 << 8)
  34018. +#define SCB_CMDCUCRESUME    (2 << 8)
  34019. +#define SCB_CMDCUCSUSPEND    (3 << 8)
  34020. +#define SCB_CMDCUCABORT        (4 << 8)
  34021. +#define SCB_CMDACKRNR        (1 << 12)
  34022. +#define SCB_CMDACKCNA        (1 << 13)
  34023. +#define SCB_CMDACKFR        (1 << 14)
  34024. +#define SCB_CMDACKCX        (1 << 15)
  34025. +    unsigned short scb_cbl_offset;    /* Offset of first command unit         */
  34026. +    unsigned short scb_rfa_offset;    /* Offset of first receive frame area     */
  34027. +    unsigned short scb_crc_errors;    /* Properly aligned frame with CRC error */
  34028. +    unsigned short scb_aln_errors;    /* Misaligned frames             */
  34029. +    unsigned short scb_rsc_errors;    /* Frames lost due to no space         */
  34030. +    unsigned short scb_ovn_errors;    /* Frames lost due to slow bus         */
  34031. +} scb_t;
  34032. +
  34033. +typedef struct { /* iscp */
  34034. +    unsigned short iscp_busy;    /* set by CPU before CA             */
  34035. +    unsigned short iscp_offset;    /* offset of SCB             */
  34036. +    unsigned short iscp_basel;    /* base of SCB                 */
  34037. +    unsigned short iscp_baseh;
  34038. +} iscp_t;
  34039. +
  34040. +    /* this address must be 0xfff6 */
  34041. +typedef struct { /* scp */
  34042. +    unsigned short scp_sysbus;    /* bus size */
  34043. +#define SCP_SY_16BBUS    0x00
  34044. +#define SCP_SY_8BBUS    0x01
  34045. +    unsigned short scp_junk[2];    /* junk */
  34046. +    unsigned short scp_iscpl;    /* lower 16 bits of iscp */
  34047. +    unsigned short scp_iscph;    /* upper 16 bits of iscp */
  34048. +} scp_t;
  34049. +
  34050. +/* commands */
  34051. +#define CMD_NOP            0
  34052. +#define CMD_SETADDRESS        1
  34053. +#define CMD_CONFIG        2
  34054. +#define CMD_SETMULTICAST    3
  34055. +#define CMD_TX            4
  34056. +#define CMD_TDR            5
  34057. +#define CMD_DUMP        6
  34058. +#define CMD_DIAGNOSE        7
  34059. +
  34060. +#define CMD_MASK        7
  34061. +
  34062. +#define CMD_INTR        (1 << 13)
  34063. +#define CMD_SUSP        (1 << 14)
  34064. +#define CMD_EOL            (1 << 15)
  34065. +
  34066. +#define STAT_COLLISIONS        (15)
  34067. +#define STAT_COLLEXCESSIVE    (1 << 5)
  34068. +#define STAT_COLLAFTERTX    (1 << 6)
  34069. +#define STAT_TXDEFERRED        (1 << 7)
  34070. +#define STAT_TXSLOWDMA        (1 << 8)
  34071. +#define STAT_TXLOSTCTS        (1 << 9)
  34072. +#define STAT_NOCARRIER        (1 << 10)
  34073. +#define STAT_FAIL        (1 << 11)
  34074. +#define STAT_ABORTED        (1 << 12)
  34075. +#define STAT_OK            (1 << 13)
  34076. +#define STAT_BUSY        (1 << 14)
  34077. +#define STAT_COMPLETE        (1 << 15)
  34078. +#endif
  34079. +#endif
  34080. +
  34081. +/*
  34082. + * Ether1 card definitions:
  34083. + *
  34084. + * FAST accesses:
  34085. + *    +0    Page register
  34086. + *             16 pages
  34087. + *    +4    Control
  34088. + *            '1' = reset
  34089. + *            '2' = loopback
  34090. + *            '4' = CA
  34091. + *            '8' = int ack
  34092. + *
  34093. + * RAM at address + 0x2000
  34094. + * Pod. Prod id = 3
  34095. + * Words after ID block [base + 8 words]
  34096. + *    +0 pcb issue (0x0c and 0xf3 invalid)
  34097. + *    +1 - +6 eth hw address
  34098. + */
  34099. +
  34100. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/ether3.c linux/arch/arm/drivers/net/ether3.c
  34101. --- linux.orig/arch/arm/drivers/net/ether3.c    Thu Jan  1 01:00:00 1970
  34102. +++ linux/arch/arm/drivers/net/ether3.c    Mon Jul 29 20:46:34 1996
  34103. @@ -0,0 +1,892 @@
  34104. +/*
  34105. + * linux/drivers/net/ether3.c
  34106. + *
  34107. + * SEEQ nq8005 ethernet driver
  34108. + *
  34109. + * By Russell King, with some suggestions from borris@ant.co.uk
  34110. + *
  34111. + * Changelog:
  34112. + *  29/02/96:    RMK    Won't pass packets that are from our ethernet address
  34113. + *            up to the higher levels - they're silently ignored.
  34114. + *            I/F can now be put into multicast mode.  Receiver
  34115. + *            routine optimised.
  34116. + *
  34117. + *  30/02/96:    RMK    Now claims interrupt at open when part of the kernel
  34118. + *            rather than when a module.
  34119. + *
  34120. + *  02/03/96:    RMK    Various code cleanups
  34121. + *
  34122. + * TODO:
  34123. + *  When we detect a fatal error on the interface, we should restart it.
  34124. + */
  34125. +
  34126. +#include <linux/module.h>
  34127. +#include <linux/kernel.h>
  34128. +#include <linux/sched.h>
  34129. +#include <linux/types.h>
  34130. +#include <linux/fcntl.h>
  34131. +#include <linux/interrupt.h>
  34132. +#include <linux/ptrace.h>
  34133. +#include <linux/ioport.h>
  34134. +#include <linux/in.h>
  34135. +#include <linux/malloc.h>
  34136. +#include <linux/string.h>
  34137. +#include <linux/errno.h>
  34138. +#include <linux/netdevice.h>
  34139. +#include <linux/etherdevice.h>
  34140. +#include <linux/skbuff.h>
  34141. +
  34142. +#include <asm/system.h>
  34143. +#include <asm/bitops.h>
  34144. +#include <asm/io.h>
  34145. +#include <asm/dma.h>
  34146. +#include <asm/ecard.h>
  34147. +
  34148. +#include "ether3.h"
  34149. +
  34150. +static unsigned int net_debug = NET_DEBUG;
  34151. +static const int ether3_prods[] = { 0x00A4 };
  34152. +static const int ether3_manus[] = { 0x0011 };
  34153. +
  34154. +static void
  34155. +ether3_setmulticastlist (struct device *dev);
  34156. +
  34157. +static char *version = "ether3 ethernet driver (c) 1995 R.M.King v1.10\n";
  34158. +
  34159. +extern int inswb(int reg, void *buffer, int len);
  34160. +extern int outswb(int reg, void *buffer, int len);
  34161. +
  34162. +#define FUNC_PROLOGUE \
  34163. +    struct dev_priv *priv = (struct dev_priv *)dev->priv
  34164. +
  34165. +#define BUS_16 16
  34166. +#define BUS_8  8
  34167. +
  34168. +/*
  34169. + * I'm not sure what address we should default to if the internal one
  34170. + * is corrupted...
  34171. + */
  34172. +unsigned char def_eth_addr[6] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};
  34173. +
  34174. +/* --------------------------------------------------------------------------- */
  34175. +
  34176. +/*
  34177. + * write data to the buffer memory
  34178. + */
  34179. +static void
  34180. +ether3_writebuffer(struct device *dev, void *data, int start, int length)
  34181. +{
  34182. +    FUNC_PROLOGUE;
  34183. +    int timeout = 1000000;
  34184. +
  34185. +    if (start != -1) {
  34186. +    outw (priv->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34187. +    outw (priv->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  34188. +    while ((inw (REG_STATUS) & STAT_FIFOEMPTY) == 0)
  34189. +        if (!timeout--) {
  34190. +        printk (KERN_CRIT "%s: writebuf broken\n", dev->name);
  34191. +        priv->broken = 1;
  34192. +        return;
  34193. +        }
  34194. +    outw (priv->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  34195. +    outw (start, REG_DMAADDR);
  34196. +    }
  34197. +    if(length != 0)
  34198. +    outswb (REG_BUFWIN, data, length);
  34199. +}
  34200. +
  34201. +/*
  34202. + * read data from the buffer memory
  34203. + */
  34204. +static void
  34205. +ether3_readbuffer(struct device *dev, void *data, int start, int length)
  34206. +{
  34207. +    FUNC_PROLOGUE;
  34208. +    int timeout = 1000000;
  34209. +
  34210. +    if (start != -1) {
  34211. +    outw (priv->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34212. +    outw (priv->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  34213. +    while ((inw( REG_STATUS) & STAT_FIFOEMPTY) == 0)
  34214. +        if (!timeout--) {
  34215. +        printk (KERN_CRIT "%s: readbuf broken\n", dev->name);
  34216. +        priv->broken = 1;
  34217. +        return;
  34218. +        }
  34219. +    outw (start, REG_DMAADDR);
  34220. +    outw (priv->regs.command | CMD_FIFOREAD, REG_COMMAND);
  34221. +    }
  34222. +    if(length != 0)
  34223. +    inswb (REG_BUFWIN, data, length);
  34224. +}
  34225. +
  34226. +/*
  34227. + * Increment the use count, and switch LED on if necessary
  34228. + */
  34229. +static inline void
  34230. +ether3_ledincrementuse (struct device *dev)
  34231. +{
  34232. +    FUNC_PROLOGUE;
  34233. +
  34234. +    if (++ priv->use == 1) {
  34235. +    priv->regs.config2 &= ~CFG2_CTRLO;
  34236. +    outw (priv->regs.config2 , REG_CONFIG2);
  34237. +    }
  34238. +}
  34239. +
  34240. +/*
  34241. + * Decrement the use count and switch LED off if necessary
  34242. + */
  34243. +static inline void
  34244. +ether3_leddecrementuse (struct device *dev)
  34245. +{
  34246. +    FUNC_PROLOGUE;
  34247. +
  34248. +    if (priv->use && -- priv->use == 0) {
  34249. +    priv->regs.config2 |= CFG2_CTRLO;
  34250. +    outw (priv->regs.config2, REG_CONFIG2);
  34251. +    }
  34252. +}
  34253. +
  34254. +/*
  34255. + * Read the ethernet address string from the on board rom.
  34256. + * This is an ascii string!!!
  34257. + */
  34258. +static void
  34259. +ether3_addr (char *addr, struct expansion_card *ec)
  34260. +{
  34261. +    struct chunk_dir cd;
  34262. +    char *s;
  34263. +    
  34264. +    if (ecard_readchunk(&cd, ec, 0xf5, 0) && (s = strchr(cd.d.string, '('))) {
  34265. +    int i;
  34266. +    for (i = 0; i<6; i++) {
  34267. +        addr[i] = simple_strtoul(s + 1, &s, 0x10);
  34268. +        if (*s != (i==5?')' : ':' ))
  34269. +        break;
  34270. +    }
  34271. +    if (i == 6)
  34272. +        return;
  34273. +    }
  34274. +    memcpy (addr, def_eth_addr, 6);
  34275. +}
  34276. +
  34277. +/* --------------------------------------------------------------------------- */
  34278. +
  34279. +static int
  34280. +ether3_ramtest(struct device *dev, unsigned char byte)
  34281. +{
  34282. +    unsigned char *buffer = kmalloc(RX_END, GFP_KERNEL);
  34283. +    int i,ret=0;
  34284. +    int max_errors = 4;
  34285. +    int bad=-1;
  34286. +
  34287. +    if (!buffer)
  34288. +    return 1;
  34289. +
  34290. +    memset (buffer, byte, RX_END);
  34291. +    ether3_writebuffer (dev, buffer, 0, TX_END);
  34292. +    ether3_writebuffer (dev, buffer+RX_START, RX_START, RX_LEN);
  34293. +
  34294. +    memset (buffer, byte ^ 0xff, RX_END);
  34295. +    ether3_readbuffer (dev, buffer, 0, TX_END);
  34296. +    ether3_readbuffer (dev, buffer+RX_START, RX_START, RX_LEN);
  34297. +
  34298. +    for (i=0; i<RX_END; i++) {
  34299. +    if (buffer[i] != byte) {
  34300. +        if (max_errors>=0 && bad!=buffer[i]) {
  34301. +        printk (KERN_ERR "%s: RAM failed with (%02X instead of %02X) at 0x%04X",
  34302. +            dev->name, buffer[i], byte, i);
  34303. +        ret = 2;
  34304. +        max_errors--;
  34305. +        bad = buffer[i];
  34306. +        }
  34307. +    } else {
  34308. +        if (bad != -1) {
  34309. +        printk(" - 0x%04X\n", i);
  34310. +        bad = -1;
  34311. +        }
  34312. +    }
  34313. +    }
  34314. +    if (bad != -1)
  34315. +    printk (" - 0x10000\n");
  34316. +    kfree (buffer);
  34317. +
  34318. +    return ret;
  34319. +}
  34320. +
  34321. +/* ------------------------------------------------------------------------------- */
  34322. +
  34323. +static int
  34324. +ether3_init_2(struct device *dev)
  34325. +{
  34326. +    FUNC_PROLOGUE;
  34327. +    int i;
  34328. +    unsigned long txhdr = 0;
  34329. +
  34330. +    priv->regs.config1 = CFG1_RECVCOMPSTAT0|CFG1_DMABURST8;
  34331. +    priv->regs.config2 = CFG2_CTRLO|CFG2_RECVCRC|CFG2_ERRENCRC;
  34332. +    priv->regs.command = 0;
  34333. +    /*
  34334. +     * Set up our hardware address
  34335. +     */
  34336. +    outw (priv->regs.config1 | CFG1_BUFSELSTAT0, REG_CONFIG1);
  34337. +    for (i = 0; i < 6; i++)
  34338. +    outb (dev->dev_addr[i], REG_BUFWIN);
  34339. +
  34340. +    if (dev->flags & IFF_PROMISC)
  34341. +    priv->regs.config1 |= CFG1_RECVPROMISC;
  34342. +    else
  34343. +    if (dev->flags & IFF_MULTICAST)
  34344. +    priv->regs.config1 |= CFG1_RECVSPECBRMULTI;
  34345. +    else
  34346. +    priv->regs.config1 |= CFG1_RECVSPECBROAD;
  34347. +
  34348. +    /*
  34349. +     * There is a problem with the NQ8005 in that it occasionally losses the
  34350. +     * last two bytes.  To get round this problem, we receive the CRC as well.
  34351. +     * That way, if we do loose the last two, then it doesn't matter
  34352. +     */
  34353. +    outw (priv->regs.config1 | CFG1_TRANSEND, REG_CONFIG1);
  34354. +    outw ((TX_END>>8) - 1, REG_BUFWIN);
  34355. +    outw (priv->regs.recvptr, REG_RECVPTR);
  34356. +    outw (priv->regs.transmitptr, REG_TRANSMITPTR);
  34357. +    outw (priv->regs.recvptr >> 8, REG_RECVEND);
  34358. +    outw (priv->regs.config2, REG_CONFIG2);
  34359. +    outw (priv->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34360. +
  34361. +    ether3_writebuffer (dev, &txhdr, priv->regs.transmitptr, 4);
  34362. +
  34363. +    outw (priv->regs.command, REG_COMMAND);
  34364. +
  34365. +    i = ether3_ramtest (dev, 0x5A);
  34366. +    if(i)
  34367. +    return i;
  34368. +    return ether3_ramtest (dev, 0x1E);
  34369. +}
  34370. +
  34371. +static void
  34372. +ether3_init_for_open(struct device *dev)
  34373. +{
  34374. +    FUNC_PROLOGUE;
  34375. +    unsigned long txhdr = 0;
  34376. +    int i;
  34377. +
  34378. +    memset (&priv->stats, 0, sizeof (struct enet_statistics));
  34379. +
  34380. +    priv->regs.command = 0;
  34381. +    priv->txbuffered = 0;
  34382. +    outw (CMD_RXOFF|CMD_TXOFF, REG_COMMAND);
  34383. +    while (inw (REG_STATUS) & (STAT_RXON|STAT_TXON));
  34384. +
  34385. +    outw (priv->regs.config1 | CFG1_BUFSELSTAT0, REG_CONFIG1);
  34386. +    for (i = 0; i < 6; i++)
  34387. +    outb (dev->dev_addr[i], REG_BUFWIN);
  34388. +
  34389. +    priv->regs.transmitptr = 0;    /* address that transmitter has processed to */
  34390. +    priv->txinsert = 0;        /* address of next available packet for tx */
  34391. +    priv->txed = 0;            /* transmitted length index */
  34392. +    priv->txto = 0;            /* to transmit length index */
  34393. +    priv->tx_ends[0] = 0;
  34394. +    priv->use = 0;
  34395. +
  34396. +    priv->regs.config2 |= CFG2_CTRLO;
  34397. +
  34398. +    outw (priv->regs.config1 | CFG1_TRANSEND, REG_CONFIG1);
  34399. +    outw ((TX_END>>8) - 1, REG_BUFWIN);
  34400. +
  34401. +    priv->regs.recvptr    = RX_START;
  34402. +    outw (priv->regs.recvptr, REG_RECVPTR);
  34403. +    outw (priv->regs.recvptr >> 8, REG_RECVEND);
  34404. +
  34405. +    outw (0, REG_TRANSMITPTR);
  34406. +    outw (priv->regs.config2, REG_CONFIG2);
  34407. +    outw (priv->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34408. +
  34409. +    ether3_writebuffer (dev, &txhdr, priv->regs.transmitptr, 4);
  34410. +
  34411. +    priv->regs.command = CMD_ENINTRX|CMD_ENINTTX;
  34412. +    outw (priv->regs.command | CMD_RXON, REG_COMMAND);
  34413. +}
  34414. +
  34415. +/*
  34416. + * This is the real probe routine.
  34417. + */
  34418. +static int
  34419. +ether3_probe1(struct device *dev)
  34420. +{
  34421. +    static unsigned version_printed = 0;
  34422. +    struct dev_priv *priv;
  34423. +    int i;
  34424. +
  34425. +    if (!dev->priv)
  34426. +    dev->priv = kmalloc (sizeof (struct dev_priv), GFP_KERNEL);
  34427. +
  34428. +    if (!dev->priv)
  34429. +    return -ENOMEM;
  34430. +
  34431. +    priv = (struct dev_priv *) dev->priv;
  34432. +    memset (priv, 0, sizeof(struct dev_priv));
  34433. +    priv->broken = 0;
  34434. +
  34435. +    outb (0x80, REG_CONFIG2 + 1);
  34436. +    outb (0, REG_COMMAND);
  34437. +
  34438. +    /*
  34439. +     * test to see if we have an 8 or 16-bit IO bus
  34440. +     */
  34441. +    outb (1, REG_CONFIG1);
  34442. +    if (inb (REG_CONFIG1 + 1) == 1 && inb (REG_CONFIG1) == 0)
  34443. +        priv->bus_type = BUS_8;
  34444. +    else
  34445. +    if (inw (REG_CONFIG1) == 0x0101)
  34446. +        priv->bus_type = BUS_16;
  34447. +    else {
  34448. +    kfree(dev->priv);
  34449. +    dev->priv = NULL;
  34450. +    return -ENODEV;
  34451. +    }
  34452. +
  34453. +    if (net_debug  &&  version_printed++ == 0)
  34454. +    printk (KERN_INFO "%s", version);
  34455. +
  34456. +    printk(KERN_INFO "%s: ether3 found [%d, %04lx, %d] ", dev->name, priv->bus_type,
  34457. +    dev->base_addr, dev->irq);
  34458. +
  34459. +    request_region (dev->base_addr, 128, "ether3");
  34460. +
  34461. +    if (priv->bus_type == BUS_8) {
  34462. +    printk (KERN_CRIT "*** 8-bit not supported (yet) ***\n");
  34463. +    kfree (dev->priv);
  34464. +    dev->priv = NULL;
  34465. +    return -ENODEV;
  34466. +    }
  34467. +
  34468. +    /* Retrive and print the ethernet address. */
  34469. +    for (i = 0; i < 6; i++)
  34470. +    printk (i == 5 ? "%02x\n" : "%02x:", dev->dev_addr[i]);
  34471. +
  34472. +    if (ether3_init_2(dev)) {
  34473. +    kfree (dev->priv);
  34474. +    dev->priv = NULL;
  34475. +    return -ENODEV;
  34476. +    }
  34477. +
  34478. +    dev->open = ether3_open;
  34479. +    dev->stop = ether3_close;
  34480. +    dev->hard_start_xmit = ether3_sendpacket;
  34481. +    dev->get_stats = ether3_getstats;
  34482. +    dev->set_multicast_list = ether3_setmulticastlist;
  34483. +
  34484. +    /* Fill in the fields of the device structure with ethernet values. */
  34485. +    ether_setup(dev);
  34486. +#ifndef CLAIM_IRQ_AT_OPEN
  34487. +    if (request_irq(dev->irq, ether3_interrupt, 0, "ether3", dev)) {
  34488. +    kfree (dev->priv);
  34489. +    dev->priv = NULL;
  34490. +    return -EAGAIN;
  34491. +    }
  34492. +#endif
  34493. +    return 0;
  34494. +}
  34495. +
  34496. +#ifndef MODULE
  34497. +int
  34498. +ether3_probe(struct device *dev)
  34499. +{
  34500. +    struct expansion_card *ec;
  34501. +
  34502. +    if (!dev)
  34503. +    return ENODEV;
  34504. +
  34505. +    if ((ec = ecard_find (0, sizeof(ether3_prods), ether3_prods, ether3_manus)) == NULL)
  34506. +    return ENODEV;
  34507. +
  34508. +    dev->base_addr = ((unsigned long)ecard_address (ec->slot_no, ECARD_MEMC, 0)) >> 2;
  34509. +    dev->irq = ec->irq;
  34510. +
  34511. +    ecard_claim (ec);
  34512. +
  34513. +    ether3_addr (dev->dev_addr, ec);
  34514. +    return ether3_probe1(dev);
  34515. +}
  34516. +#endif
  34517. +
  34518. +/*
  34519. + * Open/initialize the board.  This is called (in the current kernel)
  34520. + * sometime after booting when the 'ifconfig' program is run.
  34521. + *
  34522. + * This routine should set everything up anew at each open, even
  34523. + * registers that "should" only need to be set once at boot, so that
  34524. + * there is non-reboot way to recover if something goes wrong.
  34525. + */
  34526. +static int
  34527. +ether3_open(struct device *dev)
  34528. +{
  34529. +    ether3_init_for_open(dev);
  34530. +
  34531. +#ifdef CLAIM_IRQ_AT_OPEN
  34532. +    if (request_irq(dev->irq, ether3_interrupt, 0, "ether3", dev))
  34533. +    return -EAGAIN;
  34534. +#endif
  34535. +
  34536. +    MOD_INC_USE_COUNT;
  34537. +
  34538. +    dev->tbusy = 0;
  34539. +    dev->interrupt = 0;
  34540. +    dev->start = 1;
  34541. +    return 0;
  34542. +}
  34543. +
  34544. +/*
  34545. + * The inverse routine to ether3_open().
  34546. + */
  34547. +static int
  34548. +ether3_close(struct device *dev)
  34549. +{
  34550. +    FUNC_PROLOGUE;
  34551. +    unsigned long flags;
  34552. +
  34553. +    dev->tbusy = 1;
  34554. +    dev->start = 0;
  34555. +
  34556. +    save_flags_cli (flags);
  34557. +
  34558. +    outw (CMD_RXOFF|CMD_TXOFF, REG_COMMAND);
  34559. +    priv->regs.command = 0;
  34560. +    while (inw (REG_STATUS) & (STAT_RXON|STAT_TXON));
  34561. +    outb (0x80, REG_CONFIG2 + 1);
  34562. +    outw (0, REG_COMMAND);
  34563. +
  34564. +    restore_flags (flags);
  34565. +#ifdef CLAIM_IRQ_AT_OPEN
  34566. +    free_irq (dev->irq, dev);
  34567. +#endif
  34568. +
  34569. +    MOD_DEC_USE_COUNT;
  34570. +    return 0;
  34571. +}
  34572. +
  34573. +/*
  34574. + * Get the current statistics.    This may be called with the card open or
  34575. + * closed.
  34576. + */
  34577. +static struct enet_statistics *ether3_getstats (struct device *dev)
  34578. +{
  34579. +    FUNC_PROLOGUE;
  34580. +    return &priv->stats;
  34581. +}
  34582. +
  34583. +/*
  34584. + * Set or clear promiscuous/multicast mode filter for this adaptor.
  34585. + *
  34586. + * We don't attempt any packet filtering.  The card may have a SEEQ 8004
  34587. + * in which does not have the other ethernet address registers present...
  34588. + */
  34589. +static void ether3_setmulticastlist (struct device *dev)
  34590. +{
  34591. +    FUNC_PROLOGUE;
  34592. +
  34593. +    priv->regs.config1 &= ~CFG1_RECVPROMISC;
  34594. +
  34595. +    if (dev->flags & IFF_PROMISC) {
  34596. +    /* promiscuous mode */
  34597. +    priv->regs.config1 |= CFG1_RECVPROMISC;
  34598. +    } else
  34599. +    if (dev->flags & IFF_ALLMULTI) {
  34600. +    priv->regs.config1 |= CFG1_RECVSPECBRMULTI;
  34601. +    } else
  34602. +    priv->regs.config1 |= CFG1_RECVSPECBROAD;
  34603. +
  34604. +    outw (priv->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34605. +}
  34606. +
  34607. +/*
  34608. + * Transmit a packet
  34609. + */
  34610. +static int
  34611. +ether3_sendpacket(struct sk_buff *skb, struct device *dev)
  34612. +{
  34613. +    FUNC_PROLOGUE;
  34614. +
  34615. +    if (dev->tbusy) {
  34616. +    /* If we get here, some higher level has decided we are broken.
  34617. +       There should really be a "kick me" function call instead. */
  34618. +    int tickssofar = jiffies - dev->trans_start;
  34619. +    if (tickssofar < 5)
  34620. +        return 1;
  34621. +    printk (KERN_WARNING "%s: transmit timed out, network cable problem?\n", dev->name);
  34622. +    /* Try to restart the adaptor. */
  34623. +    dev->tbusy = 0;
  34624. +    priv->use = 0;
  34625. +    priv->regs.config2 |= CFG2_CTRLO;
  34626. +    outw (priv->regs.config2 , REG_CONFIG2);
  34627. +    dev->trans_start = jiffies;
  34628. +    }
  34629. +
  34630. +    /* If some higher layer thinks we've missed an tx-done interrupt
  34631. +       we are passed NULL. Caution: dev_tint() handles the cli()/sti()
  34632. +       itself. */
  34633. +    if (skb == NULL) {
  34634. +    dev_tint(dev);
  34635. +    return 0;
  34636. +    }
  34637. +
  34638. +    /* Block a timer-based transmit from overlapping.  This could better be
  34639. +       done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
  34640. +    if (set_bit(0, (void*)&dev->tbusy) != 0)
  34641. +    printk(KERN_ERR "%s: Transmitter access conflict.\n", dev->name);
  34642. +    else {
  34643. +    unsigned int length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
  34644. +    unsigned int thisdata, thisstart, nextpacket;
  34645. +    unsigned long flags;
  34646. +    unsigned long thishdr = TXHDR_TRANSMIT|TXHDR_CHAINCONTINUE|TXHDR_DATAFOLLOWS
  34647. +                |TXHDR_ENSUCCESS;
  34648. +    unsigned long nexthdr = 0;
  34649. +
  34650. +    if (priv->broken) {
  34651. +        dev_kfree_skb(skb, FREE_WRITE);
  34652. +        priv->stats.tx_dropped ++;
  34653. +        dev->tbusy = 0;
  34654. +        return 0;
  34655. +    }
  34656. +
  34657. +    thisstart = priv->txinsert;
  34658. +    thisdata  = thisstart + 4;
  34659. +    if (thisdata >= TX_END)
  34660. +        thisdata -= TX_END;
  34661. +
  34662. +    nextpacket = thisdata + length;
  34663. +    if (nextpacket >= TX_END)
  34664. +        nextpacket -= TX_END;
  34665. +
  34666. +    priv->txinsert = nextpacket;
  34667. +    priv->tx_ends[priv->txto++] = nextpacket;
  34668. +
  34669. +    if (priv->txto >= MAX_TXED)
  34670. +        priv->txto = 0;
  34671. +
  34672. +    thishdr |= htons (nextpacket);
  34673. +
  34674. +    save_flags_cli (flags);
  34675. +    ether3_writebuffer(dev, skb->data, thisdata, (length & 1) ? (length + 1) : length);
  34676. +    ether3_writebuffer(dev, &nexthdr, -1, 4);
  34677. +    ether3_ledincrementuse (dev);
  34678. +    ether3_writebuffer(dev, &thishdr, thisstart, 4);
  34679. +
  34680. +    if ((inw (REG_STATUS) & STAT_TXON) == 0) {
  34681. +        outw (thisstart, REG_TRANSMITPTR);
  34682. +        outw (priv->regs.command | CMD_TXON, REG_COMMAND);
  34683. +    }
  34684. +    restore_flags(flags);
  34685. +
  34686. +    dev->trans_start = jiffies;
  34687. +    if (priv->txbuffered ++ < MAX_TX_BUFFERED)
  34688. +        dev->tbusy = 0;
  34689. +    }
  34690. +    dev_kfree_skb (skb, FREE_WRITE);
  34691. +
  34692. +    return 0;
  34693. +}
  34694. +
  34695. +static void
  34696. +ether3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  34697. +{
  34698. +    struct device *dev = (struct device *)dev_id;
  34699. +    struct dev_priv *priv;
  34700. +    int boguscount = 20, done;
  34701. +
  34702. +#if NET_DEBUG > 1
  34703. +    if(net_debug & DEBUG_INT)
  34704. +    printk(KERN_DEBUG "eth3irq: %d ", irq);
  34705. +#endif
  34706. +
  34707. +    priv = (struct dev_priv *)dev->priv;
  34708. +
  34709. +    dev->interrupt = 1;
  34710. +
  34711. +    do {
  34712. +        unsigned int status;
  34713. +
  34714. +        done = 0;
  34715. +    status = inw(REG_STATUS);
  34716. +
  34717. +    if (status & STAT_INTRX) { /* Got a packet(s). */
  34718. +        outw (CMD_ACKINTRX | priv->regs.command, REG_COMMAND);
  34719. +        ether3_rx (dev, priv);
  34720. +        done = 1;
  34721. +    }
  34722. +    if (status & STAT_INTTX) { /* Packets transmitted */
  34723. +        outw (CMD_ACKINTTX | priv->regs.command, REG_COMMAND);
  34724. +        ether3_tx (dev, priv);
  34725. +        done = 1;
  34726. +    }
  34727. +    if (status & STAT_INTBUFWIN) { /* buffer window interrupt */
  34728. +        outw (CMD_ACKINTBUFWIN | priv->regs.command, REG_COMMAND);
  34729. +    }
  34730. +    } while (-- boguscount && !done) ;
  34731. +
  34732. +    dev->interrupt = 0;
  34733. +
  34734. +#if NET_DEBUG > 1
  34735. +    if(net_debug & DEBUG_INT)
  34736. +    printk("done\n");
  34737. +#endif
  34738. +}
  34739. +
  34740. +/*
  34741. + * If we have a good packet(s), get it/them out of the buffers.
  34742. + */
  34743. +static void
  34744. +ether3_rx(struct device *dev, struct dev_priv *priv)
  34745. +{
  34746. +    unsigned int current_recv_ptr;
  34747. +    unsigned int maxcnt = 10;
  34748. +
  34749. +    ether3_ledincrementuse (dev);
  34750. +
  34751. +    current_recv_ptr = priv->regs.recvptr;
  34752. +
  34753. +    do {
  34754. +        struct t {
  34755. +            unsigned long rxhdr;
  34756. +            unsigned char dst_addr[6];
  34757. +            unsigned char src_addr[6];
  34758. +        } p;
  34759. +    unsigned int prev_recv_ptr;
  34760. +
  34761. +    /*
  34762. +     * read the first 16 bytes from the buffer.
  34763. +     * This contains the status bytes etc and ethernet addresses,
  34764. +     * and we also check the source ethernet address to see if
  34765. +     * it origionated from us.
  34766. +     */
  34767. +    prev_recv_ptr = current_recv_ptr;
  34768. +    ether3_readbuffer (dev, &p, current_recv_ptr, 16);
  34769. +
  34770. +    if ((p.rxhdr & RX_NEXT) == 0 || (p.rxhdr & RXSTAT_DONE) == 0)
  34771. +        break;
  34772. +    current_recv_ptr = ntohs (p.rxhdr & RX_NEXT);
  34773. +
  34774. +    /*
  34775. +      * ignore our own packets...
  34776. +      */
  34777. +    if (memcmp (dev->dev_addr, &p.src_addr, 6) == 0) {
  34778. +        outw (current_recv_ptr >> 8, REG_RECVEND);
  34779. +        if (p.rxhdr & RXHDR_CHAINCONTINUE)
  34780. +        continue;
  34781. +        else
  34782. +        break;
  34783. +    }
  34784. +
  34785. +    if (!(p.rxhdr & (RXSTAT_OVERSIZE|RXSTAT_CRCERROR|RXSTAT_DRIBBLEERROR|RXSTAT_SHORTPACKET))) {
  34786. +        unsigned char *buf;
  34787. +        unsigned int length;
  34788. +        struct sk_buff *skb;
  34789. +
  34790. +        if (current_recv_ptr > prev_recv_ptr)
  34791. +        length = current_recv_ptr - prev_recv_ptr - 4;
  34792. +        else
  34793. +        length = (current_recv_ptr - RX_START) + (RX_END - prev_recv_ptr) - 4;
  34794. +
  34795. +        skb = dev_alloc_skb(length + 2);
  34796. +        if (skb == NULL) {
  34797. +        printk (KERN_WARNING "%s: memory squeeze, dropping packet.\n", dev->name);
  34798. +        priv->stats.rx_dropped ++;
  34799. +        break;
  34800. +        }
  34801. +
  34802. +        skb->dev = dev;
  34803. +        skb_reserve (skb, 2);
  34804. +        buf = skb_put (skb, length);
  34805. +        /*
  34806. +         * buf isn't word aligned, and it is probably faster to
  34807. +         * copy the address this way
  34808. +         */
  34809. +        *(unsigned short *)&buf[0] = *(unsigned short *)&p.dst_addr[0];
  34810. +        *(unsigned short *)&buf[2] = *(unsigned short *)&p.dst_addr[2];
  34811. +        *(unsigned short *)&buf[4] = *(unsigned short *)&p.dst_addr[4];
  34812. +        *(unsigned short *)&buf[6] = *(unsigned short *)&p.src_addr[0];
  34813. +        *(unsigned short *)&buf[8] = *(unsigned short *)&p.src_addr[2];
  34814. +        *(unsigned short *)&buf[10] = *(unsigned short *)&p.src_addr[4];
  34815. +    
  34816. +        ether3_readbuffer (dev, buf + 12, -1, length - 12);
  34817. +
  34818. +        outw (current_recv_ptr >> 8, REG_RECVEND);
  34819. +
  34820. +        skb->protocol = eth_type_trans(skb, dev);
  34821. +        netif_rx (skb);
  34822. +        priv->stats.rx_packets++;
  34823. +    } else {
  34824. +        priv->stats.rx_errors++;
  34825. +        if(p.rxhdr & RXSTAT_OVERSIZE) priv->stats.rx_length_errors ++;
  34826. +        if(p.rxhdr & RXSTAT_CRCERROR) priv->stats.rx_crc_errors ++;
  34827. +        if(p.rxhdr & RXSTAT_DRIBBLEERROR) priv->stats.rx_fifo_errors ++;
  34828. +        if(p.rxhdr & RXSTAT_SHORTPACKET) priv->stats.rx_length_errors ++;
  34829. +        outw (current_recv_ptr >> 8, REG_RECVEND);
  34830. +    }
  34831. +    if (!(p.rxhdr & RXHDR_CHAINCONTINUE))
  34832. +        break;
  34833. +    }
  34834. +    while (-- maxcnt);
  34835. +
  34836. +    priv->regs.recvptr = current_recv_ptr;
  34837. +    if (!(inw (REG_STATUS) & STAT_RXON)) {
  34838. +        outw (priv->regs.recvptr, REG_RECVPTR);
  34839. +    outw (priv->regs.command | CMD_RXON, REG_COMMAND);
  34840. +    }
  34841. +
  34842. +    /* If any worth-while packets have been received, dev_rint()
  34843. +       has done a mark_bh(NET_BH) for us and will work on them
  34844. +       when we get to the bottom-half routine. */
  34845. +    ether3_leddecrementuse (dev);
  34846. +}
  34847. +
  34848. +/*
  34849. + * Update stats for the transmitted packet
  34850. + */
  34851. +static void
  34852. +ether3_tx(struct device *dev, struct dev_priv *priv)
  34853. +{
  34854. +    unsigned long txhdr;
  34855. +    unsigned char *buffer = (unsigned char *)&txhdr;
  34856. +    unsigned int txptr;
  34857. +
  34858. +    txptr = priv->regs.transmitptr;
  34859. +
  34860. +    do {
  34861. +        /*
  34862. +         * Read the packet header
  34863. +         */
  34864. +    if (txptr + 4 > TX_END) {
  34865. +        int len = TX_END - txptr;
  34866. +        if (len)
  34867. +        ether3_readbuffer (dev, buffer, txptr, len);
  34868. +        ether3_readbuffer (dev, buffer + len, 0, 4 - len);
  34869. +    } else
  34870. +        ether3_readbuffer (dev, buffer, txptr, 4);
  34871. +
  34872. +    /*
  34873. +     * Check to see if this packet has been transmitted
  34874. +     */
  34875. +    if (!(txhdr & TXSTAT_DONE) || !(txhdr & TXHDR_TRANSMIT)) {
  34876. +        priv->regs.transmitptr = txptr;
  34877. +        return;
  34878. +    }
  34879. +
  34880. +    /*
  34881. +     * Update collision count (undocumented in datasheet)
  34882. +     */
  34883. +    if (txhdr & TXSTAT_COLLISION)
  34884. +        priv->stats.collisions += (txhdr >> (3+24)) & 15;
  34885. +
  34886. +    /*
  34887. +     * Update errors
  34888. +     */
  34889. +    if (txhdr & (TXSTAT_BABBLED | TXSTAT_16COLLISIONS)) {
  34890. +        priv->stats.tx_errors ++;
  34891. +        if (txhdr & TXSTAT_16COLLISIONS) priv->stats.collisions += 16;
  34892. +        if (txhdr & TXSTAT_BABBLED) priv->stats.tx_fifo_errors ++;
  34893. +    } else
  34894. +        priv->stats.tx_packets++;
  34895. +
  34896. +    /*
  34897. +     * Get next packet address
  34898. +     */
  34899. +    txptr = priv->tx_ends[priv->txed++]; /* next packet address */
  34900. +
  34901. +    if (priv->txed >= MAX_TXED)
  34902. +        priv->txed = 0;
  34903. +
  34904. +    if (txptr != ntohs (txhdr & TX_NEXT)) {
  34905. +        printk (KERN_WARNING "%s: TX: bad next pointer - %04X instead of %04X\n",
  34906. +        dev->name, ntohs (txhdr & TX_NEXT), txptr);
  34907. +        priv->regs.transmitptr = txptr;
  34908. +        return;
  34909. +    }
  34910. +
  34911. +    if (priv->regs.transmitptr >= TX_END)
  34912. +        priv->regs.transmitptr -= TX_END;
  34913. +
  34914. +    if (priv->txbuffered)
  34915. +        priv->txbuffered -= 1;
  34916. +
  34917. +    dev->tbusy = 0;
  34918. +
  34919. +    ether3_leddecrementuse (dev);
  34920. +    mark_bh (NET_BH);    /* Inform upper layers. */
  34921. +    } while (1);
  34922. +}
  34923. +
  34924. +#ifdef MODULE
  34925. +
  34926. +char ethernames[MAX_ECARDS][9];
  34927. +
  34928. +static struct device *my_ethers[MAX_ECARDS];
  34929. +static struct expansion_card *ec[MAX_ECARDS];
  34930. +
  34931. +int
  34932. +init_module(void)
  34933. +{
  34934. +    int i;
  34935. +
  34936. +    for(i = 0; i < MAX_ECARDS; i++) {
  34937. +    my_ethers[i] = NULL;
  34938. +    ec[i] = NULL;
  34939. +    strcpy (ethernames[i], "        ");
  34940. +    }
  34941. +
  34942. +    i = 0;
  34943. +
  34944. +    do {
  34945. +    if ((ec[i] = ecard_find(0, sizeof(ether3_prods), ether3_prods, ether3_manus)) == NULL)
  34946. +        break;
  34947. +
  34948. +    my_ethers[i] = (struct device *)kmalloc(sizeof(struct device), GFP_KERNEL);
  34949. +    memset(my_ethers[i], 0, sizeof(struct device));
  34950. +
  34951. +    my_ethers[i]->irq = ec[i]->irq;
  34952. +    my_ethers[i]->base_addr= ((unsigned long)ecard_address (ec[i]->slot_no, ECARD_MEMC, 0))>>2;
  34953. +    my_ethers[i]->init = ether3_probe1;
  34954. +    my_ethers[i]->name = ethernames[i];
  34955. +
  34956. +    ether3_addr(my_ethers[i]->dev_addr, ec[i]);
  34957. +
  34958. +    ecard_claim(ec[i]);
  34959. +
  34960. +    if(register_netdev(my_ethers[i]) != 0) {
  34961. +        for (i = 0; i < 4; i++) {
  34962. +        if(my_ethers[i]) {
  34963. +            kfree(my_ethers[i]);
  34964. +            my_ethers[i] = NULL;
  34965. +        }
  34966. +        if(ec[i]) {
  34967. +            ecard_release(ec[i]);
  34968. +            ec[i] = NULL;
  34969. +        }
  34970. +        }
  34971. +        return -EIO;
  34972. +    }
  34973. +    i++;
  34974. +    }
  34975. +    while(i < MAX_ECARDS);
  34976. +
  34977. +    return i != 0 ? 0 : -ENODEV;
  34978. +}
  34979. +
  34980. +void
  34981. +cleanup_module(void)
  34982. +{
  34983. +    int i;
  34984. +    for (i = 0; i < MAX_ECARDS; i++) {
  34985. +    if (my_ethers[i]) {
  34986. +        unregister_netdev(my_ethers[i]);
  34987. +        my_ethers[i] = NULL;
  34988. +    }
  34989. +    if (ec[i]) {
  34990. +        ecard_release(ec[i]);
  34991. +        ec[i] = NULL;
  34992. +    }
  34993. +    }
  34994. +}
  34995. +#endif /* MODULE */
  34996. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/ether3.h linux/arch/arm/drivers/net/ether3.h
  34997. --- linux.orig/arch/arm/drivers/net/ether3.h    Thu Jan  1 01:00:00 1970
  34998. +++ linux/arch/arm/drivers/net/ether3.h    Fri Jul 19 20:44:42 1996
  34999. @@ -0,0 +1,174 @@
  35000. +/*
  35001. + * linux/drivers/net/ether3.h
  35002. + *
  35003. + * network driver for Acorn Ether3 cards
  35004. + */
  35005. +
  35006. +#ifndef _LINUX_ether3_H
  35007. +#define _LINUX_ether3_H
  35008. +
  35009. +/* use 0 for production, 1 for verification, >2 for debug. debug flags: */
  35010. +#define DEBUG_TX     2
  35011. +#define DEBUG_RX     4
  35012. +#define DEBUG_INT     8
  35013. +#define DEBUG_IC    16
  35014. +#ifndef NET_DEBUG
  35015. +#define NET_DEBUG     0
  35016. +#endif
  35017. +
  35018. +/* Command register definitions & bits */
  35019. +#define REG_COMMAND        (dev->base_addr + 0x00)
  35020. +#define CMD_ENINTDMA        0x0001
  35021. +#define CMD_ENINTRX        0x0002
  35022. +#define CMD_ENINTTX        0x0004
  35023. +#define CMD_ENINTBUFWIN        0x0008
  35024. +#define CMD_ACKINTDMA        0x0010
  35025. +#define CMD_ACKINTRX        0x0020
  35026. +#define CMD_ACKINTTX        0x0040
  35027. +#define CMD_ACKINTBUFWIN    0x0080
  35028. +#define CMD_DMAON        0x0100
  35029. +#define CMD_RXON        0x0200
  35030. +#define CMD_TXON        0x0400
  35031. +#define CMD_DMAOFF        0x0800
  35032. +#define CMD_RXOFF        0x1000
  35033. +#define CMD_TXOFF        0x2000
  35034. +#define CMD_FIFOREAD        0x4000
  35035. +#define CMD_FIFOWRITE        0x8000
  35036. +
  35037. +/* status register */
  35038. +#define REG_STATUS        (dev->base_addr + 0x00)
  35039. +#define STAT_ENINTSTAT        0x0001
  35040. +#define STAT_ENINTRX        0x0002
  35041. +#define STAT_ENINTTX        0x0004
  35042. +#define STAT_ENINTBUFWIN    0x0008
  35043. +#define STAT_INTDMA        0x0010
  35044. +#define STAT_INTRX        0x0020
  35045. +#define STAT_INTTX        0x0040
  35046. +#define STAT_INTBUFWIN        0x0080
  35047. +#define STAT_DMAON        0x0100
  35048. +#define STAT_RXON        0x0200
  35049. +#define STAT_TXON        0x0400
  35050. +#define STAT_FIFOFULL        0x2000
  35051. +#define STAT_FIFOEMPTY        0x4000
  35052. +#define STAT_FIFODIR        0x8000
  35053. +
  35054. +/* configuration register 1 */
  35055. +#define REG_CONFIG1        (dev->base_addr + 0x10)
  35056. +#define CFG1_BUFSELSTAT0    0x0000
  35057. +#define CFG1_BUFSELSTAT1    0x0001
  35058. +#define CFG1_BUFSELSTAT2    0x0002
  35059. +#define CFG1_BUFSELSTAT3    0x0003
  35060. +#define CFG1_BUFSELSTAT4    0x0004
  35061. +#define CFG1_BUFSELSTAT5    0x0005
  35062. +#define CFG1_ADDRPROM        0x0006
  35063. +#define CFG1_TRANSEND        0x0007
  35064. +#define CFG1_LOCBUFMEM        0x0008
  35065. +#define CFG1_INTVECTOR        0x0009
  35066. +#define CFG1_DMABURSTCONT    0x0000
  35067. +#define CFG1_DMABURST800NS    0x0010
  35068. +#define CFG1_DMABURST1600NS    0x0020
  35069. +#define CFG1_DMABURST3200NS    0x0030
  35070. +#define CFG1_DMABURST1        0x0000
  35071. +#define CFG1_DMABURST4        0x0040
  35072. +#define CFG1_DMABURST8        0x0080
  35073. +#define CFG1_DMABURST16        0x00C0
  35074. +#define CFG1_RECVCOMPSTAT0    0x0100
  35075. +#define CFG1_RECVCOMPSTAT1    0x0200
  35076. +#define CFG1_RECVCOMPSTAT2    0x0400
  35077. +#define CFG1_RECVCOMPSTAT3    0x0800
  35078. +#define CFG1_RECVCOMPSTAT4    0x1000
  35079. +#define CFG1_RECVCOMPSTAT5    0x2000
  35080. +#define CFG1_RECVSPECONLY    0x0000
  35081. +#define CFG1_RECVSPECBROAD    0x4000
  35082. +#define CFG1_RECVSPECBRMULTI    0x8000
  35083. +#define CFG1_RECVPROMISC    0xC000
  35084. +
  35085. +/* configuration register 2 */
  35086. +#define REG_CONFIG2        (dev->base_addr + 0x20)
  35087. +#define CFG2_BYTESWAP        0x0001
  35088. +#define CFG2_ERRENCRC        0x0008
  35089. +#define CFG2_ERRENDRIBBLE    0x0010
  35090. +#define CFG2_ERRSHORTFRAME    0x0020
  35091. +#define CFG2_SLOTSELECT        0x0040
  35092. +#define CFG2_PREAMSELECT    0x0080
  35093. +#define CFG2_ADDRLENGTH        0x0100
  35094. +#define CFG2_RECVCRC        0x0200
  35095. +#define CFG2_XMITNOCRC        0x0400
  35096. +#define CFG2_LOOPBACK        0x0800
  35097. +#define CFG2_CTRLO        0x1000
  35098. +#define CFG2_RESET        0x8000
  35099. +
  35100. +#define REG_RECVEND        (dev->base_addr + 0x30)
  35101. +
  35102. +#define REG_BUFWIN        (dev->base_addr + 0x40)
  35103. +
  35104. +#define REG_RECVPTR        (dev->base_addr + 0x50)
  35105. +
  35106. +#define REG_TRANSMITPTR        (dev->base_addr + 0x60)
  35107. +
  35108. +#define REG_DMAADDR        (dev->base_addr + 0x70)
  35109. +
  35110. +/*
  35111. + * Cards transmit/receive headers
  35112. + */
  35113. +#define TX_NEXT            (0xffff)
  35114. +#define TXHDR_ENBABBLEINT    (1 << 16)
  35115. +#define TXHDR_ENCOLLISIONINT    (1 << 17)
  35116. +#define TXHDR_EN16COLLISION    (1 << 18)
  35117. +#define TXHDR_ENSUCCESS        (1 << 19)
  35118. +#define TXHDR_DATAFOLLOWS    (1 << 21)
  35119. +#define TXHDR_CHAINCONTINUE    (1 << 22)
  35120. +#define TXHDR_TRANSMIT        (1 << 23)
  35121. +#define TXSTAT_BABBLED        (1 << 24)
  35122. +#define TXSTAT_COLLISION    (1 << 25)
  35123. +#define TXSTAT_16COLLISIONS    (1 << 26)
  35124. +#define TXSTAT_DONE        (1 << 31)
  35125. +
  35126. +#define RX_NEXT            (0xffff)
  35127. +#define RXHDR_CHAINCONTINUE    (1 << 22)
  35128. +#define RXHDR_RECEIVE        (1 << 23)
  35129. +#define RXSTAT_OVERSIZE        (1 << 24)
  35130. +#define RXSTAT_CRCERROR        (1 << 25)
  35131. +#define RXSTAT_DRIBBLEERROR    (1 << 26)
  35132. +#define RXSTAT_SHORTPACKET    (1 << 27)
  35133. +#define RXSTAT_DONE        (1 << 31)
  35134. +
  35135. +
  35136. +#define TX_END          0x6000
  35137. +#define RX_START        0x6000
  35138. +#define RX_LEN          0xA000
  35139. +#define RX_END          0x10000
  35140. +#define MAX_TXED    360
  35141. +#define MAX_TX_BUFFERED    10
  35142. +
  35143. +struct dev_priv {
  35144. +    int bus_type;            /* type of bus (not currently used)     */
  35145. +    struct {
  35146. +    unsigned int command;
  35147. +    unsigned int config1;
  35148. +    unsigned int config2;
  35149. +    unsigned int transmitptr;
  35150. +    unsigned int recvptr;
  35151. +    } regs;
  35152. +    struct enet_statistics stats;
  35153. +    unsigned int txinsert;        /* address to insert next packet     */
  35154. +    unsigned int txed;            /* transmitted index in tx_ends         */
  35155. +    unsigned int txto;            /* to transmit index in tx_ends         */
  35156. +    unsigned int txbuffered;        /* number of packets currently buffered     */
  35157. +    unsigned int tx_ends[MAX_TXED];    /* addresses of transmit packets     */
  35158. +    unsigned int use;            /* 0 = card not in use, >0 packet transferring */
  35159. +    int broken;                /* 0 = ok, 1 = something went wrong     */
  35160. +};
  35161. +
  35162. +extern int    ether3_probe (struct device *dev);
  35163. +static int    ether3_probe1 (struct device *dev);
  35164. +static int    ether3_open (struct device *dev);
  35165. +static int    ether3_sendpacket (struct sk_buff *skb, struct device *dev);
  35166. +static void    ether3_interrupt (int irq, void *dev_id, struct pt_regs *regs);
  35167. +static void    ether3_rx (struct device *dev, struct dev_priv *priv);
  35168. +static void    ether3_tx (struct device *dev, struct dev_priv *priv);
  35169. +static int    ether3_close (struct device *dev);
  35170. +static struct enet_statistics *ether3_getstats (struct device *dev);
  35171. +static void    ether3_setmulticastlist (struct device *dev);
  35172. +
  35173. +#endif
  35174. diff -u -X rej --recursive --new-file linux.orig/arch/arm/drivers/net/ppp.c linux/arch/arm/drivers/net/ppp.c
  35175. --- linux.orig/arch/arm/drivers/net/ppp.c    Thu Jan  1 01:00:00 1970
  35176. +++ linux/arch/arm/drivers/net/ppp.c    Thu Jul 25 23:07:09 1996
  35177. @@ -0,0 +1,3516 @@
  35178. +/*  PPP for Linux
  35179. + *
  35180. + *  Michael Callahan <callahan@maths.ox.ac.uk>
  35181. + *  Al Longyear <longyear@netcom.com>
  35182. + *
  35183. + *  Dynamic PPP devices by Jim Freeman <jfree@caldera.com>.
  35184. + *  ppp_tty_receive ``noisy-raise-bug'' fixed by Ove Ewerlid <ewerlid@syscon.uu.se>
  35185. + *
  35186. + *  ==FILEVERSION 960528==
  35187. + *
  35188. + *  NOTE TO MAINTAINERS:
  35189. + *     If you modify this file at all, please set the number above to the
  35190. + *     date of the modification as YYMMDD (year month day).
  35191. + *     ppp.c is shipped with a PPP distribution as well as with the kernel;
  35192. + *     if everyone increases the FILEVERSION number above, then scripts
  35193. + *     can do the right thing when deciding whether to install a new ppp.c
  35194. + *     file.  Don't change the format of that line otherwise, so the
  35195. + *     installation script can recognize it.
  35196. + */
  35197. +
  35198. +/*
  35199. +   Sources:
  35200. +
  35201. +   slip.c
  35202. +
  35203. +   RFC1331: The Point-to-Point Protocol (PPP) for the Transmission of
  35204. +   Multi-protocol Datagrams over Point-to-Point Links
  35205. +
  35206. +   RFC1332: IPCP
  35207. +
  35208. +   ppp-2.0
  35209. +
  35210. +   Flags for this module (any combination is acceptable for testing.):
  35211. +
  35212. +   OPTIMIZE_FLAG_TIME - Number of jiffies to force sending of leading flag
  35213. +            character. This is normally set to ((HZ * 3) / 2).
  35214. +            This is 1.5 seconds. If zero then the leading
  35215. +            flag is always sent.
  35216. +
  35217. +   CHECK_CHARACTERS   - Enable the checking on all received characters for
  35218. +            8 data bits, no parity. This adds a small amount of
  35219. +            processing for each received character.
  35220. +*/
  35221. +
  35222. +#define OPTIMIZE_FLAG_TIME    ((HZ * 3)/2)
  35223. +
  35224. +#define CHECK_CHARACTERS    1
  35225. +#define PPP_COMPRESS        1
  35226. +
  35227. +#ifndef PPP_MAX_DEV
  35228. +#define PPP_MAX_DEV    256
  35229. +#endif
  35230. +
  35231. +/* $Id: ppp.c,v 1.5 1995/06/12 11:36:53 paulus Exp $
  35232. + * Added dynamic allocation of channels to eliminate
  35233. + *   compiled-in limits on the number of channels.
  35234. + *
  35235. + * Dynamic channel allocation code Copyright 1995 Caldera, Inc.,
  35236. + *   released under the GNU General Public License Version 2.
  35237. + */
  35238. +
  35239. +#include <linux/autoconf.h>
  35240. +#include <linux/module.h>
  35241. +#include <linux/kernel.h>
  35242. +#include <linux/sched.h>
  35243. +#include <linux/types.h>
  35244. +#include <linux/fcntl.h>
  35245. +#include <linux/interrupt.h>
  35246. +#include <linux/ptrace.h>
  35247. +#include <linux/ioport.h>
  35248. +#include <linux/in.h>
  35249. +#include <linux/malloc.h>
  35250. +#include <linux/tty.h>
  35251. +#include <linux/errno.h>
  35252. +#include <linux/sched.h>    /* to get the struct task_struct */
  35253. +#include <linux/string.h>    /* used in new tty drivers */
  35254. +#include <linux/signal.h>    /* used in new tty drivers */
  35255. +#include <asm/system.h>
  35256. +#include <asm/bitops.h>
  35257. +#include <asm/segment.h>
  35258. +#include <linux/if.h>
  35259. +#include <linux/if_ether.h>
  35260. +#include <linux/netdevice.h>
  35261. +#include <linux/skbuff.h>
  35262. +#include <linux/inet.h>
  35263. +#include <linux/ioctl.h>
  35264. +
  35265. +typedef struct sk_buff         sk_buff;
  35266. +#define skb_data(skb)         ((__u8 *) (skb)->data)
  35267. +
  35268. +#include <linux/ip.h>
  35269. +#include <linux/tcp.h>
  35270. +#include <linux/if_arp.h>
  35271. +#include <net/slhc_vj.h>
  35272. +
  35273. +#define fcstab ppp_crc16_table        /* Name of the table in the kernel */
  35274. +#include <linux/ppp_defs.h>
  35275. +
  35276. +#include <linux/socket.h>
  35277. +#include <linux/if_ppp.h>
  35278. +#include <linux/if_pppvar.h>
  35279. +
  35280. +#undef     PACKETPTR
  35281. +#define     PACKETPTR 1
  35282. +#include <linux/ppp-comp.h>
  35283. +#undef     PACKETPTR
  35284. +
  35285. +#define bsd_decompress    (*ppp->sc_rcomp->decompress)
  35286. +#define bsd_compress    (*ppp->sc_xcomp->compress)
  35287. +
  35288. +#ifndef PPP_IPX
  35289. +#define PPP_IPX 0x2b  /* IPX protocol over PPP */
  35290. +#endif
  35291. +
  35292. +#ifndef PPP_LQR
  35293. +#define PPP_LQR 0xc025    /* Link Quality Reporting Protocol */
  35294. +#endif
  35295. +
  35296. +static int ppp_register_compressor (struct compressor *cp);
  35297. +static void ppp_unregister_compressor (struct compressor *cp);
  35298. +
  35299. +/*
  35300. + * Local functions
  35301. + */
  35302. +
  35303. +static struct compressor *find_compressor (int type);
  35304. +static void ppp_init_ctrl_blk (register struct ppp *);
  35305. +static void ppp_kick_tty (struct ppp *, struct ppp_buffer *bfr);
  35306. +static int ppp_doframe (struct ppp *);
  35307. +static struct ppp *ppp_alloc (void);
  35308. +static struct ppp *ppp_find (int pid_value);
  35309. +static void ppp_print_buffer (const __u8 *, const __u8 *, int);
  35310. +extern inline void ppp_stuff_char (struct ppp *ppp,
  35311. +                   register struct ppp_buffer *buf,
  35312. +                   register __u8 chr);
  35313. +extern inline int lock_buffer (register struct ppp_buffer *buf);
  35314. +
  35315. +static int rcv_proto_ip         (struct ppp *, __u16, __u8 *, int);
  35316. +static int rcv_proto_ipx        (struct ppp *, __u16, __u8 *, int);
  35317. +static int rcv_proto_vjc_comp   (struct ppp *, __u16, __u8 *, int);
  35318. +static int rcv_proto_vjc_uncomp (struct ppp *, __u16, __u8 *, int);
  35319. +static int rcv_proto_unknown    (struct ppp *, __u16, __u8 *, int);
  35320. +static int rcv_proto_lqr        (struct ppp *, __u16, __u8 *, int);
  35321. +static void ppp_doframe_lower   (struct ppp *, __u8 *, int);
  35322. +static int ppp_doframe          (struct ppp *);
  35323. +
  35324. +extern int  ppp_bsd_compressor_init(void);
  35325. +static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd);
  35326. +static int  rcv_proto_ccp (struct ppp *, __u16, __u8 *, int);
  35327. +
  35328. +#define ins_char(pbuf,c) (buf_base(pbuf) [(pbuf)->count++] = (__u8)(c))
  35329. +
  35330. +#ifndef OPTIMIZE_FLAG_TIME
  35331. +#define OPTIMIZE_FLAG_TIME    0
  35332. +#endif
  35333. +
  35334. +#ifndef PPP_MAX_DEV
  35335. +#define PPP_MAX_DEV 256
  35336. +#endif
  35337. +
  35338. +/*
  35339. + * Parameters which may be changed via insmod.
  35340. + */
  35341. +
  35342. +static int  flag_time = OPTIMIZE_FLAG_TIME;
  35343. +static int  max_dev   = PPP_MAX_DEV;
  35344. +
  35345. +/*
  35346. + * The "main" procedure to the ppp device
  35347. + */
  35348. +
  35349. +int ppp_init (struct device *);
  35350. +
  35351. +/*
  35352. + * Network device driver callback routines
  35353. + */
  35354. +
  35355. +static int ppp_dev_open (struct device *);
  35356. +static int ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd);
  35357. +static int ppp_dev_close (struct device *);
  35358. +static int ppp_dev_xmit (sk_buff *, struct device *);
  35359. +static struct enet_statistics *ppp_dev_stats (struct device *);
  35360. +static int ppp_dev_header (sk_buff *, struct device *, __u16,
  35361. +               void *, void *, unsigned int);
  35362. +static int ppp_dev_rebuild (void *eth, struct device *dev,
  35363. +                 unsigned long raddr, struct sk_buff *skb);
  35364. +/*
  35365. + * TTY callbacks
  35366. + */
  35367. +
  35368. +static int ppp_tty_read (struct tty_struct *, struct file *, __u8 *,
  35369. +             unsigned int);
  35370. +static int ppp_tty_write (struct tty_struct *, struct file *, const __u8 *,
  35371. +              unsigned int);
  35372. +static int ppp_tty_ioctl (struct tty_struct *, struct file *, unsigned int,
  35373. +              unsigned long);
  35374. +static int ppp_tty_select (struct tty_struct *tty, struct inode *inode,
  35375. +              struct file *filp, int sel_type, select_table * wait);
  35376. +static int ppp_tty_open (struct tty_struct *);
  35377. +static void ppp_tty_close (struct tty_struct *);
  35378. +static int ppp_tty_room (struct tty_struct *tty);
  35379. +static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
  35380. +                 char *fp, int count);
  35381. +static void ppp_tty_wakeup (struct tty_struct *tty);
  35382. +
  35383. +#define CHECK_PPP(a)  if (!ppp->inuse) { printk (ppp_warning, __LINE__); return a;}
  35384. +#define CHECK_PPP_VOID()  if (!ppp->inuse) { printk (ppp_warning, __LINE__); return;}
  35385. +
  35386. +#define in_xmap(ppp,c)    (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
  35387. +#define in_rmap(ppp,c)    ((((unsigned int) (__u8) (c)) < 0x20) && \
  35388. +            ppp->recv_async_map & (1 << (c)))
  35389. +
  35390. +#define bset(p,b)    ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
  35391. +
  35392. +#define tty2ppp(tty)    ((struct ppp *) (tty->disc_data))
  35393. +#define dev2ppp(dev)    ((struct ppp *) (dev->priv))
  35394. +#define ppp2tty(ppp)    ((struct tty_struct *) ppp->tty)
  35395. +#define ppp2dev(ppp)    ((struct device *) ppp->dev)
  35396. +
  35397. +struct ppp_hdr {
  35398. +    __u8 address;
  35399. +    __u8 control;
  35400. +    __u8 protocol[2];
  35401. +};
  35402. +
  35403. +#define PPP_HARD_HDR_LEN    (sizeof (struct ppp_hdr))
  35404. +
  35405. +typedef struct  ppp_ctrl {
  35406. +    struct ppp_ctrl *next;        /* Next structure in the list    */
  35407. +    char            name [8];    /* Name of the device        */
  35408. +    struct ppp      ppp;        /* PPP control table        */
  35409. +    struct device   dev;        /* Device information table    */
  35410. +} ppp_ctrl_t;
  35411. +
  35412. +static ppp_ctrl_t *ppp_list = NULL;
  35413. +
  35414. +#define ctl2ppp(ctl) (struct ppp *)    &ctl->ppp
  35415. +#define ctl2dev(ctl) (struct device *) &ctl->dev
  35416. +#undef  PPP_NRUNIT
  35417. +
  35418. +/* Buffer types */
  35419. +#define BUFFER_TYPE_DEV_RD    0  /* ppp read buffer       */
  35420. +#define BUFFER_TYPE_TTY_WR    1  /* tty write buffer      */
  35421. +#define BUFFER_TYPE_DEV_WR    2  /* ppp write buffer      */
  35422. +#define BUFFER_TYPE_TTY_RD    3  /* tty read buffer       */
  35423. +#define BUFFER_TYPE_VJ        4  /* vj compression buffer */
  35424. +
  35425. +/* Define this string only once for all macro invocations */
  35426. +static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
  35427. +
  35428. +static char szVersion[]         = PPP_VERSION;
  35429. + 
  35430. +/*
  35431. + * Information for the protocol decoder
  35432. + */
  35433. +
  35434. +typedef int (*pfn_proto)  (struct ppp *, __u16, __u8 *, int);
  35435. +
  35436. +typedef struct ppp_proto_struct {
  35437. +    int        proto;
  35438. +    pfn_proto    func;
  35439. +} ppp_proto_type;
  35440. +
  35441. +static
  35442. +ppp_proto_type proto_list[] = {
  35443. +    { PPP_IP,         rcv_proto_ip         },
  35444. +    { PPP_IPX,        rcv_proto_ipx        },
  35445. +    { PPP_VJC_COMP,   rcv_proto_vjc_comp   },
  35446. +    { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
  35447. +    { PPP_LQR,        rcv_proto_lqr        },
  35448. +    { PPP_CCP,        rcv_proto_ccp        },
  35449. +    { 0,              rcv_proto_unknown    }  /* !!! MUST BE LAST !!! */
  35450. +};
  35451. +
  35452. +__u16 ppp_crc16_table[256] =
  35453. +{
  35454. +    0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  35455. +    0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  35456. +    0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  35457. +    0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  35458. +    0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  35459. +    0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  35460. +    0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  35461. +    0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  35462. +    0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  35463. +    0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  35464. +    0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  35465. +    0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  35466. +    0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  35467. +    0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  35468. +    0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  35469. +    0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  35470. +    0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  35471. +    0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  35472. +    0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  35473. +    0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  35474. +    0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  35475. +    0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  35476. +    0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  35477. +    0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  35478. +    0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  35479. +    0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  35480. +    0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  35481. +    0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  35482. +    0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  35483. +    0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  35484. +    0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  35485. +    0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  35486. +};
  35487. +
  35488. +#ifdef CHECK_CHARACTERS
  35489. +static __u32 paritytab[8] =
  35490. +{
  35491. +    0x96696996, 0x69969669, 0x69969669, 0x96696996,
  35492. +    0x69969669, 0x96696996, 0x96696996, 0x69969669
  35493. +};
  35494. +#endif
  35495. +
  35496. +/* local function to store a value into the LQR frame */
  35497. +extern inline __u8 * store_long (register __u8 *p, register int value) {
  35498. +    *p++ = (__u8) (value >> 24);
  35499. +    *p++ = (__u8) (value >> 16);
  35500. +    *p++ = (__u8) (value >>  8);
  35501. +    *p++ = (__u8) value;
  35502. +    return p;
  35503. +}
  35504. +
  35505. +/*************************************************************
  35506. + * INITIALIZATION
  35507. + *************************************************************/
  35508. +
  35509. +/* This procedure is called once and once only to define who we are to
  35510. + * the operating system and the various procedures that it may use in
  35511. + * accessing the ppp protocol.
  35512. + */
  35513. +
  35514. +static int
  35515. +ppp_first_time (void)
  35516. +{
  35517. +    static struct tty_ldisc    ppp_ldisc;
  35518. +    int    status;
  35519. +
  35520. +    printk (KERN_INFO
  35521. +        "PPP: version %s (dynamic channel allocation)"
  35522. +        "\n", szVersion);
  35523. +
  35524. +#ifndef MODULE /* slhc module logic has its own copyright announcement */
  35525. +    printk (KERN_INFO
  35526. +        "TCP compression code copyright 1989 Regents of the "
  35527. +        "University of California\n");
  35528. +#endif
  35529. +    
  35530. +    printk (KERN_INFO
  35531. +        "PPP Dynamic channel allocation code copyright 1995 "
  35532. +        "Caldera, Inc.\n");
  35533. +/*
  35534. + * Register the tty discipline
  35535. + */    
  35536. +    (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
  35537. +    ppp_ldisc.magic        = TTY_LDISC_MAGIC;
  35538. +    ppp_ldisc.open        = ppp_tty_open;
  35539. +    ppp_ldisc.close        = ppp_tty_close;
  35540. +    ppp_ldisc.read        = ppp_tty_read;
  35541. +    ppp_ldisc.write        = ppp_tty_write;
  35542. +    ppp_ldisc.ioctl        = ppp_tty_ioctl;
  35543. +    ppp_ldisc.select    = ppp_tty_select;
  35544. +    ppp_ldisc.receive_room    = ppp_tty_room;
  35545. +    ppp_ldisc.receive_buf    = ppp_tty_receive;
  35546. +    ppp_ldisc.write_wakeup    = ppp_tty_wakeup;
  35547. +    
  35548. +    status = tty_register_ldisc (N_PPP, &ppp_ldisc);
  35549. +    if (status == 0)
  35550. +        printk (KERN_INFO "PPP line discipline registered.\n");
  35551. +    else
  35552. +        printk (KERN_ERR "error registering line discipline: %d\n",
  35553. +            status);
  35554. +    return status;
  35555. +}
  35556. +
  35557. +/*************************************************************
  35558. + * INITIALIZATION
  35559. + *************************************************************/
  35560. +
  35561. +/* called when the device is actually created */
  35562. +
  35563. +static int
  35564. +ppp_init_dev (struct device *dev)
  35565. +{
  35566. +    int    indx;
  35567. +
  35568. +    dev->hard_header      = ppp_dev_header;
  35569. +    dev->rebuild_header   = ppp_dev_rebuild;
  35570. +    dev->hard_header_len  = PPP_HARD_HDR_LEN;
  35571. +
  35572. +    /* device INFO */
  35573. +    dev->mtu              = PPP_MTU;
  35574. +    dev->hard_start_xmit  = ppp_dev_xmit;
  35575. +    dev->open             = ppp_dev_open;
  35576. +    dev->stop             = ppp_dev_close;
  35577. +    dev->get_stats        = ppp_dev_stats;
  35578. +    dev->do_ioctl         = ppp_dev_ioctl;
  35579. +    dev->addr_len         = 0;
  35580. +    dev->tx_queue_len     = 10;
  35581. +    dev->type             = ARPHRD_PPP;
  35582. +
  35583. +    for (indx = 0; indx < DEV_NUMBUFFS; indx++)
  35584. +        skb_queue_head_init (&dev->buffs[indx]);
  35585. +
  35586. +    /* New-style flags */
  35587. +    dev->flags      = IFF_POINTOPOINT;
  35588. +    dev->family     = AF_INET;
  35589. +    dev->pa_addr    = 0;
  35590. +    dev->pa_brdaddr = 0;
  35591. +    dev->pa_mask    = 0;
  35592. +    dev->pa_alen    = 4; /* sizeof (__u32) */
  35593. +
  35594. +    return 0;
  35595. +}
  35596. +
  35597. +/*
  35598. + * Local procedure to initialize the ppp structure
  35599. + */
  35600. +
  35601. +static void
  35602. +ppp_init_ctrl_blk (register struct ppp *ppp)
  35603. +{
  35604. +    ppp->magic  = PPP_MAGIC;
  35605. +    ppp->toss   = 0xE0;
  35606. +    ppp->escape = 0;
  35607. +
  35608. +    ppp->flags  = 0;
  35609. +    ppp->mtu    = PPP_MTU;
  35610. +    ppp->mru    = PPP_MRU;
  35611. +
  35612. +    memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
  35613. +    ppp->xmit_async_map[0] = 0xffffffff;
  35614. +    ppp->xmit_async_map[3] = 0x60000000;
  35615. +    ppp->recv_async_map    = 0x00000000;
  35616. +
  35617. +    ppp->rbuf       = NULL;
  35618. +    ppp->wbuf       = NULL;
  35619. +    ppp->ubuf       = NULL;
  35620. +    ppp->cbuf       = NULL;
  35621. +    ppp->slcomp     = NULL;
  35622. +    ppp->read_wait  = NULL;
  35623. +    ppp->write_wait = NULL;
  35624. +    ppp->last_xmit  = jiffies - flag_time;
  35625. +
  35626. +    /* clear statistics */
  35627. +    memset (&ppp->stats, '\0', sizeof (struct pppstat));
  35628. +
  35629. +    /* Reset the demand dial information */
  35630. +    ppp->ddinfo.xmit_idle=         /* time since last NP packet sent */
  35631. +    ppp->ddinfo.recv_idle=jiffies; /* time since last NP packet received */
  35632. +
  35633. +    /* PPP compression data */
  35634. +    ppp->sc_xc_state =
  35635. +    ppp->sc_rc_state = NULL;
  35636. +}
  35637. +
  35638. +static struct symbol_table ppp_syms = {
  35639. +#include <linux/symtab_begin.h>
  35640. +    X(ppp_register_compressor),
  35641. +    X(ppp_unregister_compressor),
  35642. +    X(ppp_crc16_table),
  35643. +#include <linux/symtab_end.h>
  35644. +};
  35645. +
  35646. +/* called at boot/load time for each ppp device defined in the kernel */
  35647. +
  35648. +#ifndef MODULE
  35649. +int
  35650. +ppp_init (struct device *dev)
  35651. +{
  35652. +    static int first_time = 1;
  35653. +    int    answer = 0;
  35654. +
  35655. +    if (first_time) {
  35656. +        first_time = 0;
  35657. +        answer     = ppp_first_time();
  35658. +        if (answer == 0)
  35659. +            (void) register_symtab (&ppp_syms);
  35660. +    }
  35661. +    if (answer == 0)
  35662. +        answer = -ENODEV;
  35663. +    return answer;
  35664. +}
  35665. +#endif
  35666. +
  35667. +/*
  35668. + * Routine to allocate a buffer for later use by the driver.
  35669. + */
  35670. +
  35671. +static struct ppp_buffer *
  35672. +ppp_alloc_buf (int size, int type)
  35673. +{
  35674. +    struct ppp_buffer *buf;
  35675. +
  35676. +    buf = (struct ppp_buffer *) kmalloc (size + sizeof (struct ppp_buffer),
  35677. +                         GFP_ATOMIC);
  35678. +
  35679. +    if (buf != NULL) {
  35680. +        buf->size   = size - 1;    /* Mask for the buffer size */
  35681. +        buf->type   = type;
  35682. +        buf->locked = 0;
  35683. +        buf->count  = 0;
  35684. +        buf->head   = 0;
  35685. +        buf->tail   = 0;
  35686. +        buf->fcs    = PPP_INITFCS;
  35687. +
  35688. +    }
  35689. +    return (buf);
  35690. +}
  35691. +
  35692. +/*
  35693. + * Routine to release the allocated buffer.
  35694. + */
  35695. +
  35696. +static void
  35697. +ppp_free_buf (struct ppp_buffer *ptr)
  35698. +{
  35699. +    if (ptr != NULL)
  35700. +        kfree (ptr);
  35701. +}
  35702. +
  35703. +/*
  35704. + * Lock the indicated transmit buffer
  35705. + */
  35706. +
  35707. +extern inline int
  35708. +lock_buffer (register struct ppp_buffer *buf)
  35709. +{
  35710. +    register int state;
  35711. +    int flags;
  35712. +/*
  35713. + * Save the current state and if free then set it to the "busy" state
  35714. + */
  35715. +    save_flags (flags);
  35716. +    cli ();
  35717. +    state = buf->locked;
  35718. +    if (state == 0)
  35719. +        buf->locked = 2;
  35720. +
  35721. +    restore_flags (flags);
  35722. +    return (state);
  35723. +}
  35724. +
  35725. +/*
  35726. + * MTU has been changed by the IP layer. Unfortunately we are not told
  35727. + * about this, but we spot it ourselves and fix things up. We could be
  35728. + * in an upcall from the tty driver, or in an ip packet queue.
  35729. + */
  35730. +
  35731. +static int
  35732. +ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
  35733. +{
  35734. +    struct device *dev;
  35735. +
  35736. +    struct ppp_buffer *new_rbuf;
  35737. +    struct ppp_buffer *new_wbuf;
  35738. +    struct ppp_buffer *new_cbuf;
  35739. +    struct ppp_buffer *new_tbuf;
  35740. +
  35741. +    struct ppp_buffer *old_rbuf;
  35742. +    struct ppp_buffer *old_wbuf;
  35743. +    struct ppp_buffer *old_cbuf;
  35744. +    struct ppp_buffer *old_tbuf;
  35745. +
  35746. +    int mtu, mru;
  35747. +/*
  35748. + *  Allocate the buffer from the kernel for the data
  35749. + */
  35750. +    dev = ppp2dev (ppp);
  35751. +    mru = new_mru;
  35752. +    /* allow for possible escaping of every character */
  35753. +    mtu = (new_mtu * 2) + 20;
  35754. +
  35755. +    /* RFC 1331, section 7.2 says the minimum value is 1500 bytes */
  35756. +    if (mru < PPP_MRU)
  35757. +        mru = PPP_MRU;
  35758. +
  35759. +    mru += 10;
  35760. +    
  35761. +    if (ppp->flags & SC_DEBUG)
  35762. +        printk (KERN_INFO "ppp: channel %s mtu = %d, mru = %d\n",
  35763. +            dev->name, new_mtu, new_mru);
  35764. +
  35765. +    new_wbuf = ppp_alloc_buf (mtu+PPP_HARD_HDR_LEN,    BUFFER_TYPE_DEV_WR);
  35766. +    new_tbuf = ppp_alloc_buf ((PPP_MTU * 2) + 24,    BUFFER_TYPE_TTY_WR);
  35767. +    new_rbuf = ppp_alloc_buf (mru + 84,        BUFFER_TYPE_DEV_RD);
  35768. +    new_cbuf = ppp_alloc_buf (mru+PPP_HARD_HDR_LEN,    BUFFER_TYPE_VJ);
  35769. +/*
  35770. + *  If the buffers failed to allocate then complain and release the partial
  35771. + *  allocations.
  35772. + */
  35773. +    if (new_wbuf == NULL || new_tbuf == NULL ||
  35774. +        new_rbuf == NULL || new_cbuf == NULL) {
  35775. +        if (ppp->flags & SC_DEBUG)
  35776. +            printk (KERN_ERR
  35777. +                "ppp: failed to allocate new buffers\n");
  35778. +
  35779. +        ppp_free_buf (new_wbuf);
  35780. +        ppp_free_buf (new_tbuf);
  35781. +        ppp_free_buf (new_rbuf);
  35782. +        ppp_free_buf (new_cbuf);
  35783. +        return 0;
  35784. +    }
  35785. +/*
  35786. + *  Update the pointers to the new buffer structures.
  35787. + */
  35788. +    cli ();
  35789. +    old_wbuf = ppp->wbuf;
  35790. +    old_rbuf = ppp->rbuf;
  35791. +    old_cbuf = ppp->cbuf;
  35792. +    old_tbuf = ppp->tbuf;
  35793. +
  35794. +    ppp->wbuf = new_wbuf;
  35795. +    ppp->rbuf = new_rbuf;
  35796. +    ppp->cbuf = new_cbuf;
  35797. +    ppp->tbuf = new_tbuf;
  35798. +
  35799. +    ppp->rbuf->size -= 80;  /* reserve space for vj header expansion */
  35800. +
  35801. +    dev->mem_start  = (unsigned long) buf_base (new_wbuf);
  35802. +    dev->mem_end    = (unsigned long) (dev->mem_start + mtu);
  35803. +    dev->rmem_start = (unsigned long) buf_base (new_rbuf);
  35804. +    dev->rmem_end   = (unsigned long) (dev->rmem_start + mru);
  35805. +/*
  35806. + *  Update the parameters for the new buffer sizes
  35807. + */
  35808. +    ppp->toss   = 0xE0;    /* To ignore characters until new FLAG */
  35809. +    ppp->escape = 0;    /* No pending escape character */
  35810. +
  35811. +    dev->mtu    =
  35812. +    ppp->mtu    = new_mtu;
  35813. +    ppp->mru    = new_mru;
  35814. +
  35815. +    ppp->s1buf  = NULL;
  35816. +    ppp->s2buf  = NULL;
  35817. +    ppp->xbuf   = NULL;
  35818. +
  35819. +    ppp->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  35820. +    ppp->flags      &= ~SC_XMIT_BUSY;
  35821. +
  35822. +    sti ();
  35823. +/*
  35824. + *  Release old buffer pointers
  35825. + */
  35826. +    ppp_free_buf (old_rbuf);
  35827. +    ppp_free_buf (old_wbuf);
  35828. +    ppp_free_buf (old_cbuf);
  35829. +    ppp_free_buf (old_tbuf);
  35830. +    return 1;
  35831. +}
  35832. +
  35833. +/*
  35834. + * CCP is down; free (de)compressor state if necessary.
  35835. + */
  35836. +
  35837. +static void
  35838. +ppp_ccp_closed (struct ppp *ppp)
  35839. +{
  35840. +    if (ppp->sc_xc_state) {
  35841. +        (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
  35842. +        ppp->sc_xc_state = NULL;
  35843. +    }
  35844. +
  35845. +    if (ppp->sc_rc_state) {
  35846. +        (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
  35847. +        ppp->sc_rc_state = NULL;
  35848. +    }
  35849. +}
  35850. +
  35851. +/*
  35852. + * Called to release all of the information in the current PPP structure.
  35853. + *
  35854. + * It is called when the ppp device goes down or if it is unable to go
  35855. + * up.
  35856. + */
  35857. +
  35858. +static void
  35859. +ppp_release (struct ppp *ppp)
  35860. +{
  35861. +    struct tty_struct *tty;
  35862. +    struct device *dev;
  35863. +
  35864. +    tty = ppp2tty (ppp);
  35865. +    dev = ppp2dev (ppp);
  35866. +
  35867. +    ppp_ccp_closed (ppp);
  35868. +
  35869. +    /* Ensure that the pppd process is not hanging on select() */
  35870. +    wake_up_interruptible (&ppp->read_wait);
  35871. +    wake_up_interruptible (&ppp->write_wait);
  35872. +    
  35873. +    if (tty != NULL && tty->disc_data == ppp)
  35874. +        tty->disc_data = NULL;    /* Break the tty->ppp link */
  35875. +
  35876. +    if (dev && dev->flags & IFF_UP) {
  35877. +        dev_close (dev); /* close the device properly */
  35878. +        dev->flags = 0;  /* prevent recursion */
  35879. +    }
  35880. +
  35881. +    ppp_free_buf (ppp->rbuf);
  35882. +    ppp_free_buf (ppp->wbuf);
  35883. +    ppp_free_buf (ppp->cbuf);
  35884. +    ppp_free_buf (ppp->ubuf);
  35885. +    ppp_free_buf (ppp->tbuf);
  35886. +
  35887. +    ppp->rbuf  =
  35888. +    ppp->wbuf  =
  35889. +    ppp->cbuf  =
  35890. +    ppp->tbuf  =
  35891. +    ppp->xbuf  =
  35892. +    ppp->s1buf =
  35893. +    ppp->s2buf =
  35894. +    ppp->ubuf  = NULL;
  35895. +
  35896. +    if (ppp->slcomp) {
  35897. +        slhc_free (ppp->slcomp);
  35898. +        ppp->slcomp = NULL;
  35899. +    }
  35900. +
  35901. +    ppp->inuse = 0;
  35902. +    ppp->tty   = NULL;
  35903. +}
  35904. +
  35905. +/*
  35906. + * Device callback.
  35907. + *
  35908. + * Called when the PPP device goes down in response to an ifconfig request.
  35909. + */
  35910. +
  35911. +static void
  35912. +ppp_tty_close_local (struct tty_struct *tty, int sc_xfer)
  35913. +{
  35914. +    struct ppp *ppp = tty2ppp (tty);
  35915. +
  35916. +    if (ppp != NULL) {
  35917. +        if (ppp->magic != PPP_MAGIC) {
  35918. +            if (ppp->flags & SC_DEBUG)
  35919. +                printk (KERN_WARNING
  35920. +                       "ppp: trying to close unopened tty!\n");
  35921. +        } else {
  35922. +            CHECK_PPP_VOID();
  35923. +            ppp->sc_xfer = sc_xfer;
  35924. +            if (ppp->flags & SC_DEBUG)
  35925. +                printk (KERN_INFO "ppp: channel %s closing.\n",
  35926. +                    ppp2dev(ppp) -> name);
  35927. +            ppp_release (ppp);
  35928. +            MOD_DEC_USE_COUNT;
  35929. +        }
  35930. +    }
  35931. +}
  35932. +
  35933. +static void
  35934. +ppp_tty_close (struct tty_struct *tty)
  35935. +{
  35936. +    ppp_tty_close_local (tty, 0);
  35937. +}
  35938. +
  35939. +/*
  35940. + * TTY callback.
  35941. + *
  35942. + * Called when the tty discipline is switched to PPP.
  35943. + */
  35944. +
  35945. +static int
  35946. +ppp_tty_open (struct tty_struct *tty)
  35947. +{
  35948. +    struct ppp *ppp = tty2ppp (tty);
  35949. +    int indx;
  35950. +/*
  35951. + * There should not be an existing table for this slot.
  35952. + */
  35953. +    if (ppp) {
  35954. +        if (ppp->flags & SC_DEBUG)
  35955. +            printk (KERN_ERR
  35956. +            "ppp_tty_open: gack! tty already associated to %s!\n",
  35957. +            ppp->magic == PPP_MAGIC ? ppp2dev(ppp)->name
  35958. +                        : "unknown");
  35959. +        return -EEXIST;
  35960. +    }
  35961. +/*
  35962. + * Allocate the structure from the system
  35963. + */
  35964. +     ppp = ppp_find(current->pid);
  35965. +     if (ppp == NULL) {
  35966. +         ppp = ppp_find(0);
  35967. +         if (ppp == NULL)
  35968. +             ppp = ppp_alloc();
  35969. +     }
  35970. + 
  35971. +    if (ppp == NULL) {
  35972. +        if (ppp->flags & SC_DEBUG)
  35973. +            printk (KERN_ERR
  35974. +            "ppp_tty_open: couldn't allocate ppp channel\n");
  35975. +        return -ENFILE;
  35976. +    }
  35977. +/*
  35978. + * Initialize the control block
  35979. + */
  35980. +    ppp_init_ctrl_blk (ppp);
  35981. +    ppp->tty       = tty;
  35982. +    tty->disc_data = ppp;
  35983. +/*
  35984. + * Flush any pending characters in the driver and discipline.
  35985. + */
  35986. +    if (tty->ldisc.flush_buffer)
  35987. +        tty->ldisc.flush_buffer (tty);
  35988. +
  35989. +    if (tty->driver.flush_buffer)
  35990. +        tty->driver.flush_buffer (tty);
  35991. +/*
  35992. + * Allocate space for the default VJ header compression slots
  35993. + */
  35994. +    ppp->slcomp = slhc_init (16, 16);
  35995. +    if (ppp->slcomp == NULL) {
  35996. +        if (ppp->flags & SC_DEBUG)
  35997. +            printk (KERN_ERR
  35998. +            "ppp_tty_open: no space for compression buffers!\n");
  35999. +        ppp_release (ppp);
  36000. +        return -ENOMEM;
  36001. +    }
  36002. +/*
  36003. + * Allocate space for the MTU and MRU buffers
  36004. + */
  36005. +    if (ppp_changedmtu (ppp, ppp2dev(ppp)->mtu, ppp->mru) == 0) {
  36006. +        ppp_release (ppp);
  36007. +        return -ENOMEM;
  36008. +    }
  36009. +/*
  36010. + * Allocate space for a user level buffer
  36011. + */
  36012. +    ppp->ubuf = ppp_alloc_buf (RBUFSIZE, BUFFER_TYPE_TTY_RD);
  36013. +    if (ppp->ubuf == NULL) {
  36014. +        if (ppp->flags & SC_DEBUG)
  36015. +            printk (KERN_ERR
  36016. +               "ppp_tty_open: no space for user receive buffer\n");
  36017. +        ppp_release (ppp);
  36018. +        return -ENOMEM;
  36019. +    }
  36020. +
  36021. +    if (ppp->flags & SC_DEBUG)
  36022. +        printk (KERN_INFO "ppp: channel %s open\n",
  36023. +            ppp2dev(ppp)->name);
  36024. +
  36025. +    for (indx = 0; indx < NUM_NP; ++indx)
  36026. +        ppp->sc_npmode[indx] = NPMODE_PASS;
  36027. +
  36028. +    MOD_INC_USE_COUNT;
  36029. +    return (ppp->line);
  36030. +}
  36031. +
  36032. +/*
  36033. + * Local function to send the next portion of the buffer.
  36034. + *
  36035. + * Called by the tty driver's tty_wakeup function should it be entered
  36036. + * because the partial buffer was transmitted.
  36037. + *
  36038. + * Called by kick_tty to send the initial portion of the buffer.
  36039. + *
  36040. + * Completion processing of the buffer transmission is handled here.
  36041. + */
  36042. +
  36043. +static void
  36044. +ppp_tty_wakeup_code (struct ppp *ppp, struct tty_struct *tty,
  36045. +             struct ppp_buffer *xbuf)
  36046. +{
  36047. +    register int count, actual;
  36048. +/*
  36049. + * Prevent re-entrancy by ensuring that this routine is called only once.
  36050. + */
  36051. +    cli ();
  36052. +    if (ppp->flags & SC_XMIT_BUSY) {
  36053. +        sti ();
  36054. +        return;
  36055. +    }
  36056. +    ppp->flags |= SC_XMIT_BUSY;
  36057. +    sti ();
  36058. +/*
  36059. + * Send the next block of data to the modem
  36060. + */
  36061. +    count = xbuf->count - xbuf->tail;
  36062. +    actual = tty->driver.write (tty, 0,
  36063. +                    buf_base (xbuf) + xbuf->tail, count);
  36064. +/*
  36065. + * Terminate transmission of any block which may have an error.
  36066. + * This could occur should the carrier drop.
  36067. + */
  36068. +    if (actual < 0) {
  36069. +            ppp->stats.ppp_oerrors++;
  36070. +        actual = count;
  36071. +    } else
  36072. +        ppp->bytes_sent += actual;
  36073. +/*
  36074. + * If the buffer has been transmitted then clear the indicators.
  36075. + */
  36076. +    xbuf->tail += actual;
  36077. +    if (actual == count) {
  36078. +        xbuf = NULL;
  36079. +        ppp->flags &= ~SC_XMIT_BUSY;
  36080. +/*
  36081. + * Complete the transmission on the current buffer.
  36082. + */
  36083. +        xbuf = ppp->xbuf;
  36084. +        if (xbuf != NULL) {
  36085. +            tty->flags  &= ~(1 << TTY_DO_WRITE_WAKEUP);
  36086. +            xbuf->locked = 0;
  36087. +            ppp->xbuf    = NULL;
  36088. +/*
  36089. + * If the completed buffer came from the device write, then complete the
  36090. + * transmission block.
  36091. + */
  36092. +            if (ppp2dev (ppp) -> flags & IFF_UP) {
  36093. +                if (xbuf->type == BUFFER_TYPE_DEV_WR)
  36094. +                        ppp2dev (ppp)->tbusy = 0;
  36095. +                mark_bh (NET_BH);
  36096. +            }
  36097. +/*
  36098. + * Wake up the transmission queue for all completion events.
  36099. + */
  36100. +            wake_up_interruptible (&ppp->write_wait);
  36101. +/*
  36102. + * Look at the priorities. Choose a daemon write over the device driver.
  36103. + */
  36104. +            cli();
  36105. +            xbuf = ppp->s1buf;
  36106. +            ppp->s1buf = NULL;
  36107. +            if (xbuf == NULL) {
  36108. +                xbuf = ppp->s2buf;
  36109. +                ppp->s2buf = NULL;
  36110. +            }
  36111. +            sti();
  36112. +/*
  36113. + * If there is a pending buffer then transmit it now.
  36114. + */
  36115. +            if (xbuf != NULL) {
  36116. +                ppp->flags &= ~SC_XMIT_BUSY;
  36117. +                ppp_kick_tty (ppp, xbuf);
  36118. +                return;
  36119. +            }
  36120. +        }
  36121. +    }
  36122. +/*
  36123. + * Clear the re-entry flag
  36124. + */
  36125. +    ppp->flags &= ~SC_XMIT_BUSY;
  36126. +}
  36127. +
  36128. +/*
  36129. + * This function is called by the tty driver when the transmit buffer has
  36130. + * additional space. It is used by the ppp code to continue to transmit
  36131. + * the current buffer should the buffer have been partially sent.
  36132. + *
  36133. + * In addition, it is used to send the first part of the buffer since the
  36134. + * logic and the inter-locking would be identical.
  36135. + */
  36136. +
  36137. +static void
  36138. +ppp_tty_wakeup (struct tty_struct *tty)
  36139. +{
  36140. +    struct ppp_buffer *xbuf;
  36141. +    struct ppp *ppp = tty2ppp (tty);
  36142. +
  36143. +    if (!ppp)
  36144. +        return;
  36145. +
  36146. +    if (ppp->magic != PPP_MAGIC)
  36147. +        return;
  36148. +/*
  36149. + * Ensure that there is a transmission pending. Clear the re-entry flag if
  36150. + * there is no pending buffer. Otherwise, send the buffer.
  36151. + */
  36152. +    xbuf = ppp->xbuf;
  36153. +    if (xbuf == NULL)
  36154. +        tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  36155. +    else
  36156. +        ppp_tty_wakeup_code (ppp, tty, xbuf);
  36157. +}
  36158. +
  36159. +/*
  36160. + * This function is called to transmit a buffer to the remote. The buffer
  36161. + * is placed on the pending queue if there is presently a buffer being
  36162. + * sent or it is transmitted with the aid of ppp_tty_wakeup.
  36163. + */
  36164. +
  36165. +static void
  36166. +ppp_kick_tty (struct ppp *ppp, struct ppp_buffer *xbuf)
  36167. +{
  36168. +    register int flags;
  36169. +/*
  36170. + * Hold interrupts.
  36171. + */
  36172. +    save_flags (flags);
  36173. +    cli ();
  36174. +/*
  36175. + * Control the flags which are best performed with the interrupts masked.
  36176. + */
  36177. +    xbuf->locked     = 1;
  36178. +    xbuf->tail       = 0;
  36179. +/*
  36180. + * If the transmitter is busy then place the buffer on the appropriate
  36181. + * priority queue.
  36182. + */
  36183. +    if (ppp->xbuf != NULL) {
  36184. +        if (xbuf->type == BUFFER_TYPE_TTY_WR)
  36185. +            ppp->s1buf = xbuf;
  36186. +        else
  36187. +            ppp->s2buf = xbuf;
  36188. +        restore_flags (flags);
  36189. +        return;
  36190. +    }
  36191. +/*
  36192. + * If the transmitter is not busy then this is the highest priority frame
  36193. + */
  36194. +    ppp->flags      &= ~SC_XMIT_BUSY;
  36195. +    ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
  36196. +    ppp->xbuf        = xbuf;
  36197. +    restore_flags (flags);
  36198. +/*
  36199. + * Do the "tty wakeup_code" to actually send this buffer.
  36200. + */
  36201. +    ppp_tty_wakeup_code (ppp, ppp2tty (ppp), xbuf);
  36202. +}
  36203. +
  36204. +/*************************************************************
  36205. + * TTY INPUT
  36206. + *    The following functions handle input that arrives from
  36207. + *    the TTY.    It recognizes PPP frames and either hands them
  36208. + *    to the network layer or queues them for delivery to a
  36209. + *    user process reading this TTY.
  36210. + *************************************************************/
  36211. +
  36212. +/*
  36213. + * Callback function from tty driver. Return the amount of space left
  36214. + * in the receiver's buffer to decide if remote transmitter is to be
  36215. + * throttled.
  36216. + */
  36217. +
  36218. +static int
  36219. +ppp_tty_room (struct tty_struct *tty)
  36220. +{
  36221. +    return 65536;        /* We can handle an infinite amount of data. :-) */
  36222. +}
  36223. +
  36224. +/*
  36225. + * Callback function when data is available at the tty driver.
  36226. + */
  36227. +
  36228. +static void
  36229. +ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
  36230. +         char *flags, int count)
  36231. +{
  36232. +    register struct ppp *ppp = tty2ppp (tty);
  36233. +    register struct ppp_buffer *buf = NULL;
  36234. +    __u8 chr;
  36235. +/*
  36236. + * Fetch the pointer to the buffer. Be careful about race conditions.
  36237. + */
  36238. +    if (ppp != NULL)
  36239. +        buf = ppp->rbuf;
  36240. +
  36241. +    if (buf == NULL)
  36242. +        return;
  36243. +/*
  36244. + * Verify the table pointer and ensure that the line is
  36245. + * still in PPP discipline.
  36246. + */
  36247. +    if (ppp->magic != PPP_MAGIC) {
  36248. +        if (ppp->flags & SC_DEBUG)
  36249. +            printk (KERN_DEBUG
  36250. +                "PPP: handler called but couldn't find "
  36251. +                "PPP struct.\n");
  36252. +        return;
  36253. +    }
  36254. +    CHECK_PPP_VOID ();
  36255. +/*
  36256. + * Print the buffer if desired
  36257. + */
  36258. +    if (ppp->flags & SC_LOG_RAWIN)
  36259. +        ppp_print_buffer ("receive buffer", data, count);
  36260. +/*
  36261. + * Collect the character and error condition for the character. Set the toss
  36262. + * flag for the first character error.
  36263. + */
  36264. +    while (count-- > 0) {
  36265. +        ppp->bytes_rcvd++;
  36266. +        chr = *data++;
  36267. +        if (flags) {
  36268. +            if (*flags && ppp->toss == 0)
  36269. +                ppp->toss = *flags;
  36270. +            ++flags;
  36271. +        }
  36272. +/*
  36273. + * Set the flags for 8 data bits and no parity.
  36274. + *
  36275. + * Actually, it sets the flags for d7 being 0/1 and parity being even/odd
  36276. + * so that the normal processing would have all flags set at the end of the
  36277. + * session. A missing flag bit would denote an error condition.
  36278. + */
  36279. +
  36280. +#ifdef CHECK_CHARACTERS
  36281. +        if (chr & 0x80)
  36282. +            ppp->flags |= SC_RCV_B7_1;
  36283. +        else
  36284. +            ppp->flags |= SC_RCV_B7_0;
  36285. +
  36286. +        if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
  36287. +            ppp->flags |= SC_RCV_ODDP;
  36288. +        else
  36289. +            ppp->flags |= SC_RCV_EVNP;
  36290. +#endif
  36291. +/*
  36292. + * Branch on the character. Process the escape character. The sequence ESC ESC
  36293. + * is defined to be ESC.
  36294. + */
  36295. +        switch (chr) {
  36296. +        case PPP_ESCAPE: /* PPP_ESCAPE: invert bit in next character */
  36297. +            ppp->escape = PPP_TRANS;
  36298. +            break;
  36299. +/*
  36300. + * FLAG. This is the end of the block. If the block terminated by ESC FLAG,
  36301. + * then the block is to be ignored. In addition, characters before the very
  36302. + * first FLAG are also tossed by this procedure.
  36303. + */
  36304. +        case PPP_FLAG:    /* PPP_FLAG: end of frame */
  36305. +            ppp->stats.ppp_ibytes += ppp->rbuf->count;
  36306. +            if (ppp->escape)
  36307. +                ppp->toss |= 0x80;
  36308. +/*
  36309. + * Process frames which are not to be ignored. If the processing failed,
  36310. + * then clean up the VJ tables.
  36311. + */
  36312. +            if ((ppp->toss & 0x80) != 0 ||
  36313. +                ppp_doframe (ppp) == 0) {
  36314. +                slhc_toss (ppp->slcomp);
  36315. +            }
  36316. +/*
  36317. + * Reset all indicators for the new frame to follow.
  36318. + */
  36319. +            buf->count  = 0;
  36320. +            buf->fcs    = PPP_INITFCS;
  36321. +            ppp->escape = 0;
  36322. +            ppp->toss   = 0;
  36323. +            break;
  36324. +/*
  36325. + * All other characters in the data come here. If the character is in the
  36326. + * receive mask then ignore the character.
  36327. + */
  36328. +        default:
  36329. +            if (in_rmap (ppp, chr))
  36330. +                break;
  36331. +/*
  36332. + * Adjust the character and if the frame is to be discarded then simply
  36333. + * ignore the character until the ending FLAG is received.
  36334. + */
  36335. +            chr ^= ppp->escape;
  36336. +            ppp->escape = 0;
  36337. +
  36338. +            if (ppp->toss != 0)
  36339. +                break;
  36340. +/*
  36341. + * If the count sent is within reason then store the character, bump the
  36342. + * count, and update the FCS for the character.
  36343. + */
  36344. +            if (buf->count < buf->size) {
  36345. +                buf_base (buf)[buf->count++] = chr;
  36346. +                buf->fcs = PPP_FCS (buf->fcs, chr);
  36347. +                break;
  36348. +            }
  36349. +/*
  36350. + * The peer sent too much data. Set the flags to discard the current frame
  36351. + * and wait for the re-synchronization FLAG to be sent.
  36352. + */
  36353. +            ppp->stats.ppp_ierrors++;
  36354. +            ppp->toss |= 0xC0;
  36355. +            break;
  36356. +        }
  36357. +    }
  36358. +}
  36359. +
  36360. +/*
  36361. + * Put the input frame into the networking system for the indicated protocol
  36362. + */
  36363. +
  36364. +static int
  36365. +ppp_rcv_rx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
  36366. +{
  36367. +    sk_buff *skb = dev_alloc_skb (count);
  36368. +/*
  36369. + * Generate a skb buffer for the new frame.
  36370. + */
  36371. +    if (skb == NULL) {
  36372. +        if (ppp->flags & SC_DEBUG)
  36373. +            printk (KERN_ERR
  36374. +             "ppp_do_ip: packet dropped on %s (no memory)!\n",
  36375. +             ppp2dev (ppp)->name);
  36376. +        return 0;
  36377. +    }
  36378. +/*
  36379. + * Move the received data from the input buffer to the skb buffer.
  36380. + */
  36381. +    skb->dev      = ppp2dev (ppp);    /* We are the device */
  36382. +    skb->protocol = proto;
  36383. +    skb->mac.raw  = skb_data(skb);
  36384. +    memcpy (skb_put(skb,count), data, count);    /* move data */
  36385. +/*
  36386. + * Tag the frame and kick it to the proper receive routine
  36387. + */
  36388. +    skb->free = 1;
  36389. +    ppp->ddinfo.recv_idle = jiffies;
  36390. +    netif_rx (skb);
  36391. +    return 1;
  36392. +}
  36393. +
  36394. +/*
  36395. + * Process the receipt of an IP frame
  36396. + */
  36397. +
  36398. +static int
  36399. +rcv_proto_ip (struct ppp *ppp, __u16 proto, __u8 * data, int count)
  36400. +{
  36401. +    if ((ppp2dev (ppp)->flags & IFF_UP) && (count > 0))
  36402. +        if (ppp->sc_npmode[NP_IP] == NPMODE_PASS)
  36403. +            return ppp_rcv_rx (ppp, htons (ETH_P_IP), data, count);
  36404. +    return 0;
  36405. +}
  36406. +
  36407. +/*
  36408. + * Process the receipt of an IPX frame
  36409. + */
  36410. +
  36411. +static int
  36412. +rcv_proto_ipx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
  36413. +{
  36414. +    if (((ppp2dev (ppp)->flags & IFF_UP) != 0) && (count > 0))
  36415. +        return ppp_rcv_rx (ppp, htons (ETH_P_IPX), data, count);
  36416. +    return 0;
  36417. +}
  36418. +
  36419. +/*
  36420. + * Process the receipt of an VJ Compressed frame
  36421. + */
  36422. +
  36423. +static int
  36424. +rcv_proto_vjc_comp (struct ppp *ppp, __u16 proto,
  36425. +            __u8 *data, int count)
  36426. +{
  36427. +    if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
  36428. +        int new_count = slhc_uncompress (ppp->slcomp, data, count);
  36429. +        if (new_count >= 0) {
  36430. +            return rcv_proto_ip (ppp, PPP_IP, data, new_count);
  36431. +        }
  36432. +        if (ppp->flags & SC_DEBUG)
  36433. +            printk (KERN_NOTICE
  36434. +                "ppp: error in VJ decompression\n");
  36435. +    }
  36436. +    return 0;
  36437. +}
  36438. +
  36439. +/*
  36440. + * Process the receipt of an VJ Un-compressed frame
  36441. + */
  36442. +
  36443. +static int
  36444. +rcv_proto_vjc_uncomp (struct ppp *ppp, __u16 proto,
  36445. +              __u8 *data, int count)
  36446. +{
  36447. +    if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
  36448. +        if (slhc_remember (ppp->slcomp, data, count) > 0) {
  36449. +            return rcv_proto_ip (ppp, PPP_IP, data, count);
  36450. +        }
  36451. +        if (ppp->flags & SC_DEBUG)
  36452. +            printk (KERN_NOTICE
  36453. +                "ppp: error in VJ memorizing\n");
  36454. +    }
  36455. +    return 0;
  36456. +}
  36457. +
  36458. +/*
  36459. + * Receive all unclassified protocols.
  36460. + */
  36461. +
  36462. +static int
  36463. +rcv_proto_unknown (struct ppp *ppp, __u16 proto,
  36464. +           __u8 *data, int len)
  36465. +{
  36466. +    int totlen;
  36467. +    register int current_idx;
  36468. +
  36469. +#define PUTC(c)                         \
  36470. +{                             \
  36471. +    buf_base (ppp->ubuf) [current_idx++] = (__u8) (c); \
  36472. +    current_idx &= ppp->ubuf->size;             \
  36473. +    if (current_idx == ppp->ubuf->tail)             \
  36474. +        goto failure;                 \
  36475. +}
  36476. +
  36477. +/*
  36478. + * The total length includes the protocol data.
  36479. + * Lock the user information buffer.
  36480. + */
  36481. +    if (set_bit (0, &ppp->ubuf->locked)) {
  36482. +        if (ppp->flags & SC_DEBUG)
  36483. +            printk (KERN_DEBUG
  36484. +                "ppp_us_queue: can't get lock\n");
  36485. +    } else {
  36486. +        current_idx = ppp->ubuf->head;
  36487. +/*
  36488. + * Insert the buffer length (not counted), the protocol, and the data
  36489. + */
  36490. +        totlen = len + 2;
  36491. +        PUTC (totlen >> 8);
  36492. +        PUTC (totlen);
  36493. +
  36494. +        PUTC (proto >> 8);
  36495. +        PUTC (proto);
  36496. +
  36497. +        totlen -= 2;
  36498. +        while (totlen-- > 0) {
  36499. +            PUTC (*data++);
  36500. +        }
  36501. +#undef PUTC
  36502. +/*
  36503. + * The frame is complete. Update the head pointer and wakeup the pppd
  36504. + * process.
  36505. + */
  36506. +        ppp->ubuf->head = current_idx;
  36507. +
  36508. +        clear_bit (0, &ppp->ubuf->locked);
  36509. +        wake_up_interruptible (&ppp->read_wait);
  36510. +        if (ppp->tty->fasync != NULL)
  36511. +            kill_fasync (ppp->tty->fasync, SIGIO);
  36512. +
  36513. +        if (ppp->flags & SC_DEBUG)
  36514. +            printk (KERN_INFO
  36515. +                "ppp: successfully queued %d bytes, flags = %x\n",
  36516. +                len + 2, ppp->flags);
  36517. +
  36518. +        return 1;
  36519. +/*
  36520. + * The buffer is full. Unlock the header
  36521. + */
  36522. +failure:
  36523. +        clear_bit (0, &ppp->ubuf->locked);
  36524. +        if (ppp->flags & SC_DEBUG)
  36525. +            printk (KERN_INFO
  36526. +                "ppp_us_queue: ran out of buffer space.\n");
  36527. +    }
  36528. +/*
  36529. + * Discard the frame. There are no takers for this protocol.
  36530. + */
  36531. +    if (ppp->flags & SC_DEBUG)
  36532. +        printk (KERN_WARNING
  36533. +            "ppp: dropping packet on the floor.\n");
  36534. +    slhc_toss (ppp->slcomp);
  36535. +    return 0;
  36536. +}
  36537. +
  36538. +/*
  36539. + * Handle a CCP packet.
  36540. + *
  36541. + * The CCP packet is passed along to the pppd process just like any
  36542. + * other PPP frame. The difference is that some processing needs to be
  36543. + * immediate or the compressors will become confused on the peer.
  36544. + */
  36545. +
  36546. +static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd)
  36547. +{
  36548. +    int slen    = CCP_LENGTH(dp);
  36549. +    __u8 *opt = dp   + CCP_HDRLEN;
  36550. +    int opt_len = slen - CCP_HDRLEN;
  36551. +
  36552. +    if (slen > len)
  36553. +        return;
  36554. +
  36555. +    switch (CCP_CODE(dp)) {
  36556. +    case CCP_CONFREQ:
  36557. +    case CCP_TERMREQ:
  36558. +    case CCP_TERMACK:
  36559. +/*
  36560. + * CCP must be going down - disable compression
  36561. + */
  36562. +        if (ppp->flags & SC_CCP_UP) {
  36563. +            ppp->flags &= ~(SC_CCP_UP   |
  36564. +                    SC_COMP_RUN |
  36565. +                    SC_DECOMP_RUN);
  36566. +        }
  36567. +        break;
  36568. +
  36569. +    case CCP_CONFACK:
  36570. +        if ((ppp->flags & SC_CCP_OPEN) == 0)
  36571. +            break;
  36572. +        if (ppp->flags & SC_CCP_UP)
  36573. +            break;
  36574. +        if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
  36575. +            break;
  36576. +        if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
  36577. +            break;
  36578. +/*
  36579. + * we're agreeing to send compressed packets.
  36580. + */
  36581. +        if (!rcvd) {
  36582. +            if (ppp->sc_xc_state == NULL)
  36583. +                break;
  36584. +
  36585. +            if ((*ppp->sc_xcomp->comp_init)
  36586. +                (ppp->sc_xc_state,
  36587. +                 opt,
  36588. +                 opt_len,
  36589. +                 ppp2dev (ppp)->base_addr,
  36590. +                 0,
  36591. +                 ppp->flags))
  36592. +                ppp->flags |= SC_COMP_RUN;
  36593. +            break;
  36594. +        }
  36595. +/*
  36596. + * peer is agreeing to send compressed packets.
  36597. + */
  36598. +        if (ppp->sc_rc_state == NULL)
  36599. +            break;
  36600. +
  36601. +        if ((*ppp->sc_rcomp->decomp_init)
  36602. +            (ppp->sc_rc_state,
  36603. +             opt,
  36604. +             opt_len,
  36605. +             ppp2dev (ppp)->base_addr,
  36606. +             0,
  36607. +             ppp->mru,
  36608. +             ppp->flags)) {
  36609. +            ppp->flags |= SC_DECOMP_RUN;
  36610. +            ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
  36611. +        }
  36612. +        break;
  36613. +/*
  36614. + * The protocol sequence is complete at this end
  36615. + */
  36616. +    case CCP_RESETACK:
  36617. +        if ((ppp->flags & SC_CCP_UP) == 0)
  36618. +            break;
  36619. +
  36620. +        if (!rcvd) {
  36621. +            if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN))
  36622. +                (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
  36623. +        } else {
  36624. +            if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
  36625. +                  (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
  36626. +                ppp->flags &= ~SC_DC_ERROR;
  36627. +            }
  36628. +        }
  36629. +        break;
  36630. +    }
  36631. +}
  36632. +
  36633. +static int
  36634. +rcv_proto_ccp (struct ppp *ppp, __u16 proto, __u8 *dp, int len)
  36635. +{
  36636. +    ppp_proto_ccp (ppp, dp, len, 1);
  36637. +    return rcv_proto_unknown (ppp, proto, dp, len);
  36638. +}
  36639. +
  36640. +/*
  36641. + * Handle a LQR packet.
  36642. + */
  36643. +
  36644. +static int
  36645. +rcv_proto_lqr (struct ppp *ppp, __u16 proto, __u8 * data, int len)
  36646. +{
  36647. +    return rcv_proto_unknown (ppp, proto, data, len);
  36648. +}
  36649. +
  36650. +/* on entry, a received frame is in ppp->rbuf.bufr
  36651. +   check it and dispose as appropriate */
  36652. +
  36653. +static void ppp_doframe_lower (struct ppp *ppp, __u8 *data, int count)
  36654. +{
  36655. +    __u16        proto = PPP_PROTOCOL (data);
  36656. +    ppp_proto_type  *proto_ptr;
  36657. +/*
  36658. + * Ignore empty frames
  36659. + */
  36660. +    if (count <= 4)
  36661. +        return;
  36662. +/*
  36663. + * Count the frame and print it
  36664. + */
  36665. +    ++ppp->stats.ppp_ipackets;
  36666. +    if (ppp->flags & SC_LOG_INPKT)
  36667. +        ppp_print_buffer ("receive frame", data, count);
  36668. +/*
  36669. + * Find the procedure to handle this protocol. The last one is marked
  36670. + * as a protocol 0 which is the 'catch-all' to feed it to the pppd daemon.
  36671. + */
  36672. +    proto_ptr = proto_list;
  36673. +    while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
  36674. +        ++proto_ptr;
  36675. +/*
  36676. + * Update the appropriate statistic counter.
  36677. + */
  36678. +    if ((*proto_ptr->func) (ppp, proto,
  36679. +                &data[PPP_HARD_HDR_LEN],
  36680. +                count - PPP_HARD_HDR_LEN))
  36681. +        ppp->stats.ppp_ioctects += count;
  36682. +    else
  36683. +        ++ppp->stats.ppp_discards;
  36684. +}
  36685. +
  36686. +/* on entry, a received frame is in ppp->rbuf.bufr
  36687. +   check it and dispose as appropriate */
  36688. +
  36689. +static int
  36690. +ppp_doframe (struct ppp *ppp)
  36691. +{
  36692. +    __u8    *data = buf_base (ppp->rbuf);
  36693. +    int    count = ppp->rbuf->count;
  36694. +    int    addr, ctrl, proto;
  36695. +    int    new_count;
  36696. +    __u8 *new_data;
  36697. +#ifndef NO_RMK_TEMP_FIX
  36698. +    int    malloced_data;
  36699. +#endif
  36700. +/*
  36701. + * If there is a pending error from the receiver then log it and discard
  36702. + * the damaged frame.
  36703. + */
  36704. +    if (ppp->toss) {
  36705. +        if (ppp->flags & SC_DEBUG)
  36706. +            printk (KERN_WARNING
  36707. +                "ppp_toss: tossing frame, reason = %d\n",
  36708. +                ppp->toss);
  36709. +        ppp->stats.ppp_ierrors++;
  36710. +        return 0;
  36711. +    }
  36712. +/*
  36713. + * An empty frame is ignored. This occurs if the FLAG sequence precedes and
  36714. + * follows each frame.
  36715. + */
  36716. +    if (count == 0)
  36717. +        return 1;
  36718. +/*
  36719. + * Generate an error if the frame is too small.
  36720. + */
  36721. +    if (count < PPP_HARD_HDR_LEN) {
  36722. +        if (ppp->flags & SC_DEBUG)
  36723. +            printk (KERN_WARNING
  36724. +                "ppp: got runt ppp frame, %d chars\n", count);
  36725. +        slhc_toss (ppp->slcomp);
  36726. +        ppp->stats.ppp_ierrors++;
  36727. +        return 1;
  36728. +    }
  36729. +/*
  36730. + * Verify the CRC of the frame and discard the CRC characters from the
  36731. + * end of the buffer.
  36732. + */
  36733. +    if (ppp->rbuf->fcs != PPP_GOODFCS) {
  36734. +        if (ppp->flags & SC_DEBUG)
  36735. +            printk (KERN_WARNING
  36736. +                "ppp: frame with bad fcs, excess = %x\n",
  36737. +                ppp->rbuf->fcs ^ PPP_GOODFCS);
  36738. +        ppp->stats.ppp_ierrors++;
  36739. +        return 0;
  36740. +    }
  36741. +    count -= 2;        /* ignore the fcs characters */
  36742. +/*
  36743. + * Ignore the leading ADDRESS and CONTROL fields in the frame.
  36744. + */
  36745. +    addr   = PPP_ALLSTATIONS;
  36746. +    ctrl   = PPP_UI;
  36747. +
  36748. +    if ((data[0] == PPP_ALLSTATIONS) && (data[1] == PPP_UI)) {
  36749. +        data  += 2;
  36750. +        count -= 2;
  36751. +    }
  36752. +/*
  36753. + * Obtain the protocol from the frame
  36754. + */
  36755. +    proto = (__u16) *data++;
  36756. +    if ((proto & 1) == 0) {
  36757. +        proto = (proto << 8) | (__u16) *data++;
  36758. +        --count;
  36759. +    }
  36760. +/*
  36761. + * Rewrite the header with the full information. This may encroach upon
  36762. + * the 'filler' area in the buffer header. This is the purpose for the
  36763. + * filler.
  36764. + */
  36765. +    *(--data) = proto;
  36766. +    *(--data) = proto >> 8;
  36767. +    *(--data) = ctrl;
  36768. +    *(--data) = addr;
  36769. +    count    += 3;
  36770. +#ifndef NO_RMK_TEMP_FIX
  36771. +    /*
  36772. +     * rmk: should make sure that the packet received is on a word boundary.
  36773. +     * this is a temporary fix!!!
  36774. +     */
  36775. +    if ((int)data & 3) {
  36776. +        new_data = kmalloc (ppp->mru + 4, GFP_ATOMIC); /* would like to have 'count' here */
  36777. +        memcpy (new_data, data, count);
  36778. +        data = new_data;
  36779. +        malloced_data = 1;
  36780. +    } else
  36781. +        malloced_data = 0;
  36782. +#endif
  36783. +/*
  36784. + * Process the active decompressor.
  36785. + */
  36786. +    if ((ppp->sc_rc_state != (void *) 0) &&
  36787. +        (ppp->flags & SC_DECOMP_RUN)     &&
  36788. +        ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
  36789. +        if (proto == PPP_COMP) {
  36790. +/*
  36791. + * If the frame is compressed then decompress it.
  36792. + */
  36793. +            new_data = kmalloc (ppp->mru + 4, GFP_ATOMIC);
  36794. +            if (new_data == NULL) {
  36795. +                if (ppp->flags & SC_DEBUG)
  36796. +                    printk (KERN_ERR
  36797. +                        "ppp_doframe: no memory\n");
  36798. +                slhc_toss (ppp->slcomp);
  36799. +                (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
  36800. +                              data,
  36801. +                              count);
  36802. +#ifndef NO_RMK_TEMP_FIX
  36803. +                if (malloced_data) kfree (data);
  36804. +#endif                              
  36805. +                return 1;
  36806. +            }
  36807. +/*
  36808. + * Decompress the frame
  36809. + */
  36810. +            new_count = bsd_decompress (ppp->sc_rc_state,
  36811. +                            data,
  36812. +                            count,
  36813. +                            new_data,
  36814. +                            ppp->mru + 4);
  36815. +            switch (new_count) {
  36816. +            default:
  36817. +                ppp_doframe_lower (ppp, new_data, new_count);
  36818. +                kfree (new_data);
  36819. +#ifndef NO_RMK_TEMP_FIX
  36820. +                if (malloced_data) kfree (data);
  36821. +#endif
  36822. +                return 1;
  36823. +
  36824. +            case DECOMP_OK:
  36825. +                break;
  36826. +
  36827. +            case DECOMP_ERROR:
  36828. +                ppp->flags |= SC_DC_ERROR;
  36829. +                break;
  36830. +
  36831. +            case DECOMP_FATALERROR:
  36832. +                ppp->flags |= SC_DC_FERROR;
  36833. +                break;
  36834. +            }
  36835. +/*
  36836. + * Log the error condition and discard the frame.
  36837. + */
  36838. +            if (ppp->flags & SC_DEBUG)
  36839. +                printk (KERN_ERR
  36840. +                    "ppp_proto_comp: "
  36841. +                    "decompress err %d\n", new_count);
  36842. +            kfree (new_data);
  36843. +            slhc_toss (ppp->slcomp);
  36844. +#ifndef NO_RMK_TEMP_FIX
  36845. +            if (malloced_data) kfree (data);
  36846. +#endif                              
  36847. +            return 1;
  36848. +        }
  36849. +/*
  36850. + * The frame is not special. Pass it through the compressor without
  36851. + * actually compressing the data
  36852. + */
  36853. +        (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
  36854. +                      data,
  36855. +                      count);
  36856. +    }
  36857. +/*
  36858. + * Process the uncompressed frame.
  36859. + */
  36860. +    ppp_doframe_lower (ppp, data, count);
  36861. +#ifndef NO_RMK_TEMP_FIX
  36862. +    if (malloced_data) kfree (data);
  36863. +#endif                              
  36864. +    return 1;
  36865. +}
  36866. +
  36867. +/*************************************************************
  36868. + * LINE DISCIPLINE SUPPORT
  36869. + *    The following functions form support user programs
  36870. + *    which read and write data on a TTY with the PPP line
  36871. + *    discipline.  Reading is done from a circular queue,
  36872. + *    filled by the lower TTY levels.
  36873. + *************************************************************/
  36874. +
  36875. +/* read a PPP frame from the us_rbuff circular buffer,
  36876. +   waiting if necessary
  36877. +*/
  36878. +
  36879. +static int
  36880. +ppp_tty_read (struct tty_struct *tty, struct file *file, __u8 * buf,
  36881. +          unsigned int nr)
  36882. +{
  36883. +    struct ppp *ppp = tty2ppp (tty);
  36884. +    __u8 c;
  36885. +    int len, indx;
  36886. +
  36887. +#define GETC(c)                        \
  36888. +{                            \
  36889. +    c = buf_base (ppp->ubuf) [ppp->ubuf->tail++];    \
  36890. +    ppp->ubuf->tail &= ppp->ubuf->size;        \
  36891. +}
  36892. +
  36893. +/*
  36894. + * Validate the pointers
  36895. + */
  36896. +    if (!ppp)
  36897. +        return -EIO;
  36898. +
  36899. +    if (ppp->magic != PPP_MAGIC)
  36900. +        return -EIO;
  36901. +
  36902. +    CHECK_PPP (-ENXIO);
  36903. +
  36904. +    if (ppp->flags & SC_DEBUG)
  36905. +        printk (KERN_DEBUG
  36906. +            "ppp_tty_read: called buf=%p nr=%u\n",
  36907. +            buf, nr);
  36908. +/*
  36909. + * Acquire the read lock.
  36910. + */
  36911. +    for (;;) {
  36912. +        ppp = tty2ppp (tty);
  36913. +        if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse)
  36914. +            return 0;
  36915. +
  36916. +        if (set_bit (0, &ppp->ubuf->locked) != 0) {
  36917. +            if (ppp->flags & SC_DEBUG)
  36918. +                printk (KERN_DEBUG
  36919. +                     "ppp_tty_read: sleeping(ubuf)\n");
  36920. +
  36921. +            current->timeout = 0;
  36922. +            current->state   = TASK_INTERRUPTIBLE;
  36923. +            schedule ();
  36924. +
  36925. +            if (current->signal & ~current->blocked)
  36926. +                return -EINTR;
  36927. +            continue;
  36928. +        }
  36929. +/*
  36930. + * Before we attempt to write the frame to the user, ensure that the
  36931. + * user has access to the pages for the total buffer length.
  36932. + */
  36933. +        indx = verify_area (VERIFY_WRITE, buf, nr);
  36934. +        if (indx != 0)
  36935. +            return (indx);
  36936. +/*
  36937. + * Fetch the length of the buffer from the first two bytes.
  36938. + */
  36939. +        if (ppp->ubuf->head == ppp->ubuf->tail)
  36940. +            len = 0;
  36941. +        else {
  36942. +            GETC (c);
  36943. +            len = c << 8;
  36944. +            GETC (c);
  36945. +            len += c;
  36946. +        }
  36947. +/*
  36948. + * If there is no length then wait for the data to arrive.
  36949. + */
  36950. +        if (len == 0) {
  36951. +            /* no data */
  36952. +            clear_bit (0, &ppp->ubuf->locked);
  36953. +            if (file->f_flags & O_NONBLOCK) {
  36954. +                if (ppp->flags & SC_DEBUG)
  36955. +                    printk (KERN_DEBUG
  36956. +                        "ppp_tty_read: no data "
  36957. +                        "(EAGAIN)\n");
  36958. +                return -EAGAIN;
  36959. +            }
  36960. +            current->timeout = 0;
  36961. +
  36962. +            if (ppp->flags & SC_DEBUG)
  36963. +                printk (KERN_DEBUG
  36964. +                    "ppp_tty_read: sleeping(read_wait)\n");
  36965. +
  36966. +            interruptible_sleep_on (&ppp->read_wait);
  36967. +            if (current->signal & ~current->blocked)
  36968. +                return -EINTR;
  36969. +            continue;
  36970. +        }
  36971. +/*
  36972. + * Reset the time of the last read operation.
  36973. + */
  36974. +        if (ppp->flags & SC_DEBUG)
  36975. +            printk (KERN_DEBUG "ppp_tty_read: len = %d\n", len);
  36976. +/*
  36977. + * Ensure that the frame will fit within the caller's buffer. If not, then
  36978. + * discard the frame from the input buffer.
  36979. + */
  36980. +        if (len + 2 > nr) {
  36981. +            /* Can't copy it, update us_rbuff_head */
  36982. +
  36983. +            if (ppp->flags & SC_DEBUG)
  36984. +                printk (KERN_DEBUG
  36985. +                "ppp: read of %u bytes too small for %d "
  36986. +                "frame\n", nr, len + 2);
  36987. +            ppp->ubuf->tail += len;
  36988. +            ppp->ubuf->tail &= ppp->ubuf->size;
  36989. +            clear_bit (0, &ppp->ubuf->locked);
  36990. +            ppp->stats.ppp_ierrors++;
  36991. +            return -EOVERFLOW;
  36992. +        }
  36993. +/*
  36994. + * Before we attempt to write the frame to the user, ensure that the
  36995. + * page tables are proper.
  36996. + */
  36997. +        indx = verify_area (VERIFY_WRITE, buf, len + 2);
  36998. +        if (indx != 0) {
  36999. +            ppp->ubuf->tail += len;
  37000. +            ppp->ubuf->tail &= ppp->ubuf->size;
  37001. +            clear_bit (0, &ppp->ubuf->locked);
  37002. +            return (indx);
  37003. +        }
  37004. +/*
  37005. + * Fake the insertion of the ADDRESS and CONTROL information because these
  37006. + * were not saved in the buffer.
  37007. + */
  37008. +        put_user (PPP_ALLSTATIONS, buf++);
  37009. +        put_user (PPP_UI,          buf++);
  37010. +
  37011. +        indx = len;
  37012. +/*
  37013. + * Copy the received data from the buffer to the caller's area.
  37014. + */
  37015. +        while (indx-- > 0) {
  37016. +            GETC (c);
  37017. +            put_user (c, buf);
  37018. +            ++buf;
  37019. +        }
  37020. +
  37021. +        clear_bit (0, &ppp->ubuf->locked);
  37022. +        len += 2; /* Account for ADDRESS and CONTROL bytes */
  37023. +        if (ppp->flags & SC_DEBUG)
  37024. +            printk (KERN_DEBUG
  37025. +                "ppp_tty_read: passing %d bytes up\n", len);
  37026. +        return len;
  37027. +    }
  37028. +#undef GETC
  37029. +}
  37030. +
  37031. +/* stuff a character into the transmit buffer, using PPP's way of escaping
  37032. +   special characters.
  37033. +   also, update fcs to take account of new character */
  37034. +
  37035. +extern inline void
  37036. +ppp_stuff_char (struct ppp *ppp, register struct ppp_buffer *buf,
  37037. +        register __u8 chr)
  37038. +{
  37039. +/*
  37040. + * The buffer should not be full.
  37041. + */
  37042. +    if (ppp->flags & SC_DEBUG) {
  37043. +        if ((buf->count < 0) || (buf->count > 3000))
  37044. +            printk (KERN_DEBUG "ppp_stuff_char: %x %d\n",
  37045. +                (unsigned int) buf->count,
  37046. +                (unsigned int) chr);
  37047. +    }
  37048. +/*
  37049. + * Update the FCS and if the character needs to be escaped, do it.
  37050. + */
  37051. +    buf->fcs = PPP_FCS (buf->fcs, chr);
  37052. +    if (in_xmap (ppp, chr)) {
  37053. +        chr ^= PPP_TRANS;
  37054. +        ins_char (buf, PPP_ESCAPE);
  37055. +    }
  37056. +/*
  37057. + * Add the character to the buffer.
  37058. + */
  37059. +    ins_char (buf, chr);
  37060. +}
  37061. +
  37062. +/*
  37063. + * Procedure to encode the data with the proper escaping and send the
  37064. + * data to the remote system.
  37065. + */
  37066. +
  37067. +static void
  37068. +ppp_dev_xmit_lower (struct ppp *ppp, struct ppp_buffer *buf,
  37069. +            __u8 *data, int count, int non_ip)
  37070. +{
  37071. +    __u16 write_fcs;
  37072. +    int     address, control;
  37073. +    int    proto;
  37074. +/*
  37075. + * Insert the leading FLAG character
  37076. + */
  37077. +    buf->count = 0;
  37078. +
  37079. +    if (non_ip || flag_time == 0)
  37080. +        ins_char (buf, PPP_FLAG);
  37081. +    else {
  37082. +        if (jiffies - ppp->last_xmit > flag_time)
  37083. +            ins_char (buf, PPP_FLAG);
  37084. +    }
  37085. +    ppp->last_xmit = jiffies;
  37086. +    buf->fcs       = PPP_INITFCS;
  37087. +/*
  37088. + * Emit the address/control information if needed
  37089. + */
  37090. +    address = PPP_ADDRESS  (data);
  37091. +    control = PPP_CONTROL  (data);
  37092. +    proto   = PPP_PROTOCOL (data);
  37093. +
  37094. +    if (address != PPP_ALLSTATIONS ||
  37095. +        control != PPP_UI ||
  37096. +        (ppp->flags & SC_COMP_AC) == 0) {
  37097. +        ppp_stuff_char (ppp, buf, address);
  37098. +        ppp_stuff_char (ppp, buf, control);
  37099. +    }
  37100. +/*
  37101. + * Emit the protocol (compressed if possible)
  37102. + */
  37103. +    if ((ppp->flags & SC_COMP_PROT) == 0 || (proto & 0xFF00))
  37104. +        ppp_stuff_char (ppp, buf, proto >> 8);
  37105. +
  37106. +    ppp_stuff_char (ppp, buf, proto);
  37107. +/*
  37108. + * Insert the data
  37109. + */
  37110. +    data  += 4;
  37111. +    count -= 4;
  37112. +
  37113. +    while (count-- > 0)
  37114. +        ppp_stuff_char (ppp, buf, *data++);
  37115. +/*
  37116. + * Add the trailing CRC and the final flag character
  37117. + */
  37118. +    write_fcs = buf->fcs ^ 0xFFFF;
  37119. +    ppp_stuff_char (ppp, buf, write_fcs);
  37120. +    ppp_stuff_char (ppp, buf, write_fcs >> 8);
  37121. +
  37122. +    if (ppp->flags & SC_DEBUG)
  37123. +        printk (KERN_DEBUG "ppp_dev_xmit_lower: fcs is %hx\n",
  37124. +            write_fcs);
  37125. +/*
  37126. + * Add the trailing flag character
  37127. + */
  37128. +    ins_char (buf, PPP_FLAG);
  37129. +/*
  37130. + * Print the buffer
  37131. + */
  37132. +    if (ppp->flags & SC_LOG_FLUSH)
  37133. +        ppp_print_buffer ("ppp flush", buf_base (buf),
  37134. +                  buf->count);
  37135. +    else {
  37136. +        if (ppp->flags & SC_DEBUG)
  37137. +            printk (KERN_DEBUG
  37138. +                "ppp_dev_xmit: writing %d chars\n",
  37139. +                buf->count);
  37140. +    }
  37141. +/*
  37142. + * Send the block to the tty driver.
  37143. + */
  37144. +    ppp->stats.ppp_obytes += buf->count;
  37145. +    ppp_kick_tty (ppp, buf);
  37146. +}
  37147. +
  37148. +/*
  37149. + * Send an frame to the remote with the proper bsd compression.
  37150. + *
  37151. + * Return 0 if frame was queued for transmission.
  37152. + *        1 if frame must be re-queued for later driver support.
  37153. + */
  37154. +
  37155. +static int
  37156. +ppp_dev_xmit_frame (struct ppp *ppp, struct ppp_buffer *buf,
  37157. +            __u8 *data, int count)
  37158. +{
  37159. +    int    proto;
  37160. +    int     address, control;
  37161. +    __u8 *new_data;
  37162. +    int     new_count;
  37163. +/*
  37164. + * Print the buffer
  37165. + */
  37166. +    if (ppp->flags & SC_LOG_OUTPKT)
  37167. +        ppp_print_buffer ("write frame", data, count);
  37168. +/*
  37169. + * Determine if the frame may be compressed. Attempt to compress the
  37170. + * frame if possible.
  37171. + */
  37172. +    proto   = PPP_PROTOCOL (data);
  37173. +    address = PPP_ADDRESS  (data);
  37174. +    control = PPP_CONTROL  (data);
  37175. +
  37176. +    if (((ppp->flags & SC_COMP_RUN) != 0)    &&
  37177. +        (ppp->sc_xc_state != (void *) 0)    &&
  37178. +        (address == PPP_ALLSTATIONS)    &&
  37179. +        (control == PPP_UI)            &&
  37180. +        (proto != PPP_LCP)            &&
  37181. +        (proto != PPP_CCP)) {
  37182. +        new_data = kmalloc (count, GFP_ATOMIC);
  37183. +        if (new_data == NULL) {
  37184. +            if (ppp->flags & SC_DEBUG)
  37185. +                printk (KERN_ERR
  37186. +                    "ppp_dev_xmit_frame: no memory\n");
  37187. +            return 1;
  37188. +        }
  37189. +
  37190. +        new_count = bsd_compress (ppp->sc_xc_state,
  37191. +                      data,
  37192. +                      new_data,
  37193. +                      count,
  37194. +                      count);
  37195. +
  37196. +        if (new_count > 0) {
  37197. +            ++ppp->stats.ppp_opackets;
  37198. +            ppp->stats.ppp_ooctects += new_count;
  37199. +
  37200. +            ppp_dev_xmit_lower (ppp, buf, new_data,
  37201. +                        new_count, 0);
  37202. +            kfree (new_data);
  37203. +            return 0;
  37204. +        }
  37205. +/*
  37206. + * The frame could not be compressed.
  37207. + */
  37208. +        kfree (new_data);
  37209. +    }
  37210. +/*
  37211. + * The frame may not be compressed. Update the statistics before the
  37212. + * count field is destroyed. The frame will be transmitted.
  37213. + */
  37214. +    ++ppp->stats.ppp_opackets;
  37215. +    ppp->stats.ppp_ooctects += count;
  37216. +/*
  37217. + * Go to the escape encoding
  37218. + */
  37219. +    ppp_dev_xmit_lower (ppp, buf, data, count, !!(proto & 0xFF00));
  37220. +    return 0;
  37221. +}
  37222. +
  37223. +/*
  37224. + * Revise the tty frame for specific protocols.
  37225. + */
  37226. +
  37227. +static int
  37228. +send_revise_frame (register struct ppp *ppp, __u8 *data, int len)
  37229. +{
  37230. +    __u8 *p;
  37231. +
  37232. +    switch (PPP_PROTOCOL (data)) {
  37233. +/*
  37234. + * Update the LQR frame with the current MIB information. This saves having
  37235. + * the daemon read old MIB data from the driver.
  37236. + */
  37237. +    case PPP_LQR:
  37238. +        len = 48;            /* total size of this frame */
  37239. +        p   = (__u8 *) &data [40];    /* Point to last two items. */
  37240. +        p   = store_long (p, ppp->stats.ppp_opackets + 1);
  37241. +        p   = store_long (p, ppp->stats.ppp_ooctects + len);
  37242. +        break;
  37243. +/*
  37244. + * Outbound compression frames
  37245. + */
  37246. +    case PPP_CCP:
  37247. +        ppp_proto_ccp (ppp,
  37248. +                   data + PPP_HARD_HDR_LEN,
  37249. +                   len  - PPP_HARD_HDR_LEN,
  37250. +                   0);
  37251. +        break;
  37252. +
  37253. +    default:
  37254. +        break;
  37255. +    }
  37256. +
  37257. +    return len;
  37258. +}
  37259. +
  37260. +/*
  37261. + * write a frame with NR chars from BUF to TTY
  37262. + * we have to put the FCS field on ourselves
  37263. + */
  37264. +
  37265. +static int
  37266. +ppp_tty_write (struct tty_struct *tty, struct file *file, const __u8 * data,
  37267. +           unsigned int count)
  37268. +{
  37269. +    struct ppp *ppp = tty2ppp (tty);
  37270. +    __u8 *new_data;
  37271. +    int status;
  37272. +/*
  37273. + * Verify the pointers.
  37274. + */
  37275. +    if (!ppp)
  37276. +        return -EIO;
  37277. +
  37278. +    if (ppp->magic != PPP_MAGIC)
  37279. +        return -EIO;
  37280. +
  37281. +    CHECK_PPP (-ENXIO);
  37282. +/*
  37283. + * Ensure that the caller does not wish to send too much.
  37284. + */
  37285. +    if (count > PPP_MTU) {
  37286. +        if (ppp->flags & SC_DEBUG)
  37287. +            printk (KERN_WARNING
  37288. +                "ppp_tty_write: truncating user packet "
  37289. +                "from %u to mtu %d\n", count, PPP_MTU);
  37290. +        count = PPP_MTU;
  37291. +    }
  37292. +/*
  37293. + * Allocate a buffer for the data and fetch it from the user space.
  37294. + */
  37295. +    new_data = kmalloc (count, GFP_KERNEL);
  37296. +    if (new_data == NULL) {
  37297. +        if (ppp->flags & SC_DEBUG)
  37298. +            printk (KERN_ERR
  37299. +                "ppp_tty_write: no memory\n");
  37300. +        return 0;
  37301. +    }
  37302. +/*
  37303. + * lock this PPP unit so we will be the only writer;
  37304. + * sleep if necessary
  37305. + */
  37306. +    while (lock_buffer (ppp->tbuf) != 0) {
  37307. +        current->timeout = 0;
  37308. +        if (ppp->flags & SC_DEBUG)
  37309. +            printk (KERN_DEBUG "ppp_tty_write: sleeping\n");
  37310. +        interruptible_sleep_on (&ppp->write_wait);
  37311. +
  37312. +        ppp = tty2ppp (tty);
  37313. +        if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse) {
  37314. +            kfree (new_data);
  37315. +            return 0;
  37316. +        }
  37317. +
  37318. +        if (current->signal & ~current->blocked) {
  37319. +            kfree (new_data);
  37320. +            return -EINTR;
  37321. +        }
  37322. +    }
  37323. +/*
  37324. + * Ensure that the caller's buffer is valid.
  37325. + */
  37326. +    status = verify_area (VERIFY_READ, data, count);
  37327. +    if (status != 0) {
  37328. +        kfree (new_data);
  37329. +        ppp->tbuf->locked = 0;
  37330. +        return status;
  37331. +    }
  37332. +
  37333. +    memcpy_fromfs (new_data, data, count);
  37334. +/*
  37335. + * Change the LQR frame
  37336. + */
  37337. +    count = send_revise_frame (ppp, new_data, count);
  37338. +/*
  37339. + * Send the data
  37340. + */
  37341. +    ppp_dev_xmit_frame (ppp, ppp->tbuf, new_data, count);
  37342. +    kfree (new_data);
  37343. +    return (int) count;
  37344. +}
  37345. +
  37346. +/*
  37347. + * Process the BSD compression IOCTL event for the tty device.
  37348. + */
  37349. +
  37350. +static int
  37351. +ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
  37352. +{
  37353. +    struct compressor *cp;
  37354. +    struct ppp_option_data data;
  37355. +    int error;
  37356. +    int nb;
  37357. +    __u8 *ptr;
  37358. +    __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
  37359. +/*
  37360. + * Fetch the compression parameters
  37361. + */
  37362. +    error = verify_area (VERIFY_READ, odp, sizeof (data));
  37363. +    if (error == 0) {
  37364. +        memcpy_fromfs (&data, odp, sizeof (data));
  37365. +        nb  = data.length;
  37366. +        ptr = data.ptr;
  37367. +        if ((__u32) nb >= (__u32)CCP_MAX_OPTION_LENGTH)
  37368. +            nb = CCP_MAX_OPTION_LENGTH;
  37369. +    
  37370. +        error = verify_area (VERIFY_READ, ptr, nb);
  37371. +    }
  37372. +
  37373. +    if (error != 0)
  37374. +        return error;
  37375. +
  37376. +    memcpy_fromfs (ccp_option, ptr, nb);
  37377. +
  37378. +    if (ccp_option[1] < 2)    /* preliminary check on the length byte */
  37379. +        return (-EINVAL);
  37380. +
  37381. +    cp = find_compressor ((int) (unsigned int) (__u8) ccp_option[0]);
  37382. +    if (cp != (struct compressor *) 0) {
  37383. +        /*
  37384. +         * Found a handler for the protocol - try to allocate
  37385. +         * a compressor or decompressor.
  37386. +         */
  37387. +        error = 0;
  37388. +        if (data.transmit) {
  37389. +            if (ppp->sc_xc_state != NULL)
  37390. +                (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
  37391. +
  37392. +            ppp->sc_xcomp    = cp;
  37393. +            ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
  37394. +
  37395. +            if (ppp->sc_xc_state == NULL) {
  37396. +                if (ppp->flags & SC_DEBUG)
  37397. +                    printk("ppp%ld: comp_alloc failed\n",
  37398. +                           ppp2dev (ppp)->base_addr);
  37399. +                error = -ENOBUFS;
  37400. +            }
  37401. +            ppp->flags &= ~SC_COMP_RUN;
  37402. +        } else {
  37403. +            if (ppp->sc_rc_state != NULL)
  37404. +                (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
  37405. +            ppp->sc_rcomp    = cp;
  37406. +            ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
  37407. +            if (ppp->sc_rc_state == NULL) {
  37408. +                if (ppp->flags & SC_DEBUG)
  37409. +                    printk("ppp%ld: decomp_alloc failed\n",
  37410. +                           ppp2dev (ppp)->base_addr);
  37411. +                error = ENOBUFS;
  37412. +            }
  37413. +            ppp->flags &= ~SC_DECOMP_RUN;
  37414. +        }
  37415. +        return (error);
  37416. +    }
  37417. +
  37418. +    if (ppp->flags & SC_DEBUG)
  37419. +        printk(KERN_DEBUG "ppp%ld: no compressor for [%x %x %x], %x\n",
  37420. +               ppp2dev (ppp)->base_addr, ccp_option[0], ccp_option[1],
  37421. +               ccp_option[2], nb);
  37422. +    return (-EINVAL);    /* no handler found */
  37423. +}
  37424. +
  37425. +/*
  37426. + * Process the IOCTL event for the tty device.
  37427. + */
  37428. +
  37429. +static int
  37430. +ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
  37431. +           unsigned int param2, unsigned long param3)
  37432. +{
  37433. +    struct ppp *ppp = tty2ppp (tty);
  37434. +    register int temp_i = 0;
  37435. +    int error = 0;
  37436. +/*
  37437. + * Verify the status of the PPP device.
  37438. + */
  37439. +    if (!ppp)
  37440. +        return -EBADF;
  37441. +
  37442. +    if (ppp->magic != PPP_MAGIC)
  37443. +        return -EBADF;
  37444. +
  37445. +    CHECK_PPP (-ENXIO);
  37446. +/*
  37447. + * The user must have an euid of root to do these requests.
  37448. + */
  37449. +    if (!suser ())
  37450. +        return -EPERM;
  37451. +/*
  37452. + * Set the MRU value
  37453. + */
  37454. +    switch (param2) {
  37455. +    case PPPIOCSMRU:
  37456. +        error = verify_area (VERIFY_READ, (void *) param3,
  37457. +                     sizeof (temp_i));
  37458. +        if (error == 0) {
  37459. +            temp_i = get_user ((int *) param3);
  37460. +            if (ppp->flags & SC_DEBUG)
  37461. +                printk (KERN_INFO
  37462. +                 "ppp_tty_ioctl: set mru to %x\n", temp_i);
  37463. +
  37464. +            if (ppp->mru != temp_i)
  37465. +                ppp_changedmtu (ppp, ppp2dev (ppp)->mtu, temp_i);
  37466. +        }
  37467. +        break;
  37468. +/*
  37469. + * Fetch the flags
  37470. + */
  37471. +    case PPPIOCGFLAGS:
  37472. +        error = verify_area (VERIFY_WRITE, (void *) param3,
  37473. +                     sizeof (temp_i));
  37474. +        if (error == 0) {
  37475. +            temp_i = (ppp->flags & SC_MASK);
  37476. +#ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
  37477. +            temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
  37478. +                  SC_RCV_ODDP | SC_RCV_EVNP;
  37479. +#endif
  37480. +            put_user (temp_i, (int *) param3);
  37481. +            if (ppp->flags & SC_DEBUG)
  37482. +                printk (KERN_DEBUG
  37483. +                "ppp_tty_ioctl: get flags: addr %lx flags "
  37484. +                "%x\n", param3, temp_i);
  37485. +        }
  37486. +        break;
  37487. +/*
  37488. + * Set the flags for the various options
  37489. + */
  37490. +    case PPPIOCSFLAGS:
  37491. +        error = verify_area (VERIFY_READ, (void *) param3,
  37492. +                     sizeof (temp_i));
  37493. +        if (error == 0) {
  37494. +            temp_i  = get_user ((int *) param3) & SC_MASK;
  37495. +            temp_i |= (ppp->flags & ~SC_MASK);
  37496. +
  37497. +            if ((ppp->flags & SC_CCP_OPEN) &&
  37498. +                (temp_i & SC_CCP_OPEN) == 0)
  37499. +                ppp_ccp_closed (ppp);
  37500. +
  37501. +            if ((ppp->flags | temp_i) & SC_DEBUG)
  37502. +                printk (KERN_INFO
  37503. +                   "ppp_tty_ioctl: set flags to %x\n", temp_i);
  37504. +            ppp->flags = temp_i;
  37505. +        }
  37506. +        break;
  37507. +/*
  37508. + * Set the compression mode
  37509. + */
  37510. +    case PPPIOCSCOMPRESS:
  37511. +        error = ppp_set_compression (ppp,
  37512. +                        (struct ppp_option_data *) param3);
  37513. +        break;
  37514. +/*
  37515. + * Retrieve the transmit async map
  37516. + */
  37517. +    case PPPIOCGASYNCMAP:
  37518. +        error = verify_area (VERIFY_WRITE, (void *) param3,
  37519. +                     sizeof (temp_i));
  37520. +        if (error == 0) {
  37521. +            put_user (ppp->xmit_async_map[0], (int *) param3);
  37522. +            if (ppp->flags & SC_DEBUG)
  37523. +                printk (KERN_INFO
  37524. +                     "ppp_tty_ioctl: get asyncmap: addr "
  37525. +                     "%lx asyncmap %x\n",
  37526. +                     param3,
  37527. +                     ppp->xmit_async_map[0]);
  37528. +        }
  37529. +        break;
  37530. +/*
  37531. + * Set the transmit async map
  37532. + */
  37533. +    case PPPIOCSASYNCMAP:
  37534. +        error = verify_area (VERIFY_READ, (void *) param3,
  37535. +                     sizeof (temp_i));
  37536. +        if (error == 0) {
  37537. +            ppp->xmit_async_map[0] = get_user ((int *) param3);
  37538. +            if (ppp->flags & SC_DEBUG)
  37539. +                printk (KERN_INFO
  37540. +                     "ppp_tty_ioctl: set xmit asyncmap %x\n",
  37541. +                     ppp->xmit_async_map[0]);
  37542. +        }
  37543. +        break;
  37544. +/*
  37545. + * Set the receive async map
  37546. + */
  37547. +    case PPPIOCSRASYNCMAP:
  37548. +        error = verify_area (VERIFY_READ, (void *) param3,
  37549. +                     sizeof (temp_i));
  37550. +        if (error == 0) {
  37551. +            ppp->recv_async_map = get_user ((int *) param3);
  37552. +            if (ppp->flags & SC_DEBUG)
  37553. +                printk (KERN_INFO
  37554. +                     "ppp_tty_ioctl: set rcv asyncmap %x\n",
  37555. +                     ppp->recv_async_map);
  37556. +        }
  37557. +        break;
  37558. +/*
  37559. + * Obtain the unit number for this device.
  37560. + */
  37561. +    case PPPIOCGUNIT:
  37562. +        error = verify_area (VERIFY_WRITE, (void *) param3,
  37563. +                     sizeof (temp_i));
  37564. +        if (error == 0) {
  37565. +            put_user (ppp2dev (ppp)->base_addr, (int *) param3);
  37566. +            if (ppp->flags & SC_DEBUG)
  37567. +                printk (KERN_INFO
  37568. +                    "ppp_tty_ioctl: get unit: %ld",
  37569. +                    ppp2dev (ppp)->base_addr);
  37570. +        }
  37571. +        break;
  37572. +/*
  37573. + * Set the debug level
  37574. + */
  37575. +    case PPPIOCSDEBUG:
  37576. +        error = verify_area (VERIFY_READ, (void *) param3,
  37577. +                     sizeof (temp_i));
  37578. +        if (error == 0) {
  37579. +            temp_i  = (get_user ((int *) param3) & 0x1F) << 16;
  37580. +            temp_i |= (ppp->flags & ~0x1F0000);
  37581. +
  37582. +            if ((ppp->flags | temp_i) & SC_DEBUG)
  37583. +                printk (KERN_INFO
  37584. +                   "ppp_tty_ioctl: set flags to %x\n", temp_i);
  37585. +            ppp->flags = temp_i;
  37586. +        }
  37587. +        break;
  37588. +/*
  37589. + * Get the debug level
  37590. + */
  37591. +    case PPPIOCGDEBUG:
  37592. +        error = verify_area (VERIFY_WRITE, (void *) param3,
  37593. +                     sizeof (temp_i));
  37594. +        if (error == 0) {
  37595. +            temp_i = (ppp->flags >> 16) & 0x1F;
  37596. +            put_user (temp_i, (int *) param3);
  37597. +
  37598. +            if (ppp->flags & SC_DEBUG)
  37599. +                printk (KERN_INFO
  37600. +                    "ppp_tty_ioctl: get debug level %d\n",
  37601. +                    temp_i);
  37602. +              }
  37603. +        break;
  37604. +/*
  37605. + * Get the times since the last send/receive frame operation
  37606. + */
  37607. +    case PPPIOCGIDLE:
  37608. +        error = verify_area (VERIFY_WRITE, (void *) param3,
  37609. +                     sizeof (struct ppp_idle));
  37610. +        if (error == 0) {
  37611. +            struct ppp_idle cur_ddinfo;
  37612. +            __u32 cur_jiffies = jiffies;
  37613. +
  37614. +            /* change absolute times to relative times. */
  37615. +            cur_ddinfo.xmit_idle = (cur_jiffies - ppp->ddinfo.xmit_idle) / HZ;
  37616. +            cur_ddinfo.recv_idle = (cur_jiffies - ppp->ddinfo.recv_idle) / HZ;
  37617. +            memcpy_tofs ((void *) param3, &cur_ddinfo,
  37618. +                     sizeof (cur_ddinfo));
  37619. +            if (ppp->flags & SC_DEBUG)
  37620. +                printk (KERN_INFO
  37621. +                "ppp_tty_ioctl: read demand dial info\n");
  37622. +        }
  37623. +        break;
  37624. +/*
  37625. + * Retrieve the extended async map
  37626. + */
  37627. +    case PPPIOCGXASYNCMAP:
  37628. +        error = verify_area (VERIFY_WRITE,
  37629. +                     (void *) param3,
  37630. +                     sizeof (ppp->xmit_async_map));
  37631. +        if (error == 0) {
  37632. +            memcpy_tofs ((void *) param3,
  37633. +                     ppp->xmit_async_map,
  37634. +                     sizeof (ppp->xmit_async_map));
  37635. +
  37636. +            if (ppp->flags & SC_DEBUG)
  37637. +                printk (KERN_INFO
  37638. +                "ppp_tty_ioctl: get xasyncmap: addr %lx\n",
  37639. +                param3);
  37640. +        }
  37641. +        break;
  37642. +/*
  37643. + * Set the async extended map
  37644. + */
  37645. +    case PPPIOCSXASYNCMAP:
  37646. +        error = verify_area (VERIFY_READ, (void *) param3,
  37647. +                     sizeof (ppp->xmit_async_map));
  37648. +        if (error == 0) {
  37649. +            __u32 temp_tbl[8];
  37650. +
  37651. +            memcpy_fromfs (temp_tbl, (void *) param3,
  37652. +                       sizeof (ppp->xmit_async_map));
  37653. +            temp_tbl[1]  =  0x00000000;
  37654. +            temp_tbl[2] &= ~0x40000000;
  37655. +            temp_tbl[3] |=  0x60000000;
  37656. +
  37657. +            if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
  37658. +                (temp_tbl[4] & temp_tbl[5]) != 0 ||
  37659. +                (temp_tbl[6] & temp_tbl[7]) != 0)
  37660. +                error = -EINVAL;
  37661. +            else {
  37662. +                memcpy (ppp->xmit_async_map, temp_tbl,
  37663. +                    sizeof (ppp->xmit_async_map));
  37664. +
  37665. +                if (ppp->flags & SC_DEBUG)
  37666. +                    printk (KERN_INFO
  37667. +                    "ppp_tty_ioctl: set xasyncmap\n");
  37668. +            }
  37669. +        }
  37670. +        break;
  37671. +/*
  37672. + * Set the maximum VJ header compression slot number.
  37673. + */
  37674. +    case PPPIOCSMAXCID:
  37675. +        error = verify_area (VERIFY_READ, (void *) param3,
  37676. +                     sizeof (temp_i));
  37677. +        if (error == 0) {
  37678. +            temp_i = get_user ((int *) param3) + 1;
  37679. +            if (ppp->flags & SC_DEBUG)
  37680. +                printk (KERN_INFO
  37681. +                     "ppp_tty_ioctl: set maxcid to %d\n",
  37682. +                     temp_i);
  37683. +            if (ppp->slcomp != NULL)
  37684. +                slhc_free (ppp->slcomp);
  37685. +            ppp->slcomp = slhc_init (16, temp_i);
  37686. +
  37687. +            if (ppp->slcomp == NULL) {
  37688. +                if (ppp->flags & SC_DEBUG)
  37689. +                    printk (KERN_ERR
  37690. +                    "ppp: no space for compression buffers!\n");
  37691. +                ppp_release (ppp);
  37692. +                error = -ENOMEM;
  37693. +            }
  37694. +        }
  37695. +        break;
  37696. +
  37697. +    case PPPIOCXFERUNIT:
  37698. +        ppp_tty_close_local (tty, current->pid);
  37699. +        break;
  37700. +
  37701. +    case PPPIOCGNPMODE:
  37702. +    case PPPIOCSNPMODE:
  37703. +        error = verify_area (VERIFY_READ, (void *) param3,
  37704. +                    sizeof (struct npioctl));
  37705. +        if (error == 0) {
  37706. +            struct npioctl npi;
  37707. +            memcpy_fromfs (&npi,
  37708. +                       (void *) param3,
  37709. +                       sizeof (npi));
  37710. +
  37711. +            switch (npi.protocol) {
  37712. +            case PPP_IP:
  37713. +                npi.protocol = NP_IP;
  37714. +                break;
  37715. +            default:
  37716. +                error = -EINVAL;
  37717. +            }
  37718. +
  37719. +            if (error != 0)
  37720. +                break;
  37721. +
  37722. +            if (param2 == PPPIOCGNPMODE) {
  37723. +                npi.mode = ppp->sc_npmode[npi.protocol];
  37724. +                error = verify_area (VERIFY_WRITE,
  37725. +                             (void *) param3,
  37726. +                             sizeof (npi));
  37727. +                if (error != 0)
  37728. +                    break;
  37729. +
  37730. +                memcpy_tofs ((void *) param3,
  37731. +                         &npi,
  37732. +                         sizeof (npi));
  37733. +                break;
  37734. +            }
  37735. +
  37736. +            if (npi.mode != ppp->sc_npmode[npi.protocol]) {
  37737. +                ppp->sc_npmode[npi.protocol] = npi.mode;
  37738. +                if (npi.mode != NPMODE_QUEUE) {
  37739. +                    /* ppp_requeue(ppp); maybe needed */
  37740. +                    ppp_tty_wakeup (ppp2tty(ppp));
  37741. +                }
  37742. +            }
  37743. +        }
  37744. +        break;
  37745. +/*
  37746. + * Allow users to read, but not set, the serial port parameters
  37747. + */
  37748. +    case TCGETS:
  37749. +    case TCGETA:
  37750. +        error = n_tty_ioctl (tty, file, param2, param3);
  37751. +        break;
  37752. +
  37753. +    case FIONREAD:
  37754. +        error = verify_area (VERIFY_WRITE,
  37755. +                     (void *) param3,
  37756. +                     sizeof (int));
  37757. +        if (error == 0) {
  37758. +            int count = ppp->ubuf->tail - ppp->ubuf->head;
  37759. +            if (count < 0)
  37760. +                count += (ppp->ubuf->size + 1);
  37761. +
  37762. +            put_user (count, (int *) param3);
  37763. +        }
  37764. +        break;
  37765. +/*
  37766. + *  All other ioctl() events will come here.
  37767. + */
  37768. +    default:
  37769. +        if (ppp->flags & SC_DEBUG)
  37770. +            printk (KERN_ERR
  37771. +                "ppp_tty_ioctl: invalid ioctl: %x, addr %lx\n",
  37772. +                param2,
  37773. +                param3);
  37774. +
  37775. +        error = -ENOIOCTLCMD;
  37776. +        break;
  37777. +    }
  37778. +    return error;
  37779. +}
  37780. +
  37781. +/*
  37782. + * TTY callback.
  37783. + *
  37784. + * Process the select() statement for the PPP device.
  37785. + */
  37786. +
  37787. +static int
  37788. +ppp_tty_select (struct tty_struct *tty, struct inode *inode,
  37789. +        struct file *filp, int sel_type, select_table * wait)
  37790. +{
  37791. +    struct ppp *ppp = tty2ppp (tty);
  37792. +    int result = 1;
  37793. +/*
  37794. + * Verify the status of the PPP device.
  37795. + */
  37796. +    if (!ppp)
  37797. +        return -EBADF;
  37798. +
  37799. +    if (ppp->magic != PPP_MAGIC)
  37800. +        return -EBADF;
  37801. +
  37802. +    CHECK_PPP (0);
  37803. +/*
  37804. + * Branch on the type of select mode. A read request must lock the user
  37805. + * buffer area.
  37806. + */
  37807. +    switch (sel_type) {
  37808. +    case SEL_IN:
  37809. +        if (set_bit (0, &ppp->ubuf->locked) == 0) {
  37810. +            /* Test for the presence of data in the queue */
  37811. +            if (ppp->ubuf->head != ppp->ubuf->tail) {
  37812. +                clear_bit (0, &ppp->ubuf->locked);
  37813. +                break;
  37814. +            }
  37815. +            clear_bit (0, &ppp->ubuf->locked);
  37816. +        }        /* fall through */
  37817. +        /*
  37818. + * Exceptions or read errors.
  37819. + */
  37820. +    case SEL_EX:
  37821. +        /* Is this a pty link and the remote disconnected? */
  37822. +        if (tty->flags & (1 << TTY_OTHER_CLOSED))
  37823. +            break;
  37824. +
  37825. +        /* Is this a local link and the modem disconnected? */
  37826. +        if (tty_hung_up_p (filp))
  37827. +            break;
  37828. +
  37829. +        select_wait (&ppp->read_wait, wait);
  37830. +        result = 0;
  37831. +        break;
  37832. +/*
  37833. + * Write mode. A write is allowed if there is no current transmission.
  37834. + */
  37835. +    case SEL_OUT:
  37836. +        if (ppp->tbuf->locked != 0) {
  37837. +            select_wait (&ppp->write_wait, wait);
  37838. +            result = 0;
  37839. +        }
  37840. +        break;
  37841. +    }
  37842. +    return result;
  37843. +}
  37844. +
  37845. +/*************************************************************
  37846. + * NETWORK OUTPUT
  37847. + *    This routine accepts requests from the network layer
  37848. + *    and attempts to deliver the packets.
  37849. + *    It also includes various routines we are compelled to
  37850. + *    have to make the network layer work (arp, etc...).
  37851. + *************************************************************/
  37852. +
  37853. +/*
  37854. + * Callback from the network layer when the device goes up.
  37855. + */
  37856. +
  37857. +static int
  37858. +ppp_dev_open (struct device *dev)
  37859. +{
  37860. +    struct ppp *ppp = dev2ppp (dev);
  37861. +
  37862. +    /* reset POINTOPOINT every time, since dev_close zaps it! */
  37863. +    dev->flags |= IFF_POINTOPOINT;
  37864. +
  37865. +    if (ppp2tty (ppp) == NULL) {
  37866. +        if (ppp->flags & SC_DEBUG)
  37867. +            printk (KERN_ERR
  37868. +            "ppp: %s not connected to a TTY! can't go open!\n",
  37869. +            dev->name);
  37870. +        return -ENXIO;
  37871. +    }
  37872. +
  37873. +    if (ppp->flags & SC_DEBUG)
  37874. +        printk (KERN_INFO
  37875. +            "ppp: channel %s going up for IP packets!\n",
  37876. +            dev->name);
  37877. +
  37878. +    CHECK_PPP (-ENXIO);
  37879. +    return 0;
  37880. +}
  37881. +
  37882. +/*
  37883. + * Callback from the network layer when the ppp device goes down.
  37884. + */
  37885. +
  37886. +static int
  37887. +ppp_dev_close (struct device *dev)
  37888. +{
  37889. +    struct ppp *ppp = dev2ppp (dev);
  37890. +
  37891. +    if (ppp2tty (ppp) == NULL) {
  37892. +        if (ppp->flags & SC_DEBUG)
  37893. +            printk (KERN_ERR
  37894. +            "ppp: %s not connected to a TTY! can't go down!\n",
  37895. +            dev->name);
  37896. +        return -ENXIO;
  37897. +    }
  37898. +/*
  37899. + * We don't do anything about the device going down. It is not important
  37900. + * for us.
  37901. + */
  37902. +    if (ppp->flags & SC_DEBUG)
  37903. +        printk (KERN_INFO
  37904. +            "ppp: channel %s going down for IP packets!\n",
  37905. +            dev->name);
  37906. +    CHECK_PPP (-ENXIO);
  37907. +    return 0;
  37908. +}
  37909. +
  37910. +/*
  37911. + * IOCTL operation to read the version of the driver.
  37912. + */
  37913. +
  37914. +static int
  37915. +ppp_dev_ioctl_version (struct ppp *ppp, struct ifreq *ifr)
  37916. +{
  37917. +        int error;
  37918. +    int len;
  37919. +    char *result;
  37920. +/*
  37921. + * Must have write access to the buffer.
  37922. + */
  37923. +    result = (char *) ifr->ifr_ifru.ifru_data;
  37924. +    len    = strlen (szVersion) + 1;
  37925. +    error  = verify_area (VERIFY_WRITE, result, len);
  37926. +/*
  37927. + * Move the version data
  37928. + */
  37929. +    if (error == 0)
  37930. +        memcpy_tofs (result, szVersion, len);
  37931. +
  37932. +    return error;
  37933. +}
  37934. +
  37935. +/*
  37936. + * IOCTL to read the statistics for the pppstats program.
  37937. + */
  37938. +
  37939. +static int
  37940. +ppp_dev_ioctl_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
  37941. +{
  37942. +    struct ppp_stats *result, temp;
  37943. +    int    error;
  37944. +/*
  37945. + * Must have write access to the buffer.
  37946. + */
  37947. +    result = (struct ppp_stats *) ifr->ifr_ifru.ifru_data;
  37948. +    error = verify_area (VERIFY_WRITE,
  37949. +                 result,
  37950. +                 sizeof (temp));
  37951. +/*
  37952. + * Supply the information for the caller. First move the version data
  37953. + * then move the ppp stats; and finally the vj stats.
  37954. + */
  37955. +    memset (&temp, 0, sizeof(temp));
  37956. +    if (error == 0 && dev->flags & IFF_UP) {
  37957. +        memcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
  37958. +        if (ppp->slcomp != NULL) {
  37959. +            temp.vj.vjs_packets    = ppp->slcomp->sls_o_compressed+
  37960. +                         ppp->slcomp->sls_o_uncompressed;
  37961. +            temp.vj.vjs_compressed = ppp->slcomp->sls_o_compressed;
  37962. +            temp.vj.vjs_searches   = ppp->slcomp->sls_o_searches;
  37963. +            temp.vj.vjs_misses     = ppp->slcomp->sls_o_misses;
  37964. +            temp.vj.vjs_errorin    = ppp->slcomp->sls_i_error;
  37965. +            temp.vj.vjs_tossed     = ppp->slcomp->sls_i_tossed;
  37966. +            temp.vj.vjs_uncompressedin = ppp->slcomp->sls_i_uncompressed;
  37967. +            temp.vj.vjs_compressedin   = ppp->slcomp->sls_i_compressed;
  37968. +        }
  37969. +    }
  37970. +
  37971. +    if (error == 0)
  37972. +        memcpy_tofs (result, &temp, sizeof (temp));
  37973. +    return error;
  37974. +}
  37975. +
  37976. +/*
  37977. + * IOCTL to read the compression statistics for the pppstats program.
  37978. + */
  37979. +
  37980. +static int
  37981. +ppp_dev_ioctl_comp_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
  37982. +{
  37983. +    struct ppp_comp_stats *result, temp;
  37984. +    int    error;
  37985. +/*
  37986. + * Must have write access to the buffer.
  37987. + */
  37988. +    result = (struct ppp_comp_stats *) ifr->ifr_ifru.ifru_data;
  37989. +    error = verify_area (VERIFY_WRITE,
  37990. +                 result,
  37991. +                 sizeof (temp));
  37992. +/*
  37993. + * Supply the information for the caller.
  37994. + */
  37995. +    memset (&temp, 0, sizeof(temp));
  37996. +    if (error == 0 && dev->flags & IFF_UP) {
  37997. +        if (ppp->sc_xc_state != NULL)
  37998. +            (*ppp->sc_xcomp->comp_stat) (ppp->sc_xc_state,
  37999. +                             &temp.c);
  38000. +
  38001. +        if (ppp->sc_rc_state != NULL)
  38002. +            (*ppp->sc_rcomp->decomp_stat) (ppp->sc_rc_state,
  38003. +                               &temp.d);
  38004. +    }
  38005. +/*
  38006. + * Move the data to the caller's buffer
  38007. + */
  38008. +    if (error == 0)
  38009. +        memcpy_tofs (result, &temp, sizeof (temp));
  38010. +    return error;
  38011. +}
  38012. +
  38013. +/*
  38014. + * Callback from the network layer to process the sockioctl functions.
  38015. + */
  38016. +
  38017. +static int
  38018. +ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
  38019. +{
  38020. +    struct ppp *ppp = dev2ppp (dev);
  38021. +    int error;
  38022. +/*
  38023. + * Process the requests
  38024. + */
  38025. +    switch (cmd) {
  38026. +    case SIOCGPPPSTATS:
  38027. +        error = ppp_dev_ioctl_stats (ppp, ifr, dev);
  38028. +        break;
  38029. +
  38030. +    case SIOCGPPPCSTATS:
  38031. +        error = ppp_dev_ioctl_comp_stats (ppp, ifr, dev);
  38032. +        break;
  38033. +
  38034. +    case SIOCGPPPVER:
  38035. +        error = ppp_dev_ioctl_version (ppp, ifr);
  38036. +        break;
  38037. +
  38038. +    default:
  38039. +        error = -EINVAL;
  38040. +        break;
  38041. +    }
  38042. +    return error;
  38043. +}
  38044. +
  38045. +/*
  38046. + * Send an IP frame to the remote with vj header compression.
  38047. + *
  38048. + * Return 0 if frame was queued for transmission.
  38049. + *        1 if frame must be re-queued for later driver support.
  38050. + */
  38051. +
  38052. +static int
  38053. +ppp_dev_xmit_ip (