home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / unix / armlinux / cross_comp / LINUXARM_1 / linux.diff
Encoding:
Text File  |  1995-10-27  |  2.2 MB  |  83,914 lines
Text Truncated. Only the first 1MB is shown below. Download the file for the complete contents.
  1. diff -r -u -N linux.orig/.bash_history linux.arm/.bash_history
  2. --- linux.orig/.bash_history    Thu Jan  1 01:00:00 1970
  3. +++ linux.arm/.bash_history    Fri Oct 27 23:16:06 1995
  4. @@ -0,0 +1,271 @@
  5. +dir
  6. +cd mm
  7. +ue swap.c
  8. +cp ~root/.emacsrc ~
  9. +ue swap.c
  10. +ue swap.c
  11. +ue memory.c
  12. +less ../include/asm/pgtable.h 
  13. +ue /etc/shutdown.allow 
  14. +dir
  15. +cd mm
  16. +ue swap.c
  17. +ue memory.c
  18. +ue swap.c
  19. +objdump --disassemble swap.o
  20. +objdump --disassemble swap.o | less
  21. +dir
  22. +ue swap.c
  23. +make
  24. +cd ../
  25. +make
  26. +cd mm
  27. +ue swap.c
  28. +ue Makefile
  29. +ue swap.c
  30. +cd ..
  31. +make
  32. +shutdown -t3 -rf now ; logout
  33. +nohup shutdown -r3 -rf now &; logout
  34. +nohup shutdown -r3 -rf now & ; logout
  35. +shutdown -r3 -rf now ; logout
  36. +cd mm
  37. +objdump --disassemble swap.o | less
  38. +ue swap.c
  39. +mcd ..
  40. +cd ..
  41. +make
  42. +ue mm/swap.c
  43. +make
  44. +/sbin/bootmap /dev/hda1
  45. +sync
  46. +cd /etc
  47. +mv rc rc.old
  48. +cd /sbin
  49. +mv init init.old
  50. +init.old R
  51. +sync
  52. +ue /etc/rc.d/rc.M
  53. +HOME=/root
  54. +cd arch/arm/drivers/scsi
  55. +dir
  56. +diff NCR5380.c ~lin/drivers/scsi/NCR5380.c
  57. +diff --help
  58. +diff NCR5380.c ~lin/drivers/scsi/NCR5380.c -bw
  59. +rm NCR5380.c
  60. +ln -s ../../../../drivers/scsi/NCR5380.c .
  61. +ue ecoscsi.c
  62. +rm NCR5380.h
  63. +ln -s ../../../../drivers/scsi/NCR5380.h .
  64. +rm ecoscsi.o
  65. +ue ecoscsi.c
  66. +make
  67. +make ecoscsi.o
  68. +dir
  69. +ue oak.c
  70. +ue cumana_1.c
  71. +ue oak.c
  72. +ue cumana_1.c
  73. +ue ecoscsi.c
  74. +ue ecoscsi.c
  75. +ue oak.c
  76. +ue cumana_1.c
  77. +ifconfig
  78. +/sbin/ifconfig
  79. +/sbin/ifconfig
  80. +/sbin/ifconfig
  81. +/sbin/ifconfig
  82. +/sbin/ifconfig
  83. +/sbin/ifconfig
  84. +/sbin/ifconfig
  85. +/sbin/ifconfig
  86. +/sbin/ifconfig
  87. +/sbin/ifconfig
  88. +/sbin/ifconfig
  89. +/sbin/ifconfig
  90. +/sbin/ifconfig
  91. +/sbin/ifconfig
  92. +/sbin/ifconfig
  93. +/sbin/ifconfig
  94. +/sbin/ifconfig
  95. +/sbin/ifconfig
  96. +/sbin/ifconfig
  97. +/sbin/ifconfig
  98. +/sbin/ifconfig
  99. +/sbin/ifconfig
  100. +/sbin/ifconfig
  101. +/sbin/ifconfig
  102. +/sbin/ifconfig
  103. +/sbin/ifconfig
  104. +/sbin/ifconfig
  105. +/sbin/ifconfig
  106. +/sbin/ifconfig
  107. +/sbin/ifconfig
  108. +/sbin/ifconfig
  109. +/sbin/ifconfig
  110. +/sbin/ifconfig
  111. +/sbin/ifconfig
  112. +/sbin/ifconfig
  113. +/sbin/ifconfig
  114. +/sbin/ifconfig
  115. +/sbin/ifconfig
  116. +ifconfig eth0 promisc
  117. +/sbin/ifconfig
  118. +/sbin/ifconfig eth0 promisc
  119. +/sbin/ifconfig
  120. +/sbin/ifconfig
  121. +/sbin/ifconfig
  122. +/sbin/ifconfig
  123. +/sbin/ifconfig
  124. +man tcpdump
  125. +/sbin/ifconfig
  126. +/sbin/ifconfig
  127. +/sbin/ifconfig
  128. +man tcpdump
  129. +/sbin/ifconfig
  130. +/sbin/ifconfig
  131. +fdir
  132. +dir
  133. +make -n
  134. +ue cumana_1.c
  135. +less ../podules/scsi.c 
  136. +less ../podules/podlist.c 
  137. +%1
  138. +%2
  139. +%3
  140. +%2
  141. +less ../podules/podlist.c 
  142. +jobs
  143. +%3
  144. +jobs
  145. +ue cumana_1.c
  146. +less ../podules/scsi.c 
  147. +%2
  148. +grep scsi_mem_init *.c
  149. +grep scsi_mem_init ~lin/drivers/scsi/*.c
  150. +diff hosts.c ~lin/drivers/scsi/hosts.c -bw | less
  151. +pwd
  152. +mv hosts.c hosts.c.old
  153. +cp ~lin/drivers/scsi/hosts.c .
  154. +ue hosts.c
  155. +cd ../../../..
  156. +cd arch/arm/drivers/scsi/
  157. +ue hosts.c
  158. +nm hosts.o | grep *UND* | less
  159. +nm hosts.o
  160. +ue hosts.c
  161. +nm hosts.o
  162. +dir
  163. +less hosts.c
  164. +dir
  165. +cd ../..
  166. +ue Makefile 
  167. +cd ../../init
  168. +less init.c
  169. +less main.c
  170. +rm main.o
  171. +cd ..
  172. +cd /
  173. +dir
  174. +dir boot
  175. +dir
  176. +dir etc
  177. +dir
  178. +dir home
  179. +dir home/arm
  180. +dir home/arm/a
  181. +dir home/arm/1
  182. +dir home/arm/1/users/
  183. +dir /root
  184. +rm -f /root/project
  185. +rm -rf /root/project
  186. +df
  187. +dir /root
  188. +rm /root/checklinux 
  189. +df
  190. +dir
  191. +dir sbin
  192. +rm /sbin/connect.cua2
  193. +dir /bin
  194. +cd /bin
  195. +rm sh
  196. +ln -s bash sh
  197. +dir
  198. +chgrp bin bash bashbug csh 
  199. +dir
  200. +cd ..
  201. +df
  202. +cd ../ld.so/
  203. +dir
  204. +less fixups.c
  205. +less ld.so.c
  206. +%1
  207. +less fixups.h
  208. +%1
  209. +jobs
  210. +%1
  211. +%2
  212. +cd arch/arm/drivers/scsi
  213. +HOME=~root
  214. +ue acornscsi.c
  215. +less oak.h
  216. +less acornscsi.h
  217. +%1
  218. +%1
  219. +ue acornscsi.c
  220. +less oak.c
  221. +%1
  222. +ue acornscsi.c
  223. +ps -aux
  224. +%1
  225. +less acornscsi.h
  226. +less scsi.h
  227. +less hosts.c
  228. +less hosts.h
  229. +%1
  230. +less acornscsi.h
  231. +%1
  232. +%2
  233. +less hosts.h
  234. +ue acornscsi.h
  235. +%1
  236. +jobs
  237. +%2
  238. +ue acornscsi.c
  239. +ps -aux
  240. +kill -9 459
  241. + kill -TERM 459
  242. +ps -aux
  243. +kill -KILL 459
  244. +ps -aux
  245. +kill -SEGV 459
  246. +kill -ILL 459
  247. +kill -PWR 459
  248. +kill -l
  249. +kill -BUS 459
  250. +kill -IO 459
  251. +kill -FPE 459
  252. +kill -IOT 459
  253. +ps -aux
  254. +ps -aux
  255. +cat /proc/devices 
  256. +ue acornscsi.c
  257. +mount -w -o remount ~lin
  258. +ue acornscsi.c
  259. +source ~root/.bashrc
  260. +cd arch/arm/drivers/block
  261. +ue blk.h
  262. +cp ~root/.bashrc ./bashrc
  263. +mount -w -o remount .
  264. +cp ~root/.bashrc ./bashrc
  265. +source ~/.bashrc
  266. +pwd
  267. +cp ~root/.bashrc ./.bashrc
  268. +rm bashrc 
  269. +source ~/.bashrc
  270. +cd arch/arm/drivers/block/
  271. +ue mfmhd.c
  272. +../cdplay
  273. +cd arch/arm/drivers/block/
  274. +dir
  275. +ue mfmhd.c
  276. diff -r -u -N linux.orig/.bashrc linux.arm/.bashrc
  277. --- linux.orig/.bashrc    Thu Jan  1 01:00:00 1970
  278. +++ linux.arm/.bashrc    Fri Oct 27 23:16:06 1995
  279. @@ -0,0 +1,4 @@
  280. +PATH=/sbin:/usr/sbin:$PATH
  281. +PS1="\u@\h:[\W]:<\!> "
  282. +alias rm='rm -i'
  283. +
  284. diff -r -u -N linux.orig/.config linux.arm/.config
  285. --- linux.orig/.config    Fri Oct 27 23:09:26 1995
  286. +++ linux.arm/.config    Fri Oct 27 23:16:04 1995
  287. @@ -1,27 +1,26 @@
  288.  #
  289.  # Automatically generated make config: don't edit
  290.  #
  291. +CONFIG_ARM=1
  292. +CONFIG_ARMMOUSE=1
  293.  
  294.  #
  295.  # General setup
  296.  #
  297. -# CONFIG_MATH_EMULATION is not set
  298. +CONFIG_PAGE_32K=y
  299. +CONFIG_MATH_EMULATION=y
  300.  CONFIG_BLK_DEV_FD=y
  301.  CONFIG_ST506=y
  302.  
  303.  #
  304.  # Please see drivers/block/README.ide for help/info on IDE drives
  305.  #
  306. -# CONFIG_BLK_DEV_HD is not set
  307. -CONFIG_BLK_DEV_IDE=y
  308. -# CONFIG_BLK_DEV_IDECD is not set
  309. +CONFIG_BLK_DEV_HD=y
  310. +# CONFIG_BLK_DEV_IDE is not set
  311.  # CONFIG_BLK_DEV_XD is not set
  312.  CONFIG_NET=y
  313.  # CONFIG_MAX_16M is not set
  314. -# CONFIG_PCI is not set
  315.  CONFIG_SYSVIPC=y
  316. -CONFIG_BINFMT_ELF=y
  317. -CONFIG_M486=y
  318.  
  319.  #
  320.  # Loadable module support
  321. @@ -32,8 +31,8 @@
  322.  # Networking options
  323.  #
  324.  CONFIG_INET=y
  325. -# CONFIG_IP_FORWARD is not set
  326. -# CONFIG_IP_MULTICAST is not set
  327. +CONFIG_IP_FORWARD=y
  328. +CONFIG_IP_MULTICAST=y
  329.  # CONFIG_IP_FIREWALL is not set
  330.  # CONFIG_IP_ACCT is not set
  331.  
  332. @@ -49,44 +48,37 @@
  333.  #
  334.  # SCSI support
  335.  #
  336. -# CONFIG_SCSI is not set
  337. +CONFIG_SCSI=y
  338.  
  339.  #
  340. -# Skipping SCSI configuration options...
  341. +# SCSI support type (disk, tape, CDrom)
  342.  #
  343. +CONFIG_BLK_DEV_SD=y
  344. +# CONFIG_CHR_DEV_ST is not set
  345. +CONFIG_BLK_DEV_SR=y
  346. +# CONFIG_CHR_DEV_SG is not set
  347. +
  348. +#
  349. +# SCSI low-level drivers
  350. +#
  351. +CONFIG_SCSI_ACORNSCSI_3=y
  352. +# CONFIG_SCSI_CUMANA_1 is not set
  353. +# CONFIG_SCSI_ECOSCSI is not set
  354. +# CONFIG_SCSI_OAK is not set
  355. +# CONFIG_SCSI_DEBUG is not set
  356.  
  357.  #
  358.  # Network device support
  359.  #
  360.  CONFIG_NETDEVICES=y
  361.  CONFIG_DUMMY=y
  362. -# CONFIG_SLIP is not set
  363. +CONFIG_SLIP=y
  364. +CONFIG_SLIP_COMPRESSED=y
  365. +# SL_SLIP_LOTS is not set
  366. +# SL_DUMP is not set
  367.  # CONFIG_PPP is not set
  368.  # CONFIG_PLIP is not set
  369. -# CONFIG_NET_ALPHA is not set
  370. -# CONFIG_NET_VENDOR_SMC is not set
  371. -# CONFIG_LANCE is not set
  372. -# CONFIG_NET_VENDOR_3COM is not set
  373. -CONFIG_NET_ISA=y
  374. -# CONFIG_E2100 is not set
  375. -# CONFIG_DEPCA is not set
  376. -# CONFIG_EWRK3 is not set
  377. -# CONFIG_HPLAN_PLUS is not set
  378. -# CONFIG_HPLAN is not set
  379. -CONFIG_NE2000=y
  380. -# CONFIG_SK_G16 is not set
  381. -# CONFIG_NET_EISA is not set
  382. -# CONFIG_NET_POCKET is not set
  383. -
  384. -#
  385. -# CD-ROM drivers (not for SCSI or IDE/ATAPI drives)
  386. -#
  387. -# CONFIG_CDU31A is not set
  388. -# CONFIG_MCD is not set
  389. -CONFIG_SBPCD=y
  390. -# CONFIG_SBPCD2 is not set
  391. -# CONFIG_AZTCD is not set
  392. -# CONFIG_CDU535 is not set
  393. +CONFIG_ETHER3=y
  394.  
  395.  #
  396.  # Filesystems
  397. @@ -100,28 +92,19 @@
  398.  CONFIG_PROC_FS=y
  399.  CONFIG_NFS_FS=y
  400.  CONFIG_ISO9660_FS=y
  401. -# CONFIG_HPFS_FS is not set
  402. -# CONFIG_SYSV_FS is not set
  403.  
  404.  #
  405.  # character devices
  406.  #
  407. -# CONFIG_CYCLADES is not set
  408.  CONFIG_PRINTER=y
  409. -CONFIG_BUSMOUSE=y
  410. -# CONFIG_PSMOUSE is not set
  411. -# CONFIG_MS_BUSMOUSE is not set
  412. -# CONFIG_ATIXL_BUSMOUSE is not set
  413. -# CONFIG_QIC02_TAPE is not set
  414. -CONFIG_FTAPE=y
  415. -NR_FTAPE_BUFFERS=3
  416.  
  417.  #
  418.  # Sound
  419.  #
  420. -# CONFIG_SOUND is not set
  421. +CONFIG_SOUND=y
  422.  
  423.  #
  424.  # Kernel hacking
  425.  #
  426.  # CONFIG_PROFILE is not set
  427. +CONFIG_SCSI_CONSTANTS=y
  428. diff -r -u -N linux.orig/.config.old linux.arm/.config.old
  429. --- linux.orig/.config.old    Fri Oct 27 23:09:26 1995
  430. +++ linux.arm/.config.old    Fri Oct 27 23:16:05 1995
  431. @@ -1,27 +1,27 @@
  432.  #
  433.  # Automatically generated make config: don't edit
  434.  #
  435. +CONFIG_ARM=1
  436. +CONFIG_ARMMOUSE=1
  437.  
  438.  #
  439.  # General setup
  440.  #
  441. -# CONFIG_MATH_EMULATION is not set
  442. +CONFIG_PAGE_32K=y
  443. +CONFIG_MATH_EMULATION=y
  444.  CONFIG_BLK_DEV_FD=y
  445.  CONFIG_ST506=y
  446.  
  447.  #
  448.  # Please see drivers/block/README.ide for help/info on IDE drives
  449.  #
  450. -# CONFIG_BLK_DEV_HD is not set
  451. -CONFIG_BLK_DEV_IDE=y
  452. -# CONFIG_BLK_DEV_IDECD is not set
  453. +CONFIG_BLK_DEV_HD=y
  454. +# CONFIG_BLK_DEV_IDE is not set
  455.  # CONFIG_BLK_DEV_XD is not set
  456.  CONFIG_NET=y
  457.  # CONFIG_MAX_16M is not set
  458. -# CONFIG_PCI is not set
  459.  CONFIG_SYSVIPC=y
  460. -CONFIG_BINFMT_ELF=y
  461. -CONFIG_M486=y
  462. +# CONFIG_BINFMT_ELF is not set
  463.  
  464.  #
  465.  # Loadable module support
  466. @@ -32,8 +32,8 @@
  467.  # Networking options
  468.  #
  469.  CONFIG_INET=y
  470. -# CONFIG_IP_FORWARD is not set
  471. -# CONFIG_IP_MULTICAST is not set
  472. +CONFIG_IP_FORWARD=y
  473. +CONFIG_IP_MULTICAST=y
  474.  # CONFIG_IP_FIREWALL is not set
  475.  # CONFIG_IP_ACCT is not set
  476.  
  477. @@ -49,43 +49,36 @@
  478.  #
  479.  # SCSI support
  480.  #
  481. -# CONFIG_SCSI is not set
  482. +CONFIG_SCSI=y
  483.  
  484.  #
  485. -# Skipping SCSI configuration options...
  486. +# SCSI support type (disk, tape, CDrom)
  487.  #
  488. +CONFIG_BLK_DEV_SD=y
  489. +# CONFIG_CHR_DEV_ST is not set
  490. +CONFIG_BLK_DEV_SR=y
  491. +# CONFIG_CHR_DEV_SG is not set
  492. +
  493. +#
  494. +# SCSI low-level drivers
  495. +#
  496. +# CONFIG_SCSI_CUMANA_1 is not set
  497. +# CONFIG_SCSI_ECOSCSI is not set
  498. +# CONFIG_SCSI_OAK is not set
  499. +# CONFIG_SCSI_DEBUG is not set
  500.  
  501.  #
  502.  # Network device support
  503.  #
  504.  CONFIG_NETDEVICES=y
  505.  CONFIG_DUMMY=y
  506. -# CONFIG_SLIP is not set
  507. +CONFIG_SLIP=y
  508. +CONFIG_SLIP_COMPRESSED=y
  509. +# SL_SLIP_LOTS is not set
  510. +# SL_DUMP is not set
  511.  # CONFIG_PPP is not set
  512.  # CONFIG_PLIP is not set
  513. -# CONFIG_NET_ALPHA is not set
  514. -# CONFIG_NET_VENDOR_SMC is not set
  515. -# CONFIG_LANCE is not set
  516. -# CONFIG_NET_VENDOR_3COM is not set
  517. -CONFIG_NET_ISA=y
  518. -# CONFIG_E2100 is not set
  519. -# CONFIG_DEPCA is not set
  520. -# CONFIG_EWRK3 is not set
  521. -# CONFIG_HPLAN_PLUS is not set
  522. -# CONFIG_HPLAN is not set
  523. -CONFIG_NE2000=y
  524. -# CONFIG_SK_G16 is not set
  525. -# CONFIG_NET_EISA is not set
  526. -# CONFIG_NET_POCKET is not set
  527. -
  528. -#
  529. -# CD-ROM drivers (not for SCSI or IDE/ATAPI drives)
  530. -#
  531. -# CONFIG_CDU31A is not set
  532. -# CONFIG_MCD is not set
  533. -# CONFIG_SBPCD is not set
  534. -# CONFIG_AZTCD is not set
  535. -# CONFIG_CDU535 is not set
  536. +CONFIG_ETHER3=y
  537.  
  538.  #
  539.  # Filesystems
  540. @@ -99,28 +92,19 @@
  541.  CONFIG_PROC_FS=y
  542.  CONFIG_NFS_FS=y
  543.  CONFIG_ISO9660_FS=y
  544. -# CONFIG_HPFS_FS is not set
  545. -# CONFIG_SYSV_FS is not set
  546.  
  547.  #
  548.  # character devices
  549.  #
  550. -# CONFIG_CYCLADES is not set
  551.  CONFIG_PRINTER=y
  552. -CONFIG_BUSMOUSE=y
  553. -# CONFIG_PSMOUSE is not set
  554. -# CONFIG_MS_BUSMOUSE is not set
  555. -# CONFIG_ATIXL_BUSMOUSE is not set
  556. -# CONFIG_QIC02_TAPE is not set
  557. -CONFIG_FTAPE=y
  558. -NR_FTAPE_BUFFERS=3
  559.  
  560.  #
  561.  # Sound
  562.  #
  563. -# CONFIG_SOUND is not set
  564. +CONFIG_SOUND=y
  565.  
  566.  #
  567.  # Kernel hacking
  568.  #
  569.  # CONFIG_PROFILE is not set
  570. +CONFIG_SCSI_CONSTANTS=y
  571. diff -r -u -N linux.orig/.emacsrc linux.arm/.emacsrc
  572. --- linux.orig/.emacsrc    Thu Jan  1 01:00:00 1970
  573. +++ linux.arm/.emacsrc    Fri Oct 27 23:16:06 1995
  574. @@ -0,0 +1,259 @@
  575. +;    EMACS.RC:    Standard MicroEMACS Startup program
  576. +;            for MicroEMACS 3.12 and above
  577. +;            (C)opyright 1987,92 by Daniel M Lawrence
  578. +;            Last Update: 12/28/92
  579. +
  580. +set $discmd FALSE
  581. +write-message "[Setting up....]"
  582. +
  583. +; If you screen "SNOWS", comment this line
  584. +    set $flicker "FALSE"
  585. +
  586. +; To use an IBM-PC EGA card, uncomment the following line
  587. +;    set $sres "EGA"
  588. +
  589. +;    If you hate clocks or position counters, comment these
  590. +set $timeflag TRUE
  591. +set $posflag TRUE
  592. +
  593. +;    Set Default Global modes
  594. +
  595. +add-global-mode "blue"
  596. +add-global-mode "WHITE"
  597. +;bind-to-key meta-prefix `    ;for annoying keyboards with ` at the top left
  598. +
  599. +;    Toggle function key window display
  600. +
  601. +store-procedure toggle-fkeys
  602. +    !if %rcfkeys
  603. +        !goto rcfoff
  604. +    !endif
  605. +
  606. +;    toggle function key window on
  607. +    save-window
  608. +    1 next-window
  609. +    !if &sequal $cbufname "emacs.hlp"
  610. +        delete-window
  611. +    !endif
  612. +    !if ¬ &sequal $cbufname "Function Keys"
  613. +        1 split-current-window
  614. +        1 select-buffer "Function Keys"
  615. +        add-mode "red"
  616. +        !force 5 resize-window
  617. +        1 goto-line
  618. +    !endif
  619. +    set %rcfkeys TRUE
  620. +    !force restore-window
  621. +    !if &sequal $cbufname "Function Keys"
  622. +        next-window
  623. +    !endif
  624. +    write-message "[Function key window ON]"
  625. +    !return
  626. +
  627. +    ;Toggle the function key window off
  628. +*rcfoff
  629. +    save-window
  630. +    1 next-window
  631. +    !if &sequal "Function Keys" $cbufname
  632. +        delete-window
  633. +    !endif
  634. +    !force restore-window
  635. +    write-message "[Function key window OFF]"
  636. +    set %rcfkeys FALSE
  637. +!endm
  638. +
  639. +;    Bring up Online-help system
  640. +
  641. +store-procedure get-help
  642. +    set $discmd FALSE
  643. +    source ehelp.cmd
  644. +    set $discmd TRUE
  645. +!endm
  646. +
  647. +;    Load a new page
  648. +
  649. +store-procedure get-page-loader
  650. +    !if &seq &find newpage.cmd ""
  651. +        write-message "[Can not find NEWPAGE.CMD]"
  652. +        !return
  653. +    !endif
  654. +    execute-file newpage.cmd
  655. +!endm
  656. +
  657. +;procedure to clean out the current page (which is nothing right now)
  658. +
  659. +store-procedure clean
  660. +    ; nothing by default
  661. +!endm
  662. +
  663. +;    Set up auto CMODE
  664. +
  665. +store-procedure set-default-mode
  666. +    set %rctmp &sin $cfname "."
  667. +    !if &equ %rctmp 0
  668. +        !return
  669. +    !endif
  670. +    set %rctmp &mid $cfname &add %rctmp 1 5
  671. +    !if &or &seq %rctmp "c" &seq %rctmp "h"
  672. +        add-mode "cmode"
  673. +    !endif
  674. +    !if &or &seq %rctmp "cpp" &seq %rctmp "hpp"
  675. +        add-mode "cmode"
  676. +    !endif
  677. +    !if &or &seq %rctmp "mss" &seq %rctmp "txt"
  678. +        add-mode "wrap"
  679. +    !endif
  680. +!endm
  681. +set $readhook set-default-mode
  682. +
  683. +;    This function activates the function key window as
  684. +;    a legitimate place to call up function keys using the mouse
  685. +
  686. +store-procedure mouse-clicks
  687. +
  688. +    ;remember where we started, and do the mouse movement
  689. +    save-window
  690. +    !force mouse-move-down
  691. +
  692. +    ;If not in the function key window... leave
  693. +    !if ¬ &sequal $cbufname "Function Keys"
  694. +        !return
  695. +    !endif
  696. +
  697. +    ;First pos is a screen reposition, let it through
  698. +    !if &and &equ $xpos 0 &equ $ypos 0
  699. +        restore-window
  700. +        !return
  701. +    !endif
  702. +
  703. +    ;Find out what function key were gonna do
  704. +    add-mode magic
  705. +    2 forward-character
  706. +    set %rctmp $search
  707. +    !force search-reverse "[fF][0-9]"
  708. +    !if &seq $status FALSE
  709. +        delete-mode magic
  710. +        set $search %rctmp
  711. +        !return
  712. +    !endif
  713. +
  714. +    ;we are on the "f" or "F".  Get the function key type and number now
  715. +    set $search %rctmp
  716. +    set %fcase lower
  717. +    !if &equ $curchar 70
  718. +        set %fcase upper
  719. +    !endif
  720. +    1 forward-character
  721. +    set %fnum &chr $curchar
  722. +    1 forward-character
  723. +    set %fnum &cat %fnum &chr $curchar
  724. +    set %fnum &add %fnum 0
  725. +    !if &equ %fnum 10
  726. +        set %fnum "0"
  727. +    !endif
  728. +    set %fname &cat "FN" %fnum
  729. +    !if &seq %fcase upper
  730. +        set %fname &cat "S-" %fname
  731. +    !endif
  732. +
  733. +    ;save the function
  734. +    set %rccmd &bind %fname
  735. +    delete-mode MAGIC
  736. +
  737. +    ;swallow the up-button
  738. +    set %rctmp >c
  739. +
  740. +    ;restore the window and exit
  741. +    restore-window
  742. +
  743. +    ;procedures don't need the square brackets
  744. +    !if &seq &left %rccmd 1 "["
  745. +        set %rccmd &mid %rccmd 2 &sub &len %rccmd 2
  746. +        %rccmd
  747. +        !return
  748. +    !endif
  749. +
  750. +    ;and then execute it
  751. +    !force execute-named-command %rccmd
  752. +!endm   
  753. +macro-to-key mouse-clicks MSa
  754. +
  755. +;    ***** Rebind the Function key group
  756. +
  757. +bind-to-key search-forward        FN1
  758. +bind-to-key search-reverse        FN2
  759. +bind-to-key hunt-forward        FN3
  760. +bind-to-key hunt-backward        FN4
  761. +macro-to-key toggle-fkeys        FN5
  762. +macro-to-key get-help            FN6
  763. +bind-to-key next-window         FN7
  764. +macro-to-key get-page-loader        FN8
  765. +bind-to-key save-file            FN9
  766. +bind-to-key exit-emacs            FN0
  767. +
  768. +bind-to-key execute-macro-10        S-FN1
  769. +bind-to-key execute-macro-11        S-FN2
  770. +bind-to-key execute-macro-12        S-FN3
  771. +bind-to-key execute-macro-13        S-FN4
  772. +bind-to-key execute-macro-14        S-FN5
  773. +bind-to-key execute-macro-15        S-FN6
  774. +bind-to-key execute-macro-16        S-FN7
  775. +bind-to-key execute-macro-17        S-FN8
  776. +bind-to-key execute-macro-18        S-FN9
  777. +bind-to-key execute-macro-19        S-FN0
  778. +
  779. +;    bring up the function key window
  780. +
  781. +    1 split-current-window
  782. +    select-buffer "Function Keys"
  783. +    insert-string "f1 search-> f2 <-search Û    MicroEMACS:  Text Editor~n"
  784. +    insert-string "f3 hunt->   f4 <-hunt   Û ~n"
  785. +    insert-string "f5 fkeys    f6 help     Û  Available function key Pages include:~n"
  786. +    insert-string "f7 nxt wind f8 pg[    ] Û    Word  Box  Emacs  Pascal  C  cObol Lisp~n"
  787. +    insert-string "f9 save     f10 exit    Û  [use the f8 key to load Pages]~n"
  788. +    unmark-buffer
  789. +    delete-window
  790. +    set %rcfkeys TRUE
  791. +
  792. +    !if &seq $os "UNIX"
  793. +
  794. +        ;Allow mainframes to simulate function
  795. +        ;keys with ^C<n> and ^C shifted-<n>
  796. +        
  797. +        store-procedure emulate-fkeys
  798. +            !if ¬ $pending
  799. +                write-message "FN-"
  800. +            !endif
  801. +            set %rcchar >key
  802. +            set %rcchar &sindex "1234567890!@#$%^&*()" %rcchar
  803. +            !if &equ %rcchar 0
  804. +                write-message "[Not Bound]"
  805. +                !return
  806. +            !endif
  807. +            clear-message-line
  808. +            set %rctmp "FN"
  809. +            !if &gre %rcchar 10
  810. +                set %rctmp &cat "S-" %rctmp
  811. +            !endif
  812. +            set %rcchar &mid "12345678901234567890" %rcchar 1
  813. +            set %rctmp &bind &cat %rctmp %rcchar
  814. +            !if &seq &lef %rctmp 1 "["
  815. +                set %rctmp &mid %rctmp 2 &sub &len %rctmp 2
  816. +                run %rctmp
  817. +                !return
  818. +            !endif
  819. +            !force execute-named-command %rctmp
  820. +        !endm
  821. +
  822. +        macro-to-key emulate-fkeys ^C
  823. +        
  824. +    !endif
  825. +
  826. +    !if &seq $os "MSWIN"
  827. +        source "mewin.cmd"
  828. +    !else
  829. +        toggle-fkeys
  830. +    !endif
  831. +
  832. +    set $discmd TRUE
  833. +
  834. diff -r -u -N linux.orig/.version linux.arm/.version
  835. --- linux.orig/.version    Fri Oct 27 23:09:26 1995
  836. +++ linux.arm/.version    Fri Oct 27 23:16:05 1995
  837. @@ -1 +1 @@
  838. -4
  839. +0
  840. diff -r -u -N linux.orig/Configure linux.arm/Configure
  841. --- linux.orig/Configure    Fri Oct 27 23:08:06 1995
  842. +++ linux.arm/Configure    Fri Oct 27 23:11:54 1995
  843. @@ -126,8 +126,10 @@
  844.  fi
  845.  . $CONFIG_IN
  846.  
  847. -if [ "$CONFIG_SOUND" = "y" ] ; then
  848. +if [ "$HOSTTYPE" != "arm" ] ; then
  849. +  if [ "$CONFIG_SOUND" = "y" ] ; then
  850.      $MAKE -C drivers/sound config || exit 1
  851. +  fi
  852.  fi
  853.  
  854.  rm -f .config.old
  855. diff -r -u -N linux.orig/Makefile linux.arm/Makefile
  856. --- linux.orig/Makefile    Fri Oct 27 23:08:06 1995
  857. +++ linux.arm/Makefile    Fri Oct 27 23:09:17 1995
  858. @@ -2,7 +2,7 @@
  859.  PATCHLEVEL = 2
  860.  SUBLEVEL = 8
  861.  
  862. -ARCH = i386
  863. +ARCH = arm
  864.  
  865.  .EXPORT_ALL_VARIABLES:
  866.  
  867. @@ -86,11 +86,13 @@
  868.  
  869.  ARCHIVES    =kernel/kernel.o mm/mm.o fs/fs.o net/net.o ipc/ipc.o
  870.  FILESYSTEMS    =fs/filesystems.a
  871. -DRIVERS        =drivers/block/block.a \
  872. -         drivers/char/char.a \
  873. -         drivers/net/net.a
  874. +DRIVERS        =
  875.  LIBS        =$(TOPDIR)/lib/lib.a
  876. -SUBDIRS        =kernel drivers mm fs net ipc lib
  877. +SUBDIRS        =kernel mm fs net ipc lib
  878. +
  879. +DRIVERS := drivers/block/block.a \
  880. +       drivers/char/char.a \
  881. +       drivers/net/net.a
  882.  
  883.  ifdef CONFIG_SCSI
  884.  DRIVERS := $(DRIVERS) drivers/scsi/scsi.a
  885. @@ -125,7 +127,8 @@
  886.          $(FILESYSTEMS) \
  887.          $(DRIVERS) \
  888.          $(LIBS) -o vmlinux
  889. -    $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort > System.map
  890. +#    $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort > System.map
  891. +    $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)\|\( A \)\|\( t L\)' | sort > System.map
  892.  
  893.  symlinks:
  894.      rm -f include/asm
  895. @@ -198,7 +201,7 @@
  896.  MODV = -DCONFIG_MODVERSIONS
  897.  endif
  898.  
  899. -modules: include/linux/version.h
  900. +modules: include/linux/version.h dummy
  901.      @set -e; for i in $(SUBDIRS); do $(MAKE) -C $$i CFLAGS="$(CFLAGS) -DMODULE $(MODV)" modules; done
  902.      
  903.  modules_install:
  904. diff -r -u -N linux.orig/arch/alpha/Makefile linux.arm/arch/alpha/Makefile
  905. --- linux.orig/arch/alpha/Makefile    Fri Oct 27 23:08:07 1995
  906. +++ linux.arm/arch/alpha/Makefile    Fri Oct 27 23:13:50 1995
  907. @@ -15,7 +15,7 @@
  908.  
  909.  HEAD := arch/alpha/kernel/head.o
  910.  
  911. -SUBDIRS := $(SUBDIRS) arch/alpha/kernel arch/alpha/mm arch/alpha/lib
  912. +SUBDIRS := drivers $(SUBDIRS) arch/alpha/kernel arch/alpha/mm arch/alpha/lib
  913.  ARCHIVES := arch/alpha/kernel/kernel.o arch/alpha/mm/mm.o $(ARCHIVES)
  914.  LIBS := $(TOPDIR)/arch/alpha/lib/lib.a $(LIBS) $(TOPDIR)/arch/alpha/lib/lib.a
  915.  
  916. diff -r -u -N linux.orig/arch/arm/Makefile linux.arm/arch/arm/Makefile
  917. --- linux.orig/arch/arm/Makefile    Thu Jan  1 01:00:00 1970
  918. +++ linux.arm/arch/arm/Makefile    Fri Oct 27 23:14:02 1995
  919. @@ -0,0 +1,56 @@
  920. +#
  921. +# arch/arm/Makefile
  922. +#
  923. +# This file is included by the global makefile so that you can add your own
  924. +# architecture-specific flags and dependencies. Remember to do have actions
  925. +# for "archclean" and "archdep" for cleaning up and making dependencies for
  926. +# this architecture
  927. +#
  928. +# This file is subject to the terms and conditions of the GNU General Public
  929. +# License.  See the file "COPYING" in the main directory of this archive
  930. +# for more details.
  931. +#
  932. +# Copyright (C) 1995 by Russell King
  933. +#
  934. +
  935. +#
  936. +# Set these to indicate how to link it..
  937. +# -qmagic (we need to remove the 32 byte header for bootup purposes)
  938. +#
  939. +
  940. +ZLINKFLAGS =-N -Ttext 0x01800000
  941. +LINKFLAGS  =-Ttext 0x01800000
  942. +CFLAGS := $(CFLAGS) -fno-omit-frame-pointer
  943. +HEAD := arch/arm/kernel/head.o
  944. +SUBDIRS    := arch/arm/drivers arch/arm/kernel arch/arm/mm arch/arm/lib $(SUBDIRS)
  945. +ARCHIVES := arch/arm/kernel/kernel.o arch/arm/mm/mm.o arch/arm/lib/lib.o $(ARCHIVES)
  946. +LIBS := $(LIBS) `gcc --print-libgcc-file-name`
  947. +
  948. +DRIVERS := arch/arm/drivers/block/block.a arch/arm/drivers/char/char.a \
  949. +           arch/arm/drivers/net/net.a
  950. +
  951. +ifdef CONFIG_SOUND
  952. +DRIVERS := $(DRIVERS) arch/arm/drivers/sound/sound.a
  953. +endif
  954. +
  955. +ifdef CONFIG_SCSI
  956. +DRIVERS := $(DRIVERS) arch/arm/drivers/scsi/scsi.a
  957. +endif
  958. +
  959. +
  960. +arch/arm/kernel: dummy
  961. +    $(MAKE) linuxsubdirs SUBDIRS=arch/arm/kernel
  962. +
  963. +arch/arm/mm: dummy
  964. +    $(MAKE) linuxsubdirs SUBDIRS=arch/arm/mm
  965. +
  966. +MAKEBOOT = $(MAKE) -C arch/$(ARCH)/boot
  967. +
  968. +install: vmlinux
  969. +    @$(MAKEBOOT) install
  970. +
  971. +archclean:
  972. +    @$(MAKEBOOT) clean
  973. +
  974. +archdep:
  975. +    @$(MAKEBOOT) dep
  976. diff -r -u -N linux.orig/arch/arm/boot/Makefile linux.arm/arch/arm/boot/Makefile
  977. --- linux.orig/arch/arm/boot/Makefile    Thu Jan  1 01:00:00 1970
  978. +++ linux.arm/arch/arm/boot/Makefile    Fri Oct 27 23:15:23 1995
  979. @@ -0,0 +1,68 @@
  980. +#
  981. +# arch/i386/boot/Makefile
  982. +#
  983. +# This file is subject to the terms and conditions of the GNU General Public
  984. +# License.  See the file "COPYING" in the main directory of this archive
  985. +# for more details.
  986. +#
  987. +# Copyright (C) 1994 by Linus Torvalds
  988. +#
  989. +
  990. +Image:    $(CONFIGURE) tools/build $(TOPDIR)/vmlinux
  991. +    tools/build $(TOPDIR)/vmlinux > Image
  992. +    sync
  993. +
  994. +install: $(CONFIGURE) Image
  995. +    sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) Image $(TOPDIR)/System.map "$(INSTALL_PATH)"
  996. +
  997. +
  998. +tools/build: tools/build.c
  999. +    $(HOSTCC) $(CFLAGS) -o $@ $< -I$(TOPDIR)/include -static
  1000. +
  1001. +clean:
  1002. +    rm -f Image
  1003. +
  1004. +#zImage: $(CONFIGURE) bootsect setup compressed/vmlinux tools/build
  1005. +#    tools/build bootsect setup compressed/vmlinux $(ROOT_DEV) > zImage
  1006. +#    sync
  1007. +
  1008. +#compressed/vmlinux: $(TOPDIR)/vmlinux
  1009. +#    @$(MAKE) -C compressed vmlinux
  1010. +
  1011. +#zdisk: zImage
  1012. +#    dd bs=8192 if=zImage of=/dev/fd0
  1013. +
  1014. +#zlilo: $(CONFIGURE) zImage
  1015. +#    if [ -f $(INSTALL_PATH)/vmlinuz ]; then mv $(INSTALL_PATH)/vmlinuz $(INSTALL_PATH)/vmlinuz.old; fi
  1016. +#    if [ -f $(INSTALL_PATH)/System.map ]; then mv $(INSTALL_PATH)/System.map $(INSTALL_PATH)/System.old; fi
  1017. +#    cat zImage > $(INSTALL_PATH)/vmlinuz
  1018. +#    cp $(TOPDIR)/System.map $(INSTALL_PATH)/
  1019. +#    if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi
  1020. +
  1021. +#install: $(CONFIGURE) zImage
  1022. +#    sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) zImage $(TOPDIR)/System.map "$(INSTALL_PATH)"
  1023. +
  1024. +#setup: setup.o
  1025. +#    $(LD86) -s -o $@ $<
  1026. +
  1027. +#setup.o: setup.s
  1028. +#    $(AS86) -o $@ $<
  1029. +
  1030. +#setup.s: setup.S $(CONFIGURE) $(TOPDIR)/include/linux/config.h Makefile
  1031. +#    $(CPP) -traditional $(SVGA_MODE) $(RAMDISK) $< -o $@
  1032. +
  1033. +#bootsect: bootsect.o
  1034. +#    $(LD86) -s -o $@ $<
  1035. +
  1036. +#bootsect.o: bootsect.s
  1037. +#    $(AS86) -o $@ $<
  1038. +
  1039. +#bootsect.s: bootsect.S $(CONFIGURE) $(TOPDIR)/include/linux/config.h Makefile
  1040. +#    $(CPP) -traditional $(SVGA_MODE) $(RAMDISK) $< -o $@
  1041. +
  1042. +dep:
  1043. +
  1044. +#clean:
  1045. +#    rm -f bootsect setup
  1046. +#    rm -f zImage tools/build
  1047. +#    @$(MAKE) -C compressed clean
  1048. diff -r -u -N linux.orig/arch/arm/boot/install.sh linux.arm/arch/arm/boot/install.sh
  1049. --- linux.orig/arch/arm/boot/install.sh    Thu Jan  1 01:00:00 1970
  1050. +++ linux.arm/arch/arm/boot/install.sh    Fri Oct 27 23:15:25 1995
  1051. @@ -0,0 +1,40 @@
  1052. +#!/bin/sh
  1053. +#
  1054. +# arch/i386/boot/install.sh
  1055. +#
  1056. +# This file is subject to the terms and conditions of the GNU General Public
  1057. +# License.  See the file "COPYING" in the main directory of this archive
  1058. +# for more details.
  1059. +#
  1060. +# Copyright (C) 1995 by Linus Torvalds
  1061. +#
  1062. +# Adapted from code in arch/i386/boot/Makefile by H. Peter Anvin
  1063. +#
  1064. +# "make install" script for i386 architecture
  1065. +#
  1066. +# Arguments:
  1067. +#   $1 - kernel version
  1068. +#   $2 - kernel image file
  1069. +#   $3 - kernel map file
  1070. +#   $4 - default install path (blank if root directory)
  1071. +#
  1072. +
  1073. +# User may have a custom install script
  1074. +
  1075. +if [ -x /sbin/installkernel ]; then exec /sbin/installkernel "$@"; fi
  1076. +
  1077. +# Default install - same as make zlilo
  1078. +
  1079. +if [ -f $4/vmlinux ]; then
  1080. +    rm $4/vmlinux.$1
  1081. +#    mv $4/vmlinux $4/vmlinux.old
  1082. +fi
  1083. +
  1084. +#if [ -f $4/System.map ]; then
  1085. +#    mv $4/System.map $4/System.old
  1086. +#fi
  1087. +
  1088. +cat $2 > $4/vmlinux.$1
  1089. +#cp $3 $4/System.map
  1090. +
  1091. +if [ -x /sbin/bootmap ]; then /sbin/bootmap /dev/hda1; else echo "You have to install it yourself"; fi
  1092. diff -r -u -N linux.orig/arch/arm/boot/tools/build.c linux.arm/arch/arm/boot/tools/build.c
  1093. --- linux.orig/arch/arm/boot/tools/build.c    Thu Jan  1 01:00:00 1970
  1094. +++ linux.arm/arch/arm/boot/tools/build.c    Fri Oct 27 23:15:25 1995
  1095. @@ -0,0 +1,62 @@
  1096. +#include <stdio.h>
  1097. +#include <stdlib.h>
  1098. +#include <a.out.h>
  1099. +
  1100. +
  1101. +int main(int argc, char **argv)
  1102. +{
  1103. +    void *data;
  1104. +    struct exec ex;
  1105. +    FILE *f, *fo;
  1106. +    int totlen;
  1107. +
  1108. +    if (argc < 2)
  1109. +    {
  1110. +        fprintf(stderr, "Usage: build kernel-name\n");
  1111. +        exit(1);
  1112. +    }
  1113. +
  1114. +    f = fopen(argv[1], "rb");
  1115. +
  1116. +    fread(&ex, 1, sizeof(ex), f);
  1117. +
  1118. +    if(N_MAGIC(ex) == ZMAGIC)
  1119. +    {
  1120. +        fseek(f, 4096, SEEK_SET);
  1121. +        totlen = ex.a_text + ex.a_data + ex.a_bss;
  1122. +    }
  1123. +    else
  1124. +    if(N_MAGIC(ex) == QMAGIC)
  1125. +    {
  1126. +        unsigned long my_header[8];
  1127. +        
  1128. +        fseek(f, 0x20, SEEK_SET);
  1129. +
  1130. +        memset(my_header, 0, 0x20);
  1131. +
  1132. +        my_header[0] = 0xea000006;
  1133. +        
  1134. +        fwrite(my_header, 4, 8, stdout);
  1135. +        
  1136. +        totlen = ex.a_text + ex.a_data + ex.a_bss - 0x20;
  1137. +    }
  1138. +    else
  1139. +    {
  1140. +        fprintf(stderr, "Unacceptable a.out header on kernel\n");
  1141. +        fclose(f);
  1142. +        exit(1);
  1143. +    }
  1144. +
  1145. +    fprintf(stderr, "Kernel is %dk (%dk text, %dk data, %dk bss)\n",
  1146. +        (ex.a_text + ex.a_data + ex.a_bss)/1024,
  1147. +         ex.a_text/1024, ex.a_data/1024, ex.a_bss/1024);
  1148. +
  1149. +    data = malloc(totlen);
  1150. +    fread(data, 1, totlen, f);
  1151. +    fwrite(data, 1, totlen, stdout);
  1152. +
  1153. +    free(data);
  1154. +    fclose(f);
  1155. +    fflush(stdout);
  1156. +    return 0;
  1157. +}
  1158. diff -r -u -N linux.orig/arch/arm/config.in linux.arm/arch/arm/config.in
  1159. --- linux.orig/arch/arm/config.in    Thu Jan  1 01:00:00 1970
  1160. +++ linux.arm/arch/arm/config.in    Fri Oct 27 23:14:02 1995
  1161. @@ -0,0 +1,199 @@
  1162. +#
  1163. +# For a description of the syntax of this configuration file,
  1164. +# see the Configure script.
  1165. +#
  1166. +
  1167. +echo "#define CONFIG_ARM" >> $CONFIG_H
  1168. +echo "#define CONFIG_ARMMOUSE 1" >> $CONFIG_H
  1169. +echo "CONFIG_ARM=1" >> $CONFIG
  1170. +echo "CONFIG_ARMMOUSE=1" >> $CONFIG
  1171. +
  1172. +comment 'General setup'
  1173. +
  1174. +bool 'Page size as 32K' CONFIG_PAGE_32K y
  1175. +if [ "$CONFIG_PAGE_32K" = "n" ]; then
  1176. +  bool 'Page size as 16K' CONFIG_PAGE_16K y
  1177. +  if [ "$CONFIG_PAGE_16K" = "n" ]; then
  1178. +    echo "Auto detected page size"
  1179. +  fi
  1180. +fi
  1181. +bool 'Kernel math emulation' CONFIG_MATH_EMULATION y
  1182. +bool 'Normal floppy disk support' CONFIG_BLK_DEV_FD y
  1183. +bool 'IDE disk/cdrom support' CONFIG_ST506 y
  1184. +if [ "$CONFIG_ST506" = "y" ]; then
  1185. +  comment 'Please see drivers/block/README.ide for help/info on IDE drives'
  1186. +  bool '   Use old disk-only driver for primary i/f' CONFIG_BLK_DEV_HD y
  1187. +  if [ "$CONFIG_BLK_DEV_HD" = "y" ]; then
  1188. +    bool '   Include new IDE driver for secondary i/f support' CONFIG_BLK_DEV_IDE n
  1189. +  else
  1190. +    bool '   Use new IDE driver for primary/secondary i/f' CONFIG_BLK_DEV_IDE y
  1191. +  fi
  1192. +  if [ "$CONFIG_BLK_DEV_IDE" = "y" ]; then
  1193. +    bool '   Include support for IDE/ATAPI CDROMs' CONFIG_BLK_DEV_IDECD n
  1194. +  fi
  1195. +fi
  1196. +
  1197. +bool 'MFM harddisk support' CONFIG_BLK_DEV_XD n
  1198. +bool 'Networking support' CONFIG_NET y
  1199. +bool 'Limit memory to low 16MB' CONFIG_MAX_16M n
  1200. +bool 'System V IPC' CONFIG_SYSVIPC y
  1201. +#bool 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF n
  1202. +
  1203. +comment 'Loadable module support'
  1204. +bool 'Set version information on all symbols for modules' CONFIG_MODVERSIONS n
  1205. +
  1206. +if [ "$CONFIG_NET" = "y" ]; then
  1207. +comment 'Networking options'
  1208. +bool 'TCP/IP networking' CONFIG_INET y
  1209. +if [ "$CONFIG_INET" = "y" ]; then
  1210. +bool 'IP forwarding/gatewaying' CONFIG_IP_FORWARD n
  1211. +bool 'IP multicasting' CONFIG_IP_MULTICAST n
  1212. +bool 'IP firewalling' CONFIG_IP_FIREWALL n
  1213. +bool 'IP accounting' CONFIG_IP_ACCT n
  1214. +comment '(it is safe to leave these untouched)'
  1215. +bool 'PC/TCP compatibility mode' CONFIG_INET_PCTCP n
  1216. +bool 'Reverse ARP' CONFIG_INET_RARP n
  1217. +bool 'Assume subnets are local' CONFIG_INET_SNARL y
  1218. +bool 'Disable NAGLE algorithm (normally enabled)' CONFIG_TCP_NAGLE_OFF n
  1219. +fi
  1220. +bool 'The IPX protocol' CONFIG_IPX n
  1221. +#bool 'Appletalk DDP' CONFIG_ATALK n
  1222. +#bool 'Amateur Radio AX.25 Level 2' CONFIG_AX25 n
  1223. +fi
  1224. +
  1225. +comment 'SCSI support'
  1226. +
  1227. +bool 'SCSI support?' CONFIG_SCSI n
  1228. +
  1229. +if [ "$CONFIG_SCSI" = "n" ]; then
  1230. +
  1231. +comment 'Skipping SCSI configuration options...'
  1232. +
  1233. +else
  1234. +
  1235. +comment 'SCSI support type (disk, tape, CDrom)'
  1236. +
  1237. +bool 'Scsi disk support' CONFIG_BLK_DEV_SD y
  1238. +bool 'Scsi tape support' CONFIG_CHR_DEV_ST n
  1239. +bool 'Scsi CDROM support' CONFIG_BLK_DEV_SR n
  1240. +bool 'Scsi generic support' CONFIG_CHR_DEV_SG n
  1241. +
  1242. +comment 'SCSI low-level drivers'
  1243. +
  1244. +bool 'Acorn SCSI card (aka30) support' CONFIG_SCSI_ACORNSCSI_3 y
  1245. +bool 'Cumana 1 support' CONFIG_SCSI_CUMANA_1 n
  1246. +bool 'EcoScsi support' CONFIG_SCSI_ECOSCSI n
  1247. +bool 'Oak SCSI support' CONFIG_SCSI_OAK n
  1248. +bool 'SCSI debugging host adapter' CONFIG_SCSI_DEBUG n
  1249. +fi
  1250. +
  1251. +
  1252. +if [ "$CONFIG_NET" = "y" ]; then
  1253. +
  1254. +comment 'Network device support'
  1255. +
  1256. +bool 'Network device support?' CONFIG_NETDEVICES y
  1257. +if [ "$CONFIG_NETDEVICES" = "n" ]; then
  1258. +
  1259. +comment 'Skipping network driver configuration options...'
  1260. +
  1261. +else
  1262. +bool 'Dummy net driver support' CONFIG_DUMMY y
  1263. +bool 'SLIP (serial line) support' CONFIG_SLIP y
  1264. +if [ "$CONFIG_SLIP" = "y" ]; then
  1265. +  bool ' CSLIP compressed headers' CONFIG_SLIP_COMPRESSED y
  1266. +  bool ' 16 channels instead of 4' SL_SLIP_LOTS n
  1267. +  bool ' SLIP debugging on' SL_DUMP y
  1268. +fi
  1269. +bool 'PPP (point-to-point) support' CONFIG_PPP y
  1270. +bool 'PLIP (parallel port) support' CONFIG_PLIP y
  1271. +bool 'Ether3 (NQ8005) support' CONFIG_ETHER3 n
  1272. +fi
  1273. +fi
  1274. +
  1275. +#comment 'CD-ROM drivers (not for SCSI or IDE/ATAPI drives)'
  1276. +
  1277. +#bool 'Sony CDU31A/CDU33A CDROM driver support' CONFIG_CDU31A n
  1278. +#bool 'Mitsumi (not IDE/ATAPI) CDROM driver support' CONFIG_MCD n
  1279. +#bool 'Matsushita/Panasonic CDROM driver support' CONFIG_SBPCD n
  1280. +#if [ "$CONFIG_SBPCD" = "y" ]; then
  1281. +#  bool 'Matsushita/Panasonic second CDROM controller support' CONFIG_SBPCD2 n
  1282. +#  if [ "$CONFIG_SBPCD2" = "y" ]; then
  1283. +#    bool 'Matsushita/Panasonic third CDROM controller support' CONFIG_SBPCD3 n
  1284. +#    if [ "$CONFIG_SBPCD3" = "y" ]; then
  1285. +#      bool 'Matsushita/Panasonic fourth CDROM controller support' CONFIG_SBPCD4 n
  1286. +#    fi
  1287. +#  fi
  1288. +#fi
  1289. +#bool 'Aztech/Orchid/Okano/Wearnes (non IDE) CDROM support' CONFIG_AZTCD n
  1290. +#bool 'Sony CDU535 CDROM driver support' CONFIG_CDU535 n
  1291. +
  1292. +comment 'Filesystems'
  1293. +
  1294. +bool 'Standard (minix) fs support' CONFIG_MINIX_FS n
  1295. +bool 'Extended fs support' CONFIG_EXT_FS n
  1296. +bool 'Second extended fs support' CONFIG_EXT2_FS y
  1297. +bool 'xiafs filesystem support' CONFIG_XIA_FS n
  1298. +bool 'msdos fs support' CONFIG_MSDOS_FS y
  1299. +if [ "$CONFIG_MSDOS_FS" = "y" ]; then
  1300. +bool 'umsdos: Unix like fs on top of std MSDOS FAT fs' CONFIG_UMSDOS_FS n
  1301. +fi
  1302. +bool '/proc filesystem support' CONFIG_PROC_FS y
  1303. +if [ "$CONFIG_INET" = "y" ]; then
  1304. +bool 'NFS filesystem support' CONFIG_NFS_FS y
  1305. +fi
  1306. +if [ "$CONFIG_BLK_DEV_SR" = "y" -o "$CONFIG_CDU31A" = "y" -o "$CONFIG_MCD" = "y" -o "$CONFIG_SBPCD" = "y" -o "$CONFIG_BLK_DEV_IDECD" = "y" -o "$CONFIG_AZTCD" = "y" -o "$CONFIG_CDU535" = "y" ]; then
  1307. +    bool 'ISO9660 cdrom filesystem support' CONFIG_ISO9660_FS y
  1308. +else
  1309. +    bool 'ISO9660 cdrom filesystem support' CONFIG_ISO9660_FS n
  1310. +fi
  1311. +#bool 'OS/2 HPFS filesystem support (read only)' CONFIG_HPFS_FS n
  1312. +#bool 'System V and Coherent filesystem support' CONFIG_SYSV_FS n
  1313. +
  1314. +comment 'character devices'
  1315. +
  1316. +#bool 'Cyclades async mux support' CONFIG_CYCLADES n
  1317. +bool 'Parallel printer support' CONFIG_PRINTER y
  1318. +#bool 'Logitech busmouse support' CONFIG_BUSMOUSE n
  1319. +#bool 'PS/2 mouse (aka "auxiliary device") support' CONFIG_PSMOUSE n
  1320. +#if [ "$CONFIG_PSMOUSE" = "y" ]; then
  1321. +#bool 'C&T 82C710 mouse port support (as on TI Travelmate)' CONFIG_82C710_MOUSE y
  1322. +#fi
  1323. +#bool 'Microsoft busmouse support' CONFIG_MS_BUSMOUSE n
  1324. +#bool 'ATIXL busmouse support' CONFIG_ATIXL_BUSMOUSE n
  1325. +
  1326. +
  1327. +#bool 'QIC-02 tape support' CONFIG_QIC02_TAPE n
  1328. +#if [ "$CONFIG_QIC02_TAPE" = "y" ]; then
  1329. +#bool 'Do you want runtime configuration for QIC-02' CONFIG_QIC02_DYNCONF y
  1330. +#if [ "$CONFIG_QIC02_DYNCONF" != "y" ]; then
  1331. +
  1332. +#comment '>>> Edit configuration parameters in ./include/linux/tpqic02.h!'
  1333. +
  1334. +#else
  1335. +
  1336. +#comment '>>> Setting runtime QIC-02 configuration is done with qic02conf'
  1337. +#comment '>>> Which is available from ftp://ftp.funet.fi/pub/OS/Linux/BETA/QIC-02/'
  1338. +
  1339. +#fi
  1340. +#fi
  1341. +
  1342. +#bool 'QIC-117 tape support' CONFIG_FTAPE n
  1343. +#if [ "$CONFIG_FTAPE" = "y" ]; then
  1344. +#int ' number of ftape buffers' NR_FTAPE_BUFFERS 3
  1345. +#fi
  1346. +
  1347. +comment 'Sound'
  1348. +
  1349. +bool 'Sound support' CONFIG_SOUND n
  1350. +
  1351. +comment 'Kernel hacking'
  1352. +
  1353. +#bool 'Debug kmalloc/kfree' CONFIG_DEBUG_MALLOC n
  1354. +bool 'Kernel profiling support' CONFIG_PROFILE n
  1355. +if [ "$CONFIG_PROFILE" = "y" ]; then
  1356. +  int ' Profile shift count' CONFIG_PROFILE_SHIFT 2
  1357. +fi
  1358. +if [ "$CONFIG_SCSI" = "y" ]; then
  1359. +bool 'Verbose scsi error reporting (kernel size +=12K)' CONFIG_SCSI_CONSTANTS y
  1360. +fi
  1361. diff -r -u -N linux.orig/arch/arm/drivers/Makefile linux.arm/arch/arm/drivers/Makefile
  1362. --- linux.orig/arch/arm/drivers/Makefile    Thu Jan  1 01:00:00 1970
  1363. +++ linux.arm/arch/arm/drivers/Makefile    Fri Oct 27 23:14:58 1995
  1364. @@ -0,0 +1,48 @@
  1365. +#
  1366. +# Makefile for the linux kernel device drivers.
  1367. +#
  1368. +# Note! Dependencies are done automagically by 'make dep', which also
  1369. +# removes any old dependencies. DON'T put your own dependencies here
  1370. +# unless it's something special (ie not a .c file).
  1371. +#
  1372. +# Note 2! The CFLAGS definitions are now in the main makefile...
  1373. +
  1374. +.S.s:
  1375. +    $(CPP) -traditional $< -o $*.s
  1376. +.c.s:
  1377. +    $(CC) $(CFLAGS) -S $<
  1378. +.s.o:
  1379. +    $(AS) -c -o $*.o $<
  1380. +.c.o:
  1381. +    $(CC) $(CFLAGS) -c $<
  1382. +
  1383. +SUBDIRS    = block char net #streams
  1384. +
  1385. +ifdef CONFIG_SCSI
  1386. +SUBDIRS := $(SUBDIRS) scsi
  1387. +endif
  1388. +
  1389. +ifdef CONFIG_SOUND
  1390. +SUBDIRS := $(SUBDIRS) sound
  1391. +endif
  1392. +
  1393. +all: driversubdirs
  1394. +
  1395. +driversubdirs: dummy
  1396. +    set -e; for i in $(SUBDIRS); do $(MAKE) -C $$i; done
  1397. +
  1398. +modules: dummy
  1399. +    set -e; for i in $(SUBDIRS); do $(MAKE) -C $$i modules; done
  1400. +
  1401. +dep:
  1402. +    set -e; for i in $(SUBDIRS); do $(MAKE) -C $$i dep; done
  1403. +
  1404. +dummy:
  1405. +
  1406. +#
  1407. +# include a dependency file if one exists
  1408. +#
  1409. +ifeq (.depend,$(wildcard .depend))
  1410. +include .depend
  1411. +endif
  1412. +
  1413. diff -r -u -N linux.orig/arch/arm/drivers/block/Makefile linux.arm/arch/arm/drivers/block/Makefile
  1414. --- linux.orig/arch/arm/drivers/block/Makefile    Thu Jan  1 01:00:00 1970
  1415. +++ linux.arm/arch/arm/drivers/block/Makefile    Fri Oct 27 23:14:45 1995
  1416. @@ -0,0 +1,75 @@
  1417. +#
  1418. +# Makefile for the kernel block device drivers.
  1419. +#
  1420. +# Note! Dependencies are done automagically by 'make dep', which also
  1421. +# removes any old dependencies. DON'T put your own dependencies here
  1422. +# unless it's something special (ie not a .c file).
  1423. +#
  1424. +# Note 2! The CFLAGS definition is now inherited from the
  1425. +# parent makefile.
  1426. +#
  1427. +
  1428. +.c.s:
  1429. +    $(CC) $(CFLAGS) -S $<
  1430. +.s.o:
  1431. +    $(AS) -c -o $*.o $<
  1432. +.c.o:
  1433. +    $(CC) $(CFLAGS) -c $<
  1434. +
  1435. +#
  1436. +# Note : at this point, these files are compiled on all systems. 
  1437. +# In the future, some of these should be built conditionally.
  1438. +#
  1439. +
  1440. +all: block.a
  1441. +
  1442. +OBJS := ll_rw_blk.o ramdisk.o genhd.o hdsrch.o
  1443. +SRCS := ll_rw_blk.c ramdisk.c genhd.c hdsrch.c
  1444. +BLOCK_MODULE_OBJS =
  1445. +
  1446. +ifdef CONFIG_BLK_DEV_FD
  1447. +OBJS := $(OBJS) floppy.o
  1448. +SRCS := $(SRCS) floppy.c
  1449. +endif
  1450. +
  1451. +ifdef CONFIG_BLK_DEV_HD
  1452. +OBJS := $(OBJS) hd.o
  1453. +SRCS := $(SRCS) hd.c
  1454. +endif
  1455. +
  1456. +ifdef CONFIG_BLK_DEV_IDE
  1457. +OBJS := ide.o $(OBJS)
  1458. +SRCS := ide.c $(SRCS)
  1459. +endif
  1460. +
  1461. +ifdef CONFIG_BLK_DEV_MFM
  1462. +OBJS := mfmhd.o $(OBJS)
  1463. +SRCS := mfmhd.c $(OBJS)
  1464. +else
  1465. +BLOCK_MODULE_OBJS := mfm-hd.o
  1466. +
  1467. +mfm-hd.o: mfmhd.o
  1468. +    ld -r -o mfm-hd.o mfmhd.o `gcc --print-libgcc-file-name`
  1469. +
  1470. +endif
  1471. +
  1472. +block.a: $(OBJS)
  1473. +    rm -f block.a
  1474. +    $(AR) rcs block.a $(OBJS)
  1475. +    sync
  1476. +
  1477. +dep:
  1478. +    $(CPP) -M $(SRCS) > .depend
  1479. +
  1480. +modules: $(BLOCK_MODULE_OBJS)
  1481. +    echo $(BLOCK_MODULE_OBJS) > ../../../../modules/BLOCK_MODULES
  1482. +    (cd ../../../../modules;for i in $(BLOCK_MODULE_OBJS); do ln -sf ../arch/arm/drivers/block/$$i .; done)
  1483. +
  1484. +dummy:
  1485. +
  1486. +#
  1487. +# include a dependency file if one exists
  1488. +#
  1489. +ifeq (.depend,$(wildcard .depend))
  1490. +include .depend
  1491. +endif
  1492. diff -r -u -N linux.orig/arch/arm/drivers/block/blk.h linux.arm/arch/arm/drivers/block/blk.h
  1493. --- linux.orig/arch/arm/drivers/block/blk.h    Thu Jan  1 01:00:00 1970
  1494. +++ linux.arm/arch/arm/drivers/block/blk.h    Fri Oct 27 23:14:45 1995
  1495. @@ -0,0 +1,295 @@
  1496. +#ifndef _BLK_H
  1497. +#define _BLK_H
  1498. +
  1499. +#include <linux/blkdev.h>
  1500. +#include <linux/locks.h>
  1501. +#include <linux/config.h>
  1502. +
  1503. +/*
  1504. + * NR_REQUEST is the number of entries in the request-queue.
  1505. + * NOTE that writes may use only the low 2/3 of these: reads
  1506. + * take precedence.
  1507. + *
  1508. + * 32 seems to be a reasonable number: enough to get some benefit
  1509. + * from the elevator-mechanism, but not so much as to lock a lot of
  1510. + * buffers when they are in the queue. 64 seems to be too many (easily
  1511. + * long pauses in reading when heavy writing/syncing is going on)
  1512. + */
  1513. +#define NR_REQUEST    64
  1514. +
  1515. +/*
  1516. + * This is used in the elevator algorithm: Note that
  1517. + * reads always go before writes. This is natural: reads
  1518. + * are much more time-critical than writes.
  1519. + */
  1520. +#define IN_ORDER(s1,s2) \
  1521. +((s1)->cmd < (s2)->cmd || ((s1)->cmd == (s2)->cmd && \
  1522. +((s1)->dev < (s2)->dev || (((s1)->dev == (s2)->dev && \
  1523. +(s1)->sector < (s2)->sector)))))
  1524. +
  1525. +/*
  1526. + * These will have to be changed to be aware of different buffer
  1527. + * sizes etc.. It actually needs a major cleanup.
  1528. + */
  1529. +#define SECTOR_MASK (blksize_size[MAJOR_NR] &&     \
  1530. +    blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] ? \
  1531. +    ((blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] >> 9) - 1) :  \
  1532. +    ((BLOCK_SIZE >> 9)  -  1))
  1533. +
  1534. +#define SUBSECTOR(block) (CURRENT->current_nr_sectors > 0)
  1535. +
  1536. +extern unsigned long hd_init(unsigned long mem_start, unsigned long mem_end);
  1537. +extern unsigned long cdu31a_init(unsigned long mem_start, unsigned long mem_end);
  1538. +extern unsigned long mcd_init(unsigned long mem_start, unsigned long mem_end);
  1539. +#ifdef CONFIG_SBPCD
  1540. +extern unsigned long sbpcd_init(unsigned long, unsigned long);
  1541. +#endif /* CONFIG_SBPCD */
  1542. +extern void set_device_ro(int dev,int flag);
  1543. +
  1544. +extern void rd_load(void);
  1545. +extern long rd_init(long mem_start, int length);
  1546. +extern int ramdisk_size;
  1547. +
  1548. +extern unsigned long xd_init(unsigned long mem_start, unsigned long mem_end);
  1549. +
  1550. +#define RO_IOCTLS(dev,where) \
  1551. +  case BLKROSET: if (!suser()) return -EACCES; \
  1552. +         set_device_ro((dev),get_fs_long((long *) (where))); return 0; \
  1553. +  case BLKROGET: { int __err = verify_area(VERIFY_WRITE, (void *) (where), sizeof(long)); \
  1554. +           if (!__err) put_fs_long(0!=is_read_only(dev),(long *) (where)); return __err; }
  1555. +
  1556. +#ifdef MAJOR_NR
  1557. +
  1558. +/*
  1559. + * Add entries as needed. Currently the only block devices
  1560. + * supported are hard-disks and floppies.
  1561. + */
  1562. +
  1563. +#if (MAJOR_NR == MEM_MAJOR)
  1564. +
  1565. +/* ram disk */
  1566. +#define DEVICE_NAME "ramdisk"
  1567. +#define DEVICE_REQUEST do_rd_request
  1568. +#define DEVICE_NR(device) ((device) & 7)
  1569. +#define DEVICE_ON(device)
  1570. +#define DEVICE_OFF(device)
  1571. +
  1572. +#elif (MAJOR_NR == FLOPPY_MAJOR)
  1573. +
  1574. +static void floppy_off(unsigned int nr);
  1575. +
  1576. +#define DEVICE_NAME "floppy"
  1577. +#define DEVICE_INTR do_floppy
  1578. +#define DEVICE_REQUEST do_fd_request
  1579. +#define DEVICE_NR(device) ( ((device) & 3) | (((device) & 0x80 ) >> 5 ))
  1580. +#define DEVICE_ON(device)
  1581. +#define DEVICE_OFF(device) floppy_off(DEVICE_NR(device))
  1582. +
  1583. +#elif (MAJOR_NR == HD_MAJOR)
  1584. +
  1585. +/* harddisk: timeout is 6 seconds.. */
  1586. +#define DEVICE_NAME "harddisk"
  1587. +#define DEVICE_INTR do_hd
  1588. +#define DEVICE_TIMEOUT HD_TIMER
  1589. +#define TIMEOUT_VALUE 600
  1590. +#define DEVICE_REQUEST do_hd_request
  1591. +#define DEVICE_NR(device) (MINOR(device)>>6)
  1592. +#define DEVICE_ON(device)
  1593. +#define DEVICE_OFF(device)
  1594. +
  1595. +#elif (MAJOR_NR == SCSI_DISK_MAJOR)
  1596. +
  1597. +#define DEVICE_NAME "scsidisk"
  1598. +#define DEVICE_INTR do_sd
  1599. +#define TIMEOUT_VALUE 200
  1600. +#define DEVICE_REQUEST do_sd_request
  1601. +#define DEVICE_NR(device) (MINOR(device) >> 4)
  1602. +#define DEVICE_ON(device)
  1603. +#define DEVICE_OFF(device)
  1604. +
  1605. +#elif (MAJOR_NR == SCSI_TAPE_MAJOR)
  1606. +
  1607. +#define DEVICE_NAME "scsitape"
  1608. +#define DEVICE_INTR do_st
  1609. +#define DEVICE_NR(device) (MINOR(device))
  1610. +#define DEVICE_ON(device)
  1611. +#define DEVICE_OFF(device)
  1612. +
  1613. +#elif (MAJOR_NR == SCSI_CDROM_MAJOR)
  1614. +
  1615. +#define DEVICE_NAME "CD-ROM"
  1616. +#define DEVICE_INTR do_sr
  1617. +#define DEVICE_REQUEST do_sr_request
  1618. +#define DEVICE_NR(device) (MINOR(device))
  1619. +#define DEVICE_ON(device)
  1620. +#define DEVICE_OFF(device)
  1621. +
  1622. +#elif (MAJOR_NR == XT_DISK_MAJOR)
  1623. +
  1624. +#define DEVICE_NAME "xt disk"
  1625. +#define DEVICE_REQUEST do_xd_request
  1626. +#define DEVICE_NR(device) (MINOR(device) >> 6)
  1627. +#define DEVICE_ON(device)
  1628. +#define DEVICE_OFF(device)
  1629. +
  1630. +#elif defined(MFM_DISK_MAJOR) && (MAJOR_NR == MFM_DISK_MAJOR)
  1631. +
  1632. +#define DEVICE_NAME "mfm disk"
  1633. +#define DEVICE_INTR do_mfm
  1634. +#define DEVICE_REQUEST do_mfm_request
  1635. +#define DEVICE_NR(device) (MINOR(device) >> 6)
  1636. +#define DEVICE_ON(device)
  1637. +#define DEVICE_OFF(device)
  1638. +
  1639. +#elif (MAJOR_NR == CDU31A_CDROM_MAJOR)
  1640. +
  1641. +#define DEVICE_NAME "CDU31A"
  1642. +#define DEVICE_REQUEST do_cdu31a_request
  1643. +#define DEVICE_NR(device) (MINOR(device))
  1644. +#define DEVICE_ON(device)
  1645. +#define DEVICE_OFF(device)
  1646. +
  1647. +#elif (MAJOR_NR == MITSUMI_CDROM_MAJOR)
  1648. +
  1649. +#define DEVICE_NAME "Mitsumi CD-ROM"
  1650. +/* #define DEVICE_INTR do_mcd */
  1651. +#define DEVICE_REQUEST do_mcd_request
  1652. +#define DEVICE_NR(device) (MINOR(device))
  1653. +#define DEVICE_ON(device)
  1654. +#define DEVICE_OFF(device)
  1655. +
  1656. +#elif (MAJOR_NR == MATSUSHITA_CDROM_MAJOR)
  1657. +
  1658. +#define DEVICE_NAME "Matsushita CD-ROM controller #1"
  1659. +#define DEVICE_REQUEST do_sbpcd_request
  1660. +#define DEVICE_NR(device) (MINOR(device))
  1661. +#define DEVICE_ON(device)
  1662. +#define DEVICE_OFF(device)
  1663. +
  1664. +#elif (MAJOR_NR == MATSUSHITA_CDROM2_MAJOR)
  1665. +
  1666. +#define DEVICE_NAME "Matsushita CD-ROM controller #2"
  1667. +#define DEVICE_REQUEST do_sbpcd2_request
  1668. +#define DEVICE_NR(device) (MINOR(device))
  1669. +#define DEVICE_ON(device)
  1670. +#define DEVICE_OFF(device)
  1671. +
  1672. +#elif (MAJOR_NR == MATSUSHITA_CDROM3_MAJOR)
  1673. +
  1674. +#define DEVICE_NAME "Matsushita CD-ROM controller #3"
  1675. +#define DEVICE_REQUEST do_sbpcd3_request
  1676. +#define DEVICE_NR(device) (MINOR(device))
  1677. +#define DEVICE_ON(device)
  1678. +#define DEVICE_OFF(device)
  1679. +
  1680. +#elif (MAJOR_NR == MATSUSHITA_CDROM4_MAJOR)
  1681. +
  1682. +#define DEVICE_NAME "Matsushita CD-ROM controller #4"
  1683. +#define DEVICE_REQUEST do_sbpcd4_request
  1684. +#define DEVICE_NR(device) (MINOR(device))
  1685. +#define DEVICE_ON(device)
  1686. +#define DEVICE_OFF(device)
  1687. +
  1688. +#endif
  1689. +
  1690. +#if (MAJOR_NR != SCSI_TAPE_MAJOR)
  1691. +
  1692. +#ifndef CURRENT
  1693. +#define CURRENT (blk_dev[MAJOR_NR].current_request)
  1694. +#endif
  1695. +
  1696. +#define CURRENT_DEV DEVICE_NR(CURRENT->dev)
  1697. +
  1698. +#ifdef DEVICE_INTR
  1699. +void (*DEVICE_INTR)(void) = NULL;
  1700. +#endif
  1701. +#ifdef DEVICE_TIMEOUT
  1702. +
  1703. +#define SET_TIMER \
  1704. +((timer_table[DEVICE_TIMEOUT].expires = jiffies + TIMEOUT_VALUE), \
  1705. +(timer_active |= 1<<DEVICE_TIMEOUT))
  1706. +
  1707. +#define CLEAR_TIMER \
  1708. +timer_active &= ~(1<<DEVICE_TIMEOUT)
  1709. +
  1710. +#define SET_INTR(x) \
  1711. +if ((DEVICE_INTR = (x)) != NULL) \
  1712. +    SET_TIMER; \
  1713. +else \
  1714. +    CLEAR_TIMER;
  1715. +
  1716. +#else
  1717. +
  1718. +#define SET_INTR(x) (DEVICE_INTR = (x))
  1719. +
  1720. +#endif
  1721. +static void (DEVICE_REQUEST)(void);
  1722. +
  1723. +/* end_request() - SCSI devices have their own version */
  1724. +
  1725. +#if ! SCSI_MAJOR(MAJOR_NR)
  1726. +
  1727. +static void end_request(int uptodate)
  1728. +{
  1729. +    struct request * req;
  1730. +    struct buffer_head * bh;
  1731. +
  1732. +    req = CURRENT;
  1733. +    req->errors = 0;
  1734. +    if (!uptodate) {
  1735. +        printk(DEVICE_NAME " I/O error\n");
  1736. +        printk("dev %04lX, sector %lu\n",
  1737. +               (unsigned long)req->dev, req->sector);
  1738. +        req->nr_sectors--;
  1739. +        req->nr_sectors &= ~SECTOR_MASK;
  1740. +        req->sector += (BLOCK_SIZE / 512);
  1741. +        req->sector &= ~SECTOR_MASK;
  1742. +    }
  1743. +
  1744. +    if ((bh = req->bh) != NULL) {
  1745. +        req->bh = bh->b_reqnext;
  1746. +        bh->b_reqnext = NULL;
  1747. +        bh->b_uptodate = uptodate;
  1748. +        if (!uptodate) bh->b_req = 0; /* So no "Weird" errors */
  1749. +        unlock_buffer(bh);
  1750. +        if ((bh = req->bh) != NULL) {
  1751. +            req->current_nr_sectors = bh->b_size >> 9;
  1752. +            if (req->nr_sectors < req->current_nr_sectors) {
  1753. +                req->nr_sectors = req->current_nr_sectors;
  1754. +                printk("end_request: buffer-list destroyed\n");
  1755. +            }
  1756. +            req->buffer = bh->b_data;
  1757. +            return;
  1758. +        }
  1759. +    }
  1760. +    DEVICE_OFF(req->dev);
  1761. +    CURRENT = req->next;
  1762. +    if (req->sem != NULL)
  1763. +        up(req->sem);
  1764. +    req->dev = -1;
  1765. +    wake_up(&wait_for_request);
  1766. +}
  1767. +#endif
  1768. +
  1769. +#ifdef DEVICE_INTR
  1770. +#define CLEAR_INTR SET_INTR(NULL)
  1771. +#else
  1772. +#define CLEAR_INTR
  1773. +#endif
  1774. +
  1775. +#define INIT_REQUEST \
  1776. +    if (!CURRENT) {\
  1777. +        CLEAR_INTR; \
  1778. +        return; \
  1779. +    } \
  1780. +    if (MAJOR(CURRENT->dev) != MAJOR_NR) \
  1781. +        panic(DEVICE_NAME ": request list destroyed"); \
  1782. +    if (CURRENT->bh) { \
  1783. +        if (!CURRENT->bh->b_lock) \
  1784. +            panic(DEVICE_NAME ": block not locked"); \
  1785. +    }
  1786. +
  1787. +#endif
  1788. +
  1789. +#endif
  1790. +#endif
  1791. diff -r -u -N linux.orig/arch/arm/drivers/block/floppy.c linux.arm/arch/arm/drivers/block/floppy.c
  1792. --- linux.orig/arch/arm/drivers/block/floppy.c    Thu Jan  1 01:00:00 1970
  1793. +++ linux.arm/arch/arm/drivers/block/floppy.c    Fri Oct 27 23:14:43 1995
  1794. @@ -0,0 +1,3227 @@
  1795. +/*
  1796. + *  linux/kernel/floppy.c
  1797. + *
  1798. + *  Copyright (C) 1991, 1992  Linus Torvalds
  1799. + *  Copyright (C) 1993, 1994  Alain Knaff
  1800. + */
  1801. +
  1802. +/* Configuration */
  1803. +/* The following does some extra sanity checks */
  1804. +#define SANITY
  1805. +
  1806. +/* the following is the mask of allowed drives. By default units 2 and
  1807. + * 3 of both floppy controllers are disabled, because switching on the
  1808. + * motor of these drives causes system hangs on some PCI computers. drive
  1809. + * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
  1810. + * a drive is allowed. */
  1811. +#define ALLOWED_DRIVE_MASK 0x0F
  1812. +
  1813. +/* Undefine the following if you have to floppy disk controllers:
  1814. + * This works at least for me; if you get two controllers working, with
  1815. + * drives attached to both, please mail me: Alain.Knaff@imag.fr */
  1816. +/* #define HAVE_2_CONTROLLERS */
  1817. +
  1818. +
  1819. +/* Define the following if you don't like that your drives seek audibly
  1820. + * after a disk change (but it may not work correctly for everybody)
  1821. + */
  1822. +#define SILENT_DC_CLEAR
  1823. +
  1824. +
  1825. +/* End of configuration */
  1826. +
  1827. +/*
  1828. + * 02.12.91 - Changed to static variables to indicate need for reset
  1829. + * and recalibrate. This makes some things easier (output_byte reset
  1830. + * checking etc), and means less interrupt jumping in case of errors,
  1831. + * so the code is hopefully easier to understand.
  1832. + */
  1833. +
  1834. +/*
  1835. + * This file is certainly a mess. I've tried my best to get it working,
  1836. + * but I don't like programming floppies, and I have only one anyway.
  1837. + * Urgel. I should check for more errors, and do more graceful error
  1838. + * recovery. Seems there are problems with several drives. I've tried to
  1839. + * correct them. No promises.
  1840. + */
  1841. +
  1842. +/*
  1843. + * As with hd.c, all routines within this file can (and will) be called
  1844. + * by interrupts, so extreme caution is needed. A hardware interrupt
  1845. + * handler may not sleep, or a kernel panic will happen. Thus I cannot
  1846. + * call "floppy-on" directly, but have to set a special timer interrupt
  1847. + * etc.
  1848. + */
  1849. +
  1850. +/*
  1851. + * 28.02.92 - made track-buffering routines, based on the routines written
  1852. + * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
  1853. + */
  1854. +
  1855. +/*
  1856. + * Automatic floppy-detection and formatting written by Werner Almesberger
  1857. + * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
  1858. + * the floppy-change signal detection.
  1859. + */
  1860. +
  1861. +/*
  1862. + * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
  1863. + * FDC data overrun bug, added some preliminary stuff for vertical
  1864. + * recording support.
  1865. + *
  1866. + * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
  1867. + *
  1868. + * TODO: Errors are still not counted properly.
  1869. + */
  1870. +
  1871. +/* 1992/9/20
  1872. + * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
  1873. + * modelled after the freeware MS/DOS program fdformat/88 V1.8 by
  1874. + * Christoph H. Hochst\"atter.
  1875. + * I have fixed the shift values to the ones I always use. Maybe a new
  1876. + * ioctl() should be created to be able to modify them.
  1877. + * There is a bug in the driver that makes it impossible to format a
  1878. + * floppy as the first thing after bootup.
  1879. + */
  1880. +
  1881. +/*
  1882. + * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
  1883. + * this helped the floppy driver as well. Much cleaner, and still seems to
  1884. + * work.
  1885. + */
  1886. +
  1887. +/* 1994/6/24 --bbroad-- added the floppy table entries and made
  1888. + * minor modifications to allow 2.88 floppies to be run.
  1889. + */
  1890. +
  1891. +/* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
  1892. + * disk types.
  1893. + */
  1894. +
  1895. +/*
  1896. + * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
  1897. + * format bug fixes, but unfortunately some new bugs too...
  1898. + */
  1899. +
  1900. +/* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
  1901. + * errors to allow safe writing by specialized programs.
  1902. + */
  1903. +int no_floppies;
  1904. +#define FLOPPY_IRQ 12
  1905. +#define FLOPPY_DMA 2
  1906. +#define DEBUGT 2
  1907. +
  1908. +#include <linux/config.h>
  1909. +#include <linux/sched.h>
  1910. +#include <linux/fs.h>
  1911. +#include <linux/kernel.h>
  1912. +#include <linux/timer.h>
  1913. +#include <linux/tqueue.h>
  1914. +#define FDPATCHES
  1915. +#include <linux/fdreg.h>
  1916. +#include <linux/fd.h>
  1917. +#include <linux/errno.h>
  1918. +#include <linux/malloc.h>
  1919. +#include <linux/string.h>
  1920. +#include <linux/fcntl.h>
  1921. +#include <linux/delay.h>
  1922. +
  1923. +#include <asm/dma.h>
  1924. +#include <asm/irq.h>
  1925. +#include <asm/system.h>
  1926. +#include <asm/io.h>
  1927. +#include <asm/segment.h>
  1928. +
  1929. +#define MAJOR_NR FLOPPY_MAJOR
  1930. +#include "blk.h"
  1931. +
  1932. +static unsigned int changed_floppies = 0xff, fake_change = 0;
  1933. +static int initialising=1;
  1934. +
  1935. +#ifdef HAVE_2_CONTROLLERS
  1936. +#define N_FDC 2
  1937. +#define N_DRIVE 8
  1938. +#else
  1939. +#define N_FDC 1
  1940. +#define N_DRIVE 4
  1941. +#endif
  1942. +
  1943. +#define TYPE(x) ( ((x)>>2) & 0x1f )
  1944. +#define DRIVE(x) ( ((x)&0x03) | (((x)&0x80 ) >> 5))
  1945. +#define UNIT(x) ( (x) & 0x03 )        /* drive on fdc */
  1946. +#define FDC(x) ( ((x) & 0x04) >> 2 )  /* fdc of drive */
  1947. +#define REVDRIVE(fdc, unit) ( (unit) + ((fdc) << 2 ))
  1948. +                /* reverse mapping from unit and fdc to drive */
  1949. +#define DP (&drive_params[current_drive])
  1950. +#define DRS (&drive_state[current_drive])
  1951. +#define DRWE (&write_errors[current_drive])
  1952. +#define FDCS (&fdc_state[fdc])
  1953. +
  1954. +#define UDP (&drive_params[drive])
  1955. +#define UDRS (&drive_state[drive])
  1956. +#define UDRWE (&write_errors[drive])
  1957. +#define UFDCS (&fdc_state[FDC(drive)])
  1958. +
  1959. +#define DPRINT(x) printk(DEVICE_NAME "%d: " x,current_drive);
  1960. +
  1961. +#define DPRINT1(x,x1) \
  1962. +printk(DEVICE_NAME "%d: " x,current_drive,(x1));
  1963. +
  1964. +#define DPRINT2(x,x1,x2) \
  1965. +printk(DEVICE_NAME "%d: " x,current_drive,(x1),(x2));
  1966. +
  1967. +#define DPRINT3(x,x1,x2,x3) \
  1968. +printk(DEVICE_NAME "%d: " x,current_drive,(x1),(x2),(x3));
  1969. +
  1970. +/* read/write */
  1971. +#define COMMAND raw_cmd.cmd[0]
  1972. +#define DR_SELECT raw_cmd.cmd[1]
  1973. +#define TRACK raw_cmd.cmd[2]
  1974. +#define HEAD raw_cmd.cmd[3]
  1975. +#define SECTOR raw_cmd.cmd[4]
  1976. +#define SIZECODE raw_cmd.cmd[5]
  1977. +#define SECT_PER_TRACK raw_cmd.cmd[6]
  1978. +#define GAP raw_cmd.cmd[7]
  1979. +#define SIZECODE2 raw_cmd.cmd[8]
  1980. +#define NR_RW 9
  1981. +
  1982. +/* format */
  1983. +#define F_SIZECODE raw_cmd.cmd[2]
  1984. +#define F_SECT_PER_TRACK raw_cmd.cmd[3]
  1985. +#define F_GAP raw_cmd.cmd[4]
  1986. +#define F_FILL raw_cmd.cmd[5]
  1987. +#define NR_F 6
  1988. +
  1989. +/*
  1990. + * Maximum disk size (in kilobytes). This default is used whenever the
  1991. + * current disk size is unknown.
  1992. + */
  1993. +#define MAX_DISK_SIZE 3984
  1994. +
  1995. +
  1996. +
  1997. +/*
  1998. + * The DMA channel used by the floppy controller cannot access data at
  1999. + * addresses >= 16MB
  2000. + *
  2001. + * Went back to the 1MB limit, as some people had problems with the floppy
  2002. + * driver otherwise. It doesn't matter much for performance anyway, as most
  2003. + * floppy accesses go through the track buffer.
  2004. + */
  2005. +#if 0
  2006. +#define LAST_DMA_ADDR    (0x1000000)
  2007. +#else
  2008. +/* Everything has to go via dma buffer */
  2009. +#define LAST_DMA_ADDR    (0x1)
  2010. +#endif
  2011. +#define K_64 (0x10000) /* 64 k */
  2012. +/*
  2013. + * globals used by 'result()'
  2014. + */
  2015. +#define MAX_REPLIES 10
  2016. +static unsigned char reply_buffer[MAX_REPLIES];
  2017. +static int inr; /* size of reply buffer, when called from interrupt */
  2018. +#define ST0 (reply_buffer[0])
  2019. +#define ST1 (reply_buffer[1])
  2020. +#define ST2 (reply_buffer[2])
  2021. +#define ST3 (reply_buffer[0]) /* result of GETSTATUS */
  2022. +#define R_TRACK (reply_buffer[3])
  2023. +#define R_HEAD (reply_buffer[4])
  2024. +#define R_SECTOR (reply_buffer[5])
  2025. +#define R_SIZECODE (reply_buffer[6])
  2026. +
  2027. +/*
  2028. + * this struct defines the different floppy drive types.
  2029. + */
  2030. +static struct {
  2031. +    struct floppy_drive_params params;
  2032. +    char *name; /* name printed while booting */
  2033. +} default_drive_params[]= {
  2034. +/* NOTE: the time values in jiffies should be in msec!
  2035. + CMOS drive type
  2036. +  |     Maximum data rate supported by drive type
  2037. +  |     |   Head load time, msec
  2038. +  |     |   |   Head unload time, msec (not used)
  2039. +  |     |   |   |     Step rate interval, usec
  2040. +  |     |   |   |     |    Time needed for spinup time (jiffies)
  2041. +  |     |   |   |     |    |    Timeout for spinning down (jiffies)
  2042. +  |     |   |   |     |    |    |   Spindown offset (where disk stops)
  2043. +  |     |   |   |     |    |    |   |  Select delay
  2044. +  |     |   |   |     |    |    |   |  |  RPS
  2045. +  |     |   |   |     |    |    |   |  |  |    Max number of tracks
  2046. +  |     |   |   |     |    |    |   |  |  |    |     Interrupt timeout
  2047. +  |     |   |   |     |    |    |   |  |  |    |     |   Max nonintlv. sectors
  2048. +  |     |   |   |     |    |    |   |  |  |    |     |   | -Max Errors- flags */
  2049. +{{0,  500, 16, 16, 8000, 100, 300,  0, 2, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
  2050. +      0, { 7, 4, 8, 2, 1, 5, 3,10}, 150, 0 }, "unknown" },
  2051. +
  2052. +{{1,  300, 16, 16, 8000, 100, 300,  0, 2, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
  2053. +      0, { 1, 0, 0, 0, 0, 0, 0, 0}, 150, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
  2054. +
  2055. +{{2,  500, 16, 16, 6000,  40, 300, 14, 2, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
  2056. +      0, { 2, 5, 6,23,10,20,11, 0}, 150, 2 }, "1.2M" }, /*5 1/4 HD AT*/
  2057. +
  2058. +{{3,  250, 16, 16, 3000, 100, 300,  0, 2, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  2059. +      0, { 4,22,21,30, 3, 0, 0, 0}, 150, 4 }, "720k" }, /*3 1/2 DD*/
  2060. +
  2061. +#if 0
  2062. +{{4,  500, 16, 16, 4000,  40, 300, 10, 2, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  2063. +      0, { 7, 4,25,22,31,21,29,11}, 150, 7 }, "1.44M" }, /*3 1/2 HD*/
  2064. +#else
  2065. +{{4,  500, 16, 16, 3000,  40, 300, 10, 2, 5,  83, 3*HZ, 20, {3,1,2,0,0}, FTD_MSG,
  2066. +      0, { 7, 4,25,22,31,21,29,11}, 150, 7 }, "1.44M" }, /*3 1/2 HD*/
  2067. +#endif
  2068. +
  2069. +{{5, 1000, 15,  8, 3000,  40, 300, 10, 2, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  2070. +      0, { 7, 8, 4,25,28,22,31,21}, 150, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
  2071. +
  2072. +{{6, 1000, 15,  8, 3000,  40, 300, 10, 2, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  2073. +      0, { 7, 8, 4,25,28,22,31,21}, 150, 8 }, "2.88M" } /*3 1/2 ED*/
  2074. +/*    |  ---autodetected formats--   |   |      |
  2075. +      read_track                     |   |    Name printed when booting
  2076. +                                     |  Native format
  2077. +                                   Frequency of disk change checks */
  2078. +};
  2079. +
  2080. +static struct floppy_drive_params drive_params[N_DRIVE];
  2081. +static struct floppy_drive_struct volatile drive_state[N_DRIVE];
  2082. +static struct floppy_write_errors volatile write_errors[N_DRIVE];
  2083. +static struct floppy_raw_cmd raw_cmd;
  2084. +
  2085. +/*
  2086. + * This struct defines the different floppy types.
  2087. + *
  2088. + * The 'stretch' tells if the tracks need to be doubled for some
  2089. + * types (ie 360kB diskette in 1.2MB drive etc). Others should
  2090. + * be self-explanatory.
  2091. + */
  2092. +/*
  2093. +             Size
  2094. +             |  Sectors per track
  2095. +             |  | Head
  2096. +             |  | |  Tracks
  2097. +             |  | |  | Stretch
  2098. +             |  | |  | |  Gap 1 size
  2099. +             |  | |  | |    |  Data rate, | 0x40 for perp
  2100. +         |  | |  | |    |    |  Spec1 (stepping rate, head unload
  2101. +             |  | |  | |    |    |    |    /fmt gap (gap2) */
  2102. +static struct floppy_struct floppy_type[32] = {
  2103. +    {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL    },    /*  0 no testing    */
  2104. +    {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360"  }, /*  1 360KB PC      */
  2105. +    { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" },    /*  2 1.2MB AT      */
  2106. +    {  720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360"  },    /*  3 360KB SS 3.5" */
  2107. +    { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720"  },    /*  4 720KB 3.5"    */
  2108. +    {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360"  },    /*  5 360KB AT      */
  2109. +    { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720"  },    /*  6 720KB AT      */
  2110. +    { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" },    /*  7 1.44MB 3.5"   */
  2111. +    { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" },    /*  8 2.88MB 3.5"   */
  2112. +    { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"CompaQ"},    /*  9 2.88MB 3.5"   */
  2113. +
  2114. +    { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25"  */
  2115. +    { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5"   */
  2116. +    {  820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410"  },    /* 12 410KB 5.25"   */
  2117. +    { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820"  },    /* 13 820KB 3.5"    */
  2118. +    { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" },    /* 14 1.48MB 5.25"  */
  2119. +    { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" },    /* 15 1.72MB 3.5"   */
  2120. +    {  840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420"  },    /* 16 420KB 5.25"   */
  2121. +    { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830"  },    /* 17 830KB 3.5"    */
  2122. +    { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" },    /* 18 1.49MB 5.25"  */
  2123. +    { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5"  */
  2124. +
  2125. +    { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880"  }, /* 20 880KB 5.25"   */
  2126. +    { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5"   */
  2127. +    { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5"   */
  2128. +    { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25"   */
  2129. +    { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5"   */
  2130. +    { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5"   */
  2131. +    { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5"   */
  2132. +    { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5"   */
  2133. +    { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5"   */
  2134. +
  2135. +    { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5"   */
  2136. +    { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800"  },    /* 30 800KB 3.5"    */
  2137. +    { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5"    */
  2138. +};
  2139. +
  2140. +#define    NUMBER(x)    (sizeof(x) / sizeof(*(x)))
  2141. +#define SECTSIZE ( _FD_SECTSIZE(*floppy))
  2142. +
  2143. +/* Auto-detection: Disk type used until the next media change occurs. */
  2144. +struct floppy_struct *current_type[N_DRIVE] = {
  2145. +    NULL, NULL, NULL, NULL
  2146. +#ifdef HAVE_2_CONTROLLERS
  2147. +    ,
  2148. +    NULL, NULL, NULL, NULL
  2149. +#endif
  2150. +};
  2151. +
  2152. +/*
  2153. + * User-provided type information. current_type points to
  2154. + * the respective entry of this array.
  2155. + */
  2156. +struct floppy_struct user_params[N_DRIVE];
  2157. +
  2158. +static int floppy_sizes[256];
  2159. +
  2160. +/*
  2161. + * The driver is trying to determine the correct media format
  2162. + * while probing is set. rw_interrupt() clears it after a
  2163. + * successful access.
  2164. + */
  2165. +static int probing = 0;
  2166. +
  2167. +/* Synchronization of FDC access. */
  2168. +#define FD_COMMAND_DETECT -2
  2169. +#define FD_COMMAND_NONE -1
  2170. +#define FD_COMMAND_ERROR 2
  2171. +#define FD_COMMAND_OKAY 3
  2172. +
  2173. +static volatile int command_status = FD_COMMAND_NONE, fdc_busy = 0;
  2174. +static struct wait_queue *fdc_wait = NULL, *command_done = NULL;
  2175. +#define NO_SIGNAL (!(current->signal & ~current->blocked) || !interruptible)
  2176. +#define CALL(x) if( (x) == -EINTR) return -EINTR;
  2177. +
  2178. +/* Errors during formatting are counted here. */
  2179. +static int format_errors;
  2180. +
  2181. +/* Format request descriptor. */
  2182. +static struct format_descr format_req;
  2183. +
  2184. +/*
  2185. + * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
  2186. + * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
  2187. + * H is head unload time (1=16ms, 2=32ms, etc)
  2188. + */
  2189. +
  2190. +/*
  2191. + * Track buffer
  2192. + * Because these are written to by the DMA controller, they must
  2193. + * not contain a 64k byte boundary crossing, or data will be
  2194. + * corrupted/lost. Alignment of these is enforced in boot/head.S.
  2195. + * Note that you must not change the sizes below without updating head.S.
  2196. + */
  2197. +#if 0
  2198. +extern char floppy_track_buffer[512*2*MAX_BUFFER_SECTORS];
  2199. +#else
  2200. +char floppy_track_buffer[512*2*MAX_BUFFER_SECTORS];
  2201. +#endif
  2202. +#define max_buffer_sectors MAX_BUFFER_SECTORS
  2203. +
  2204. +int *errors;
  2205. +typedef void (*done_f)(int);
  2206. +struct cont_t {
  2207. +void (*interrupt)(void); /* this is called after the interrupt of the
  2208. +              * main command */
  2209. +void (*redo)(void); /* this is called to retry the operation */
  2210. +void (*error)(void); /* this is called to tally an error */
  2211. +done_f done; /* this is called to say if the operation has succeeded/failed */
  2212. +} *cont;
  2213. +
  2214. +static void floppy_start(void);
  2215. +static void redo_fd_request(void);
  2216. +static void recalibrate_floppy(void);
  2217. +static void seek_floppy(void);
  2218. +static void floppy_shutdown(void);
  2219. +
  2220. +static int floppy_grab_irq_and_dma(void);
  2221. +static void floppy_release_irq_and_dma(void);
  2222. +
  2223. +/*
  2224. + * The "reset" variable should be tested whenever an interrupt is scheduled,
  2225. + * after the commands have been sent. This is to ensure that the driver doesn't
  2226. + * get wedged when the interrupt doesn't come because of a failed command.
  2227. + * reset doesn't need to be tested before sending commands, because
  2228. + * output_byte is automatically disabled when reset is set.
  2229. + */
  2230. +#define CHECK_RESET { if ( FDCS->reset ){ reset_fdc(); return ; } }
  2231. +static void reset_fdc(void);
  2232. +
  2233. +/*
  2234. + * These are global variables, as that's the easiest way to give
  2235. + * information to interrupts. They are the data used for the current
  2236. + * request.
  2237. + */
  2238. +#define NO_TRACK -1
  2239. +#define NEED_1_RECAL -2
  2240. +#define NEED_2_RECAL -3
  2241. +#define PROVEN_ABSENT -4
  2242. +
  2243. +/* buffer related variables */
  2244. +static int buffer_track = -1;
  2245. +static int buffer_drive = -1;
  2246. +static int buffer_min = -1;
  2247. +static int buffer_max = -1;
  2248. +
  2249. +/* fdc related variables, should end up in a struct */
  2250. +static struct floppy_fdc_state fdc_state[N_FDC];
  2251. +int fdc; /* current fdc */
  2252. +
  2253. +static struct floppy_struct * floppy = floppy_type;
  2254. +static unsigned char current_drive = 255;
  2255. +static long current_count_sectors = 0;
  2256. +static char *current_addr = 0;
  2257. +static unsigned char sector_t; /* sector in track */
  2258. +
  2259. +#ifdef DEBUGT
  2260. +long unsigned debugtimer;
  2261. +#endif
  2262. +
  2263. +/*
  2264. + * Floppy_selects1 is the list of DOR's to select a drive n
  2265. + * Floppy_selects2 is the list of DOR's to select drive fd
  2266. + * On initialisation, the floppy list is scanned, and the drives allocated
  2267. + * in the order that they are found.  This is done by seeking the drive
  2268. + * to a non-zero track, and then restoring it to track 0.  If an error occurs,
  2269. + * then there is no floppy drive present.
  2270. + */
  2271. +
  2272. +unsigned char floppy_selects1[]={ 0x10, 0x21, 0x23, 0x33 };
  2273. +unsigned char floppy_selects2[]={ 0   , 0   , 0   , 0    };
  2274. +
  2275. +int fd_sectsizes[256];
  2276. +
  2277. +/*
  2278. + * Debugging
  2279. + * =========
  2280. + */
  2281. +static inline void set_debugt(void)
  2282. +{
  2283. +#ifdef DEBUGT
  2284. +    debugtimer = jiffies;
  2285. +#endif
  2286. +}
  2287. +
  2288. +static inline void debugt(char *message)
  2289. +{
  2290. +#ifdef DEBUGT
  2291. +  if ( DP->flags & DEBUGT )
  2292. +    printk("%s dtime=%lu\n", message, jiffies-debugtimer );
  2293. +#endif
  2294. +}
  2295. +
  2296. +/*
  2297. + * Bottom half floppy driver.
  2298. + * ==========================
  2299. + *
  2300. + * This part of the file contains the code talking directly to the hardware,
  2301. + * and also the main service loop (seek-configure-spinup-command)
  2302. + */
  2303. +
  2304. +/*
  2305. + * disk change.
  2306. + * This routine is responsible for maintaining the changed_floppies flag,
  2307. + * and the last_checked date.
  2308. + *
  2309. + * last_checked is the date of the last check which showed 'no disk change'
  2310. + * changed_floppies is set under two conditions:
  2311. + * 1. The floppy has been changed after some i/o to that floppy already
  2312. + *    took place.
  2313. + * 2. No floppy disk is in the drive.
  2314. + *
  2315. + * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
  2316. + * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
  2317. + *  each seek. If a disk is present, the disk change line should also be
  2318. + *  cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
  2319. + *  change line is set, this means either that no disk is in the drive, or
  2320. + *  that it has been removed since the last seek.
  2321. + *
  2322. + * This means that we really have a third possibility too:
  2323. + *  The floppy has been changed after the last seek.
  2324. + */
  2325. +
  2326. +static int disk_change(int drive)
  2327. +{
  2328. +    if(jiffies < DP->select_delay + DRS->select_date)
  2329. +        udelay(20000);
  2330. +
  2331. +    if(inb_p(FD_DIR) & 0x80){
  2332. +        UDRS->flags |= FD_VERIFY; /* verify write protection */
  2333. +
  2334. +        if(UDRS->maxblock || /* disk change check */
  2335. +           !(UDRS->flags & FD_DISK_NEWCHANGE)){/* disk presence check */
  2336. +            /* mark it changed or absent */
  2337. +            set_bit(drive,&changed_floppies);
  2338. +
  2339. +            /* invalidate its geometry */
  2340. +            if (UDRS->keep_data >= 0) {
  2341. +                if ((DP->flags & FTD_MSG) &&
  2342. +                    current_type[drive] != NULL)
  2343. +                    DPRINT("Disk type is undefined after "
  2344. +                           "disk change\n");
  2345. +                current_type[drive] = NULL;
  2346. +                floppy_sizes[drive] = MAX_DISK_SIZE;
  2347. +            }
  2348. +        }
  2349. +        UDRS->flags |= FD_DISK_NEWCHANGE;
  2350. +        return 1;
  2351. +    } else {
  2352. +        UDRS->last_checked=jiffies;
  2353. +        UDRS->flags &= ~FD_DISK_NEWCHANGE;
  2354. +        return 0;
  2355. +    }
  2356. +}
  2357. +
  2358. +static void arm_set_dor(int dor)
  2359. +{
  2360. +    if(dor & 0xf0)
  2361. +        outb_p((dor & 0x0c) | floppy_selects1[dor & 3], FD_DOR);
  2362. +    else
  2363. +        outb_p((dor & 0x0c), FD_DOR);
  2364. +}
  2365. +
  2366. +static int locked=0;
  2367. +static int set_dor(int fdc, char mask, char data)
  2368. +{
  2369. +    register unsigned char drive, unit, newdor,olddor;
  2370. +
  2371. +    locked=1;
  2372. +    olddor = FDCS->dor;
  2373. +    newdor =  (olddor & mask) | data;
  2374. +    if ( newdor != olddor ){
  2375. +        unit = olddor & 0x3;
  2376. +        drive = REVDRIVE(fdc,unit);
  2377. +        if ( olddor & ( 0x10 << unit ))
  2378. +            disk_change(drive);
  2379. +        FDCS->dor = newdor;
  2380. +        arm_set_dor(newdor);
  2381. +    }
  2382. +    locked=0;
  2383. +    return olddor;
  2384. +}
  2385. +
  2386. +static void twaddle(void)
  2387. +{
  2388. +    cli();
  2389. +#if 0
  2390. +    outb_p(FDCS->dor & ~(0x10<<UNIT(current_drive)),FD_DOR);
  2391. +    outb_p(FDCS->dor, FD_DOR);
  2392. +#else
  2393. +    arm_set_dor(FDCS->dor);
  2394. +#endif
  2395. +    sti();
  2396. +}
  2397. +
  2398. +/* reset all driver information about the current fdc. This is needed after
  2399. + * a reset, and after a raw command. */
  2400. +static void reset_fdc_info(int mode)
  2401. +{
  2402. +    int drive;
  2403. +
  2404. +    FDCS->spec1 = FDCS->spec2 = -1;
  2405. +    FDCS->need_configure = 1;
  2406. +    FDCS->perp_mode = 1;
  2407. +    FDCS->rawcmd = 0;
  2408. +    for ( drive = 0; drive < N_DRIVE; drive++)
  2409. +        if (FDC(drive) == fdc &&
  2410. +            UDRS->track != PROVEN_ABSENT &&
  2411. +            ( mode || UDRS->track != NEED_1_RECAL))
  2412. +            UDRS->track = NEED_2_RECAL;
  2413. +}
  2414. +
  2415. +/* selects the fdc and drive, and enables the fdc's input/dma. */
  2416. +static void set_fdc(int drive)
  2417. +{
  2418. +    if ( drive >= 0 ){
  2419. +        fdc = FDC(drive);
  2420. +        current_drive = drive;
  2421. +    }
  2422. +    set_dor(fdc,~0,8);
  2423. +#ifdef HAVE_2_CONTROLLERS
  2424. +    set_dor(1-fdc, ~8, 0);
  2425. +#endif
  2426. +    if ( FDCS->rawcmd == 2 )
  2427. +        reset_fdc_info(1);
  2428. +    if( inb_p(FD_STATUS) != STATUS_READY )
  2429. +        FDCS->reset = 1;
  2430. +}
  2431. +
  2432. +static int usage_count = 0;
  2433. +/* locks the driver */
  2434. +static int lock_fdc(int drive, int interruptible)
  2435. +{
  2436. +
  2437. +    if(!usage_count){
  2438. +        printk("trying to lock fdc while usage count=0\n");
  2439. +        return -1;
  2440. +    }
  2441. +    floppy_grab_irq_and_dma();
  2442. +    cli();
  2443. +    while (fdc_busy && NO_SIGNAL)
  2444. +        interruptible_sleep_on(&fdc_wait);
  2445. +    if(fdc_busy){
  2446. +        sti();
  2447. +        return -EINTR;
  2448. +    }
  2449. +    fdc_busy = 1;
  2450. +    sti();
  2451. +    command_status = FD_COMMAND_NONE;
  2452. +    set_fdc(drive);
  2453. +    return 0;
  2454. +}
  2455. +
  2456. +#define LOCK_FDC(drive,interruptible) \
  2457. +if(lock_fdc(drive,interruptible)) return -EINTR;
  2458. +
  2459. +/* unlocks the driver */
  2460. +static inline void unlock_fdc(void)
  2461. +{
  2462. +    if (!fdc_busy)
  2463. +        DPRINT("FDC access conflict!\n");
  2464. +
  2465. +    if ( DEVICE_INTR )
  2466. +        DPRINT1("device interrupt still active at FDC release: %p!\n",
  2467. +            DEVICE_INTR);
  2468. +    command_status = FD_COMMAND_NONE;
  2469. +    timer_active &= ~(1 << FLOPPY_TIMER);
  2470. +    fdc_busy = 0;
  2471. +    floppy_release_irq_and_dma();
  2472. +    wake_up(&fdc_wait);
  2473. +}
  2474. +
  2475. +/* switches the motor off after a given timeout */
  2476. +static void motor_off_callback(unsigned long nr)
  2477. +{
  2478. +    unsigned char mask = ~(0x10 << UNIT(nr));
  2479. +
  2480. +    if(locked)
  2481. +        floppy_off(nr);
  2482. +    else
  2483. +        set_dor( FDC(nr), mask, 0 );
  2484. +}
  2485. +
  2486. +static struct timer_list motor_off_timer[N_DRIVE] = {
  2487. +    { NULL, NULL, 0, 0, motor_off_callback },
  2488. +    { NULL, NULL, 0, 1, motor_off_callback },
  2489. +    { NULL, NULL, 0, 2, motor_off_callback },
  2490. +    { NULL, NULL, 0, 3, motor_off_callback }
  2491. +#ifdef HAVE_2_CONTROLLERS
  2492. +    ,
  2493. +    { NULL, NULL, 0, 4, motor_off_callback },
  2494. +    { NULL, NULL, 0, 5, motor_off_callback },
  2495. +    { NULL, NULL, 0, 6, motor_off_callback },
  2496. +    { NULL, NULL, 0, 7, motor_off_callback }
  2497. +#endif
  2498. +};
  2499. +
  2500. +/* schedules motor off */
  2501. +static void floppy_off(unsigned int nr)
  2502. +{
  2503. +    unsigned long volatile delta;
  2504. +    register int fdc=FDC(nr);
  2505. +
  2506. +    if( !(FDCS->dor & ( 0x10 << UNIT(nr))))
  2507. +        return;
  2508. +
  2509. +    del_timer(motor_off_timer+nr);
  2510. +
  2511. +    /* make spindle stop in a position which minimizes spinup time
  2512. +     * next time */
  2513. +    if ( drive_params[nr].rps ){
  2514. +        delta = jiffies - drive_state[nr].first_read_date + HZ -
  2515. +            drive_params[nr].spindown_offset;
  2516. +        delta = (( delta * drive_params[nr].rps) % HZ ) /
  2517. +            drive_params[nr].rps;
  2518. +        motor_off_timer[nr].expires = drive_params[nr].spindown - delta;
  2519. +    }
  2520. +    add_timer(motor_off_timer+nr);
  2521. +}
  2522. +
  2523. +/*
  2524. + * cycle through all N_DRIVE floppy drives, for disk change testing.
  2525. + * stopping at current drive. This is done before any long operation, to
  2526. + * be sure to have up to date disk change information.
  2527. + */
  2528. +static void scandrives(void)
  2529. +{
  2530. +    int i, drive, saved_drive;
  2531. +
  2532. +    saved_drive = current_drive % N_DRIVE;
  2533. +    for(i=0; i< N_DRIVE; i++){
  2534. +        drive = (saved_drive + i + 1 ) % N_DRIVE;
  2535. +        if ( UDRS->fd_ref == 0 )
  2536. +            continue; /* skip closed drives */
  2537. +        set_fdc(drive);
  2538. +        if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
  2539. +            ((FDCS->dor & 0x3) != UNIT(drive)))
  2540. +            UDRS->select_date = jiffies;
  2541. +        if(! (set_dor( fdc, ~3, UNIT(drive) | ( 0x10 << UNIT(drive))) &
  2542. +              (0x10 << UNIT(drive))))
  2543. +            /* switch the motor off again, if it was off to
  2544. +             * begin with */
  2545. +            set_dor( fdc, ~( 0x10 << UNIT(drive) ), 0 );
  2546. +    }
  2547. +    current_drive = saved_drive;
  2548. +}
  2549. +
  2550. +typedef void (*timeout_fn)(unsigned long);
  2551. +static struct timer_list fd_timer ={ NULL, NULL, 0, 0, 0 };
  2552. +
  2553. +/* this function makes sure that the disk stays in the drive during the
  2554. + * transfer */
  2555. +static void fd_watchdog(void)
  2556. +{
  2557. +    if ( disk_change(current_drive) ){
  2558. +        DPRINT("disk removed during i/o\n");
  2559. +        floppy_shutdown();
  2560. +    } else {
  2561. +        del_timer(&fd_timer);
  2562. +        fd_timer.function = (timeout_fn) fd_watchdog;
  2563. +        fd_timer.expires = 10;
  2564. +        add_timer(&fd_timer);
  2565. +    }
  2566. +}
  2567. +
  2568. +static void main_command_interrupt(void)
  2569. +{
  2570. +    del_timer(&fd_timer);
  2571. +    cont->interrupt();
  2572. +}
  2573. +
  2574. +/* waits for a delay (spinup or select) to pass */
  2575. +static int wait_for_completion(int nr, int delay, timeout_fn function)
  2576. +{
  2577. +    if ( FDCS->reset ){
  2578. +        reset_fdc(); /* do the reset during sleep to win time
  2579. +                  * if we don't need to sleep, it's a good
  2580. +                  * occasion anyways */
  2581. +        return 1;
  2582. +    }
  2583. +
  2584. +    if ( jiffies < delay ){
  2585. +        del_timer(&fd_timer);
  2586. +        fd_timer.function = function;
  2587. +        fd_timer.expires = delay  - jiffies;
  2588. +        add_timer(&fd_timer);
  2589. +        return 1;
  2590. +    }
  2591. +    return 0;
  2592. +}
  2593. +
  2594. +static void setup_DMA(void)
  2595. +{
  2596. +#ifdef SANITY
  2597. +    if ((!CURRENT ||
  2598. +         CURRENT->buffer != current_addr ||
  2599. +         raw_cmd.length > 512 * CURRENT->nr_sectors) &&
  2600. +        (current_addr < floppy_track_buffer ||
  2601. +         current_addr + raw_cmd.length >
  2602. +         floppy_track_buffer + 1024 * max_buffer_sectors)){
  2603. +        printk("bad address. start=%p lg=%lx tb=%p\n",
  2604. +               current_addr, raw_cmd.length, floppy_track_buffer);
  2605. +        if ( CURRENT ){
  2606. +            printk("buffer=%p nr=%lx cnr=%lx\n",
  2607. +                   CURRENT->buffer, CURRENT->nr_sectors,
  2608. +                   CURRENT->current_nr_sectors);
  2609. +        }
  2610. +        cont->done(0);
  2611. +        FDCS->reset=1;
  2612. +        return;
  2613. +    }
  2614. +#if 0
  2615. +    if ((long) current_addr % 512 ){
  2616. +        printk("non aligned address: %p\n", current_addr );
  2617. +        cont->done(0);
  2618. +        FDCS->reset=1;
  2619. +        return;
  2620. +    }
  2621. +    if ( ( (long)current_addr & ~(64*1024-1) ) !=
  2622. +        ((long)(current_addr + raw_cmd.length-1)  & ~(64*1024-1))){
  2623. +        printk("DMA crossing 64-K boundary %p-%p\n",
  2624. +               current_addr, current_addr + raw_cmd.length);
  2625. +        cont->done(0);
  2626. +        FDCS->reset=1;
  2627. +        return;
  2628. +    }
  2629. +#endif
  2630. +#endif
  2631. +    cli();
  2632. +    disable_dma(FLOPPY_DMA);
  2633. +    clear_dma_ff(FLOPPY_DMA);
  2634. +    set_dma_mode(FLOPPY_DMA,
  2635. +             (raw_cmd.flags & FD_RAW_READ)?
  2636. +             DMA_MODE_READ : DMA_MODE_WRITE);
  2637. +    set_dma_addr(FLOPPY_DMA, (long) current_addr);
  2638. +    set_dma_count(FLOPPY_DMA, raw_cmd.length);
  2639. +    enable_dma(FLOPPY_DMA);
  2640. +    sti();
  2641. +}
  2642. +
  2643. +/* sends a command byte to the fdc */
  2644. +static int output_byte(char byte)
  2645. +{
  2646. +    int counter;
  2647. +    unsigned char status;
  2648. +
  2649. +    if (FDCS->reset)
  2650. +        return -1;
  2651. +    for(counter = 0 ; counter < 10000 && !FDCS->reset ; counter++) {
  2652. +        status = inb_p(FD_STATUS) &(STATUS_READY|STATUS_DIR|STATUS_DMA);
  2653. +        if (status == STATUS_READY){
  2654. +            outb_p(byte,FD_DATA);
  2655. +            return 0;
  2656. +        }
  2657. +        if (!(status & STATUS_READY))
  2658. +            continue;
  2659. +        break;
  2660. +    }
  2661. +    FDCS->reset = 1;
  2662. +    if ( !initialising )
  2663. +        DPRINT2("Unable to send byte %x to FDC. Status=%x\n",
  2664. +            byte, status);
  2665. +    return -1;
  2666. +}
  2667. +#define LAST_OUT(x) if(output_byte(x)){ reset_fdc();return;}
  2668. +
  2669. +/* gets the response from the fdc */
  2670. +static int result(void)
  2671. +{
  2672. +    int i = 0, counter, status;
  2673. +
  2674. +    if (FDCS->reset)
  2675. +        return -1;
  2676. +    for (counter = 0 ; counter < 10000 && !FDCS->reset ; counter++) {
  2677. +        status = inb_p(FD_STATUS)&
  2678. +            (STATUS_DIR|STATUS_READY|STATUS_BUSY|STATUS_DMA);
  2679. +        if (!(status & STATUS_READY))
  2680. +            continue;
  2681. +        if (status == STATUS_READY)
  2682. +            return i;
  2683. +        if (status & STATUS_DMA )
  2684. +            break;
  2685. +        if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY)) {
  2686. +            if (i >= MAX_REPLIES) {
  2687. +                DPRINT("floppy_stat reply overrun\n");
  2688. +                break;
  2689. +            }
  2690. +            reply_buffer[i++] = inb_p(FD_DATA);
  2691. +        }
  2692. +    }
  2693. +    FDCS->reset = 1;
  2694. +    if ( !initialising )
  2695. +        DPRINT3("Getstatus times out (%x) on fdc %d [%d]\n",
  2696. +            status, fdc, i);
  2697. +    return -1;
  2698. +}
  2699. +
  2700. +/* Set perpendicular mode as required, based on data rate, if supported.
  2701. + * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
  2702. + */
  2703. +static inline void perpendicular_mode(void)
  2704. +{
  2705. +    unsigned char perp_mode;
  2706. +
  2707. +    if (!floppy)
  2708. +        return;
  2709. +    if (floppy->rate & 0x40){
  2710. +        switch(raw_cmd.rate){
  2711. +        case 0:
  2712. +            perp_mode=2;
  2713. +            break;
  2714. +        case 3:
  2715. +            perp_mode=3;
  2716. +            break;
  2717. +        default:
  2718. +            DPRINT("Invalid data rate for perpendicular mode!\n");
  2719. +            cont->done(0);
  2720. +            FDCS->reset = 1; /* convenient way to return to
  2721. +                      * redo without to much hassle (deep
  2722. +                      * stack et al. */
  2723. +            return;
  2724. +        }
  2725. +    } else
  2726. +        perp_mode = 0;
  2727. +
  2728. +    if ( FDCS->perp_mode == perp_mode )
  2729. +        return;
  2730. +    if (FDCS->version >= FDC_82077_ORIG && FDCS->has_fifo) {
  2731. +        output_byte(FD_PERPENDICULAR);
  2732. +        output_byte(perp_mode);
  2733. +        FDCS->perp_mode = perp_mode;
  2734. +    } else if (perp_mode) {
  2735. +        DPRINT("perpendicular mode not supported by this FDC.\n");
  2736. +    }
  2737. +} /* perpendicular_mode */
  2738. +
  2739. +#define NOMINAL_DTR 500
  2740. +
  2741. +/* Issue a "SPECIFY" command to set the step rate time, head unload time,
  2742. + * head load time, and DMA disable flag to values needed by floppy.
  2743. + *
  2744. + * The value "dtr" is the data transfer rate in Kbps.  It is needed
  2745. + * to account for the data rate-based scaling done by the 82072 and 82077
  2746. + * FDC types.  This parameter is ignored for other types of FDCs (i.e.
  2747. + * 8272a).
  2748. + *
  2749. + * Note that changing the data transfer rate has a (probably deleterious)
  2750. + * effect on the parameters subject to scaling for 82072/82077 FDCs, so
  2751. + * fdc_specify is called again after each data transfer rate
  2752. + * change.
  2753. + *
  2754. + * srt: 1000 to 16000 in microseconds
  2755. + * hut: 16 to 240 milliseconds
  2756. + * hlt: 2 to 254 milliseconds
  2757. + *
  2758. + * These values are rounded up to the next highest available delay time.
  2759. + */
  2760. +static void fdc_specify(void)
  2761. +{
  2762. +    unsigned char spec1, spec2;
  2763. +    int srt, hlt, hut;
  2764. +    unsigned long dtr = NOMINAL_DTR;
  2765. +    unsigned long scale_dtr = NOMINAL_DTR;
  2766. +    int hlt_max_code = 0x7f;
  2767. +    int hut_max_code = 0xf;
  2768. +
  2769. +    if (FDCS->need_configure && FDCS->has_fifo) {
  2770. +        if ( FDCS->reset )
  2771. +            return;
  2772. +        /* Turn on FIFO for 82077-class FDC (improves performance) */
  2773. +        /* TODO: lock this in via LOCK during initialization */
  2774. +        output_byte(FD_CONFIGURE);
  2775. +        output_byte(0);
  2776. +        output_byte(0x1A);    /* FIFO on, polling off, 10 byte threshold */
  2777. +        output_byte(0);        /* precompensation from track 0 upwards */
  2778. +        if ( FDCS->reset ){
  2779. +            FDCS->has_fifo=0;
  2780. +            return;
  2781. +        }
  2782. +        FDCS->need_configure = 0;
  2783. +        /*DPRINT("FIFO enabled\n");*/
  2784. +    }
  2785. +
  2786. +    switch (raw_cmd.rate & 0x03) {
  2787. +    case 3:
  2788. +        dtr = 1000;
  2789. +        break;
  2790. +    case 1:
  2791. +        dtr = 300;
  2792. +        break;
  2793. +    case 2:
  2794. +        dtr = 250;
  2795. +        break;
  2796. +    }
  2797. +
  2798. +    if (FDCS->version >= FDC_82072) {
  2799. +        scale_dtr = dtr;
  2800. +        hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
  2801. +        hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
  2802. +    }
  2803. +
  2804. +    /* Convert step rate from microseconds to milliseconds and 4 bits */
  2805. +    srt = 16 - (DP->srt*scale_dtr/1000 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  2806. +    if (srt > 0xf)
  2807. +        srt = 0xf;
  2808. +    else if (srt < 0)
  2809. +        srt = 0;
  2810. +
  2811. +    hlt = (DP->hlt*scale_dtr/2 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  2812. +    if (hlt < 0x01)
  2813. +        hlt = 0x01;
  2814. +    else if (hlt > 0x7f)
  2815. +        hlt = hlt_max_code;
  2816. +
  2817. +    hut = (DP->hut*scale_dtr/16 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  2818. +    if (hut < 0x1)
  2819. +        hut = 0x1;
  2820. +    else if (hut > 0xf)
  2821. +        hut = hut_max_code;
  2822. +
  2823. +    spec1 = (srt << 4) | hut;
  2824. +    spec2 = (hlt << 1);
  2825. +
  2826. +    /* If these parameters did not change, just return with success */
  2827. +    if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
  2828. +        /* Go ahead and set spec1 and spec2 */
  2829. +        output_byte(FD_SPECIFY);
  2830. +        output_byte(FDCS->spec1 = spec1);
  2831. +        output_byte(FDCS->spec2 = spec2);
  2832. +    }
  2833. +} /* fdc_specify */
  2834. +
  2835. +/* Set the FDC's data transfer rate on behalf of the specified drive.
  2836. + * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
  2837. + * of the specify command (i.e. using the fdc_specify function).
  2838. + */
  2839. +static void fdc_dtr(void)
  2840. +{
  2841. +    /* If data rate not already set to desired value, set it. */
  2842. +    if ( raw_cmd.rate == FDCS->dtr)
  2843. +        return;
  2844. +
  2845. +    /* Set dtr */
  2846. +    outb_p(raw_cmd.rate, FD_DCR);
  2847. +
  2848. +    /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
  2849. +     * need a stabilization period of several milliseconds to be
  2850. +     * enforced after data rate changes before R/W operations.
  2851. +     * Pause 5 msec to avoid trouble.
  2852. +     */
  2853. +    udelay(5000);
  2854. +    FDCS->dtr = raw_cmd.rate;
  2855. +} /* fdc_dtr */
  2856. +
  2857. +static void tell_sector(void)
  2858. +{
  2859. +    printk(": track %d, head %d, sector %d, size %d",
  2860. +           R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
  2861. +} /* tell_sector */
  2862. +
  2863. +
  2864. +/*
  2865. + * Ok, this error interpreting routine is called after a
  2866. + * DMA read/write has succeeded
  2867. + * or failed, so we check the results, and copy any buffers.
  2868. + * hhb: Added better error reporting.
  2869. + * ak: Made this into a separate routine.
  2870. + */
  2871. +static int interpret_errors(void)
  2872. +{
  2873. +    char bad;
  2874. +int res = get_dma_residue(FLOPPY_DMA);
  2875. +if(res) {printk("\n-- DMA residue (%d)",res); tell_sector(); printk("\n");}
  2876. +    if (inr!=7) {
  2877. +        DPRINT("-- FDC reply error");
  2878. +        FDCS->reset = 1;
  2879. +        return 1;
  2880. +    }
  2881. +
  2882. +    /* check IC to find cause of interrupt */
  2883. +    switch ((ST0 & ST0_INTR)>>6) {
  2884. +        case 1:    /* error occured during command execution */
  2885. +            bad = 1;
  2886. +            if (ST1 & ST1_WP) {
  2887. +                DPRINT("Drive is write protected\n");
  2888. +                DRS->flags &= ~FD_DISK_WRITABLE;
  2889. +                cont->done(0);
  2890. +                bad = 2;
  2891. +            } else if (ST1 & ST1_ND) {
  2892. +                DRS->flags |= FD_NEED_TWADDLE;
  2893. +            } else if (ST1 & ST1_OR) {
  2894. +                if (DP->flags & FTD_MSG )
  2895. +                    DPRINT("Over/Underrun - retrying\n");
  2896. +                bad = 0;
  2897. +            }else if(*errors >= DP->max_errors.reporting){
  2898. +                DPRINT("");
  2899. +                if (ST0 & ST0_ECE) {
  2900. +                    printk("Recalibrate failed!");
  2901. +                } else if (ST2 & ST2_CRC) {
  2902. +                    printk("data CRC error");
  2903. +                    tell_sector();
  2904. +                } else if (ST1 & ST1_CRC) {
  2905. +                    printk("CRC error");
  2906. +                    tell_sector();
  2907. +                } else if ((ST1 & (ST1_MAM|ST1_ND)) || (ST2 & ST2_MAM)) {
  2908. +                    if (!probing) {
  2909. +                        printk("sector not found");
  2910. +                        tell_sector();
  2911. +                    } else
  2912. +                        printk("probe failed...");
  2913. +                } else if (ST2 & ST2_WC) {    /* seek error */
  2914. +                    printk("wrong cylinder");
  2915. +                } else if (ST2 & ST2_BC) {    /* cylinder marked as bad */
  2916. +                    printk("bad cylinder");
  2917. +                } else {
  2918. +                    printk("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x", ST0, ST1, ST2);
  2919. +                    tell_sector();
  2920. +                }
  2921. +                printk("\n");
  2922. +
  2923. +            }
  2924. +            if ( ST2 & ST2_WC || ST2 & ST2_BC)
  2925. +{
  2926. +printk("Wrong cylinder!\n");
  2927. +                /* wrong cylinder => recal */
  2928. +                DRS->track = NEED_2_RECAL;
  2929. +}
  2930. +            return bad;
  2931. +        case 2: /* invalid command given */
  2932. +            DPRINT("Invalid FDC command given!\n");
  2933. +            cont->done(0);
  2934. +            return 2;
  2935. +        case 3:
  2936. +            DPRINT("Abnormal termination caused by polling\n");
  2937. +            cont->error();
  2938. +            return 2;
  2939. +        default: /* (0) Normal command termination */
  2940. +            return 0;
  2941. +    }
  2942. +}
  2943. +
  2944. +/*
  2945. + * This routine is called when everything should be correctly set up
  2946. + * for the transfer (ie floppy motor is on, the correct floppy is
  2947. + * selected, and the head is sitting on the right track).
  2948. + */
  2949. +static void setup_rw_floppy(void)
  2950. +{
  2951. +    int i,ready_date,r, flags,dflags;
  2952. +    timeout_fn function;
  2953. +
  2954. +    flags = raw_cmd.flags;
  2955. +    if ( flags & ( FD_RAW_READ | FD_RAW_WRITE))
  2956. +        flags |= FD_RAW_INTR;
  2957. +
  2958. +    if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)){
  2959. +        ready_date = DRS->spinup_date + DP->spinup;
  2960. +        /* If spinup will take a long time, rerun scandrives
  2961. +         * again just before spinup completion. Beware that
  2962. +         * after scandrives, we must again wait for selection.
  2963. +         */
  2964. +        if ( ready_date > jiffies + DP->select_delay){
  2965. +            ready_date -= DP->select_delay;
  2966. +            function = (timeout_fn) floppy_start;
  2967. +        } else
  2968. +            function = (timeout_fn) setup_rw_floppy;
  2969. +
  2970. +        /* wait until the floppy is spinning fast enough */
  2971. +        if (wait_for_completion(current_drive,ready_date,function))
  2972. +            return;
  2973. +    }
  2974. +    dflags = DRS->flags;
  2975. +
  2976. +    if ( (flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
  2977. +        setup_DMA();
  2978. +
  2979. +    if ( flags & FD_RAW_INTR )
  2980. +        SET_INTR(main_command_interrupt);
  2981. +
  2982. +    r=0;
  2983. +    for(i=0; i< raw_cmd.cmd_count; i++)
  2984. +        r|=output_byte( raw_cmd.cmd[i] );
  2985. +
  2986. +#ifdef DEBUGT
  2987. +    debugt("rw_command: ");
  2988. +#endif
  2989. +    if ( r ){
  2990. +        reset_fdc();
  2991. +        return;
  2992. +    }
  2993. +
  2994. +    if ( ! ( flags & FD_RAW_INTR )){
  2995. +        inr = result();
  2996. +        cont->interrupt();
  2997. +    } else if ( flags & FD_RAW_NEED_DISK )
  2998. +        fd_watchdog();
  2999. +}
  3000. +
  3001. +#ifdef SILENT_DC_CLEAR
  3002. +static int blind_seek;
  3003. +#endif
  3004. +
  3005. +/*
  3006. + * This is the routine called after every seek (or recalibrate) interrupt
  3007. + * from the floppy controller.
  3008. + */
  3009. +static void seek_interrupt(void)
  3010. +{
  3011. +#ifdef DEBUGT
  3012. +    debugt("seek interrupt:");
  3013. +#endif
  3014. +#ifdef SILENT_DC_CLEAR
  3015. +    set_dor(fdc, ~0,  (0x10 << UNIT(current_drive)));
  3016. +#endif
  3017. +    if (inr != 2 || (ST0 & 0xF8) != 0x20 ) {
  3018. +        DPRINT("seek failed\n");
  3019. +        DRS->track = NEED_2_RECAL;
  3020. +        cont->error();
  3021. +        cont->redo();
  3022. +        return;
  3023. +    }
  3024. +    if (DRS->track >= 0 && DRS->track != ST1
  3025. +#ifdef SILENT_DC_CLEAR
  3026. +        && !blind_seek
  3027. +#endif
  3028. +        )
  3029. +        DRS->flags &= ~FD_DISK_NEWCHANGE; /* effective seek */
  3030. +    DRS->track = ST1;
  3031. +    DRS->select_date = jiffies;
  3032. +    seek_floppy();
  3033. +}
  3034. +
  3035. +static void check_wp(void)
  3036. +{
  3037. +    if (DRS->flags & FD_VERIFY) {
  3038. +        /* check write protection */
  3039. +        output_byte( FD_GETSTATUS );
  3040. +        output_byte( UNIT(current_drive) );
  3041. +        if ( result() != 1 ){
  3042. +            FDCS->reset = 1;
  3043. +            return;
  3044. +        }
  3045. +        DRS->flags &= ~(FD_VERIFY | FD_DISK_WRITABLE | FD_NEED_TWADDLE);
  3046. +
  3047. +        if (!( ST3  & 0x40))
  3048. +            DRS->flags |= FD_DISK_WRITABLE;
  3049. +    }
  3050. +}
  3051. +
  3052. +static void seek_floppy(void)
  3053. +{
  3054. +    int track;
  3055. +
  3056. +#ifdef SILENT_DC_CLEAR
  3057. +    blind_seek=0;
  3058. +#endif
  3059. +    disk_change(current_drive);
  3060. +    if ((raw_cmd.flags & FD_RAW_NEED_DISK) &&
  3061. +        test_bit(current_drive,&changed_floppies)){
  3062. +        /* the media changed flag should be cleared after the seek.
  3063. +         * If it isn't, this means that there is really no disk in
  3064. +         * the drive.
  3065. +         */
  3066. +        cont->done(0);
  3067. +        cont->redo();
  3068. +        return;
  3069. +    }
  3070. +    if ( DRS->track <= NEED_1_RECAL ){
  3071. +        recalibrate_floppy();
  3072. +        return;
  3073. +    } else if ((DRS->flags & FD_DISK_NEWCHANGE) &&
  3074. +           (raw_cmd.flags & FD_RAW_NEED_DISK) &&
  3075. +           (DRS->track <= NO_TRACK || DRS->track == raw_cmd.track)) {
  3076. +        /* we seek to clear the media-changed condition. Does anybody
  3077. +         * know a more elegant way, which works on all drives? */
  3078. +        if ( raw_cmd.track )
  3079. +            track = raw_cmd.track - 1;
  3080. +        else {
  3081. +#ifdef SILENT_DC_CLEAR
  3082. +            set_dor(fdc, ~ (0x10 << UNIT(current_drive)), 0);
  3083. +            blind_seek = 1;
  3084. +#endif
  3085. +            track = 1;
  3086. +        }
  3087. +    } else {
  3088. +        check_wp();
  3089. +        if (raw_cmd.track != DRS->track)
  3090. +            track = raw_cmd.track;
  3091. +        else {
  3092. +            setup_rw_floppy();
  3093. +            return;
  3094. +        }
  3095. +    }
  3096. +
  3097. +#ifndef SILENT_DC_CLEAR
  3098. +    if ( !track && DRS->track >= 0 && DRS->track < 80 ){
  3099. +        DRS->flags &= ~FD_DISK_NEWCHANGE;
  3100. +        /* if we go to track 0 anyways, we can just as well use
  3101. +         * recalibrate */
  3102. +        recalibrate_floppy();
  3103. +    } else
  3104. +#endif
  3105. +    {
  3106. +        SET_INTR(seek_interrupt);
  3107. +        output_byte(FD_SEEK);
  3108. +        output_byte(UNIT(current_drive));
  3109. +        LAST_OUT(track);
  3110. +#ifdef DEBUGT
  3111. +        debugt("seek command:");
  3112. +#endif
  3113. +    }
  3114. +}
  3115. +
  3116. +static void recal_interrupt(void)
  3117. +{
  3118. +#ifdef DEBUGT
  3119. +    debugt("recal interrupt:");
  3120. +#endif
  3121. +    if (inr !=2 )
  3122. +        FDCS->reset = 1;
  3123. +    else if (ST0 & ST0_ECE) {
  3124. +               switch(DRS->track){
  3125. +        case PROVEN_ABSENT:
  3126. +#ifdef DEBUGT
  3127. +            debugt("recal interrupt proven absent:");
  3128. +#endif
  3129. +            /* fall through */
  3130. +               case NEED_1_RECAL:
  3131. +#ifdef DEBUGT
  3132. +            debugt("recal interrupt need 1 recal:");
  3133. +#endif
  3134. +            /* after a second recalibrate, we still haven't
  3135. +             * reached track 0. Probably no drive. Raise an
  3136. +             * error, as failing immediately might upset
  3137. +             * computers possessed by the Devil :-) */
  3138. +            cont->error();
  3139. +            cont->redo();
  3140. +            return;
  3141. +        case NEED_2_RECAL:
  3142. +#ifdef DEBUGT
  3143. +            debugt("recal interrupt need 2 recal:");
  3144. +#endif
  3145. +            /* If we already did a recalibrate, and we are not at
  3146. +             * track 0, this means we have moved. (The only way
  3147. +             * not to move at recalibration is to be already at
  3148. +             * track 0.) Clear the new change flag
  3149. +             */
  3150. +            DRS->flags &= ~FD_DISK_NEWCHANGE;
  3151. +            /* fall through */
  3152. +        default:
  3153. +#ifdef DEBUGT
  3154. +            debugt("recal interrupt default:");
  3155. +#endif
  3156. +            /* Recalibrate moves the head by at most 80 steps. If
  3157. +             * after one recalibrate we don't have reached track
  3158. +             * 0, this might mean that we started beyond track 80.
  3159. +             * Try again.
  3160. +             */
  3161. +            DRS->track = NEED_1_RECAL;
  3162. +            break;
  3163. +        }
  3164. +    } else
  3165. +        DRS->track = ST1;
  3166. +    seek_floppy();
  3167. +}
  3168. +
  3169. +/*
  3170. + * Unexpected interrupt - Print as much debugging info as we can...
  3171. + * All bets are off...
  3172. + */
  3173. +static void unexpected_floppy_interrupt(void)
  3174. +{
  3175. +    int i;
  3176. +    if ( initialising )
  3177. +        return;
  3178. +    cli();
  3179. +    DPRINT("unexpected interrupt\n");
  3180. +    if ( inr >= 0 )
  3181. +        for(i=0; i<inr; i++)
  3182. +            printk("%d %x\n", i, reply_buffer[i] );
  3183. +    while(1){
  3184. +        output_byte(FD_SENSEI);
  3185. +        inr=result();
  3186. +        if ( inr != 2 )
  3187. +            break;
  3188. +        printk("sensei\n");
  3189. +        for(i=0; i<inr; i++)
  3190. +            printk("%d %x\n", i, reply_buffer[i] );
  3191. +    }
  3192. +    FDCS->reset = 1;
  3193. +}
  3194. +
  3195. +struct tq_struct floppy_tq =
  3196. +{ 0, 0, (void (*) (void *)) unexpected_floppy_interrupt, 0 };
  3197. +
  3198. +/* interrupt handler */
  3199. +static void floppy_interrupt(int unused, struct pt_regs *regs)
  3200. +{
  3201. +    void (*handler)(void) = DEVICE_INTR;
  3202. +
  3203. +    CLEAR_INTR;
  3204. +    if ( fdc >= N_FDC ){ /* we don't even know which FDC is the culprit */
  3205. +        printk("floppy interrupt on bizarre fdc\n");
  3206. +        return;
  3207. +    }
  3208. +    inr = result();
  3209. +    if (!handler){
  3210. +        unexpected_floppy_interrupt();
  3211. +        return;
  3212. +    }
  3213. +    if ( inr == 0 ){
  3214. +        do {
  3215. +            output_byte(FD_SENSEI);
  3216. +            inr = result();
  3217. +        } while ( (ST0 & 0x83) != UNIT(current_drive) && inr == 2);
  3218. +    }
  3219. +    floppy_tq.routine = (void (*)(void *)) handler;
  3220. +    queue_task_irq(&floppy_tq, &tq_timer);
  3221. +}
  3222. +
  3223. +static void recalibrate_floppy(void)
  3224. +{
  3225. +#ifdef DEBUGT
  3226. +    debugt("recalibrate floppy:");
  3227. +#endif
  3228. +    SET_INTR(recal_interrupt);
  3229. +    output_byte(FD_RECALIBRATE);
  3230. +    LAST_OUT(UNIT(current_drive));
  3231. +}
  3232. +
  3233. +/*
  3234. + * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
  3235. + */
  3236. +static void reset_interrupt(void)
  3237. +{
  3238. +#ifdef DEBUGT
  3239. +    debugt("reset interrupt:");
  3240. +#endif
  3241. +    fdc_specify();        /* reprogram fdc */
  3242. +    result();        /* get the status ready for set_fdc */
  3243. +    if ( FDCS->reset )
  3244. +        cont->error(); /* a reset just after a reset. BAD! */
  3245. +    cont->redo();
  3246. +}
  3247. +
  3248. +/*
  3249. + * reset is done by pulling bit 2 of DOR low for a while (old FDC's),
  3250. + * or by setting the self clearing bit 7 of STATUS (newer FDC's)
  3251. + */
  3252. +static void reset_fdc(void)
  3253. +{
  3254. +    SET_INTR(reset_interrupt);
  3255. +    FDCS->reset = 0;
  3256. +    reset_fdc_info(0);
  3257. +    if ( FDCS->version >= FDC_82077 )
  3258. +        outb_p(0x80 | ( FDCS->dtr &3), FD_STATUS);
  3259. +    else {
  3260. +        arm_set_dor(FDCS->dor & ~0x04);
  3261. +        udelay(FD_RESET_DELAY);
  3262. +        arm_set_dor(FDCS->dor);
  3263. +    }
  3264. +}
  3265. +
  3266. +static void empty(void)
  3267. +{
  3268. +}
  3269. +
  3270. +void show_floppy(void)
  3271. +{
  3272. +    int i;
  3273. +
  3274. +    printk("\n");
  3275. +    printk("floppy driver state\n");
  3276. +    printk("-------------------\n");
  3277. +    for(i=0; i<N_FDC; i++){
  3278. +        printk("dor %d = %x\n", i, fdc_state[i].dor );
  3279. +        outb_p(fdc_state[i].address+2, fdc_state[i].dor);
  3280. +        udelay(1000); /* maybe we'll catch an interrupt... */
  3281. +    }
  3282. +    printk("status=%x\n", inb_p(FD_STATUS));
  3283. +    printk("fdc_busy=%d\n", fdc_busy);
  3284. +    if( DEVICE_INTR)
  3285. +        printk("DEVICE_INTR=%p\n", DEVICE_INTR);
  3286. +    if(floppy_tq.sync)
  3287. +        printk("floppy_tq.routine=%p\n", floppy_tq.routine);
  3288. +    if(fd_timer.prev)
  3289. +        printk("fd_timer.function=%p\n", fd_timer.function);
  3290. +    if( timer_active & (1 << FLOPPY_TIMER)){
  3291. +        printk("timer_table=%p\n",timer_table[FLOPPY_TIMER].fn);
  3292. +        printk("expires=%ld\n",timer_table[FLOPPY_TIMER].expires);
  3293. +        printk("now=%ld\n",jiffies);
  3294. +    }
  3295. +    printk("cont=%p\n", cont);
  3296. +    printk("CURRENT=%p\n", CURRENT);
  3297. +    printk("command_status=%d\n", command_status);
  3298. +    printk("\n");
  3299. +}
  3300. +
  3301. +static void floppy_shutdown(void)
  3302. +{
  3303. +    CLEAR_INTR;
  3304. +    floppy_tq.routine = (void (*)(void *)) empty;
  3305. +    del_timer( &fd_timer);
  3306. +    disable_dma(FLOPPY_DMA);
  3307. +    /* avoid dma going to a random drive after shutdown */
  3308. +    if(!initialising)
  3309. +        DPRINT("floppy timeout\n");
  3310. +    FDCS->reset = 1;
  3311. +    cont->done(0);
  3312. +    cont->redo(); /* this will recall reset when needed */
  3313. +}
  3314. +
  3315. +/* start motor, check media-changed condition and write protection */
  3316. +static void start_motor(void)
  3317. +{
  3318. +    int mask, data;
  3319. +
  3320. +    mask = 0xfc;
  3321. +    data = UNIT(current_drive);
  3322. +
  3323. +    if ( (FDCS->dor & 0x03) != UNIT(current_drive) ||
  3324. +        !(FDCS->dor & ( 0x10 << UNIT(current_drive) ) ))
  3325. +        /* notes select time if floppy is not yet selected */
  3326. +        DRS->select_date = jiffies;
  3327. +
  3328. +    if (!(raw_cmd.flags & FD_RAW_NO_MOTOR)){
  3329. +        if(!(FDCS->dor & ( 0x10 << UNIT(current_drive) ) )){
  3330. +            set_debugt();
  3331. +            /* no read since this drive is running */
  3332. +            DRS->first_read_date = 0;
  3333. +            /* note motor start time if motor is not yet running */
  3334. +            DRS->spinup_date = jiffies;
  3335. +            data |= (0x10 << UNIT(current_drive));
  3336. +        }
  3337. +    } else
  3338. +        if (FDCS->dor & ( 0x10 << UNIT(current_drive) ) )
  3339. +            mask &= ~(0x10 << UNIT(current_drive));
  3340. +
  3341. +    /* starts motor and selects floppy */
  3342. +    del_timer(motor_off_timer + current_drive);
  3343. +    set_dor( fdc, mask, data);
  3344. +    if( raw_cmd.flags & FD_RAW_NO_MOTOR)
  3345. +        return;
  3346. +
  3347. +    disk_change(current_drive);
  3348. +
  3349. +    return;
  3350. +}
  3351. +
  3352. +static void floppy_ready(void)
  3353. +{
  3354. +    CHECK_RESET;
  3355. +    start_motor();
  3356. +
  3357. +    /* wait_for_completion also schedules reset if needed. */
  3358. +    if(wait_for_completion(current_drive,
  3359. +                   DRS->select_date+DP->select_delay,
  3360. +                   (timeout_fn) floppy_ready))
  3361. +        return;
  3362. +    fdc_dtr();
  3363. +    if ( raw_cmd.flags & FD_RAW_NEED_SEEK ){
  3364. +        perpendicular_mode();
  3365. +        fdc_specify(); /* must be done here because of hut, hlt ... */
  3366. +        seek_floppy();
  3367. +    } else
  3368. +        setup_rw_floppy();
  3369. +}
  3370. +
  3371. +static void floppy_start(void)
  3372. +{
  3373. +    timer_table[FLOPPY_TIMER].expires = jiffies + DP->timeout;
  3374. +    timer_active |= 1 << FLOPPY_TIMER;
  3375. +    scandrives();
  3376. +    floppy_ready();
  3377. +}
  3378. +
  3379. +/*
  3380. + * ========================================================================
  3381. + * here ends the bottom half. Exported routines are:
  3382. +  * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
  3383. + * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
  3384. + * Initialisation also uses output_byte, result, set_dor, floppy_interrupt
  3385. + * and set_dor.
  3386. + * ========================================================================
  3387. + */
  3388. +/*
  3389. + * General purpose continuations.
  3390. + * ==============================
  3391. + */
  3392. +
  3393. +static void do_wakeup(void)
  3394. +{
  3395. +    timer_active &= ~(1 << FLOPPY_TIMER);
  3396. +    cont = 0;
  3397. +    command_status += 2;
  3398. +    wake_up(&command_done);
  3399. +}
  3400. +
  3401. +static struct cont_t wakeup_cont={
  3402. +    empty,
  3403. +    do_wakeup,
  3404. +    empty,
  3405. +    (done_f)empty
  3406. +};
  3407. +
  3408. +static int wait_til_done( void (*handler)(void ), int interruptible )
  3409. +{
  3410. +    int ret;
  3411. +
  3412. +    floppy_tq.routine = (void (*)(void *)) handler;
  3413. +    queue_task(&floppy_tq, &tq_timer);
  3414. +
  3415. +    cli();
  3416. +    while(command_status < 2 && NO_SIGNAL)
  3417. +        if (current->pid)
  3418. +            interruptible_sleep_on(&command_done);
  3419. +        else {
  3420. +            sti();
  3421. +            run_task_queue(&tq_timer);
  3422. +            cli();
  3423. +        }
  3424. +    if(command_status < 2){
  3425. +        sti();
  3426. +        floppy_shutdown();
  3427. +        redo_fd_request();
  3428. +        return -EINTR;
  3429. +    }
  3430. +    sti();
  3431. +
  3432. +    if ( FDCS->reset )
  3433. +        command_status = FD_COMMAND_ERROR;
  3434. +    if ( command_status == FD_COMMAND_OKAY )
  3435. +        ret=0;
  3436. +    else
  3437. +        ret=-EIO;
  3438. +    command_status = FD_COMMAND_NONE;
  3439. +    return ret;
  3440. +}
  3441. +
  3442. +static void generic_done(int result)
  3443. +{
  3444. +    command_status = result;
  3445. +    cont = &wakeup_cont;
  3446. +}
  3447. +
  3448. +static void generic_success(void)
  3449. +{
  3450. +    generic_done(1);
  3451. +}
  3452. +
  3453. +static void generic_failure(void)
  3454. +{
  3455. +    generic_done(0);
  3456. +}
  3457. +
  3458. +static void success_and_wakeup(void)
  3459. +{
  3460. +    generic_success();
  3461. +    do_wakeup();
  3462. +}
  3463. +
  3464. +static void failure_and_wakeup(void)
  3465. +{
  3466. +    generic_failure();
  3467. +    do_wakeup();
  3468. +}
  3469. +
  3470. +/*
  3471. + * formatting and rw support.
  3472. + * ==========================
  3473. + */
  3474. +
  3475. +static int next_valid_format(void)
  3476. +{
  3477. +    int probed_format;
  3478. +    while(1){
  3479. +        probed_format = DRS->probed_format;
  3480. +        if ( probed_format > 8 ||
  3481. +            ! DP->autodetect[probed_format] ){
  3482. +            DRS->probed_format = 0;
  3483. +            return 1;
  3484. +        }
  3485. +        if ( floppy_type[DP->autodetect[probed_format]].sect ){
  3486. +            DRS->probed_format = probed_format;
  3487. +            return 0;
  3488. +        }
  3489. +        probed_format++;
  3490. +    }
  3491. +}
  3492. +
  3493. +static void bad_flp_intr(void)
  3494. +{
  3495. +    if ( probing ){
  3496. +        DRS->probed_format++;
  3497. +        if ( !next_valid_format())
  3498. +            return;
  3499. +    }
  3500. +    (*errors)++;
  3501. +    if (*errors > DRWE->badness)
  3502. +            DRWE->badness = *errors;
  3503. +    if (*errors > DP->max_errors.abort)
  3504. +        cont->done(0);
  3505. +    if (*errors > DP->max_errors.reset)
  3506. +        FDCS->reset = 1;
  3507. +    else if (*errors > DP->max_errors.recal)
  3508. +        DRS->track = NEED_2_RECAL;
  3509. +}
  3510. +
  3511. +static void set_floppy(int device)
  3512. +{
  3513. +    if (TYPE(device))
  3514. +        floppy = TYPE(device) + floppy_type;
  3515. +    else
  3516. +        floppy = current_type[ DRIVE(device) ];
  3517. +}
  3518. +
  3519. +/*
  3520. + * formatting and support.
  3521. + * =======================
  3522. + */
  3523. +static void format_interrupt(void)
  3524. +{
  3525. +    switch (interpret_errors()){
  3526. +    case 1:
  3527. +        cont->error();
  3528. +    case 2:
  3529. +        break;
  3530. +    case 0:
  3531. +        cont->done(1);
  3532. +    }
  3533. +    cont->redo();
  3534. +}
  3535. +#define CODE2SIZE (ssize = ( ( 1 << SIZECODE ) + 3 ) >> 2)
  3536. +#define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80 ) >>1))
  3537. +#define CT(x) ( (x) | 0x40 )
  3538. +static void setup_format_params(void)
  3539. +{
  3540. +    struct fparm {
  3541. +        unsigned char track,head,sect,size;
  3542. +    } *here = (struct fparm *)floppy_track_buffer;
  3543. +    int il,n;
  3544. +    int count,head_shift,track_shift;
  3545. +
  3546. +    raw_cmd.flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
  3547. +        /*FD_RAW_NEED_DISK |*/ FD_RAW_NEED_SEEK;
  3548. +    raw_cmd.rate = floppy->rate & 0x3;
  3549. +    raw_cmd.cmd_count = NR_F;
  3550. +    COMMAND = FM_MODE(floppy,FD_FORMAT);
  3551. +    DR_SELECT = UNIT(current_drive) + ( format_req.head << 2 );
  3552. +    F_SIZECODE = FD_SIZECODE(floppy);
  3553. +    F_SECT_PER_TRACK = floppy->sect << 2 >> F_SIZECODE;
  3554. +    F_GAP = floppy->fmt_gap;
  3555. +    F_FILL = FD_FILL_BYTE;
  3556. +
  3557. +    current_addr = floppy_track_buffer;
  3558. +    raw_cmd.length = 4 * F_SECT_PER_TRACK;
  3559. +
  3560. +    /* allow for about 30ms for data transport per track */
  3561. +    head_shift  = (F_SECT_PER_TRACK + 5) / 6;
  3562. +
  3563. +    /* a ``cylinder'' is two tracks plus a little stepping time */
  3564. +    track_shift = 2 * head_shift + 1;
  3565. +
  3566. +    /* position of logical sector 1 on this track */
  3567. +    n = (track_shift * format_req.track + head_shift * format_req.head )
  3568. +        % F_SECT_PER_TRACK;
  3569. +
  3570. +    /* determine interleave */
  3571. +    il = 1;
  3572. +    if (floppy->sect > DP->interleave_sect && F_SIZECODE == 2)
  3573. +        il++;
  3574. +
  3575. +    /* initialize field */
  3576. +    for (count = 0; count < F_SECT_PER_TRACK; ++count) {
  3577. +        here[count].track = format_req.track;
  3578. +        here[count].head = format_req.head;
  3579. +        here[count].sect = 0;
  3580. +        here[count].size = F_SIZECODE;
  3581. +    }
  3582. +    /* place logical sectors */
  3583. +    for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
  3584. +        here[n].sect = count;
  3585. +        n = (n+il) % F_SECT_PER_TRACK;
  3586. +        if (here[n].sect) { /* sector busy, find next free sector */
  3587. +            ++n;
  3588. +            if (n>= F_SECT_PER_TRACK) {
  3589. +                n-=F_SECT_PER_TRACK;
  3590. +                while (here[n].sect) ++n;
  3591. +            }
  3592. +        }
  3593. +    }
  3594. +}
  3595. +
  3596. +static void redo_format(void)
  3597. +{
  3598. +    raw_cmd.track = format_req.track << floppy->stretch;
  3599. +    buffer_track = -1;
  3600. +    setup_format_params();
  3601. +    clear_bit(current_drive, &changed_floppies);
  3602. +    floppy_start();
  3603. +#ifdef DEBUGT
  3604. +    debugt("queue format request");
  3605. +#endif
  3606. +}
  3607. +
  3608. +static struct cont_t format_cont={
  3609. +    format_interrupt,
  3610. +    redo_format,
  3611. +    bad_flp_intr,
  3612. +    generic_done };
  3613. +
  3614. +static int do_format(int device, struct format_descr *tmp_format_req)
  3615. +{
  3616. +    int okay;
  3617. +
  3618. +    LOCK_FDC(DRIVE(device),1);
  3619. +    set_floppy(device);
  3620. +    if (!floppy ||
  3621. +        tmp_format_req->track >= floppy->track ||
  3622. +        tmp_format_req->head >= floppy->head){
  3623. +        redo_fd_request();
  3624. +        return -EINVAL;
  3625. +    }
  3626. +    format_req = *tmp_format_req;
  3627. +    format_errors = 0;
  3628. +    cont = &format_cont;
  3629. +    errors = &format_errors;
  3630. +    CALL(okay=wait_til_done(redo_format,1));
  3631. +    redo_fd_request();
  3632. +    return okay;
  3633. +}
  3634. +
  3635. +/*
  3636. + * Buffer read/write and support
  3637. + * =============================
  3638. + */
  3639. +
  3640. +/* new request_done. Can handle physical sectors which are smaller than a
  3641. + * logical buffer */
  3642. +static void request_done(int uptodate)
  3643. +{
  3644. +    int block;
  3645. +
  3646. +    probing = 0;
  3647. +    timer_active &= ~(1 << FLOPPY_TIMER);
  3648. +
  3649. +    if (!CURRENT){
  3650. +        DPRINT("request list destroyed in floppy request done\n");
  3651. +        return;
  3652. +    }
  3653. +    if (uptodate){
  3654. +        /* maintain values for invalidation on geometry
  3655. +           change */
  3656. +        block = current_count_sectors + CURRENT->sector;
  3657. +        if (block > DRS->maxblock)
  3658. +            DRS->maxblock=block;
  3659. +        if ( block > floppy->sect)
  3660. +            DRS->maxtrack = 1;
  3661. +
  3662. +        /* unlock chained buffers */
  3663. +        while (current_count_sectors && CURRENT &&
  3664. +               current_count_sectors >= CURRENT->current_nr_sectors ){
  3665. +            current_count_sectors -= CURRENT->current_nr_sectors;
  3666. +            CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
  3667. +            CURRENT->sector += CURRENT->current_nr_sectors;
  3668. +            end_request(1);
  3669. +        }
  3670. +        if ( current_count_sectors && CURRENT){
  3671. +            /* "unlock" last subsector */
  3672. +            CURRENT->buffer += current_count_sectors <<9;
  3673. +            CURRENT->current_nr_sectors -= current_count_sectors;
  3674. +            CURRENT->nr_sectors -= current_count_sectors;
  3675. +            CURRENT->sector += current_count_sectors;
  3676. +            return;
  3677. +        }
  3678. +
  3679. +        if ( current_count_sectors && ! CURRENT )
  3680. +            DPRINT("request list destroyed in floppy request done\n");
  3681. +
  3682. +    } else {
  3683. +        if(CURRENT->cmd == WRITE) {
  3684. +            /* record write error information */
  3685. +            DRWE->write_errors++;
  3686. +            if(DRWE->write_errors == 1) {
  3687. +                DRWE->first_error_sector = CURRENT->sector;
  3688. +                DRWE->first_error_generation = DRS->generation;
  3689. +            }
  3690. +            DRWE->last_error_sector = CURRENT->sector;
  3691. +            DRWE->last_error_generation = DRS->generation;
  3692. +        }
  3693. +        end_request(0);
  3694. +    }
  3695. +}
  3696. +
  3697. +/* Interrupt handler evaluating the result of the r/w operation */
  3698. +static void rw_interrupt(void)
  3699. +{
  3700. +    int nr_sectors, ssize;
  3701. +
  3702. +    if ( ! DRS->first_read_date )
  3703. +        DRS->first_read_date = jiffies;
  3704. +
  3705. +    nr_sectors = 0;
  3706. +    CODE2SIZE;
  3707. +    nr_sectors = ((R_TRACK-TRACK)*floppy->head+R_HEAD-HEAD) *
  3708. +        floppy->sect + ((R_SECTOR-SECTOR) <<  SIZECODE >> 2) -
  3709. +            (sector_t % floppy->sect) % ssize;
  3710. +
  3711. +#ifdef SANITY
  3712. +    if ( nr_sectors > current_count_sectors + ssize -
  3713. +        (current_count_sectors + sector_t) % ssize +
  3714. +        sector_t % ssize){
  3715. +        DPRINT2("long rw: %x instead of %lx\n",
  3716. +            nr_sectors, current_count_sectors);
  3717. +        printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
  3718. +        printk("rh=%d h=%d\n", R_HEAD, HEAD);
  3719. +        printk("rt=%d t=%d\n", R_TRACK, TRACK);
  3720. +        printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
  3721. +               sector_t, ssize);
  3722. +    }
  3723. +#endif
  3724. +    if ( nr_sectors < 0 )
  3725. +        nr_sectors = 0;
  3726. +    if ( nr_sectors < current_count_sectors )
  3727. +        current_count_sectors = nr_sectors;
  3728. +
  3729. +    switch (interpret_errors()){
  3730. +    case 2:
  3731. +        cont->redo();
  3732. +        return;
  3733. +    case 1:
  3734. +        if (  !current_count_sectors){
  3735. +            cont->error();
  3736. +            cont->redo();
  3737. +            return;
  3738. +        }
  3739. +        break;
  3740. +    case 0:
  3741. +        if (  !current_count_sectors){
  3742. +            cont->redo();
  3743. +            return;
  3744. +        }
  3745. +        current_type[current_drive] = floppy;
  3746. +        floppy_sizes[DRIVE(current_drive) + (FDC(current_drive) << 7)] =
  3747. +            floppy->size >> 1;
  3748. +        break;
  3749. +    }
  3750. +
  3751. +    if (probing) {
  3752. +        if (DP->flags & FTD_MSG)
  3753. +            DPRINT2("Auto-detected floppy type %s in fd%d\n",
  3754. +                floppy->name,current_drive);
  3755. +        current_type[current_drive] = floppy;
  3756. +        floppy_sizes[DRIVE(current_drive) + (FDC(current_drive) << 7)] =
  3757. +            floppy->size >> 1;
  3758. +        probing = 0;
  3759. +    }
  3760. +
  3761. +    if ( CT(COMMAND) != FD_READ || current_addr == CURRENT->buffer ){
  3762. +        /* transfer directly from buffer */
  3763. +        cont->done(1);
  3764. +    } else if ( CT(COMMAND) == FD_READ){
  3765. +        buffer_track = raw_cmd.track;
  3766. +        buffer_drive = current_drive;
  3767. +        if ( nr_sectors + sector_t > buffer_max )
  3768. +            buffer_max = nr_sectors + sector_t;
  3769. +    }
  3770. +    cont->redo();
  3771. +}
  3772. +
  3773. +/* Compute maximal contiguous buffer size. */
  3774. +static int buffer_chain_size(void)
  3775. +{
  3776. +    struct buffer_head *bh;
  3777. +    int size;
  3778. +    char *base;
  3779. +
  3780. +    base = CURRENT->buffer;
  3781. +    size = CURRENT->current_nr_sectors << 9;
  3782. +    bh = CURRENT->bh;
  3783. +
  3784. +    if(bh){
  3785. +        bh = bh->b_reqnext;
  3786. +        while ( bh && bh->b_data == base + size ){
  3787. +            size += bh->b_size;
  3788. +            bh = bh->b_reqnext;
  3789. +        }
  3790. +    }
  3791. +    return size >> 9;
  3792. +}
  3793. +
  3794. +/* Compute the maximal transfer size */
  3795. +static int transfer_size(int ssize, int max_sector, int max_size)
  3796. +{
  3797. +    if ( max_sector > sector_t + max_size)
  3798. +        max_sector = sector_t + max_size;
  3799. +
  3800. +    /* alignment */
  3801. +    max_sector -= (max_sector % floppy->sect ) % ssize;
  3802. +
  3803. +    /* transfer size, beginning not aligned */
  3804. +    current_count_sectors = max_sector - sector_t ;
  3805. +
  3806. +    return max_sector;
  3807. +}
  3808. +
  3809. +/*
  3810. + * Move data from/to the track buffer to/from the buffer cache.
  3811. + */
  3812. +static void copy_buffer(int ssize, int max_sector, int max_sector_2)
  3813. +{
  3814. +    int remaining; /* number of transferred 512-byte sectors */
  3815. +    struct buffer_head *bh;
  3816. +    char *buffer, *dma_buffer;
  3817. +    int size;
  3818. +
  3819. +    if ( max_sector > max_sector_2 )
  3820. +        max_sector = max_sector_2;
  3821. +
  3822. +    max_sector = transfer_size(ssize, max_sector, CURRENT->nr_sectors);
  3823. +
  3824. +    if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
  3825. +        buffer_max > sector_t + CURRENT->nr_sectors){
  3826. +        current_count_sectors = buffer_max - sector_t;
  3827. +        if ( current_count_sectors > CURRENT->nr_sectors )
  3828. +            current_count_sectors = CURRENT->nr_sectors;
  3829. +    }
  3830. +    remaining = current_count_sectors << 9;
  3831. +#ifdef SANITY
  3832. +    if ((remaining >> 9) > CURRENT->nr_sectors  &&
  3833. +        CT(COMMAND) == FD_WRITE ){
  3834. +        DPRINT("in copy buffer\n");
  3835. +        printk("current_count_sectors=%ld\n", current_count_sectors);
  3836. +        printk("remaining=%d\n", remaining >> 9);
  3837. +        printk("CURRENT->nr_sectors=%ld\n",CURRENT->nr_sectors);
  3838. +        printk("CURRENT->current_nr_sectors=%ld\n",
  3839. +               CURRENT->current_nr_sectors);
  3840. +        printk("max_sector=%d\n", max_sector);
  3841. +        printk("ssize=%d\n", ssize);
  3842. +    }
  3843. +#endif
  3844. +
  3845. +    if ( max_sector > buffer_max )
  3846. +        buffer_max = max_sector;
  3847. +
  3848. +    dma_buffer = floppy_track_buffer + ((sector_t - buffer_min) << 9);
  3849. +
  3850. +    bh = CURRENT->bh;
  3851. +    size = CURRENT->current_nr_sectors << 9;
  3852. +    buffer = CURRENT->buffer;
  3853. +
  3854. +    while ( remaining > 0){
  3855. +        if ( size > remaining )
  3856. +            size = remaining;
  3857. +#ifdef SANITY
  3858. +        if (dma_buffer + size >
  3859. +            floppy_track_buffer + (max_buffer_sectors << 10) ||
  3860. +            dma_buffer < floppy_track_buffer ){
  3861. +            DPRINT1("buffer overrun in copy buffer %d\n",
  3862. +                (floppy_track_buffer - dma_buffer) >>9);
  3863. +            printk("sector_t=%d buffer_min=%d\n",
  3864. +                   sector_t, buffer_min);
  3865. +            printk("current_count_sectors=%ld\n",
  3866. +                   current_count_sectors);
  3867. +            if ( CT(COMMAND) == FD_READ )
  3868. +                printk("read\n");
  3869. +            if ( CT(COMMAND) == FD_READ )
  3870. +                printk("write\n");
  3871. +            break;
  3872. +        }
  3873. +        if ( ((int)buffer) % 512 )
  3874. +            DPRINT1("%p buffer not aligned\n", buffer);
  3875. +#endif
  3876. +        if ( CT(COMMAND) == FD_READ )
  3877. +            memcpy( buffer, dma_buffer, size);
  3878. +        else
  3879. +            memcpy( dma_buffer, buffer, size);
  3880. +        remaining -= size;
  3881. +        if ( !remaining)
  3882. +            break;
  3883. +
  3884. +        dma_buffer += size;
  3885. +        bh = bh->b_reqnext;
  3886. +#ifdef SANITY
  3887. +        if ( !bh){
  3888. +            DPRINT("bh=null in copy buffer after copy\n");
  3889. +            break;
  3890. +        }
  3891. +#endif
  3892. +        size = bh->b_size;
  3893. +        buffer = bh->b_data;
  3894. +    }
  3895. +#ifdef SANITY
  3896. +    if ( remaining ){
  3897. +        if ( remaining > 0 )
  3898. +            max_sector -= remaining >> 9;
  3899. +        DPRINT1("weirdness: remaining %d\n", remaining>>9);
  3900. +    }
  3901. +#endif
  3902. +}
  3903. +
  3904. +/*
  3905. + * Formulate a read/write request.
  3906. + * this routine decides where to load the data (directly to buffer, or to
  3907. + * tmp floppy area), how much data to load (the size of the buffer, the whole
  3908. + * track, or a single sector)
  3909. + * All floppy_track_buffer handling goes in here. If we ever add track buffer
  3910. + * allocation on the fly, it should be done here. No other part should need
  3911. + * modification.
  3912. + */
  3913. +
  3914. +static int make_raw_rw_request(void)
  3915. +{
  3916. +    int aligned_sector_t;
  3917. +    int max_sector, max_size, tracksize, ssize;
  3918. +
  3919. +    current_drive = DRIVE(CURRENT->dev);
  3920. +
  3921. +    raw_cmd.flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
  3922. +        FD_RAW_NEED_SEEK;
  3923. +    raw_cmd.cmd_count = NR_RW;
  3924. +    if (CURRENT->cmd == READ){
  3925. +        raw_cmd.flags |= FD_RAW_READ;
  3926. +        COMMAND = FM_MODE(floppy,FD_READ);
  3927. +    } else if (CURRENT->cmd == WRITE){
  3928. +        raw_cmd.flags |= FD_RAW_WRITE;
  3929. +        COMMAND = FM_MODE(floppy,FD_WRITE);
  3930. +    } else {
  3931. +        DPRINT("make_raw_rw_request: unknown command\n");
  3932. +        return 0;
  3933. +    }
  3934. +
  3935. +    max_sector = floppy->sect * floppy->head;
  3936. +    TRACK = CURRENT->sector / max_sector;
  3937. +    sector_t = CURRENT->sector % max_sector;
  3938. +    if ( floppy->track && TRACK >= floppy->track )
  3939. +        return 0;
  3940. +    HEAD = sector_t / floppy->sect;
  3941. +
  3942. +    if ( (DRS->flags & FD_NEED_TWADDLE) && sector_t < floppy->sect )
  3943. +        max_sector = floppy->sect;
  3944. +
  3945. +    /* 2M disks have phantom sectors on the first track */
  3946. +    if ( (floppy->rate & FD_2M ) && (!TRACK) && (!HEAD)){
  3947. +        max_sector = 2 * floppy->sect / 3;
  3948. +        if (sector_t >= max_sector){
  3949. +            current_count_sectors =  (floppy->sect - sector_t);
  3950. +            if ( current_count_sectors > CURRENT->nr_sectors )
  3951. +                current_count_sectors = CURRENT->nr_sectors;
  3952. +            return 1;
  3953. +        }
  3954. +        SIZECODE = 2;
  3955. +    } else
  3956. +        SIZECODE = FD_SIZECODE(floppy);
  3957. +    raw_cmd.rate = floppy->rate & 3;
  3958. +    if ((floppy->rate & FD_2M) &&
  3959. +        (TRACK || HEAD ) &&
  3960. +        raw_cmd.rate == 2)
  3961. +        raw_cmd.rate = 1;
  3962. +
  3963. +    if ( SIZECODE )
  3964. +        SIZECODE2 = 0xff;
  3965. +    else
  3966. +        SIZECODE2 = 0x80;
  3967. +    raw_cmd.track = TRACK << floppy->stretch;
  3968. +    DR_SELECT = UNIT(current_drive) + ( HEAD << 2 );
  3969. +    GAP = floppy->gap;
  3970. +    CODE2SIZE;
  3971. +    SECT_PER_TRACK = floppy->sect << 2 >> SIZECODE;
  3972. +    SECTOR = ((sector_t % floppy->sect) << 2 >> SIZECODE) + 1;
  3973. +    tracksize = floppy->sect - floppy->sect % ssize;
  3974. +    if ( tracksize < floppy->sect ){
  3975. +        SECT_PER_TRACK ++;
  3976. +        if (  tracksize <= sector_t % floppy->sect)
  3977. +            SECTOR--;
  3978. +        while ( tracksize <= sector_t % floppy->sect){
  3979. +            while( tracksize + ssize > floppy->sect ){
  3980. +                SIZECODE--;
  3981. +                ssize >>= 1;
  3982. +            }
  3983. +            SECTOR++; SECT_PER_TRACK ++;
  3984. +            tracksize += ssize;
  3985. +        }
  3986. +        max_sector = HEAD * floppy->sect + tracksize;
  3987. +    } else if ( !TRACK && !HEAD && !( floppy->rate & FD_2M ) && probing)
  3988. +        max_sector = floppy->sect;
  3989. +
  3990. +    aligned_sector_t = sector_t - ( sector_t % floppy->sect ) % ssize;
  3991. +    max_size = CURRENT->nr_sectors;
  3992. +    if ((raw_cmd.track == buffer_track) && (current_drive == buffer_drive) &&
  3993. +        (sector_t >= buffer_min) && (sector_t < buffer_max)) {
  3994. +        /* data already in track buffer */
  3995. +        if (CT(COMMAND) == FD_READ) {
  3996. +            copy_buffer(1, max_sector, buffer_max);
  3997. +            return 1;
  3998. +        }
  3999. +    } else if (aligned_sector_t != sector_t || CURRENT->nr_sectors < ssize){
  4000. +        if (CT(COMMAND) == FD_WRITE){
  4001. +            if(sector_t + CURRENT->nr_sectors > ssize &&
  4002. +               sector_t + CURRENT->nr_sectors < ssize + ssize)
  4003. +                max_size = ssize + ssize;
  4004. +            else
  4005. +                max_size = ssize;
  4006. +        }
  4007. +        raw_cmd.flags &= ~FD_RAW_WRITE;
  4008. +        raw_cmd.flags |= FD_RAW_READ;
  4009. +        COMMAND = FM_MODE(floppy,FD_READ);
  4010. +    }
  4011. +    else if ((long)CURRENT->buffer <= LAST_DMA_ADDR ) {
  4012. +        int direct, indirect;
  4013. +
  4014. +        indirect= transfer_size(ssize,max_sector,max_buffer_sectors*2) -
  4015. +            sector_t;
  4016. +
  4017. +        max_size = buffer_chain_size();
  4018. +#if 0
  4019. +        if ( max_size > ( LAST_DMA_ADDR - ((long) CURRENT->buffer))>>9)
  4020. +            max_size=(LAST_DMA_ADDR - ((long)CURRENT->buffer))>>9;
  4021. +        /* 64 kb boundaries */
  4022. +        if ( ((max_size << 9) + ((long) CURRENT->buffer)) / K_64 !=
  4023. +             ((long) CURRENT->buffer ) / K_64 )
  4024. +            max_size = ( K_64 - ((long) CURRENT->buffer) % K_64)>>9;
  4025. +#endif
  4026. +        direct = transfer_size(ssize,max_sector,max_size) - sector_t;
  4027. +        /*
  4028. +         * We try to read tracks, but if we get too many errors, we
  4029. +         * go back to reading just one sector at a time.
  4030. +         *
  4031. +         * This means we should be able to read a sector even if there
  4032. +         * are other bad sectors on this track.
  4033. +         */
  4034. +        if ((indirect - sector_t) * 2 > (direct - sector_t) * 3 &&
  4035. +            *errors < DP->max_errors.read_track &&
  4036. +            /*!(DRS->flags & FD_NEED_TWADDLE) &&*/
  4037. +            ( ( !probing || (DP->read_track &
  4038. +               (1 <<DRS->probed_format))))){
  4039. +            max_size = CURRENT->nr_sectors;
  4040. +        } else {
  4041. +            current_addr = CURRENT->buffer;
  4042. +            raw_cmd.length = current_count_sectors << 9;
  4043. +            return 2;
  4044. +        }
  4045. +    }
  4046. +
  4047. +    if ( CT(COMMAND) == FD_READ )
  4048. +        max_size = max_sector; /* unbounded */
  4049. +
  4050. +    /* claim buffer track if needed */
  4051. +    if (buffer_track != raw_cmd.track ||  /* bad track */
  4052. +        buffer_drive !=current_drive || /* bad drive */
  4053. +        sector_t < buffer_min ||
  4054. +        ((CT(COMMAND) == FD_READ ||
  4055. +          (aligned_sector_t == sector_t && CURRENT->nr_sectors >= ssize ))&&
  4056. +         max_sector > 2 * max_buffer_sectors + buffer_min &&
  4057. +         max_size + sector_t > 2 * max_buffer_sectors + buffer_min)
  4058. +        /* not enough space */ ){
  4059. +        buffer_track = -1;
  4060. +        buffer_drive = current_drive;
  4061. +        buffer_max = buffer_min = aligned_sector_t;
  4062. +    }
  4063. +    current_addr = floppy_track_buffer +((aligned_sector_t-buffer_min )<<9);
  4064. +
  4065. +    if ( CT(COMMAND) == FD_WRITE ){
  4066. +        /* copy write buffer to track buffer.
  4067. +         * if we get here, we know that the write
  4068. +         * is either aligned or the data already in the buffer
  4069. +         * (buffer will be overwritten) */
  4070. +#ifdef SANITY
  4071. +        if (sector_t != aligned_sector_t && buffer_track == -1 )
  4072. +            DPRINT("internal error offset !=0 on write\n");
  4073. +#endif
  4074. +        buffer_track = raw_cmd.track;
  4075. +        buffer_drive = current_drive;
  4076. +        copy_buffer(ssize, max_sector, 2*max_buffer_sectors+buffer_min);
  4077. +    } else
  4078. +        transfer_size(ssize, max_sector,
  4079. +                  2*max_buffer_sectors+buffer_min-aligned_sector_t);
  4080. +
  4081. +    /* round up current_count_sectors to get dma xfer size */
  4082. +    raw_cmd.length = sector_t+current_count_sectors-aligned_sector_t;
  4083. +    raw_cmd.length = ((raw_cmd.length -1)|(ssize-1))+1;
  4084. +    raw_cmd.length <<= 9;
  4085. +
  4086. +#ifdef SANITY
  4087. +    if ((raw_cmd.length < current_count_sectors << 9) ||
  4088. +        (current_addr != CURRENT->buffer &&
  4089. +         CT(COMMAND) == FD_WRITE &&
  4090. +         (aligned_sector_t + (raw_cmd.length >> 9) > buffer_max ||
  4091. +          aligned_sector_t < buffer_min )) ||
  4092. +        raw_cmd.length % ( 128 << SIZECODE ) ||
  4093. +        raw_cmd.length <= 0 || current_count_sectors <= 0){
  4094. +        DPRINT2("fractionary current count b=%lx s=%lx\n",
  4095. +            raw_cmd.length, current_count_sectors);
  4096. +        if ( current_addr != CURRENT->buffer )
  4097. +            printk("addr=%d, length=%ld\n",
  4098. +                   (current_addr - floppy_track_buffer ) >> 9,
  4099. +                   current_count_sectors);
  4100. +        printk("st=%d ast=%d mse=%d msi=%d\n",
  4101. +               sector_t, aligned_sector_t, max_sector, max_size);
  4102. +        printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
  4103. +        printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
  4104. +               COMMAND, SECTOR, HEAD, TRACK);
  4105. +        printk("buffer drive=%d\n", buffer_drive);
  4106. +        printk("buffer track=%d\n", buffer_track);
  4107. +        printk("buffer_min=%d\n", buffer_min );
  4108. +        printk("buffer_max=%d\n", buffer_max );
  4109. +        return 0;
  4110. +    }
  4111. +
  4112. +    if (current_addr != CURRENT->buffer ){
  4113. +        if (current_addr < floppy_track_buffer ||
  4114. +            current_count_sectors < 0 ||
  4115. +            raw_cmd.length < 0 ||
  4116. +            current_addr + raw_cmd.length >
  4117. +            floppy_track_buffer + (max_buffer_sectors  << 10)){
  4118. +            DPRINT("buffer overrun in schedule dma\n");
  4119. +            printk("sector_t=%d buffer_min=%d current_count=%ld\n",
  4120. +                   sector_t, buffer_min,
  4121. +                   raw_cmd.length >> 9 );
  4122. +            printk("current_count_sectors=%ld\n",
  4123. +                   current_count_sectors);
  4124. +            if ( CT(COMMAND) == FD_READ )
  4125. +                printk("read\n");
  4126. +            if ( CT(COMMAND) == FD_READ )
  4127. +                printk("write\n");
  4128. +            return 0;
  4129. +        }
  4130. +    } else if (raw_cmd.length > CURRENT->nr_sectors << 9 ||
  4131. +           current_count_sectors > CURRENT->nr_sectors){
  4132. +        DPRINT("buffer overrun in direct transfer\n");
  4133. +        return 0;
  4134. +    } else if ( raw_cmd.length < current_count_sectors << 9 ){
  4135. +        DPRINT("more sectors than bytes\n");
  4136. +        printk("bytes=%ld\n", raw_cmd.length >> 9 );
  4137. +        printk("sectors=%ld\n", current_count_sectors);
  4138. +    }
  4139. +#endif
  4140. +    return 2;
  4141. +}
  4142. +
  4143. +static struct cont_t rw_cont={
  4144. +    rw_interrupt,
  4145. +    redo_fd_request,
  4146. +    bad_flp_intr,
  4147. +    request_done };
  4148. +
  4149. +static void redo_fd_request(void)
  4150. +{
  4151. +#define REPEAT {request_done(0); continue; }
  4152. +    int device;
  4153. +    int tmp;
  4154. +
  4155. +    if (current_drive < N_DRIVE)
  4156. +        floppy_off(current_drive);
  4157. +
  4158. +    if (CURRENT && CURRENT->dev < 0) return;
  4159. +
  4160. +    cont = &rw_cont;
  4161. +    while(1){
  4162. +        if (!CURRENT) {
  4163. +            CLEAR_INTR;
  4164. +            unlock_fdc();
  4165. +            return;
  4166. +        }
  4167. +        if (MAJOR(CURRENT->dev) != MAJOR_NR)
  4168. +            panic(DEVICE_NAME ": request list destroyed");
  4169. +        if (CURRENT->bh && !CURRENT->bh->b_lock)
  4170. +            panic(DEVICE_NAME ": block not locked");
  4171. +
  4172. +        device = CURRENT->dev;
  4173. +        set_fdc( DRIVE(device));
  4174. +
  4175. +        timer_table[FLOPPY_TIMER].expires = jiffies + DP->timeout;
  4176. +        timer_active |= 1 << FLOPPY_TIMER;
  4177. +        raw_cmd.flags=0;
  4178. +        start_motor();
  4179. +        if(test_bit( DRIVE(device), &fake_change) ||
  4180. +           test_bit( DRIVE(device), &changed_floppies)){
  4181. +            DPRINT("disk absent or changed during operation\n");
  4182. +            REPEAT;
  4183. +        }
  4184. +        set_floppy(device);
  4185. +        if (!floppy) { /* Autodetection */
  4186. +            if (!probing){
  4187. +                DRS->probed_format = 0;
  4188. +                if ( next_valid_format() ){
  4189. +                    DPRINT("no autodetectable formats\n");
  4190. +                    floppy = NULL;
  4191. +                    REPEAT;
  4192. +                }
  4193. +            }
  4194. +            probing = 1;
  4195. +            floppy = floppy_type+DP->autodetect[DRS->probed_format];
  4196. +        } else
  4197. +            probing = 0;
  4198. +        errors = & (CURRENT->errors);
  4199. +        tmp = make_raw_rw_request();
  4200. +        if ( tmp < 2 ){
  4201. +            request_done(tmp);
  4202. +            continue;
  4203. +        }
  4204. +
  4205. +        floppy_tq.routine = (void (*)(void *)) floppy_start;
  4206. +        queue_task(&floppy_tq, &tq_timer);
  4207. +#ifdef DEBUGT
  4208. +        debugt("queue fd request");
  4209. +#endif
  4210. +        return;
  4211. +    }
  4212. +#undef REPEAT
  4213. +}
  4214. +
  4215. +void do_fd_request(void)
  4216. +{
  4217. +    if (fdc_busy)
  4218. +        /* fdc busy, this new request will be treated when the
  4219. +           current one is done */
  4220. +        return;
  4221. +    /* fdc_busy cannot be set by an interrupt or a bh */
  4222. +    floppy_grab_irq_and_dma();
  4223. +    fdc_busy=1;
  4224. +    redo_fd_request();
  4225. +}
  4226. +
  4227. +/*
  4228. + * User triggered reset
  4229. + * ====================
  4230. + */
  4231. +
  4232. +static void reset_intr(void)
  4233. +{
  4234. +    printk("weird, reset interrupt called\n");
  4235. +}
  4236. +
  4237. +static struct cont_t reset_cont={
  4238. +    reset_intr,
  4239. +    success_and_wakeup,
  4240. +    generic_failure,
  4241. +    generic_done };
  4242. +
  4243. +static int user_reset_fdc(int drive, int arg, int interruptible)
  4244. +{
  4245. +    int result;
  4246. +
  4247. +    result=0;
  4248. +    LOCK_FDC(drive,interruptible);
  4249. +    switch(arg){
  4250. +    case FD_RESET_ALWAYS:
  4251. +        FDCS->reset=1;
  4252. +        break;
  4253. +    case FD_RESET_IF_RAWCMD:
  4254. +        if(FDCS->rawcmd == 2 )
  4255. +            reset_fdc_info(1);
  4256. +        break;
  4257. +    }
  4258. +    if ( FDCS->reset ){
  4259. +        cont = &reset_cont;
  4260. +        timer_table[FLOPPY_TIMER].expires = jiffies + 5;
  4261. +        timer_active |= 1 << FLOPPY_TIMER;
  4262. +        CALL(result=wait_til_done(reset_fdc,interruptible));
  4263. +    }
  4264. +    if ( UDRS->track == PROVEN_ABSENT )
  4265. +        UDRS->track = NEED_2_RECAL;
  4266. +    redo_fd_request();
  4267. +    return result;
  4268. +}
  4269. +
  4270. +/*
  4271. + * Misc Ioctl's and support
  4272. + * ========================
  4273. + */
  4274. +static int fd_copyout(void *param, volatile void *address, int size)
  4275. +{
  4276. +    int i;
  4277. +
  4278. +    i = verify_area(VERIFY_WRITE,param,size);
  4279. +    if (i)
  4280. +        return i;
  4281. +    memcpy_tofs(param,(void *) address, size);
  4282. +    return 0;
  4283. +}
  4284. +
  4285. +#define COPYOUT(x) (fd_copyout( (void *)param, &(x), sizeof(x)))
  4286. +#define COPYIN(x) (memcpy_fromfs( &(x), (void *) param, sizeof(x)),0)
  4287. +
  4288. +static char *drive_name(int type, int drive )
  4289. +{
  4290. +    struct floppy_struct *floppy;
  4291. +
  4292. +    if ( type )
  4293. +        floppy = floppy_type + type;
  4294. +    else {
  4295. +        if ( UDP->native_format )
  4296. +            floppy = floppy_type + UDP->native_format;
  4297. +        else
  4298. +            return "(null)";
  4299. +    }
  4300. +    if ( floppy->name )
  4301. +        return floppy->name;
  4302. +    else
  4303. +        return "(null)";
  4304. +}
  4305. +
  4306. +/* raw commands */
  4307. +static struct cont_t raw_cmd_cont={
  4308. +    success_and_wakeup,
  4309. +    failure_and_wakeup,
  4310. +    generic_failure,
  4311. +    generic_done };
  4312. +
  4313. +static int raw_cmd_ioctl(int drive, void *param)
  4314. +{
  4315. +    int i, count, ret;
  4316. +
  4317. +    if ( FDCS->rawcmd <= 1 )
  4318. +        FDCS->rawcmd = 1;
  4319. +    for ( i= 0; i < N_DRIVE; i++){
  4320. +        if ( FDC(i) != fdc)
  4321. +            continue;
  4322. +        if ( i == drive ){
  4323. +            if ( drive_state[i].fd_ref > 1 ){
  4324. +                FDCS->rawcmd = 2;
  4325. +                break;
  4326. +            }
  4327. +        } else if ( drive_state[i].fd_ref ){
  4328. +            FDCS->rawcmd = 2;
  4329. +            break;
  4330. +        }
  4331. +    }
  4332. +
  4333. +    if(FDCS->reset)
  4334. +        return -EIO;
  4335. +
  4336. +    COPYIN(raw_cmd);
  4337. +    raw_cmd.rate &= 0x03;
  4338. +    count = raw_cmd.length;
  4339. +    if (raw_cmd.flags & (FD_RAW_WRITE | FD_RAW_READ)){
  4340. +        if(count > max_buffer_sectors * 1024 )
  4341. +            return -ENOMEM;
  4342. +        buffer_track = -1;
  4343. +    }
  4344. +    if ( raw_cmd.flags & FD_RAW_WRITE ){
  4345. +        i = verify_area(VERIFY_READ, raw_cmd.data, count );
  4346. +        if (i)
  4347. +            return i;
  4348. +        memcpy_fromfs(floppy_track_buffer, raw_cmd.data, count);
  4349. +    }
  4350. +
  4351. +    current_addr = floppy_track_buffer;
  4352. +    cont = &raw_cmd_cont;
  4353. +    CALL(ret=wait_til_done(floppy_start,1));
  4354. +    if( disk_change(current_drive) )
  4355. +        raw_cmd.flags |= FD_RAW_DISK_CHANGE;
  4356. +    else
  4357. +        raw_cmd.flags &= ~FD_RAW_DISK_CHANGE;
  4358. +    if(raw_cmd.flags & FD_RAW_NO_MOTOR_AFTER)
  4359. +        motor_off_callback(drive);
  4360. +
  4361. +    if ( !ret && !FDCS->reset ){
  4362. +        raw_cmd.reply_count = inr;
  4363. +        for( i=0; i< raw_cmd.reply_count; i++)
  4364. +            raw_cmd.reply[i] = reply_buffer[i];
  4365. +        if ( raw_cmd.flags & ( FD_RAW_READ | FD_RAW_WRITE ))
  4366. +            raw_cmd.length = get_dma_residue(FLOPPY_DMA);
  4367. +    } else
  4368. +        ret = -EIO;
  4369. +
  4370. +    DRS->track = NO_TRACK;
  4371. +    if ( ret )
  4372. +        return ret;
  4373. +
  4374. +    if ( raw_cmd.flags & FD_RAW_READ ){
  4375. +        i=fd_copyout( raw_cmd.data, floppy_track_buffer, count);
  4376. +        if (i)
  4377. +            return i;
  4378. +    }
  4379. +
  4380. +    return COPYOUT(raw_cmd);
  4381. +}
  4382. +
  4383. +static int invalidate_drive(int rdev)
  4384. +{
  4385. +    /* invalidate the buffer track to force a reread */
  4386. +    set_bit( DRIVE(rdev), &fake_change);
  4387. +    redo_fd_request();
  4388. +    check_disk_change(rdev);
  4389. +    return 0;
  4390. +}
  4391. +
  4392. +static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
  4393. +    unsigned long param)
  4394. +{
  4395. +#define IOCTL_MODE_BIT 8
  4396. +#define IOCTL_ALLOWED (filp && (filp->f_mode & IOCTL_MODE_BIT))
  4397. +
  4398. +    struct floppy_struct newparams;
  4399. +    struct format_descr tmp_format_req;
  4400. +    int i,device,drive,type,cnt;
  4401. +    struct floppy_struct *this_floppy;
  4402. +    char *name;
  4403. +
  4404. +    device = inode->i_rdev;
  4405. +    switch (cmd) {
  4406. +        RO_IOCTLS(device,param);
  4407. +    }
  4408. +    type = TYPE(device);
  4409. +    drive = DRIVE(device);
  4410. +    switch (cmd) {
  4411. +    case FDGETDRVTYP:
  4412. +        i=verify_area(VERIFY_WRITE,(void *) param,16);
  4413. +        if (i)
  4414. +            return i;
  4415. +        name = drive_name(type,drive);
  4416. +        for ( cnt=0; cnt<16; cnt++){
  4417. +            put_fs_byte(name[cnt],
  4418. +                    ((char*)param)+cnt);
  4419. +            if ( ! *name )
  4420. +                break;
  4421. +        }
  4422. +        return 0;
  4423. +    case FDGETMAXERRS:
  4424. +        return COPYOUT(UDP->max_errors);
  4425. +    case FDGETPRM:
  4426. +        if (type)
  4427. +            this_floppy = &floppy_type[type];
  4428. +        else if ((this_floppy = current_type[drive]) ==
  4429. +             NULL)
  4430. +            return -ENODEV;
  4431. +        return COPYOUT(this_floppy[0]);
  4432. +    case FDPOLLDRVSTAT:
  4433. +        check_disk_change(device);
  4434. +        /* fall through */
  4435. +    case FDGETDRVSTAT:
  4436. +        return COPYOUT(*UDRS);
  4437. +    case FDGETFDCSTAT:
  4438. +        return COPYOUT(*UFDCS);
  4439. +    case FDGETDRVPRM:
  4440. +        return COPYOUT(*UDP);
  4441. +    case FDWERRORGET:
  4442. +        return COPYOUT(*UDRWE);
  4443. +    }
  4444. +
  4445. +    if (!IOCTL_ALLOWED)
  4446. +        return -EPERM;
  4447. +
  4448. +    switch (cmd) {
  4449. +    case FDWERRORCLR:
  4450. +                UDRWE->write_errors = 0;
  4451. +                UDRWE->first_error_sector = 0;
  4452. +                UDRWE->first_error_generation = 0;
  4453. +                UDRWE->last_error_sector = 0;
  4454. +                UDRWE->last_error_generation = 0;
  4455. +                UDRWE->badness = 0;
  4456. +                return 0;
  4457. +    case FDRAWCMD:
  4458. +        if (type)
  4459. +            return -EINVAL;
  4460. +        LOCK_FDC(drive,1);
  4461. +        set_floppy(device);
  4462. +        CALL(i = raw_cmd_ioctl(drive, (void *) param));
  4463. +        redo_fd_request();
  4464. +        return i;
  4465. +    case FDFMTTRK:
  4466. +        if (UDRS->fd_ref != 1)
  4467. +            return -EBUSY;
  4468. +        if (UDRS->track == PROVEN_ABSENT)
  4469. +            return -ENXIO;
  4470. +        COPYIN(tmp_format_req);
  4471. +        return do_format(device, &tmp_format_req);
  4472. +    case FDSETMAXERRS:
  4473. +        return COPYIN(UDP->max_errors);
  4474. +    case FDFMTBEG:
  4475. +        return 0;
  4476. +    case FDCLRPRM:
  4477. +        LOCK_FDC(drive,1);
  4478. +        current_type[drive] = NULL;
  4479. +        floppy_sizes[drive] = 2;
  4480. +        UDRS->keep_data = 0;
  4481. +        return invalidate_drive(device);
  4482. +    case FDFMTEND:
  4483. +    case FDFLUSH:
  4484. +        LOCK_FDC(drive,1);
  4485. +        return invalidate_drive(device);
  4486. +    case FDSETPRM:
  4487. +    case FDDEFPRM:
  4488. +        COPYIN(newparams);
  4489. +        /* sanity checking for parameters.*/
  4490. +        if(newparams.sect <= 0 ||
  4491. +           newparams.head <= 0 ||
  4492. +           newparams.track <= 0 ||
  4493. +           newparams.track >
  4494. +           UDP->tracks>>newparams.stretch)
  4495. +            return -EINVAL;
  4496. +        if ( type){
  4497. +            if ( !suser() )
  4498. +                return -EPERM;
  4499. +            LOCK_FDC(-1,1);
  4500. +            for ( cnt = 0; cnt < N_DRIVE; cnt++){
  4501. +                if (TYPE(drive_state[cnt].fd_device) == type &&
  4502. +                    drive_state[cnt].fd_ref)
  4503. +                    set_bit(drive, &fake_change);
  4504. +            }
  4505. +            floppy_type[type] = newparams;
  4506. +            floppy_type[type].name="user format";
  4507. +            for (cnt = type << 2 ;
  4508. +                 cnt < (type << 2 ) + 4 ;
  4509. +                 cnt++)
  4510. +                floppy_sizes[cnt]=
  4511. +#ifdef HAVE_2_CONTROLLERS
  4512. +                    floppy_sizes[cnt+0x80]=
  4513. +#endif
  4514. +                        floppy_type[type].size>>1;
  4515. +            redo_fd_request();
  4516. +            for ( cnt = 0; cnt < N_DRIVE; cnt++){
  4517. +                if (TYPE(drive_state[cnt].fd_device) == type &&
  4518. +                    drive_state[cnt].fd_ref)
  4519. +                    check_disk_change(drive_state[cnt].
  4520. +                              fd_device);
  4521. +            }
  4522. +            return 0;
  4523. +        }
  4524. +
  4525. +        LOCK_FDC(drive,1);
  4526. +        if ( cmd != FDDEFPRM ){
  4527. +            /* notice a disk change immediately, else
  4528. +             * we loose our settings immediately*/
  4529. +            raw_cmd.flags = 0;
  4530. +            start_motor();
  4531. +        }
  4532. +        user_params[drive] = newparams;
  4533. +        if (buffer_drive == drive &&
  4534. +            buffer_max > user_params[drive].sect)
  4535. +            buffer_max=user_params[drive].sect;
  4536. +        current_type[drive] = &user_params[drive];
  4537. +        floppy_sizes[drive] = user_params[drive].size >> 1;
  4538. +        if (cmd == FDDEFPRM)
  4539. +            DRS->keep_data = -1;
  4540. +        else
  4541. +            DRS->keep_data = 1;
  4542. +        /* invalidation. Invalidate only when needed, i.e.
  4543. +         * when there are already sectors in the buffer cache
  4544. +         * whose number will change. This is useful, because
  4545. +         * mtools often changes the geometry of the disk after
  4546. +         * looking at the boot block */
  4547. +        if (DRS->maxblock >
  4548. +            user_params[drive].sect ||
  4549. +            DRS->maxtrack )
  4550. +            invalidate_drive(device);
  4551. +        else
  4552. +            redo_fd_request();
  4553. +        return 0;
  4554. +    case FDRESET:
  4555. +        return user_reset_fdc( drive, (int)param, 1);
  4556. +    case FDMSGON:
  4557. +        UDP->flags |= FTD_MSG;
  4558. +        return 0;
  4559. +    case FDMSGOFF:
  4560. +        UDP->flags &= ~FTD_MSG;
  4561. +        return 0;
  4562. +    case FDSETEMSGTRESH:
  4563. +        UDP->max_errors.reporting =
  4564. +            (unsigned short) (param & 0x0f);
  4565. +        return 0;
  4566. +    case FDTWADDLE:
  4567. +        LOCK_FDC(drive,1);
  4568. +        twaddle();
  4569. +        redo_fd_request();
  4570. +    }
  4571. +    if ( ! suser() )
  4572. +        return -EPERM;
  4573. +    switch(cmd){
  4574. +    case FDSETDRVPRM:
  4575. +        return COPYIN(*UDP);
  4576. +    default:
  4577. +        return -EINVAL;
  4578. +    }
  4579. +    return 0;
  4580. +#undef IOCTL_ALLOWED
  4581. +}
  4582. +
  4583. +static void set_base_type(int drive, int code)
  4584. +{
  4585. +    if(code>0 && code <= NUMBER(default_drive_params)+1) {
  4586. +        memcpy((char *)UDP,
  4587. +            (char *)(&default_drive_params[code-1].params),
  4588. +            sizeof(struct floppy_drive_params));
  4589. +        printk("fd%d is %s", drive, default_drive_params[code-1].name);
  4590. +        return;
  4591. +    }
  4592. +    else if (!code)
  4593. +        printk("fd%d is not installed", drive);
  4594. +    else
  4595. +        printk("fd%d is unknown type %d", drive, code);
  4596. +}
  4597. +
  4598. +static void config_types(void)
  4599. +{
  4600. +    int drive;
  4601. +
  4602. +    for (drive=0; drive<N_DRIVE ; drive++){
  4603. +          /* default type for unidentifiable drives */
  4604. +          memcpy((char *) UDP, (char *) (&default_drive_params->params),
  4605. +              sizeof( struct floppy_drive_params ));
  4606. +    }
  4607. +    printk("Floppy drive(s): ");
  4608. +    for(drive=0; drive<no_floppies; drive++)
  4609. +    {
  4610. +      set_base_type(drive, 1+4);
  4611. +      if(drive < no_floppies-1)
  4612. +        printk(", ");
  4613. +    }
  4614. +    printk("\n");
  4615. +}
  4616. +
  4617. +int floppy_is_wp( int minor)
  4618. +{
  4619. +    check_disk_change(minor + (MAJOR_NR << 8));
  4620. +    return ! ( drive_state[ DRIVE(minor) ].flags & FD_DISK_WRITABLE );
  4621. +}
  4622. +
  4623. +
  4624. +#define WRAPPER(op) \
  4625. +static int floppy_##op(struct inode * inode, struct file * filp, \
  4626. +             char * buf, int count) \
  4627. +{ \
  4628. +    check_disk_change(inode->i_rdev); \
  4629. +    if ( drive_state[DRIVE(inode->i_rdev)].track == PROVEN_ABSENT ) \
  4630. +         return -ENXIO; \
  4631. +    if ( test_bit(DRIVE(inode->i_rdev),&changed_floppies)) \
  4632. +        return -ENXIO; \
  4633. +    return block_##op(inode, filp, buf, count); \
  4634. +}
  4635. +
  4636. +WRAPPER(read)
  4637. +WRAPPER(write)
  4638. +
  4639. +static void floppy_release(struct inode * inode, struct file * filp)
  4640. +{
  4641. +    int drive;
  4642. +
  4643. +    drive = DRIVE(inode->i_rdev);
  4644. +
  4645. +    fsync_dev(inode->i_rdev);
  4646. +
  4647. +    if (UDRS->fd_ref < 0)
  4648. +        UDRS->fd_ref=0;
  4649. +    else if (!UDRS->fd_ref--) {
  4650. +        DPRINT("floppy_release with fd_ref == 0");
  4651. +        UDRS->fd_ref = 0;
  4652. +    }
  4653. +    floppy_release_irq_and_dma();
  4654. +}
  4655. +
  4656. +/*
  4657. + * floppy_open check for aliasing (/dev/fd0 can be the same as
  4658. + * /dev/PS0 etc), and disallows simultaneous access to the same
  4659. + * drive with different device numbers.
  4660. + */
  4661. +#define RETERR(x) \
  4662. +    do{floppy_release(inode,filp); \
  4663. +       return -(x);}while(0)
  4664. +
  4665. +static int floppy_open(struct inode * inode, struct file * filp)
  4666. +{
  4667. +    int drive;
  4668. +    int old_dev;
  4669. +
  4670. +    if (!filp) {
  4671. +        DPRINT("Weird, open called with filp=0\n");
  4672. +        return -EIO;
  4673. +    }
  4674. +
  4675. +    drive = DRIVE(inode->i_rdev);
  4676. +    if ( drive >= N_DRIVE || !( ALLOWED_DRIVE_MASK & ( 1 << drive)) )
  4677. +        return -ENXIO;
  4678. +
  4679. +    if (TYPE(inode->i_rdev) >= NUMBER(floppy_type))
  4680. +        return -ENXIO;
  4681. +
  4682. +    if ((filp->f_mode & 3)  &&
  4683. +        UDRS->track == PROVEN_ABSENT )
  4684. +        return -ENXIO;
  4685. +
  4686. +    old_dev = UDRS->fd_device;
  4687. +    if (UDRS->fd_ref && old_dev != inode->i_rdev)
  4688. +        return -EBUSY;
  4689. +
  4690. +    if(UDRS->fd_ref == -1 ||
  4691. +       (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
  4692. +        return -EBUSY;
  4693. +
  4694. +    if (floppy_grab_irq_and_dma())
  4695. +        return -EBUSY;
  4696. +
  4697. +    if(filp->f_flags & O_EXCL)
  4698. +        UDRS->fd_ref = -1;
  4699. +    else
  4700. +        UDRS->fd_ref++;
  4701. +
  4702. +    UDRS->fd_device = inode->i_rdev;
  4703. +
  4704. +    if (old_dev && old_dev != inode->i_rdev) {
  4705. +        if (buffer_drive == drive)
  4706. +            buffer_track = -1;
  4707. +        invalidate_buffers(old_dev);
  4708. +    }
  4709. +
  4710. +    /* Allow ioctls if we have write-permissions even if read-only open */
  4711. +    if ((filp->f_mode & 2) || (permission(inode,2) == 0))
  4712. +        filp->f_mode |= IOCTL_MODE_BIT;
  4713. +
  4714. +    if (UFDCS->rawcmd == 1)
  4715. +           UFDCS->rawcmd = 2;
  4716. +
  4717. +    if (filp->f_flags & O_NDELAY)
  4718. +        return 0;
  4719. +
  4720. +    if (filp->f_mode && UDRS->track == PROVEN_ABSENT )
  4721. +        RETERR(ENXIO);
  4722. +
  4723. +    if (user_reset_fdc(drive, FD_RESET_IF_NEEDED,0))
  4724. +        RETERR(EIO);
  4725. +
  4726. +    if (filp->f_mode & 3) {
  4727. +        UDRS->last_checked = 0;
  4728. +        check_disk_change(inode->i_rdev);
  4729. +        if (test_bit(drive,&changed_floppies))
  4730. +            RETERR(ENXIO);
  4731. +    }
  4732. +
  4733. +    if (filp->f_mode && UDRS->track == PROVEN_ABSENT )
  4734. +        RETERR(ENXIO);
  4735. +
  4736. +    if ((filp->f_mode & 2) && !(UDRS->flags & FD_DISK_WRITABLE))
  4737. +        RETERR(EROFS);
  4738. +    return 0;
  4739. +#undef RETERR
  4740. +}
  4741. +
  4742. +/*
  4743. + * Check if the disk has been changed or if a change has been faked.
  4744. + */
  4745. +static int check_floppy_change(dev_t dev)
  4746. +{
  4747. +    int drive = DRIVE( dev );
  4748. +
  4749. +    if (MAJOR(dev) != MAJOR_NR) {
  4750. +        DPRINT("floppy_changed: not a floppy\n");
  4751. +        return 0;
  4752. +    }
  4753. +
  4754. +    if(test_bit(drive, &changed_floppies))
  4755. +        return 1;
  4756. +
  4757. +    if(UDRS->last_checked + UDP->checkfreq < jiffies){
  4758. +        lock_fdc(drive,0);
  4759. +        start_motor();
  4760. +        redo_fd_request();
  4761. +    }
  4762. +
  4763. +    if(test_bit(drive, &changed_floppies))
  4764. +        return 1;
  4765. +    if(test_bit(drive, &fake_change))
  4766. +        return 1;
  4767. +    return 0;
  4768. +}
  4769. +
  4770. +static struct cont_t poll_cont={
  4771. +    success_and_wakeup,
  4772. +    floppy_ready,
  4773. +    generic_failure,
  4774. +    generic_done };
  4775. +
  4776. +
  4777. +/* revalidate the floppy disk, i.e. trigger format autodetection by reading
  4778. + * the bootblock (block 0). "Autodetection" is also needed to check wether
  4779. + * there is a disk in the drive at all... Thus we also do it for fixed
  4780. + * geometry formats */
  4781. +static int floppy_revalidate(dev_t dev)
  4782. +{
  4783. +    struct buffer_head * bh;
  4784. +    int drive=DRIVE(dev);
  4785. +    int cf;
  4786. +
  4787. +    cf = test_bit(drive, &changed_floppies);
  4788. +    if(cf || test_bit(drive, &fake_change)){
  4789. +        lock_fdc(drive,0);
  4790. +        cf = test_bit(drive, &changed_floppies);
  4791. +        if(! (cf || test_bit(drive, &fake_change))){
  4792. +            redo_fd_request(); /* already done by another thread */
  4793. +            return 0;
  4794. +        }
  4795. +        UDRS->maxblock = 0;
  4796. +        UDRS->maxtrack = 0;
  4797. +        if ( buffer_drive == drive)
  4798. +            buffer_track = -1;
  4799. +        clear_bit(drive, &fake_change);
  4800. +        clear_bit(drive, &changed_floppies);
  4801. +        if(cf){
  4802. +            UDRS->generation++;
  4803. +            if(!current_type[drive] && !TYPE(dev)){
  4804. +                /* auto-sensing */
  4805. +                if (!(bh = getblk(dev,0,1024))){
  4806. +                    redo_fd_request();
  4807. +                    return 1;
  4808. +                }
  4809. +                if ( bh && ! bh->b_uptodate)
  4810. +                    ll_rw_block(READ, 1, &bh);
  4811. +                redo_fd_request();
  4812. +                wait_on_buffer(bh);
  4813. +                brelse(bh);
  4814. +                return 0;
  4815. +            } else {
  4816. +                /* no auto-sense, just clear dcl */
  4817. +                raw_cmd.flags=FD_RAW_NEED_SEEK|FD_RAW_NEED_DISK;
  4818. +                raw_cmd.track=0;
  4819. +                raw_cmd.cmd_count=0;
  4820. +                cont = &poll_cont;
  4821. +                wait_til_done(floppy_ready,0);
  4822. +            }
  4823. +        }
  4824. +        redo_fd_request();
  4825. +    }
  4826. +    return 0;
  4827. +}
  4828. +
  4829. +static struct file_operations floppy_fops = {
  4830. +    NULL,            /* lseek - default */
  4831. +    floppy_read,        /* read - general block-dev read */
  4832. +    floppy_write,        /* write - general block-dev write */
  4833. +    NULL,                   /* readdir - bad */
  4834. +    NULL,            /* select */
  4835. +    fd_ioctl,        /* ioctl */
  4836. +    NULL,            /* mmap */
  4837. +    floppy_open,        /* open */
  4838. +    floppy_release,        /* release */
  4839. +    block_fsync,        /* fsync */
  4840. +    NULL,            /* fasync */
  4841. +    check_floppy_change,    /* media_change */
  4842. +    floppy_revalidate,    /* revalidate */
  4843. +};
  4844. +
  4845. +/*
  4846. + * Floppy Driver initialisation
  4847. + * =============================
  4848. + */
  4849. +
  4850. +/* Determine the floppy disk controller type */
  4851. +/* This routine was written by David C. Niemi */
  4852. +static char get_fdc_version(void)
  4853. +{
  4854. +    int r;
  4855. +
  4856. +    output_byte(FD_DUMPREGS);    /* 82072 and better know DUMPREGS */
  4857. +    if ( FDCS->reset )
  4858. +        return FDC_NONE;
  4859. +    if ( (r = result()) <= 0x00)
  4860. +        return FDC_NONE;    /* No FDC present ??? */
  4861. +    if ((r==1) && (reply_buffer[0] == 0x80)){
  4862. +        printk("FDC %d is a 8272A\n",fdc);
  4863. +        return FDC_8272A;        /* 8272a/765 don't know DUMPREGS */
  4864. +    }
  4865. +    if (r != 10) {
  4866. +        printk("FDC init: DUMPREGS: unexpected return of %d bytes.\n", r);
  4867. +        return FDC_UNKNOWN;
  4868. +    }
  4869. +    output_byte(FD_VERSION);
  4870. +    r = result();
  4871. +    if ((r == 1) && (reply_buffer[0] == 0x80)){
  4872. +        printk("FDC %d is a 82072\n",fdc);
  4873. +        return FDC_82072;        /* 82072 doesn't know VERSION */
  4874. +    }
  4875. +    if ((r != 1) || (reply_buffer[0] != 0x90)) {
  4876. +        printk("FDC init: VERSION: unexpected return of %d bytes.\n", r);
  4877. +        return FDC_UNKNOWN;
  4878. +    }
  4879. +    output_byte(FD_UNLOCK);
  4880. +    r = result();
  4881. +    if ((r == 1) && (reply_buffer[0] == 0x80)){
  4882. +        printk("FDC %d is a pre-1991 82077\n", fdc);
  4883. +        return FDC_82077_ORIG;    /* Pre-1991 82077 doesn't know LOCK/UNLOCK */
  4884. +    }
  4885. +    if ((r != 1) || (reply_buffer[0] != 0x00)) {
  4886. +        printk("FDC init: UNLOCK: unexpected return of %d bytes.\n", r);
  4887. +        return FDC_UNKNOWN;
  4888. +    }
  4889. +    printk("FDC %d is a post-1991 82077\n",fdc);
  4890. +    return FDC_82077;    /* Revised 82077AA passes all the tests */
  4891. +} /* fdc_init */
  4892. +
  4893. +void floppy_init(void)
  4894. +{
  4895. +    int i;
  4896. +
  4897. +    sti();
  4898. +
  4899. +    if (register_blkdev(MAJOR_NR,"fd",&floppy_fops)) {
  4900. +        printk("Unable to get major %d for floppy\n",MAJOR_NR);
  4901. +        return;
  4902. +    }
  4903. +
  4904. +    for(i=0; i<256; i++)
  4905. +        if ( TYPE(i))
  4906. +            floppy_sizes[i] = floppy_type[TYPE(i)].size >> 1;
  4907. +        else
  4908. +            floppy_sizes[i] = MAX_DISK_SIZE;
  4909. +
  4910. +    blk_size[MAJOR_NR] = floppy_sizes;
  4911. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  4912. +    hardsect_size[MAJOR_NR] = fd_sectsizes;
  4913. +    timer_table[FLOPPY_TIMER].fn = floppy_shutdown;
  4914. +    timer_active &= ~(1 << FLOPPY_TIMER);
  4915. +    config_types();
  4916. +
  4917. +    for(i = 0; i<256; i++)
  4918. +        fd_sectsizes[i] = 1024;            /* patch for msdos driver */
  4919. +
  4920. +    fdc_state[0].address = 0x3f0;
  4921. +#if N_FDC > 1
  4922. +    fdc_state[1].address = 0x370;
  4923. +#endif
  4924. +    for (i = 0 ; i < N_FDC ; i++) {
  4925. +        fdc = i;
  4926. +        FDCS->dtr = -1;
  4927. +        FDCS->dor = 0;
  4928. +        FDCS->reset = 0;
  4929. +        FDCS->version = FDC_NONE;
  4930. +        set_dor(fdc, ~0, 0xc );
  4931. +    }
  4932. +
  4933. +    /* initialise drive state */
  4934. +    for (i = 0; i < N_DRIVE ; i++) {
  4935. +        current_drive = i;
  4936. +        DRS->flags = FD_VERIFY | FD_DISK_NEWCHANGE;
  4937. +        DRS->generation = 0;
  4938. +        DRS->keep_data = 0;
  4939. +        DRS->fd_ref = 0;
  4940. +        DRS->fd_device = 0;
  4941. +        DRWE->write_errors = 0;
  4942. +        DRWE->first_error_sector = 0;
  4943. +        DRWE->first_error_generation = 0;
  4944. +        DRWE->last_error_sector = 0;
  4945. +        DRWE->last_error_generation = 0;
  4946. +        DRWE->badness = 0;
  4947. +    }
  4948. +
  4949. +    floppy_grab_irq_and_dma();
  4950. +    for (i = 0 ; i < N_FDC ; i++) {
  4951. +        fdc = i;
  4952. +        FDCS->rawcmd = 2;
  4953. +        if(user_reset_fdc(-1,FD_RESET_IF_NEEDED,0))
  4954. +            continue;
  4955. +        /* Try to determine the floppy controller type */
  4956. +        FDCS->version = get_fdc_version();
  4957. +        if (FDCS->version == FDC_NONE)
  4958. +            continue;
  4959. +
  4960. +        /* Not all FDCs seem to be able to handle the version command
  4961. +         * properly, so force a reset for the standard FDC clones,
  4962. +         * to avoid interrupt garbage.
  4963. +         */
  4964. +        FDCS->has_fifo = FDCS->version >= FDC_82077_ORIG;
  4965. +        user_reset_fdc(-1,FD_RESET_ALWAYS,0);
  4966. +    }
  4967. +    fdc=0;
  4968. +    current_drive = 0;
  4969. +    floppy_release_irq_and_dma();
  4970. +    initialising=0;
  4971. +}
  4972. +
  4973. +static int floppy_grab_irq_and_dma(void)
  4974. +{
  4975. +    int i;
  4976. +    cli();
  4977. +    if (usage_count++){
  4978. +        sti();
  4979. +        return 0;
  4980. +    }
  4981. +    sti();
  4982. +
  4983. +    for(i=0; i< N_FDC; i++){
  4984. +        fdc = i;
  4985. +        reset_fdc_info(1);
  4986. +        arm_set_dor(FDCS->dor);
  4987. +    }
  4988. +    set_dor(0, ~0, 8); /* avoid immediate interrupt */
  4989. +
  4990. +    if (request_irq(FLOPPY_IRQ, floppy_interrupt, SA_INTERRUPT, "floppy")) {
  4991. +        DPRINT1("Unable to grab IRQ%d for the floppy driver\n",
  4992. +            FLOPPY_IRQ);
  4993. +        return -1;
  4994. +    }
  4995. +    if (request_dma(FLOPPY_DMA,"floppy")) {
  4996. +        DPRINT1("Unable to grab DMA%d for the floppy driver\n",
  4997. +            FLOPPY_DMA);
  4998. +        free_irq(FLOPPY_IRQ);
  4999. +        return -1;
  5000. +    }
  5001. +    enable_irq(FLOPPY_IRQ);
  5002. +    return 0;
  5003. +}
  5004. +
  5005. +static void floppy_release_irq_and_dma(void)
  5006. +{
  5007. +    int i;
  5008. +    cli();
  5009. +    if (--usage_count){
  5010. +        sti();
  5011. +        return;
  5012. +    }
  5013. +    sti();
  5014. +    disable_dma(FLOPPY_DMA);
  5015. +    free_dma(FLOPPY_DMA);
  5016. +    disable_irq(FLOPPY_IRQ);
  5017. +    free_irq(FLOPPY_IRQ);
  5018. +    /* switch off dma gates */
  5019. +    for(i=0; i< N_FDC; i++)
  5020. +        set_dor(i, ~8, 0);
  5021. +}
  5022. diff -r -u -N linux.orig/arch/arm/drivers/block/genhd.c linux.arm/arch/arm/drivers/block/genhd.c
  5023. --- linux.orig/arch/arm/drivers/block/genhd.c    Thu Jan  1 01:00:00 1970
  5024. +++ linux.arm/arch/arm/drivers/block/genhd.c    Fri Oct 27 23:14:43 1995
  5025. @@ -0,0 +1,295 @@
  5026. +/*
  5027. + *  Code extracted from
  5028. + *  linux/kernel/hd.c
  5029. + *
  5030. + *  Copyright (C) 1991, 1992  Linus Torvalds
  5031. + */
  5032. +
  5033. +/*
  5034. + *  Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
  5035. + *  in the early extended-partition checks and added DM partitions
  5036. + */
  5037. +
  5038. +#include <linux/config.h>
  5039. +#include <linux/fs.h>
  5040. +#include <linux/genhd.h>
  5041. +#include <linux/kernel.h>
  5042. +
  5043. +#ifndef __ARM__
  5044. +#define __ARM__
  5045. +#endif
  5046. +
  5047. +#ifndef __ARM__
  5048. +struct gendisk *gendisk_head = NULL;
  5049. +#else
  5050. +struct gendisk *gendisk_head;
  5051. +#endif
  5052. +
  5053. +static int current_minor;
  5054. +extern int *blk_size[];
  5055. +extern void rd_load(void);
  5056. +extern int ramdisk_size;
  5057. +
  5058. +#ifndef __ARM__
  5059. +/*
  5060. + * Create devices for each logical partition in an extended partition.
  5061. + * The logical partitions form a linked list, with each entry being
  5062. + * a partition table with two entries.  The first entry
  5063. + * is the real data partition (with a start relative to the partition
  5064. + * table start).  The second is a pointer to the next logical partition
  5065. + * (with a start relative to the entire extended partition).
  5066. + * We do not create a Linux partition for the partition tables, but
  5067. + * only for the actual data partitions.
  5068. + */
  5069. +
  5070. +static void extended_partition(struct gendisk *hd, int dev)
  5071. +{
  5072. +    struct buffer_head *bh;
  5073. +    struct partition *p;
  5074. +    unsigned long first_sector, this_sector;
  5075. +    int mask = (1 << hd->minor_shift) - 1;
  5076. +
  5077. +    first_sector = hd->part[MINOR(dev)].start_sect;
  5078. +    this_sector = first_sector;
  5079. +
  5080. +    while (1) {
  5081. +        if ((current_minor & mask) >= (4 + hd->max_p))
  5082. +            return;
  5083. +        if (!(bh = bread(dev,0,1024)))
  5084. +            return;
  5085. +      /*
  5086. +       * This block is from a device that we're about to stomp on.
  5087. +       * So make sure nobody thinks this block is usable.
  5088. +       */
  5089. +        bh->b_dirt = 0;
  5090. +        bh->b_uptodate = 0;
  5091. +        bh->b_req = 0;
  5092. +        if (*(unsigned short *) (bh->b_data+510) == 0xAA55) {
  5093. +            p = (struct partition *) (0x1BE + bh->b_data);
  5094. +        /*
  5095. +         * Process the first entry, which should be the real
  5096. +         * data partition.
  5097. +         */
  5098. +            if (p->sys_ind == EXTENDED_PARTITION ||
  5099. +                !(hd->part[current_minor].nr_sects = p->nr_sects))
  5100. +                goto done;  /* shouldn't happen */
  5101. +            hd->part[current_minor].start_sect = this_sector + p->start_sect;
  5102. +            printk(" %s%c%d", hd->major_name,
  5103. +                'a'+(current_minor >> hd->minor_shift),
  5104. +                mask & current_minor);
  5105. +            current_minor++;
  5106. +            p++;
  5107. +        /*
  5108. +         * Process the second entry, which should be a link
  5109. +         * to the next logical partition.  Create a minor
  5110. +         * for this just long enough to get the next partition
  5111. +         * table.  The minor will be reused for the real
  5112. +         * data partition.
  5113. +         */
  5114. +            if (p->sys_ind != EXTENDED_PARTITION ||
  5115. +                !(hd->part[current_minor].nr_sects = p->nr_sects))
  5116. +                goto done;  /* no more logicals in this partition */
  5117. +            hd->part[current_minor].start_sect = first_sector + p->start_sect;
  5118. +            this_sector = first_sector + p->start_sect;
  5119. +            dev = ((hd->major) << 8) | current_minor;
  5120. +            brelse(bh);
  5121. +        } else
  5122. +            goto done;
  5123. +    }
  5124. +done:
  5125. +    brelse(bh);
  5126. +}
  5127. +
  5128. +static void check_partition(struct gendisk *hd, unsigned int dev)
  5129. +{
  5130. +    static int first_time = 1;
  5131. +    int i, minor = current_minor;
  5132. +    struct buffer_head *bh;
  5133. +    struct partition *p;
  5134. +    unsigned long first_sector;
  5135. +    int mask = (1 << hd->minor_shift) - 1;
  5136. +
  5137. +    if (first_time)
  5138. +        printk("Partition check:\n");
  5139. +    first_time = 0;
  5140. +    first_sector = hd->part[MINOR(dev)].start_sect;
  5141. +    if (!(bh = bread(dev,0,1024))) {
  5142. +        printk("  unable to read partition table of device %04x\n",dev);
  5143. +        return;
  5144. +    }
  5145. +    printk("  %s%c:", hd->major_name, 'a'+(minor >> hd->minor_shift));
  5146. +    current_minor += 4;  /* first "extra" minor */
  5147. +    if (*(unsigned short *) (bh->b_data+510) == 0xAA55) {
  5148. +        p = (struct partition *) (0x1BE + bh->b_data);
  5149. +        for (i=1 ; i<=4 ; minor++,i++,p++) {
  5150. +            if (!(hd->part[minor].nr_sects = p->nr_sects))
  5151. +                continue;
  5152. +            hd->part[minor].start_sect = first_sector + p->start_sect;
  5153. +            printk(" %s%c%d", hd->major_name,'a'+(minor >> hd->minor_shift), i);
  5154. +            if ((current_minor & 0x3f) >= 60)
  5155. +                continue;
  5156. +            if (p->sys_ind == EXTENDED_PARTITION) {
  5157. +                printk(" <");
  5158. +                extended_partition(hd, (hd->major << 8) | minor);
  5159. +                printk(" >");
  5160. +            }
  5161. +        }
  5162. +        /*
  5163. +         * check for Disk Manager partition table
  5164. +         */
  5165. +        if (*(unsigned short *) (bh->b_data+0xfc) == 0x55AA) {
  5166. +            p = (struct partition *) (0x1BE + bh->b_data);
  5167. +            for (i = 4 ; i < 16 ; i++, current_minor++) {
  5168. +                p--;
  5169. +                if ((current_minor & mask) >= mask-2)
  5170. +                    break;
  5171. +                if (!(p->start_sect && p->nr_sects))
  5172. +                    continue;
  5173. +                hd->part[current_minor].start_sect = p->start_sect;
  5174. +                hd->part[current_minor].nr_sects = p->nr_sects;
  5175. +                printk(" %s%c%d", hd->major_name,
  5176. +                    'a'+(current_minor >> hd->minor_shift),
  5177. +                    current_minor & mask);
  5178. +            }
  5179. +        }
  5180. +    } else
  5181. +        printk(" bad partition table");
  5182. +    printk("\n");
  5183. +    brelse(bh);
  5184. +}
  5185. +#else
  5186. +/* 'ARC hard drives' minor allocation:
  5187. + *   physical hd    = minor >> hd->minor_shift
  5188. + *   image file        = (minor-1) & 3
  5189. + *   extra file        = image file + n<<2
  5190. + */
  5191. +
  5192. +static void pc_check_hd(struct gendisk *hd, int minor)
  5193. +{ /* minor is the whole device minor */
  5194. +    int dev = (hd->major << 8)+minor;
  5195. +    int i;
  5196. +    struct buffer_head *bh;
  5197. +    struct partition *p;
  5198. +    
  5199. +    minor+=4;
  5200. +#define GET_WORD(n) (((unsigned char *)&n)[0] + (((unsigned char *)&n)[1] << 8) + \
  5201. +            (((unsigned char *)&n)[2] << 16) + (((unsigned char *)&n)[3] << 24))
  5202. +
  5203. +    if (!(bh = bread(dev,0,1024))) {
  5204. +        printk("  unable to read partition table of device %04x\n",dev);
  5205. +        return;
  5206. +    }
  5207. +    if (*(unsigned short *) (bh->b_data + 510) == 0xAA55) {
  5208. +        printk(" <");
  5209. +        p = (struct partition *) (0x1BE + bh->b_data);
  5210. +        for (i=1 ; i<=4 ; minor+=4,i++,p++) {
  5211. +            if (!(hd->part[minor].nr_sects = GET_WORD(p->nr_sects)))
  5212. +                continue;
  5213. +            hd->part[minor].start_sect = GET_WORD(p->start_sect);
  5214. +            printk(" %s%c%d", hd->major_name,'a'+(minor >> hd->minor_shift), minor);
  5215. +        }
  5216. +        printk(" >");
  5217. +    }
  5218. +#undef GET_WORD
  5219. +}
  5220. +
  5221. +extern int image_allocate_list(int dev,int minor,struct hd_struct *);
  5222. +extern void image_release_dev(int dev);
  5223. +
  5224. +void check_imagefiles(struct gendisk *hd, int real_dev)
  5225. +{
  5226. +    static int first_time = 1;
  5227. +    int minor = current_minor;
  5228. +    int i,p = 0;
  5229. +
  5230. +    if(first_time)
  5231. +        printk("Image file check:\n");
  5232. +    first_time = 0;
  5233. +
  5234. +    current_minor += 4;  /* first "extra" minor */
  5235. +
  5236. +    for (i=1 ; i<=4 ; minor++,i++) {
  5237. +        int len;
  5238. +        len = image_allocate_list(real_dev, minor, &hd->part[minor]);
  5239. +        if(len && !p)
  5240. +        {
  5241. +            printk("  %s%c:", hd->major_name, 'a'+(minor >> hd->minor_shift));
  5242. +            p = 1;
  5243. +        }
  5244. +        if(len)
  5245. +        {
  5246. +            printk(" %s%c%d", hd->major_name,'a'+(minor >> hd->minor_shift), i);
  5247. +/* Now scan it for pc partitions */
  5248. +            pc_check_hd(hd, minor);
  5249. +        }
  5250. +    }
  5251. +    image_release_dev(real_dev);
  5252. +    printk("\n");
  5253. +}
  5254. +#endif
  5255. +/* This function is used to re-read partition tables for removable disks.
  5256. +   Much of the cleanup from the old partition tables should have already been
  5257. +   done */
  5258. +
  5259. +/* This function will re-read the partition tables for a given device,
  5260. +and set things back up again.  There are some important caveats,
  5261. +however.  You must ensure that no one is using the device, and no one
  5262. +can start using the device while this function is being executed. */
  5263. +
  5264. +void resetup_one_dev(struct gendisk *dev, int drive)
  5265. +{
  5266. +    int i;
  5267. +    int start = drive<<dev->minor_shift;
  5268. +    int j = start + dev->max_p;
  5269. +    int major = dev->major << 8;
  5270. +
  5271. +    current_minor = 1+(drive<<dev->minor_shift);
  5272. +#ifndef __ARM__
  5273. +    check_partition(dev, major+(drive<<dev->minor_shift));
  5274. +#else
  5275. +    check_imagefiles(dev, major+(drive<<dev->minor_shift));
  5276. +#endif
  5277. +
  5278. +    for (i=start ; i < j ; i++)
  5279. +        dev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
  5280. +}
  5281. +
  5282. +static void setup_dev(struct gendisk *dev)
  5283. +{
  5284. +    int i;
  5285. +    int j = dev->max_nr * dev->max_p;
  5286. +    int major = dev->major << 8;
  5287. +    int drive;
  5288. +
  5289. +
  5290. +    for (i = 0 ; i < j; i++)  {
  5291. +        dev->part[i].start_sect = 0;
  5292. +        dev->part[i].nr_sects = 0;
  5293. +    }
  5294. +    dev->init();
  5295. +    for (drive=0 ; drive<dev->nr_real ; drive++) {
  5296. +        current_minor = 1+(drive<<dev->minor_shift);
  5297. +#ifndef __ARM__
  5298. +        check_partition(dev, major+(drive<<dev->minor_shift));
  5299. +#else
  5300. +        check_imagefiles(dev, major+(drive<<dev->minor_shift));
  5301. +#endif
  5302. +    }
  5303. +    for (i=0 ; i < j ; i++)
  5304. +        dev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
  5305. +    blk_size[dev->major] = dev->sizes;
  5306. +}
  5307. +
  5308. +void device_setup(void)
  5309. +{
  5310. +    struct gendisk *p;
  5311. +    int nr=0;
  5312. +
  5313. +    for (p = gendisk_head ; p ; p=p->next) {
  5314. +        setup_dev(p);
  5315. +        nr += p->nr_real;
  5316. +    }
  5317. +
  5318. +    if (ramdisk_size)
  5319. +        rd_load();
  5320. +}
  5321. diff -r -u -N linux.orig/arch/arm/drivers/block/hd.c linux.arm/arch/arm/drivers/block/hd.c
  5322. --- linux.orig/arch/arm/drivers/block/hd.c    Thu Jan  1 01:00:00 1970
  5323. +++ linux.arm/arch/arm/drivers/block/hd.c    Fri Oct 27 23:14:44 1995
  5324. @@ -0,0 +1,1231 @@
  5325. +/*
  5326. + *  linux/arch/arm/drivers/block/hd.c
  5327. + *
  5328. + *  Copyright (C) 1991, 1992  Linus Torvalds
  5329. + *  Modified 1995  Russell King for ARM.
  5330. + */
  5331. +
  5332. +/*
  5333. + * This is the low-level hd interrupt support. It traverses the
  5334. + * request-list, using interrupts to jump between functions. As
  5335. + * all the functions are called within interrupts, we may not
  5336. + * sleep. Special care is recommended.
  5337. + * 
  5338. + *  modified by Drew Eckhardt to check nr of hd's from the CMOS.
  5339. + *
  5340. + *  Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
  5341. + *  in the early extended-partition checks and added DM partitions
  5342. + *
  5343. + *  IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
  5344. + *  and general streamlining by mlord@bnr.ca (Mark Lord).
  5345. + */
  5346. +
  5347. +/* This is the maximum number of fragments accessed in one go */
  5348. +int no_hds;
  5349. +#define MAX_FRAGS    16
  5350. +static unsigned long frag_start[MAX_FRAGS];    /* Start of fragments */
  5351. +static unsigned long frag_len[MAX_FRAGS];    /* Fragment length */
  5352. +static int frag_count;                /* Number of fragments to go */
  5353. +static int frag_pos;                /* Position in fragment arrays */
  5354. +static unsigned int frag_sectors;
  5355. +
  5356. +#define DEFAULT_MULT_COUNT  0    /* set to 0 to disable multiple mode at boot */
  5357. +#define DEFAULT_UNMASK_INTR 0    /* set to 0 to *NOT* unmask irq's more often */
  5358. +
  5359. +#include <asm/irq.h>
  5360. +#include <linux/errno.h>
  5361. +#include <linux/signal.h>
  5362. +#include <linux/sched.h>
  5363. +#include <linux/timer.h>
  5364. +#include <linux/fs.h>
  5365. +#include <linux/kernel.h>
  5366. +#include <linux/hdreg.h>
  5367. +#include <linux/genhd.h>
  5368. +#include <linux/config.h>
  5369. +#include <linux/malloc.h>
  5370. +#include <linux/string.h>
  5371. +
  5372. +#define REALLY_SLOW_IO
  5373. +#include <asm/system.h>
  5374. +#include <asm/io.h>
  5375. +#include <asm/segment.h>
  5376. +
  5377. +#define MAJOR_NR HD_MAJOR
  5378. +#include "blk.h"
  5379. +
  5380. +void reissue_request(struct request *current);
  5381. +int issue_request(int dev, unsigned int block, unsigned int nsect, struct request *current);
  5382. +#define HD_IRQ 11
  5383. +
  5384. +static int revalidate_hddisk(int, int);
  5385. +
  5386. +#define    HD_DELAY    0
  5387. +
  5388. +#define MAX_ERRORS     16    /* Max read/write errors/sector */
  5389. +#define RESET_FREQ      8    /* Reset controller every 8th retry */
  5390. +#define RECAL_FREQ      4    /* Recalibrate every 4th retry */
  5391. +#define MAX_HD        2
  5392. +
  5393. +#define STAT_OK        (READY_STAT|SEEK_STAT)
  5394. +#define OK_STATUS(s)    (((s)&(STAT_OK|(BUSY_STAT|WRERR_STAT|ERR_STAT)))==STAT_OK)
  5395. +
  5396. +static void recal_intr(void);
  5397. +static void bad_rw_intr(void);
  5398. +
  5399. +static char recalibrate[MAX_HD] = { 0, };
  5400. +static char special_op[MAX_HD] = { 0, };
  5401. +static int access_count[MAX_HD] = {0, };
  5402. +static char busy[MAX_HD] = {0, };
  5403. +static struct wait_queue * busy_wait = NULL;
  5404. +
  5405. +static int reset = 0;
  5406. +static int hd_error = 0;
  5407. +
  5408. +/*
  5409. + *  This struct defines the HD's and their types.
  5410. + */
  5411. +struct hd_i_struct {
  5412. +    unsigned int head,sect,cyl,wpcom,lzone,ctl;
  5413. +    };
  5414. +static struct hd_driveid *hd_ident_info[MAX_HD] = {0, };
  5415. +    
  5416. +#ifdef HD_TYPE
  5417. +static struct hd_i_struct hd_info[] = { HD_TYPE };
  5418. +struct hd_i_struct bios_info[] = { HD_TYPE };
  5419. +static int NR_HD = ((sizeof (hd_info))/(sizeof (struct hd_i_struct)));
  5420. +#else
  5421. +static struct hd_i_struct hd_info[] = { {0,0,0,0,0,0},{0,0,0,0,0,0} };
  5422. +struct hd_i_struct bios_info[] = { {0,0,0,0,0,0},{0,0,0,0,0,0} };
  5423. +static int NR_HD = 0;
  5424. +#endif
  5425. +
  5426. +static struct hd_struct hd[MAX_HD<<6]={{0,0},};
  5427. +static int hd_sizes[MAX_HD<<6] = {0, };
  5428. +static int hd_blocksizes[MAX_HD<<6] = {0, };
  5429. +
  5430. +#if (HD_DELAY > 0)
  5431. +unsigned long last_req;
  5432. +
  5433. +unsigned long read_timer(void)
  5434. +{
  5435. +    unsigned long t, flags;
  5436. +    int i;
  5437. +
  5438. +    save_flags(flags);
  5439. +    cli();
  5440. +    t = jiffies * 11932;
  5441. +        outb_p(0, 0x43);
  5442. +    i = inb_p(0x40);
  5443. +    i |= inb(0x40) << 8;
  5444. +    restore_flags(flags);
  5445. +    return(t - i);
  5446. +}
  5447. +#endif
  5448. +
  5449. +void hd_setup(char *str, int *ints)
  5450. +{
  5451. +    int hdind = 0;
  5452. +
  5453. +    if (ints[0] != 3)
  5454. +        return;
  5455. +    if (bios_info[0].head != 0)
  5456. +        hdind=1;
  5457. +    bios_info[hdind].head  = hd_info[hdind].head = ints[2];
  5458. +    bios_info[hdind].sect  = hd_info[hdind].sect = ints[3];
  5459. +    bios_info[hdind].cyl   = hd_info[hdind].cyl = ints[1];
  5460. +    bios_info[hdind].wpcom = hd_info[hdind].wpcom = 0;
  5461. +    bios_info[hdind].lzone = hd_info[hdind].lzone = ints[1];
  5462. +    bios_info[hdind].ctl   = hd_info[hdind].ctl = (ints[2] > 8 ? 8 : 0);
  5463. +    NR_HD = hdind+1;
  5464. +}
  5465. +
  5466. +static void dump_status (char *msg, unsigned int stat)
  5467. +{
  5468. +    unsigned long flags;
  5469. +    char devc;
  5470. +
  5471. +    devc = CURRENT ? 'a' + DEVICE_NR(CURRENT->dev) : '?';
  5472. +    save_flags (flags);
  5473. +    sti();
  5474. +    printk("hd%c: %s: status=0x%02x { ", devc, msg, stat & 0xff);
  5475. +    if (stat & BUSY_STAT)    printk("Busy ");
  5476. +    if (stat & READY_STAT)    printk("DriveReady ");
  5477. +    if (stat & WRERR_STAT)    printk("WriteFault ");
  5478. +    if (stat & SEEK_STAT)    printk("SeekComplete ");
  5479. +    if (stat & DRQ_STAT)    printk("DataRequest ");
  5480. +    if (stat & ECC_STAT)    printk("CorrectedError ");
  5481. +    if (stat & INDEX_STAT)    printk("Index ");
  5482. +    if (stat & ERR_STAT)    printk("Error ");
  5483. +    printk("}\n");
  5484. +    if ((stat & ERR_STAT) == 0) {
  5485. +        hd_error = 0;
  5486. +    } else {
  5487. +        hd_error = inb(HD_ERROR);
  5488. +        printk("hd%c: %s: error=0x%02x { ", devc, msg, hd_error & 0xff);
  5489. +        if (hd_error & BBD_ERR)        printk("BadSector ");
  5490. +        if (hd_error & ECC_ERR)        printk("UncorrectableError ");
  5491. +        if (hd_error & ID_ERR)        printk("SectorIdNotFound ");
  5492. +        if (hd_error & ABRT_ERR)    printk("DriveStatusError ");
  5493. +        if (hd_error & TRK0_ERR)    printk("TrackZeroNotFound ");
  5494. +        if (hd_error & MARK_ERR)    printk("AddrMarkNotFound ");
  5495. +        printk("}");
  5496. +        if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
  5497. +            printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
  5498. +                inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
  5499. +            if (CURRENT)
  5500. +                printk(", sector=%ld", CURRENT->sector);
  5501. +        }
  5502. +        printk("\n");
  5503. +    }
  5504. +    restore_flags (flags);
  5505. +}
  5506. +
  5507. +void check_status(void)
  5508. +{
  5509. +    int i = inb_p(HD_STATUS);
  5510. +
  5511. +    if (!OK_STATUS(i)) {
  5512. +        dump_status("check_status", i);
  5513. +        bad_rw_intr();
  5514. +    }
  5515. +}
  5516. +
  5517. +static int controller_busy(void)
  5518. +{
  5519. +    int retries = 100000;
  5520. +    unsigned char status;
  5521. +
  5522. +    do {
  5523. +        status = inb_p(HD_STATUS);
  5524. +    } while ((status & BUSY_STAT) && --retries);
  5525. +    return status;
  5526. +}
  5527. +
  5528. +static int status_ok(void)
  5529. +{
  5530. +    unsigned char status = inb_p(HD_STATUS);
  5531. +
  5532. +    if (status & BUSY_STAT)
  5533. +        return 1;    /* Ancient, but does it make sense??? */
  5534. +    if (status & WRERR_STAT)
  5535. +        return 0;
  5536. +    if (!(status & READY_STAT))
  5537. +        return 0;
  5538. +    if (!(status & SEEK_STAT))
  5539. +        return 0;
  5540. +    return 1;
  5541. +}
  5542. +
  5543. +static int controller_ready(unsigned int drive, unsigned int head)
  5544. +{
  5545. +    int retry = 100;
  5546. +
  5547. +    do {
  5548. +        if (controller_busy() & BUSY_STAT)
  5549. +            return 0;
  5550. +        outb_p(0xA0 | (drive<<4) | head, HD_CURRENT);
  5551. +        if (status_ok())
  5552. +            return 1;
  5553. +    } while (--retry);
  5554. +    return 0;
  5555. +}
  5556. +
  5557. +static void hd_out(unsigned int drive,unsigned int nsect,unsigned int sect,
  5558. +        unsigned int head,unsigned int cyl,unsigned int cmd,
  5559. +        void (*intr_addr)(void))
  5560. +{
  5561. +    unsigned short port;
  5562. +
  5563. +#if (HD_DELAY > 0)
  5564. +    while (read_timer() - last_req < HD_DELAY)
  5565. +        /* nothing */;
  5566. +#endif
  5567. +    if (reset)
  5568. +        return;
  5569. +    if (!controller_ready(drive, head)) {
  5570. +        reset = 1;
  5571. +        return;
  5572. +    }
  5573. +    SET_INTR(intr_addr);
  5574. +    outb_p(hd_info[drive].ctl,HD_CMD);
  5575. +    port=HD_DATA;
  5576. +    outb_p(hd_info[drive].wpcom>>2,++port);
  5577. +    outb_p(nsect,++port);
  5578. +    outb_p(sect,++port);
  5579. +    outb_p(cyl,++port);
  5580. +    outb_p(cyl>>8,++port);
  5581. +    outb_p(0xA0|(drive<<4)|head,++port);
  5582. +    outb_p(cmd,++port);
  5583. +}
  5584. +
  5585. +static void hd_request (void);
  5586. +static unsigned int identified  [MAX_HD] = {0,}; /* 1 = drive ID already displayed   */
  5587. +static unsigned int unmask_intr [MAX_HD] = {0,}; /* 1 = unmask IRQs during I/O       */
  5588. +static unsigned int max_mult    [MAX_HD] = {0,}; /* max sectors for MultMode         */
  5589. +static unsigned int mult_req    [MAX_HD] = {0,}; /* requested MultMode count         */
  5590. +static unsigned int mult_count  [MAX_HD] = {0,}; /* currently enabled MultMode count */
  5591. +static struct request WCURRENT;
  5592. +
  5593. +static void fixstring (unsigned char *s, int bytecount)
  5594. +{
  5595. +    unsigned char *p, *end = &s[bytecount &= ~1];    /* bytecount must be even */
  5596. +
  5597. +    /* convert from big-endian to little-endian */
  5598. +    for (p = end ; p != s;) {
  5599. +        unsigned short *pp = (unsigned short *) (p -= 2);
  5600. +        *pp = (*pp >> 8) | (*pp << 8);
  5601. +    }
  5602. +
  5603. +    /* strip leading blanks */
  5604. +    while (s != end && *s == ' ')
  5605. +        ++s;
  5606. +
  5607. +    /* compress internal blanks and strip trailing blanks */
  5608. +    while (s != end && *s) {
  5609. +        if (*s++ != ' ' || (s != end && *s && *s != ' '))
  5610. +            *p++ = *(s-1);
  5611. +    }
  5612. +
  5613. +    /* wipe out trailing garbage */
  5614. +    while (p != end)
  5615. +        *p++ = '\0';
  5616. +}
  5617. +
  5618. +static void identify_intr(void)
  5619. +{
  5620. +    unsigned int dev = DEVICE_NR(CURRENT->dev);
  5621. +    unsigned short stat = inb_p(HD_STATUS);
  5622. +    struct hd_driveid *id = hd_ident_info[dev];
  5623. +
  5624. +    if (unmask_intr[dev])
  5625. +        sti();
  5626. +    if (stat & (BUSY_STAT|ERR_STAT)) {
  5627. +        printk ("  hd%c: non-IDE device, %dMB, CHS=%d/%d/%d\n", dev+'a',
  5628. +            hd_info[dev].cyl*hd_info[dev].head*hd_info[dev].sect / 2048,
  5629. +            hd_info[dev].cyl, hd_info[dev].head, hd_info[dev].sect);
  5630. +        if (id != NULL) {
  5631. +            hd_ident_info[dev] = NULL;
  5632. +            kfree_s (id, 512);
  5633. +        }
  5634. +    } else {
  5635. +        insw(HD_DATA, id, 256); /* get ID info */
  5636. +        max_mult[dev] = id->max_multsect;
  5637. +        if ((id->field_valid&1) && id->cur_cyls && id->cur_heads && (id->cur_heads <= 16) && id->cur_sectors) {
  5638. +            /*
  5639. +             * Extract the physical drive geometry for our use.
  5640. +             * Note that we purposely do *not* update the bios_info.
  5641. +             * This way, programs that use it (like fdisk) will 
  5642. +             * still have the same logical view as the BIOS does,
  5643. +             * which keeps the partition table from being screwed.
  5644. +             */
  5645. +            hd_info[dev].cyl  = id->cur_cyls;
  5646. +            hd_info[dev].head = id->cur_heads;
  5647. +            hd_info[dev].sect = id->cur_sectors; 
  5648. +        }
  5649. +        fixstring (id->serial_no, sizeof(id->serial_no));
  5650. +        fixstring (id->fw_rev, sizeof(id->fw_rev));
  5651. +        fixstring (id->model, sizeof(id->model));
  5652. +        printk ("  hd%c: %.40s, %dMB w/%dKB Cache, CHS=%d/%d/%d, MaxMult=%d\n",
  5653. +            dev+'a', id->model, id->cyls*id->heads*id->sectors/2048,
  5654. +            id->buf_size/2, hd_info[dev].cyl, hd_info[dev].head,
  5655. +            hd_info[dev].sect, id->max_multsect);
  5656. +        /*
  5657. +         * Early model Quantum drives go weird at this point,
  5658. +         *   but doing a recalibrate seems to "fix" them.
  5659. +         * (Doing a full reset confuses some other model Quantums)
  5660. +         */
  5661. +        if (!strncmp(id->model, "QUANTUM", 7))
  5662. +            special_op[dev] = recalibrate[dev] = 1;
  5663. +    }
  5664. +#if (HD_DELAY > 0)
  5665. +    last_req = read_timer();
  5666. +#endif
  5667. +    hd_request();
  5668. +    return;
  5669. +}
  5670. +
  5671. +static void set_multmode_intr(void)
  5672. +{
  5673. +    unsigned int dev = DEVICE_NR(CURRENT->dev), stat = inb_p(HD_STATUS);
  5674. +
  5675. +    if (unmask_intr[dev])
  5676. +        sti();
  5677. +    if (stat & (BUSY_STAT|ERR_STAT)) {
  5678. +        mult_req[dev] = mult_count[dev] = 0;
  5679. +        dump_status("set multmode failed", stat);
  5680. +    } else {
  5681. +        if ((mult_count[dev] = mult_req[dev]))
  5682. +            printk ("  hd%c: enabled %d-sector multiple mode\n",
  5683. +                dev+'a', mult_count[dev]);
  5684. +        else
  5685. +            printk ("  hd%c: disabled multiple mode\n", dev+'a');
  5686. +    }
  5687. +#if (HD_DELAY > 0)
  5688. +    last_req = read_timer();
  5689. +#endif
  5690. +    hd_request();
  5691. +    return;
  5692. +}
  5693. +
  5694. +static int drive_busy(void)
  5695. +{
  5696. +    unsigned int i;
  5697. +    unsigned char c;
  5698. +
  5699. +    for (i = 0; i < 500000 ; i++) {
  5700. +        c = inb_p(HD_STATUS);
  5701. +        if ((c & (BUSY_STAT | READY_STAT | SEEK_STAT)) == STAT_OK)
  5702. +            return 0;
  5703. +    }
  5704. +    dump_status("reset timed out", c);
  5705. +    return 1;
  5706. +}
  5707. +
  5708. +static void reset_controller(void)
  5709. +{
  5710. +    int    i;
  5711. +
  5712. +    outb_p(4,HD_CMD);
  5713. +    for(i = 0; i < 1000; i++) nop();
  5714. +    outb_p(hd_info[0].ctl & 0x0f,HD_CMD);
  5715. +    for(i = 0; i < 1000; i++) nop();
  5716. +    if (drive_busy())
  5717. +        printk("hd: controller still busy\n");
  5718. +    else if ((hd_error = inb(HD_ERROR)) != 1)
  5719. +        printk("hd: controller reset failed: %02x\n",hd_error);
  5720. +}
  5721. +
  5722. +static void reset_hd(void)
  5723. +{
  5724. +    static int i;
  5725. +
  5726. +repeat:
  5727. +    if (reset) {
  5728. +        reset = 0;
  5729. +        i = -1;
  5730. +        reset_controller();
  5731. +    } else {
  5732. +        check_status();
  5733. +        if (reset)
  5734. +            goto repeat;
  5735. +    }
  5736. +    if (++i < NR_HD) {
  5737. +        special_op[i] = recalibrate[i] = 1;
  5738. +        if (unmask_intr[i]) {
  5739. +            unmask_intr[i] = DEFAULT_UNMASK_INTR;
  5740. +            printk("hd%c: reset irq-unmasking to %d\n",i+'a',
  5741. +                DEFAULT_UNMASK_INTR);
  5742. +        }
  5743. +        if (mult_req[i] || mult_count[i]) {
  5744. +            mult_count[i] = 0;
  5745. +            mult_req[i] = DEFAULT_MULT_COUNT;
  5746. +            printk("hd%c: reset multiple mode to %d\n",i+'a',
  5747. +                DEFAULT_MULT_COUNT);
  5748. +        }
  5749. +        hd_out(i,hd_info[i].sect,hd_info[i].sect,hd_info[i].head-1,
  5750. +            hd_info[i].cyl,WIN_SPECIFY,&reset_hd);
  5751. +        if (reset)
  5752. +            goto repeat;
  5753. +    } else
  5754. +        hd_request();
  5755. +}
  5756. +
  5757. +/*
  5758. + * Ok, don't know what to do with the unexpected interrupts: on some machines
  5759. + * doing a reset and a retry seems to result in an eternal loop. Right now I
  5760. + * ignore it, and just set the timeout.
  5761. + *
  5762. + * On laptops (and "green" PCs), an unexpected interrupt occurs whenever the
  5763. + * drive enters "idle", "standby", or "sleep" mode, so if the status looks
  5764. + * "good", we just ignore the interrupt completely.
  5765. + */
  5766. +void unexpected_hd_interrupt(void)
  5767. +{
  5768. +    unsigned int stat = inb_p(HD_STATUS);
  5769. +
  5770. +    if (stat & (BUSY_STAT|DRQ_STAT|ECC_STAT|ERR_STAT)) {
  5771. +        dump_status ("unexpected interrupt", stat);
  5772. +        SET_TIMER;
  5773. +    }
  5774. +}
  5775. +
  5776. +/*
  5777. + * bad_rw_intr() now tries to be a bit smarter and does things
  5778. + * according to the error returned by the controller.
  5779. + * -Mika Liljeberg (liljeber@cs.Helsinki.FI)
  5780. + */
  5781. +static void bad_rw_intr(void)
  5782. +{
  5783. +    int dev;
  5784. +
  5785. +    if (!CURRENT)
  5786. +        return;
  5787. +    dev = DEVICE_NR(CURRENT->dev);
  5788. +    if (++CURRENT->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
  5789. +        end_request(0);
  5790. +        special_op[dev] = recalibrate[dev] = 1;
  5791. +    } else if (CURRENT->errors % RESET_FREQ == 0)
  5792. +        reset = 1;
  5793. +    else if ((hd_error & TRK0_ERR) || CURRENT->errors % RECAL_FREQ == 0)
  5794. +        special_op[dev] = recalibrate[dev] = 1;
  5795. +    /* Otherwise just retry */
  5796. +}
  5797. +
  5798. +static inline int wait_DRQ(void)
  5799. +{
  5800. +    int retries = 100000, stat;
  5801. +
  5802. +    while (--retries > 0)
  5803. +        if ((stat = inb_p(HD_STATUS)) & DRQ_STAT)
  5804. +            return 0;
  5805. +    dump_status("wait_DRQ", stat);
  5806. +    return -1;
  5807. +}
  5808. +
  5809. +static void read_intr(void)
  5810. +{
  5811. +    unsigned int dev = DEVICE_NR(CURRENT->dev);
  5812. +    int i, retries = 100000, msect = mult_count[dev], nsect;
  5813. +
  5814. +    if (unmask_intr[dev])
  5815. +        sti();            /* permit other IRQs during xfer */
  5816. +    do {
  5817. +        i = (unsigned) inb_p(HD_STATUS);
  5818. +        if (i & BUSY_STAT)
  5819. +            continue;
  5820. +        if (!OK_STATUS(i))
  5821. +            break;
  5822. +        if (i & DRQ_STAT)
  5823. +            goto ok_to_read;
  5824. +    } while (--retries > 0);
  5825. +    dump_status("read_intr", i);
  5826. +    bad_rw_intr();
  5827. +    hd_request();
  5828. +    return;
  5829. +ok_to_read:
  5830. +    if (msect) {
  5831. +        if ((nsect = CURRENT->current_nr_sectors) > msect)
  5832. +            nsect = msect;
  5833. +        msect -= nsect;
  5834. +    } else
  5835. +        nsect = 1;
  5836. +    insw(HD_DATA,CURRENT->buffer,nsect<<8);
  5837. +    CURRENT->sector += nsect;
  5838. +    CURRENT->buffer += nsect<<9;
  5839. +    CURRENT->errors = 0;
  5840. +    i = (CURRENT->nr_sectors -= nsect);
  5841. +
  5842. +#ifdef DEBUG
  5843. +    printk("hd%c: read: sectors(%ld-%ld), remaining=%ld, buffer=0x%08lx\n",
  5844. +        dev+'a', CURRENT->sector, CURRENT->sector+nsect,
  5845. +        CURRENT->nr_sectors, (unsigned long) CURRENT->buffer+(nsect<<9));
  5846. +#endif
  5847. +    if ((CURRENT->current_nr_sectors -= nsect) <= 0)
  5848. +        end_request(1);
  5849. +    if (i > 0) {
  5850. +        if (msect)
  5851. +            goto ok_to_read;
  5852. +        if(!(--frag_sectors))
  5853. +         /* Next fragment req.d */
  5854. +            reissue_request(CURRENT);
  5855. +        else
  5856. +        {
  5857. +            SET_INTR(&read_intr);
  5858. +        }
  5859. +        return;
  5860. +    }
  5861. +    (void) inb_p(HD_STATUS);
  5862. +#if (HD_DELAY > 0)
  5863. +    last_req = read_timer();
  5864. +#endif
  5865. +    if (CURRENT)
  5866. +        hd_request();
  5867. +    return;
  5868. +}
  5869. +
  5870. +static inline void multwrite (unsigned int dev)
  5871. +{
  5872. +    unsigned int mcount = mult_count[dev];
  5873. +
  5874. +    while (mcount--) {
  5875. +        outsw(HD_DATA,WCURRENT.buffer,256);
  5876. +        if (!--WCURRENT.nr_sectors)
  5877. +            return;
  5878. +        WCURRENT.buffer += 512;
  5879. +        if (!--WCURRENT.current_nr_sectors) {
  5880. +            WCURRENT.bh = WCURRENT.bh->b_reqnext;
  5881. +            if (WCURRENT.bh == NULL)
  5882. +                panic("buffer list corrupted\n");
  5883. +            WCURRENT.current_nr_sectors = WCURRENT.bh->b_size>>9;
  5884. +            WCURRENT.buffer             = WCURRENT.bh->b_data;
  5885. +        }
  5886. +    }
  5887. +}
  5888. +
  5889. +static void multwrite_intr(void)
  5890. +{
  5891. +    int i;
  5892. +    unsigned int dev = DEVICE_NR(WCURRENT.dev);
  5893. +
  5894. +    if (unmask_intr[dev])
  5895. +        sti();
  5896. +    if (OK_STATUS(i=inb_p(HD_STATUS))) {
  5897. +        if (i & DRQ_STAT) {
  5898. +            if (WCURRENT.nr_sectors) {
  5899. +                multwrite(dev);
  5900. +                SET_INTR(&multwrite_intr);
  5901. +                return;
  5902. +            }
  5903. +        } else {
  5904. +            if (!WCURRENT.nr_sectors) {    /* all done? */
  5905. +                for (i = CURRENT->nr_sectors; i > 0;){
  5906. +                    i -= CURRENT->current_nr_sectors;
  5907. +                    end_request(1);
  5908. +                }
  5909. +#if (HD_DELAY > 0)
  5910. +                last_req = read_timer();
  5911. +#endif
  5912. +                if (CURRENT)
  5913. +                    hd_request();
  5914. +                return;
  5915. +            }
  5916. +        }
  5917. +    }
  5918. +    dump_status("multwrite_intr", i);
  5919. +    bad_rw_intr();
  5920. +    hd_request();
  5921. +}
  5922. +
  5923. +static void write_intr(void)
  5924. +{
  5925. +    int i;
  5926. +    int retries = 100000;
  5927. +
  5928. +    if (unmask_intr[DEVICE_NR(WCURRENT.dev)])
  5929. +        sti();
  5930. +    do {
  5931. +        i = (unsigned) inb_p(HD_STATUS);
  5932. +        if (i & BUSY_STAT)
  5933. +            continue;
  5934. +        if (!OK_STATUS(i))
  5935. +            break;
  5936. +        if ((CURRENT->nr_sectors <= 1) || (frag_sectors <= 1) || (i & DRQ_STAT))
  5937. +            goto ok_to_write;
  5938. +    } while (--retries > 0);
  5939. +    dump_status("write_intr", i);
  5940. +    bad_rw_intr();
  5941. +    hd_request();
  5942. +    return;
  5943. +ok_to_write:
  5944. +    CURRENT->sector++;
  5945. +    i = --CURRENT->nr_sectors;
  5946. +    --CURRENT->current_nr_sectors;
  5947. +    CURRENT->buffer += 512;
  5948. +    if (!i || (CURRENT->bh && !SUBSECTOR(i)))
  5949. +        end_request(1);
  5950. +    if (i > 0) {
  5951. +        if(!(--frag_sectors))
  5952. +         /* Next fragment req.d */
  5953. +            reissue_request(CURRENT);
  5954. +        else
  5955. +        {
  5956. +            SET_INTR(&write_intr);
  5957. +            outsw(HD_DATA,CURRENT->buffer,256);
  5958. +            sti();
  5959. +        }
  5960. +    } else {
  5961. +#if (HD_DELAY > 0)
  5962. +        last_req = read_timer();
  5963. +#endif
  5964. +        hd_request();
  5965. +    }
  5966. +    return;
  5967. +}
  5968. +
  5969. +static void recal_intr(void)
  5970. +{
  5971. +    check_status();
  5972. +#if (HD_DELAY > 0)
  5973. +    last_req = read_timer();
  5974. +#endif
  5975. +    hd_request();
  5976. +}
  5977. +
  5978. +/*
  5979. + * This is another of the error-routines I don't know what to do with. The
  5980. + * best idea seems to just set reset, and start all over again.
  5981. + */
  5982. +static void hd_times_out(void)
  5983. +{
  5984. +    unsigned int dev;
  5985. +
  5986. +    DEVICE_INTR = NULL;
  5987. +    if (!CURRENT)
  5988. +        return;
  5989. +    disable_irq(HD_IRQ);
  5990. +    sti();
  5991. +    reset = 1;
  5992. +    dev = DEVICE_NR(CURRENT->dev);
  5993. +    printk("hd%c: timeout\n", dev+'a');
  5994. +    if (++CURRENT->errors >= MAX_ERRORS) {
  5995. +#ifdef DEBUG
  5996. +        printk("hd%c: too many errors\n", dev+'a');
  5997. +#endif
  5998. +        end_request(0);
  5999. +    }
  6000. +    cli();
  6001. +    hd_request();
  6002. +    enable_irq(HD_IRQ);
  6003. +}
  6004. +
  6005. +int do_special_op (unsigned int dev)
  6006. +{
  6007. +    if (recalibrate[dev]) {
  6008. +        recalibrate[dev] = 0;
  6009. +        hd_out(dev,hd_info[dev].sect,0,0,0,WIN_RESTORE,&recal_intr);
  6010. +        return reset;
  6011. +    }
  6012. +    if (!identified[dev]) {
  6013. +        identified[dev]  = 1;
  6014. +        unmask_intr[dev] = DEFAULT_UNMASK_INTR;
  6015. +        mult_req[dev]    = DEFAULT_MULT_COUNT;
  6016. +        hd_out(dev,0,0,0,0,WIN_IDENTIFY,&identify_intr);
  6017. +        return reset;
  6018. +    }
  6019. +    if (mult_req[dev] != mult_count[dev]) {
  6020. +        hd_out(dev,mult_req[dev],0,0,0,WIN_SETMULT,&set_multmode_intr);
  6021. +        return reset;
  6022. +    }
  6023. +    if (hd_info[dev].head > 16) {
  6024. +        printk ("hd%c: cannot handle device with more than 16 heads - giving up\n", dev+'a');
  6025. +        end_request(0);
  6026. +    }
  6027. +    special_op[dev] = 0;
  6028. +    return 1;
  6029. +}
  6030. +
  6031. +/*
  6032. + * The driver enables interrupts as much as possible.  In order to do this,
  6033. + * (a) the device-interrupt is disabled before entering hd_request(),
  6034. + * and (b) the timeout-interrupt is disabled before the sti().
  6035. + *
  6036. + * Interrupts are still masked (by default) whenever we are exchanging
  6037. + * data/cmds with a drive, because some drives seem to have very poor
  6038. + * tolerance for latency during I/O.  For devices which don't suffer from
  6039. + * that problem (most don't), the unmask_intr[] flag can be set to unmask
  6040. + * other interrupts during data/cmd transfers (by defining DEFAULT_UNMASK_INTR
  6041. + * to 1, or by using "hdparm -u1 /dev/hd?" from the shell).
  6042. + */
  6043. +static void hd_request(void)
  6044. +{
  6045. +    unsigned int dev, block, nsect;
  6046. +
  6047. +    if (CURRENT && CURRENT->dev < 0) return;
  6048. +    if (DEVICE_INTR)
  6049. +        return;
  6050. +repeat:
  6051. +    timer_active &= ~(1<<HD_TIMER);
  6052. +    sti();
  6053. +    INIT_REQUEST;
  6054. +    if (reset) {
  6055. +        cli();
  6056. +        reset_hd();
  6057. +        return;
  6058. +    }
  6059. +    dev = MINOR(CURRENT->dev);
  6060. +    block = CURRENT->sector;
  6061. +    nsect = CURRENT->nr_sectors;
  6062. +    if (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects || ((block+nsect) > hd[dev].nr_sects)) {
  6063. +#ifdef DEBUG
  6064. +        if (dev >= (NR_HD<<6))
  6065. +            printk("hd: bad minor number: device=0x%04x\n", CURRENT->dev);
  6066. +        else
  6067. +            printk("hd%c: bad access: block=%d, count=%d\n",
  6068. +                (dev>>6)+'a', block, nsect);
  6069. +#endif
  6070. +        end_request(0);
  6071. +        goto repeat;
  6072. +    }
  6073. +    block += hd[dev].start_sect;
  6074. +    if(dev & 0x3f)
  6075. +    { /* map sectors block to block+nsect to frags, 
  6076. +       */
  6077. +        if(!image_file_check(CURRENT->dev,CURRENT->cmd))
  6078. +            goto repeat;
  6079. +        frag_count = image_file_map(CURRENT->dev, block, nsect, MAX_FRAGS, 
  6080. +                        frag_start, frag_len);
  6081. +        if(!frag_count)
  6082. +        {
  6083. +            goto repeat;
  6084. +        }
  6085. +        
  6086. +        block = frag_start[0];
  6087. +        frag_sectors = nsect = frag_len[0];
  6088. +        frag_pos = 0;
  6089. +    }
  6090. +    else
  6091. +    {
  6092. +        frag_pos = 0;
  6093. +        frag_count = 1;
  6094. +        frag_sectors = nsect;
  6095. +        if(CURRENT->cmd == WRITE)
  6096. +        { /* Protect normal HD from writes */
  6097. +            printk("hd%d : attempted write on protected drive\n",dev);
  6098. +            end_request(0);
  6099. +            goto repeat;
  6100. +        }
  6101. +    }
  6102. +    if(issue_request(dev,block,nsect, CURRENT))
  6103. +        goto repeat;
  6104. +}
  6105. +
  6106. +void reissue_request(struct request *current)
  6107. +{
  6108. +    unsigned int dev, block, nsect;
  6109. +
  6110. +    dev = MINOR(current->dev);
  6111. +    frag_pos++;
  6112. +    if(frag_pos >= MAX_FRAGS)
  6113. +    {
  6114. +        block = current->sector;
  6115. +        block += hd[dev].start_sect;
  6116. +        nsect = current->nr_sectors;
  6117. +        if(!image_file_check(current->dev,current->cmd))
  6118. +        {
  6119. +            end_request(0);
  6120. +            hd_request();
  6121. +            return;
  6122. +        }
  6123. +        frag_count = image_file_map(current->dev, block, nsect, MAX_FRAGS, 
  6124. +                        frag_start, frag_len);
  6125. +        if(!frag_count)
  6126. +        {
  6127. +            end_request(0);
  6128. +            hd_request();
  6129. +            return;
  6130. +        }
  6131. +        
  6132. +        frag_pos = 0;
  6133. +        }        
  6134. +    frag_sectors = frag_len[frag_pos];
  6135. +repeat:
  6136. +    if(issue_request(dev, frag_start[frag_pos], frag_len[frag_pos], current))
  6137. +    {
  6138. +        printk("EEEEK - going round the loop\n");
  6139. +        goto repeat;
  6140. +    }
  6141. +}
  6142. +
  6143. +/* 
  6144. + * This routine actually issues a request to the hard disk itself
  6145. + */
  6146. +int issue_request(int dev, unsigned int block, unsigned int nsect, struct request *current)
  6147. +{
  6148. +    unsigned int sec, track, head, cyl;
  6149. +int d = dev;
  6150. +    dev >>= 6;
  6151. +    if (special_op[dev]) {
  6152. +        if (do_special_op(dev))
  6153. +            return 1;
  6154. +        return 0;
  6155. +    }
  6156. +    sec   = block % hd_info[dev].sect + 1;
  6157. +    track = block / hd_info[dev].sect;
  6158. +    head  = track % hd_info[dev].head;
  6159. +    cyl   = track / hd_info[dev].head;
  6160. +#ifdef DEBUG
  6161. +    printk("hd%c: %sing: CHS=%d/%d/%d, sectors=%d, buffer=0x%08lx (%p)\n",
  6162. +        dev+'a', (current->cmd == READ)?"read":"writ",
  6163. +        cyl, head, sec, nsect, (unsigned long) current->buffer,current);
  6164. +#endif
  6165. +    frag_sectors = nsect;
  6166. +    if (!unmask_intr[dev])
  6167. +        cli();
  6168. +    if (current->cmd == READ) {
  6169. +        unsigned int cmd = mult_count[dev] > 1 ? WIN_MULTREAD : WIN_READ;
  6170. +        hd_out(dev,nsect,sec,head,cyl,cmd,&read_intr);
  6171. +        if (reset)
  6172. +            return 1;
  6173. +        return 0;
  6174. +    }
  6175. +    if (current->cmd == WRITE) {
  6176. +#if 1
  6177. +#if 0
  6178. +        if (mult_count[dev])
  6179. +            hd_out(dev,nsect,sec,head,cyl,WIN_MULTWRITE,&multwrite_intr);
  6180. +        else
  6181. +#endif
  6182. +            hd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr);
  6183. +        if (reset)
  6184. +            return 1;
  6185. +        if (wait_DRQ()) {
  6186. +            bad_rw_intr();
  6187. +            return 1;
  6188. +        }
  6189. +#if 0
  6190. +        if (mult_count[dev]) {
  6191. +            WCURRENT = *current;
  6192. +            multwrite(dev);
  6193. +        } else
  6194. +#endif
  6195. +            outsw(HD_DATA,current->buffer,256);
  6196. +if(d == 1 && block < 10) while(1);
  6197. +#else
  6198. +if(d == 1)
  6199. +        printk("write: buffer = %p (%08lX)\n", current->buffer, *(unsigned long *)current->buffer);
  6200. +{int i; for(i=0; i<0x003fffff; i++); }
  6201. +        end_request(0);
  6202. +        return 1;
  6203. +#endif
  6204. +        return 0;
  6205. +    }
  6206. +    panic("unknown hd-command");
  6207. +    return 0;
  6208. +}
  6209. +
  6210. +static void do_hd_request (void)
  6211. +{
  6212. +    disable_irq(HD_IRQ);
  6213. +    hd_request();
  6214. +    enable_irq(HD_IRQ);
  6215. +}
  6216. +
  6217. +static int hd_ioctl(struct inode * inode, struct file * file,
  6218. +    unsigned int cmd, unsigned long arg)
  6219. +{
  6220. +    struct hd_geometry *loc = (struct hd_geometry *) arg;
  6221. +    int dev, err;
  6222. +    unsigned long flags;
  6223. +
  6224. +    if ((!inode) || (!inode->i_rdev))
  6225. +        return -EINVAL;
  6226. +    dev = DEVICE_NR(inode->i_rdev);
  6227. +    if (dev >= NR_HD)
  6228. +        return -EINVAL;
  6229. +    switch (cmd) {
  6230. +        case HDIO_GETGEO:
  6231. +            if (!loc)  return -EINVAL;
  6232. +            err = verify_area(VERIFY_WRITE, loc, sizeof(*loc));
  6233. +            if (err)
  6234. +                return err;
  6235. +            put_fs_byte(bios_info[dev].head,
  6236. +                (char *) &loc->heads);
  6237. +            put_fs_byte(bios_info[dev].sect,
  6238. +                (char *) &loc->sectors);
  6239. +            put_fs_word(bios_info[dev].cyl,
  6240. +                (short *) &loc->cylinders);
  6241. +            put_fs_long(hd[MINOR(inode->i_rdev)].start_sect,
  6242. +                (long *) &loc->start);
  6243. +            return 0;
  6244. +        case BLKRASET:
  6245. +            if(!suser())  return -EACCES;
  6246. +            if(arg > 0xff) return -EINVAL;
  6247. +            read_ahead[MAJOR(inode->i_rdev)] = arg;
  6248. +            return 0;
  6249. +        case BLKRAGET:
  6250. +            if (!arg)  return -EINVAL;
  6251. +            err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  6252. +            if (err)
  6253. +                return err;
  6254. +            put_fs_long(read_ahead[MAJOR(inode->i_rdev)],(long *) arg);
  6255. +            return 0;
  6256. +             case BLKGETSIZE:   /* Return device size */
  6257. +            if (!arg)  return -EINVAL;
  6258. +            err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  6259. +            if (err)
  6260. +                return err;
  6261. +            put_fs_long(hd[MINOR(inode->i_rdev)].nr_sects, (long *) arg);
  6262. +            return 0;
  6263. +        case BLKFLSBUF:
  6264. +            if(!suser())  return -EACCES;
  6265. +            fsync_dev(inode->i_rdev);
  6266. +            invalidate_buffers(inode->i_rdev);
  6267. +            return 0;
  6268. +
  6269. +        case BLKRRPART: /* Re-read partition tables */
  6270. +            return revalidate_hddisk(inode->i_rdev, 1);
  6271. +
  6272. +        case HDIO_SET_UNMASKINTR:
  6273. +            if (!suser()) return -EACCES;
  6274. +            if ((arg > 1) || (MINOR(inode->i_rdev) & 0x3F))
  6275. +                return -EINVAL;
  6276. +            unmask_intr[dev] = arg;
  6277. +            return 0;
  6278. +
  6279. +                case HDIO_GET_UNMASKINTR:
  6280. +            if (!arg)  return -EINVAL;
  6281. +            err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  6282. +            if (err)
  6283. +                return err;
  6284. +            put_fs_long(unmask_intr[dev], (long *) arg);
  6285. +            return 0;
  6286. +
  6287. +                case HDIO_GET_MULTCOUNT:
  6288. +            if (!arg)  return -EINVAL;
  6289. +            err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  6290. +            if (err)
  6291. +                return err;
  6292. +            put_fs_long(mult_count[dev], (long *) arg);
  6293. +            return 0;
  6294. +
  6295. +        case HDIO_SET_MULTCOUNT:
  6296. +            if (!suser()) return -EACCES;
  6297. +            if (MINOR(inode->i_rdev) & 0x3F) return -EINVAL;
  6298. +            save_flags(flags);
  6299. +            cli();    /* a prior request might still be in progress */
  6300. +            if (arg > max_mult[dev])
  6301. +                err = -EINVAL;    /* out of range for device */
  6302. +            else if (mult_req[dev] != mult_count[dev]) {
  6303. +                special_op[dev] = 1;
  6304. +                err = -EBUSY;    /* busy, try again */
  6305. +            } else {
  6306. +                mult_req[dev] = arg;
  6307. +                special_op[dev] = 1;
  6308. +                err = 0;
  6309. +            }
  6310. +            restore_flags(flags);
  6311. +            return err;
  6312. +
  6313. +        case HDIO_GET_IDENTITY:
  6314. +            if (!arg)  return -EINVAL;
  6315. +            if (MINOR(inode->i_rdev) & 0x3F) return -EINVAL;
  6316. +            if (hd_ident_info[dev] == NULL)  return -ENOMSG;
  6317. +            err = verify_area(VERIFY_WRITE, (char *) arg, sizeof(struct hd_driveid));
  6318. +            if (err)
  6319. +                return err;
  6320. +            memcpy_tofs((char *)arg, (char *) hd_ident_info[dev], sizeof(struct hd_driveid));
  6321. +            return 0;
  6322. +
  6323. +        RO_IOCTLS(inode->i_rdev,arg);
  6324. +        default:
  6325. +            return -EINVAL;
  6326. +    }
  6327. +}
  6328. +
  6329. +static int hd_open(struct inode * inode, struct file * filp)
  6330. +{
  6331. +    int target;
  6332. +    target =  DEVICE_NR(inode->i_rdev);
  6333. +
  6334. +    if (target >= NR_HD)
  6335. +        return -ENODEV;
  6336. +
  6337. +    while (busy[target])
  6338. +        sleep_on(&busy_wait);
  6339. +    access_count[target]++;
  6340. +    return 0;
  6341. +}
  6342. +
  6343. +/*
  6344. + * Releasing a block device means we sync() it, so that it can safely
  6345. + * be forgotten about...
  6346. + */
  6347. +static void hd_release(struct inode * inode, struct file * file)
  6348. +{
  6349. +        int target;
  6350. +    sync_dev(inode->i_rdev);
  6351. +
  6352. +    target =  DEVICE_NR(inode->i_rdev);
  6353. +    access_count[target]--;
  6354. +
  6355. +}
  6356. +
  6357. +static void hd_geninit(void);
  6358. +
  6359. +static struct gendisk hd_gendisk = {
  6360. +    MAJOR_NR,    /* Major number */    
  6361. +    "hd",        /* Major name */
  6362. +    6,        /* Bits to shift to get real from partition */
  6363. +    1 << 6,        /* Number of partitions per real */
  6364. +    MAX_HD,        /* maximum number of real */
  6365. +    hd_geninit,    /* init function */
  6366. +    hd,        /* hd struct */
  6367. +    hd_sizes,    /* block sizes */
  6368. +    0,        /* number */
  6369. +    (void *) bios_info,    /* internal */
  6370. +    NULL        /* next */
  6371. +};
  6372. +    
  6373. +static void hd_interrupt(int irq, struct pt_regs *regs)
  6374. +{
  6375. +    void (*handler)(void) = DEVICE_INTR;
  6376. +
  6377. +    DEVICE_INTR = NULL;
  6378. +    timer_active &= ~(1<<HD_TIMER);
  6379. +    if (!handler)
  6380. +        handler = unexpected_hd_interrupt;
  6381. +    handler();
  6382. +    sti();
  6383. +}
  6384. +
  6385. +
  6386. +void set_hdinfo(int dev,unsigned char secsptrack,unsigned char heads,
  6387. +                    unsigned long discsize,unsigned int secsize)
  6388. +{
  6389. +  dev=MINOR(dev);
  6390. +  if(hd_info[dev>>6].cyl==1)
  6391. +  {
  6392. +    hd_info[dev>>6].cyl=discsize/(secsptrack*heads*secsize);
  6393. +    hd_info[dev>>6].head=heads;
  6394. +    hd_info[dev>>6].wpcom=-1;
  6395. +    hd_info[dev>>6].ctl=8;
  6396. +    hd_info[dev>>6].lzone=hd_info[dev>>6].cyl-1;
  6397. +    hd_info[dev>>6].sect=secsptrack;
  6398. +  }
  6399. +  hd[dev].start_sect=0;
  6400. +  hd[dev].nr_sects=discsize/secsize;
  6401. +#if 0
  6402. +  printk("hd%c: %d cylinders, %d heads, %d sectors (%d total)\n",'a'+(dev>>6),
  6403. +    hd_info[dev>>6].cyl, heads, secsptrack, discsize);
  6404. +#endif
  6405. +}
  6406. +
  6407. +/*
  6408. + * This is the harddisk IRQ description. The SA_INTERRUPT in sa_flags
  6409. + * means we run the IRQ-handler with interrupts disabled: this is bad for
  6410. + * interrupt latency, but anything else has led to problems on some
  6411. + * machines...
  6412. + *
  6413. + * We enable interrupts in some of the routines after making sure it's
  6414. + * safe.
  6415. + */
  6416. +int no_hds;
  6417. +static void hd_geninit(void)
  6418. +{
  6419. +    int drive, i;
  6420. +
  6421. +NR_HD = 0;
  6422. +    if (!NR_HD) {
  6423. +    /* Default settings */
  6424. +        for (drive=0 ; drive<2 ; drive++) {
  6425. +            bios_info[drive].cyl    = hd_info[drive].cyl    = 1;
  6426. +            bios_info[drive].head    = hd_info[drive].head    = 1;
  6427. +            bios_info[drive].wpcom    = hd_info[drive].wpcom    = -1;
  6428. +            bios_info[drive].ctl    = hd_info[drive].ctl    = 8;
  6429. +            bios_info[drive].lzone    = hd_info[drive].lzone    = 1;
  6430. +            bios_info[drive].sect    = hd_info[drive].sect    = 17;
  6431. +            if(hd_info[drive].cyl && NR_HD == drive)
  6432. +                NR_HD++;
  6433. +        }
  6434. +        }
  6435. +
  6436. +    NR_HD = no_hds;
  6437. +
  6438. +    i = NR_HD;
  6439. +    while (i-- > 0) {
  6440. +        /*
  6441. +         * The newer E-IDE BIOSs handle drives larger than 1024
  6442. +         * cylinders by increasing the number of logical heads
  6443. +         * to keep the number of logical cylinders below the
  6444. +         * sacred INT13 limit of 1024 (10 bits).  If that is
  6445. +         * what's happening here, we'll find out and correct
  6446. +         * it later when "identifying" the drive.
  6447. +         */
  6448. +        hd[i<<6].nr_sects = bios_info[i].head *
  6449. +                bios_info[i].sect * bios_info[i].cyl;
  6450. +        hd_ident_info[i] = (struct hd_driveid *) kmalloc(512,GFP_KERNEL);
  6451. +        special_op[i] = 1;
  6452. +    }
  6453. +    if (NR_HD) {
  6454. +        if (request_irq(HD_IRQ, hd_interrupt, SA_INTERRUPT, "hd")) {
  6455. +            printk("hd: unable to get IRQ%d for the harddisk driver\n",HD_IRQ);
  6456. +            NR_HD = 0;
  6457. +        } else {
  6458. +            request_region(HD_DATA, 8, "hd");
  6459. +            request_region(HD_CMD, 1, "hd(cmd)");
  6460. +        }
  6461. +    }
  6462. +    hd_gendisk.nr_real = NR_HD;
  6463. +
  6464. +    for(i=0;i<(MAX_HD << 6);i++) hd_blocksizes[i] = 1024;
  6465. +    blksize_size[MAJOR_NR] = hd_blocksizes;
  6466. +}
  6467. +
  6468. +static struct file_operations hd_fops = {
  6469. +    NULL,            /* lseek - default */
  6470. +    block_read,        /* read - general block-dev read */
  6471. +    block_write,        /* write - general block-dev write */
  6472. +    NULL,            /* readdir - bad */
  6473. +    NULL,            /* select */
  6474. +    hd_ioctl,        /* ioctl */
  6475. +    NULL,            /* mmap */
  6476. +    hd_open,        /* open */
  6477. +    hd_release,        /* release */
  6478. +    block_fsync        /* fsync */
  6479. +};
  6480. +
  6481. +unsigned long hd_init(unsigned long mem_start, unsigned long mem_end)
  6482. +{
  6483. +    if (register_blkdev(MAJOR_NR,"hd",&hd_fops)) {
  6484. +        printk("hd: unable to get major %d for harddisk\n",MAJOR_NR);
  6485. +        return mem_start;
  6486. +    }
  6487. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  6488. +    read_ahead[MAJOR_NR] = 8;        /* 8 sector (4kB) read-ahead */
  6489. +    hd_gendisk.next = gendisk_head;
  6490. +    gendisk_head = &hd_gendisk;
  6491. +    timer_table[HD_TIMER].fn = hd_times_out;
  6492. +    return mem_start;
  6493. +}
  6494. +
  6495. +#define DEVICE_BUSY busy[target]
  6496. +#define USAGE access_count[target]
  6497. +#define CAPACITY (bios_info[target].head*bios_info[target].sect*bios_info[target].cyl)
  6498. +/* We assume that the the bios parameters do not change, so the disk capacity
  6499. +   will not change */
  6500. +#undef MAYBE_REINIT
  6501. +#define GENDISK_STRUCT hd_gendisk
  6502. +
  6503. +/*
  6504. + * This routine is called to flush all partitions and partition tables
  6505. + * for a changed scsi disk, and then re-read the new partition table.
  6506. + * If we are revalidating a disk because of a media change, then we
  6507. + * enter with usage == 0.  If we are using an ioctl, we automatically have
  6508. + * usage == 1 (we need an open channel to use an ioctl :-), so this
  6509. + * is our limit.
  6510. + */
  6511. +static int revalidate_hddisk(int dev, int maxusage)
  6512. +{
  6513. +    int target, major;
  6514. +    struct gendisk * gdev;
  6515. +    int max_p;
  6516. +    int start;
  6517. +    int i;
  6518. +    unsigned long flags;
  6519. +
  6520. +    target =  DEVICE_NR(dev);
  6521. +    gdev = &GENDISK_STRUCT;
  6522. +
  6523. +    save_flags(flags);
  6524. +    cli();
  6525. +    if (DEVICE_BUSY || USAGE > maxusage) {
  6526. +        restore_flags(flags);
  6527. +        return -EBUSY;
  6528. +    };
  6529. +    DEVICE_BUSY = 1;
  6530. +    restore_flags(flags);
  6531. +
  6532. +    max_p = gdev->max_p;
  6533. +    start = target << gdev->minor_shift;
  6534. +    major = MAJOR_NR << 8;
  6535. +
  6536. +    for (i=max_p - 1; i >=0 ; i--) {
  6537. +        sync_dev(major | start | i);
  6538. +        invalidate_inodes(major | start | i);
  6539. +        invalidate_buffers(major | start | i);
  6540. +        gdev->part[start+i].start_sect = 0;
  6541. +        gdev->part[start+i].nr_sects = 0;
  6542. +    };
  6543. +
  6544. +#ifdef MAYBE_REINIT
  6545. +    MAYBE_REINIT;
  6546. +#endif
  6547. +
  6548. +    gdev->part[start].nr_sects = CAPACITY;
  6549. +    resetup_one_dev(gdev, target);
  6550. +
  6551. +    DEVICE_BUSY = 0;
  6552. +    wake_up(&busy_wait);
  6553. +    return 0;
  6554. +}
  6555. +
  6556. diff -r -u -N linux.orig/arch/arm/drivers/block/hd.diff linux.arm/arch/arm/drivers/block/hd.diff
  6557. --- linux.orig/arch/arm/drivers/block/hd.diff    Thu Jan  1 01:00:00 1970
  6558. +++ linux.arm/arch/arm/drivers/block/hd.diff    Fri Oct 27 23:14:52 1995
  6559. @@ -0,0 +1,2672 @@
  6560. +--- /usr/src/linux/arch/arm/drivers/block/floppy.c    Thu Aug 31 22:19:59 1995
  6561. ++++ /usr/src/linux/drivers/block/floppy.c    Sun Sep 24 10:23:30 1995
  6562. +@@ -4,32 +4,6 @@
  6563. +  *  Copyright (C) 1991, 1992  Linus Torvalds
  6564. +  *  Copyright (C) 1993, 1994  Alain Knaff
  6565. +  */
  6566. +-
  6567. +-/* Configuration */
  6568. +-/* The following does some extra sanity checks */
  6569. +-#define SANITY
  6570. +-
  6571. +-/* the following is the mask of allowed drives. By default units 2 and
  6572. +- * 3 of both floppy controllers are disabled, because switching on the
  6573. +- * motor of these drives causes system hangs on some PCI computers. drive
  6574. +- * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
  6575. +- * a drive is allowed. */
  6576. +-#define ALLOWED_DRIVE_MASK 0x0F
  6577. +-
  6578. +-/* Undefine the following if you have to floppy disk controllers:
  6579. +- * This works at least for me; if you get two controllers working, with
  6580. +- * drives attached to both, please mail me: Alain.Knaff@imag.fr */
  6581. +-/* #define HAVE_2_CONTROLLERS */
  6582. +-
  6583. +-
  6584. +-/* Define the following if you don't like that your drives seek audibly
  6585. +- * after a disk change (but it may not work correctly for everybody)
  6586. +- */
  6587. +-#define SILENT_DC_CLEAR
  6588. +-
  6589. +-
  6590. +-/* End of configuration */
  6591. +-
  6592. + /*
  6593. +  * 02.12.91 - Changed to static variables to indicate need for reset
  6594. +  * and recalibrate. This makes some things easier (output_byte reset
  6595. +@@ -103,15 +77,39 @@
  6596. +  * format bug fixes, but unfortunately some new bugs too...
  6597. +  */
  6598. + 
  6599. +-/* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
  6600. ++/* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write 
  6601. +  * errors to allow safe writing by specialized programs.
  6602. +  */
  6603. +-int no_floppies;
  6604. +-#define FLOPPY_IRQ 12
  6605. +-#define FLOPPY_DMA 2
  6606. ++
  6607. ++#define CONFIG_FLOPPY_SANITY
  6608. ++#undef  CONFIG_FLOPPY_SILENT_DCL_CLEAR
  6609. ++
  6610. ++#define REALLY_SLOW_IO
  6611. ++
  6612. + #define DEBUGT 2
  6613. ++#define DCL_DEBUG /* debug disk change line */
  6614. + 
  6615. + #include <linux/config.h>
  6616. ++
  6617. ++/* do print messages for unexpected interrupts */
  6618. ++static int print_unex=1;
  6619. ++
  6620. ++#ifndef FD_MODULE
  6621. ++/* the following is the mask of allowed drives. By default units 2 and
  6622. ++ * 3 of both floppy controllers are disabled, because switching on the
  6623. ++ * motor of these drives causes system hangs on some PCI computers. drive
  6624. ++ * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
  6625. ++ * a drive is allowed. */
  6626. ++static int ALLOWED_DRIVE_MASK=0x33;
  6627. ++
  6628. ++#define FLOPPY_IRQ 6
  6629. ++#define FLOPPY_DMA 2
  6630. ++#define FDC1 0x3f0
  6631. ++static int FDC2=-1;
  6632. ++#endif
  6633. ++
  6634. ++#define MODULE_AWARE_DRIVER
  6635. ++
  6636. + #include <linux/sched.h>
  6637. + #include <linux/fs.h>
  6638. + #include <linux/kernel.h>
  6639. +@@ -125,6 +123,7 @@
  6640. + #include <linux/string.h>
  6641. + #include <linux/fcntl.h>
  6642. + #include <linux/delay.h>
  6643. ++#include <linux/mc146818rtc.h> /* CMOS defines */
  6644. + 
  6645. + #include <asm/dma.h>
  6646. + #include <asm/irq.h>
  6647. +@@ -135,16 +134,24 @@
  6648. + #define MAJOR_NR FLOPPY_MAJOR
  6649. + #include "blk.h"
  6650. + 
  6651. +-static unsigned int changed_floppies = 0xff, fake_change = 0;
  6652. ++static unsigned int fake_change = 0;
  6653. + static int initialising=1;
  6654. + 
  6655. +-#ifdef HAVE_2_CONTROLLERS
  6656. ++#define FLOPPY0_TYPE    ((CMOS_READ(0x10) >> 4) & 15)
  6657. ++#define FLOPPY1_TYPE    (CMOS_READ(0x10) & 15)
  6658. ++
  6659. ++/*
  6660. ++ * Again, the CMOS information doesn't work on the alpha..
  6661. ++ */
  6662. ++#ifdef __alpha__
  6663. ++#undef FLOPPY0_TYPE
  6664. ++#undef FLOPPY1_TYPE
  6665. ++#define FLOPPY0_TYPE 6
  6666. ++#define FLOPPY1_TYPE 0
  6667. ++#endif
  6668. ++
  6669. + #define N_FDC 2
  6670. + #define N_DRIVE 8
  6671. +-#else
  6672. +-#define N_FDC 1
  6673. +-#define N_DRIVE 4
  6674. +-#endif
  6675. + 
  6676. + #define TYPE(x) ( ((x)>>2) & 0x1f )
  6677. + #define DRIVE(x) ( ((x)&0x03) | (((x)&0x80 ) >> 5))
  6678. +@@ -156,22 +163,28 @@
  6679. + #define DRS (&drive_state[current_drive])
  6680. + #define DRWE (&write_errors[current_drive])
  6681. + #define FDCS (&fdc_state[fdc])
  6682. ++#define CLEARF(x) (clear_bit(x##_BIT, &DRS->flags))
  6683. ++#define SETF(x) (set_bit(x##_BIT, &DRS->flags))
  6684. ++#define TESTF(x) (test_bit(x##_BIT, &DRS->flags))
  6685. + 
  6686. + #define UDP (&drive_params[drive])
  6687. + #define UDRS (&drive_state[drive])
  6688. + #define UDRWE (&write_errors[drive])
  6689. + #define UFDCS (&fdc_state[FDC(drive)])
  6690. ++#define UCLEARF(x) (clear_bit(x##_BIT, &UDRS->flags))
  6691. ++#define USETF(x) (set_bit(x##_BIT, &UDRS->flags))
  6692. ++#define UTESTF(x) (test_bit(x##_BIT, &UDRS->flags))
  6693. + 
  6694. +-#define DPRINT(x) printk(DEVICE_NAME "%d: " x,current_drive);
  6695. ++#define DPRINT(x) printk(DEVICE_NAME "%d: " x,current_drive)
  6696. + 
  6697. + #define DPRINT1(x,x1) \
  6698. +-printk(DEVICE_NAME "%d: " x,current_drive,(x1));
  6699. ++printk(DEVICE_NAME "%d: " x,current_drive,(x1))
  6700. + 
  6701. + #define DPRINT2(x,x1,x2) \
  6702. +-printk(DEVICE_NAME "%d: " x,current_drive,(x1),(x2));
  6703. ++printk(DEVICE_NAME "%d: " x,current_drive,(x1),(x2))
  6704. + 
  6705. + #define DPRINT3(x,x1,x2,x3) \
  6706. +-printk(DEVICE_NAME "%d: " x,current_drive,(x1),(x2),(x3));
  6707. ++printk(DEVICE_NAME "%d: " x,current_drive,(x1),(x2),(x3))
  6708. + 
  6709. + /* read/write */
  6710. + #define COMMAND raw_cmd.cmd[0]
  6711. +@@ -195,8 +208,9 @@
  6712. + /*
  6713. +  * Maximum disk size (in kilobytes). This default is used whenever the
  6714. +  * current disk size is unknown.
  6715. ++ * [Now it is rather a minimum]
  6716. +  */
  6717. +-#define MAX_DISK_SIZE 3984
  6718. ++#define MAX_DISK_SIZE 2 /* 3984*/
  6719. + 
  6720. + 
  6721. + 
  6722. +@@ -208,13 +222,9 @@
  6723. +  * driver otherwise. It doesn't matter much for performance anyway, as most
  6724. +  * floppy accesses go through the track buffer.
  6725. +  */
  6726. +-#if 0
  6727. + #define LAST_DMA_ADDR    (0x1000000)
  6728. +-#else
  6729. +-/* Everything has to go via dma buffer */
  6730. +-#define LAST_DMA_ADDR    (0x1)
  6731. +-#endif
  6732. + #define K_64 (0x10000) /* 64 k */
  6733. ++
  6734. + /*
  6735. +  * globals used by 'result()'
  6736. +  */
  6737. +@@ -230,6 +240,9 @@
  6738. + #define R_SECTOR (reply_buffer[5])
  6739. + #define R_SIZECODE (reply_buffer[6])
  6740. + 
  6741. ++#define SEL_DLY (2*HZ/100)
  6742. ++
  6743. ++#define ARRAY_SIZE(x) (sizeof(x) / sizeof( (x)[0] ))
  6744. + /*
  6745. +  * this struct defines the different floppy drive types.
  6746. +  */
  6747. +@@ -243,49 +256,44 @@
  6748. +   |     |   Head load time, msec
  6749. +   |     |   |   Head unload time, msec (not used)
  6750. +   |     |   |   |     Step rate interval, usec
  6751. +-  |     |   |   |     |    Time needed for spinup time (jiffies)
  6752. +-  |     |   |   |     |    |    Timeout for spinning down (jiffies)
  6753. +-  |     |   |   |     |    |    |   Spindown offset (where disk stops)
  6754. +-  |     |   |   |     |    |    |   |  Select delay
  6755. +-  |     |   |   |     |    |    |   |  |  RPS
  6756. +-  |     |   |   |     |    |    |   |  |  |    Max number of tracks
  6757. +-  |     |   |   |     |    |    |   |  |  |    |     Interrupt timeout
  6758. +-  |     |   |   |     |    |    |   |  |  |    |     |   Max nonintlv. sectors
  6759. +-  |     |   |   |     |    |    |   |  |  |    |     |   | -Max Errors- flags */
  6760. +-{{0,  500, 16, 16, 8000, 100, 300,  0, 2, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
  6761. +-      0, { 7, 4, 8, 2, 1, 5, 3,10}, 150, 0 }, "unknown" },
  6762. +-
  6763. +-{{1,  300, 16, 16, 8000, 100, 300,  0, 2, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
  6764. +-      0, { 1, 0, 0, 0, 0, 0, 0, 0}, 150, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
  6765. +-
  6766. +-{{2,  500, 16, 16, 6000,  40, 300, 14, 2, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
  6767. +-      0, { 2, 5, 6,23,10,20,11, 0}, 150, 2 }, "1.2M" }, /*5 1/4 HD AT*/
  6768. +-
  6769. +-{{3,  250, 16, 16, 3000, 100, 300,  0, 2, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  6770. +-      0, { 4,22,21,30, 3, 0, 0, 0}, 150, 4 }, "720k" }, /*3 1/2 DD*/
  6771. +-
  6772. +-#if 0
  6773. +-{{4,  500, 16, 16, 4000,  40, 300, 10, 2, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  6774. +-      0, { 7, 4,25,22,31,21,29,11}, 150, 7 }, "1.44M" }, /*3 1/2 HD*/
  6775. +-#else
  6776. +-{{4,  500, 16, 16, 3000,  40, 300, 10, 2, 5,  83, 3*HZ, 20, {3,1,2,0,0}, FTD_MSG,
  6777. +-      0, { 7, 4,25,22,31,21,29,11}, 150, 7 }, "1.44M" }, /*3 1/2 HD*/
  6778. +-#endif
  6779. +-
  6780. +-{{5, 1000, 15,  8, 3000,  40, 300, 10, 2, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  6781. +-      0, { 7, 8, 4,25,28,22,31,21}, 150, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
  6782. +-
  6783. +-{{6, 1000, 15,  8, 3000,  40, 300, 10, 2, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  6784. +-      0, { 7, 8, 4,25,28,22,31,21}, 150, 8 }, "2.88M" } /*3 1/2 ED*/
  6785. +-/*    |  ---autodetected formats--   |   |      |
  6786. +-      read_track                     |   |    Name printed when booting
  6787. +-                                     |  Native format
  6788. ++  |     |   |   |     |       Time needed for spinup time (jiffies)
  6789. ++  |     |   |   |     |       |      Timeout for spinning down (jiffies)
  6790. ++  |     |   |   |     |       |      |   Spindown offset (where disk stops)
  6791. ++  |     |   |   |     |       |      |   |     Select delay
  6792. ++  |     |   |   |     |       |      |   |     |     RPS
  6793. ++  |     |   |   |     |       |      |   |     |     |    Max number of tracks
  6794. ++  |     |   |   |     |       |      |   |     |     |    |     Interrupt timeout
  6795. ++  |     |   |   |     |       |      |   |     |     |    |     |   Max nonintlv. sectors
  6796. ++  |     |   |   |     |       |      |   |     |     |    |     |   | -Max Errors- flags */
  6797. ++{{0,  500, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
  6798. ++      0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
  6799. ++
  6800. ++{{1,  300, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
  6801. ++      0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
  6802. ++
  6803. ++{{2,  500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
  6804. ++      0, { 2, 5, 6,23,10,20,11, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
  6805. ++
  6806. ++{{3,  250, 16, 16, 3000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  6807. ++      0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
  6808. ++
  6809. ++{{4,  500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  6810. ++      0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
  6811. ++
  6812. ++{{5, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  6813. ++      0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
  6814. ++
  6815. ++{{6, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  6816. ++      0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
  6817. ++/*    |  ---autodetected formats--   |      |      |
  6818. ++      read_track                     |      |    Name printed when booting
  6819. ++                                     |     Native format
  6820. +                                    Frequency of disk change checks */
  6821. + };
  6822. + 
  6823. + static struct floppy_drive_params drive_params[N_DRIVE];
  6824. +-static struct floppy_drive_struct volatile drive_state[N_DRIVE];
  6825. +-static struct floppy_write_errors volatile write_errors[N_DRIVE];
  6826. ++static struct floppy_drive_struct drive_state[N_DRIVE];
  6827. ++static struct floppy_write_errors write_errors[N_DRIVE];
  6828. + static struct floppy_raw_cmd raw_cmd;
  6829. + 
  6830. + /*
  6831. +@@ -295,16 +303,6 @@
  6832. +  * types (ie 360kB diskette in 1.2MB drive etc). Others should
  6833. +  * be self-explanatory.
  6834. +  */
  6835. +-/*
  6836. +-             Size
  6837. +-             |  Sectors per track
  6838. +-             |  | Head
  6839. +-             |  | |  Tracks
  6840. +-             |  | |  | Stretch
  6841. +-             |  | |  | |  Gap 1 size
  6842. +-             |  | |  | |    |  Data rate, | 0x40 for perp
  6843. +-         |  | |  | |    |    |  Spec1 (stepping rate, head unload
  6844. +-             |  | |  | |    |    |    |    /fmt gap (gap2) */
  6845. + static struct floppy_struct floppy_type[32] = {
  6846. +     {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL    },    /*  0 no testing    */
  6847. +     {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360"  }, /*  1 360KB PC      */
  6848. +@@ -348,11 +346,8 @@
  6849. + 
  6850. + /* Auto-detection: Disk type used until the next media change occurs. */
  6851. + struct floppy_struct *current_type[N_DRIVE] = {
  6852. ++    NULL, NULL, NULL, NULL,
  6853. +     NULL, NULL, NULL, NULL
  6854. +-#ifdef HAVE_2_CONTROLLERS
  6855. +-    ,
  6856. +-    NULL, NULL, NULL, NULL
  6857. +-#endif
  6858. + };
  6859. + 
  6860. + /*
  6861. +@@ -362,6 +357,7 @@
  6862. + struct floppy_struct user_params[N_DRIVE];
  6863. + 
  6864. + static int floppy_sizes[256];
  6865. ++static int floppy_blocksizes[256] = { 0, };
  6866. + 
  6867. + /*
  6868. +  * The driver is trying to determine the correct media format
  6869. +@@ -380,6 +376,9 @@
  6870. + static struct wait_queue *fdc_wait = NULL, *command_done = NULL;
  6871. + #define NO_SIGNAL (!(current->signal & ~current->blocked) || !interruptible)
  6872. + #define CALL(x) if( (x) == -EINTR) return -EINTR;
  6873. ++#define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
  6874. ++#define WAIT(x) _WAIT((x),interruptible)
  6875. ++#define IWAIT(x) _WAIT((x),1)
  6876. + 
  6877. + /* Errors during formatting are counted here. */
  6878. + static int format_errors;
  6879. +@@ -400,11 +399,7 @@
  6880. +  * corrupted/lost. Alignment of these is enforced in boot/head.S.
  6881. +  * Note that you must not change the sizes below without updating head.S.
  6882. +  */
  6883. +-#if 0
  6884. + extern char floppy_track_buffer[512*2*MAX_BUFFER_SECTORS];
  6885. +-#else
  6886. +-char floppy_track_buffer[512*2*MAX_BUFFER_SECTORS];
  6887. +-#endif
  6888. + #define max_buffer_sectors MAX_BUFFER_SECTORS
  6889. + 
  6890. + int *errors;
  6891. +@@ -417,10 +412,10 @@
  6892. + done_f done; /* this is called to say if the operation has succeeded/failed */
  6893. + } *cont;
  6894. + 
  6895. ++static void floppy_ready(void);
  6896. + static void floppy_start(void);
  6897. +-static void redo_fd_request(void);
  6898. ++static void process_fd_request(void);
  6899. + static void recalibrate_floppy(void);
  6900. +-static void seek_floppy(void);
  6901. + static void floppy_shutdown(void);
  6902. + 
  6903. + static int floppy_grab_irq_and_dma(void);
  6904. +@@ -444,7 +439,10 @@
  6905. + #define NO_TRACK -1
  6906. + #define NEED_1_RECAL -2
  6907. + #define NEED_2_RECAL -3
  6908. +-#define PROVEN_ABSENT -4
  6909. ++
  6910. ++/* */
  6911. ++static int usage_count = 0;
  6912. ++
  6913. + 
  6914. + /* buffer related variables */
  6915. + static int buffer_track = -1;
  6916. +@@ -454,10 +452,10 @@
  6917. + 
  6918. + /* fdc related variables, should end up in a struct */
  6919. + static struct floppy_fdc_state fdc_state[N_FDC];
  6920. +-int fdc; /* current fdc */
  6921. ++static int fdc; /* current fdc */
  6922. + 
  6923. + static struct floppy_struct * floppy = floppy_type;
  6924. +-static unsigned char current_drive = 255;
  6925. ++static unsigned char current_drive = 0;
  6926. + static long current_count_sectors = 0;
  6927. + static char *current_addr = 0;
  6928. + static unsigned char sector_t; /* sector in track */
  6929. +@@ -467,20 +465,6 @@
  6930. + #endif
  6931. + 
  6932. + /*
  6933. +- * Floppy_selects1 is the list of DOR's to select a drive n
  6934. +- * Floppy_selects2 is the list of DOR's to select drive fd
  6935. +- * On initialisation, the floppy list is scanned, and the drives allocated
  6936. +- * in the order that they are found.  This is done by seeking the drive
  6937. +- * to a non-zero track, and then restoring it to track 0.  If an error occurs,
  6938. +- * then there is no floppy drive present.
  6939. +- */
  6940. +-
  6941. +-unsigned char floppy_selects1[]={ 0x10, 0x21, 0x23, 0x33 };
  6942. +-unsigned char floppy_selects2[]={ 0   , 0   , 0   , 0    };
  6943. +-
  6944. +-int fd_sectsizes[256];
  6945. +-
  6946. +-/*
  6947. +  * Debugging
  6948. +  * =========
  6949. +  */
  6950. +@@ -509,14 +493,17 @@
  6951. + 
  6952. + /*
  6953. +  * disk change.
  6954. +- * This routine is responsible for maintaining the changed_floppies flag,
  6955. ++ * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
  6956. +  * and the last_checked date.
  6957. +  *
  6958. +  * last_checked is the date of the last check which showed 'no disk change'
  6959. +- * changed_floppies is set under two conditions:
  6960. ++ * FD_DISK_CHANGE is set under two conditions:
  6961. +  * 1. The floppy has been changed after some i/o to that floppy already
  6962. +  *    took place.
  6963. +- * 2. No floppy disk is in the drive.
  6964. ++ * 2. No floppy disk is in the drive. This is done in order to ensure that
  6965. ++ *    requests are quickly flushed in case there is no disk in the drive. It
  6966. ++ *    follows that FD_DISK_CHANGE can only be cleared if there is a disk in
  6967. ++ *    the drive.
  6968. +  *
  6969. +  * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
  6970. +  * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
  6971. +@@ -531,74 +518,102 @@
  6972. + 
  6973. + static int disk_change(int drive)
  6974. + {
  6975. +-    if(jiffies < DP->select_delay + DRS->select_date)
  6976. +-        udelay(20000);
  6977. +-
  6978. +-    if(inb_p(FD_DIR) & 0x80){
  6979. +-        UDRS->flags |= FD_VERIFY; /* verify write protection */
  6980. ++    int fdc=FDC(drive);
  6981. ++#ifdef CONFIG_FLOPPY_SANITY
  6982. ++    if(jiffies < UDP->select_delay + UDRS->select_date)
  6983. ++        DPRINT("WARNING disk change called early\n");
  6984. ++    if(! (FDCS->dor & (0x10 << UNIT(drive))) ||
  6985. ++       (FDCS->dor & 3) != UNIT(drive) ||
  6986. ++       fdc != FDC(drive)){
  6987. ++        DPRINT("probing disk change on unselected drive\n");
  6988. ++        DPRINT3("drive=%d fdc=%d dor=%x\n",drive, FDC(drive),
  6989. ++            FDCS->dor);
  6990. ++    }
  6991. ++#endif
  6992. + 
  6993. +-        if(UDRS->maxblock || /* disk change check */
  6994. +-           !(UDRS->flags & FD_DISK_NEWCHANGE)){/* disk presence check */
  6995. +-            /* mark it changed or absent */
  6996. +-            set_bit(drive,&changed_floppies);
  6997. ++#ifdef DCL_DEBUG
  6998. ++    if (UDP->flags & FD_DEBUG){
  6999. ++        DPRINT1("checking disk change line for drive %d\n",drive);
  7000. ++        DPRINT1("jiffies=%ld\n", jiffies);
  7001. ++        DPRINT1("disk change line=%x\n",inb_p(FD_DIR)&0x80);
  7002. ++        DPRINT1("flags=%x\n",UDRS->flags);
  7003. ++    }
  7004. ++#endif
  7005. ++    if (UDP->flags & FD_BROKEN_DCL)
  7006. ++        return UTESTF(FD_DISK_CHANGED);
  7007. ++    if( (inb_p(FD_DIR) ^ UDP->flags) & 0x80){
  7008. ++        USETF(FD_VERIFY); /* verify write protection */        
  7009. ++        if(UDRS->maxblock){
  7010. ++            /* mark it changed */
  7011. ++            USETF(FD_DISK_CHANGED);
  7012. + 
  7013. +             /* invalidate its geometry */
  7014. +             if (UDRS->keep_data >= 0) {
  7015. +-                if ((DP->flags & FTD_MSG) &&
  7016. ++                if ((UDP->flags & FTD_MSG) &&
  7017. +                     current_type[drive] != NULL)
  7018. +                     DPRINT("Disk type is undefined after "
  7019. +                            "disk change\n");
  7020. +                 current_type[drive] = NULL;
  7021. +-                floppy_sizes[drive] = MAX_DISK_SIZE;
  7022. ++                floppy_sizes[DRIVE(current_drive) + (FDC(current_drive) << 7)] = MAX_DISK_SIZE;
  7023. +             }
  7024. +         }
  7025. +-        UDRS->flags |= FD_DISK_NEWCHANGE;
  7026. ++        /*USETF(FD_DISK_NEWCHANGE);*/
  7027. +         return 1;
  7028. +     } else {
  7029. +         UDRS->last_checked=jiffies;
  7030. +-        UDRS->flags &= ~FD_DISK_NEWCHANGE;
  7031. +-        return 0;
  7032. ++        UCLEARF(FD_DISK_NEWCHANGE);
  7033. +     }
  7034. ++    return 0;
  7035. + }
  7036. + 
  7037. +-static void arm_set_dor(int dor)
  7038. ++static inline int is_selected(int dor, int unit)
  7039. + {
  7040. +-    if(dor & 0xf0)
  7041. +-        outb_p((dor & 0x0c) | floppy_selects1[dor & 3], FD_DOR);
  7042. +-    else
  7043. +-        outb_p((dor & 0x0c), FD_DOR);
  7044. ++    return ( (dor  & (0x10 << unit)) && (dor &3) == unit);
  7045. + }
  7046. + 
  7047. +-static int locked=0;
  7048. + static int set_dor(int fdc, char mask, char data)
  7049. + {
  7050. +     register unsigned char drive, unit, newdor,olddor;
  7051. + 
  7052. +-    locked=1;
  7053. ++    if(FDCS->address == -1)
  7054. ++        return -1;
  7055. ++
  7056. +     olddor = FDCS->dor;
  7057. +     newdor =  (olddor & mask) | data;
  7058. +     if ( newdor != olddor ){
  7059. +         unit = olddor & 0x3;
  7060. +-        drive = REVDRIVE(fdc,unit);
  7061. +-        if ( olddor & ( 0x10 << unit ))
  7062. ++        if(is_selected(olddor, unit) && !is_selected(newdor,unit)){
  7063. ++            drive = REVDRIVE(fdc,unit);
  7064. ++#ifdef DCL_DEBUG
  7065. ++    if (UDP->flags & FD_DEBUG){
  7066. ++        DPRINT("calling disk change from set_dor\n");
  7067. ++    }
  7068. ++#endif
  7069. +             disk_change(drive);
  7070. ++        }
  7071. +         FDCS->dor = newdor;
  7072. +-        arm_set_dor(newdor);
  7073. ++        outb_p(newdor, FD_DOR);
  7074. ++
  7075. ++        unit = newdor & 0x3;
  7076. ++        if(!is_selected(olddor, unit) && is_selected(newdor,unit)){
  7077. ++            drive = REVDRIVE(fdc,unit);
  7078. ++            UDRS->select_date = jiffies;
  7079. ++        }
  7080. +     }
  7081. +-    locked=0;
  7082. ++    if ( newdor & 0xf0 )
  7083. ++        floppy_grab_irq_and_dma();
  7084. ++    if( olddor & 0xf0 )
  7085. ++        floppy_release_irq_and_dma();
  7086. +     return olddor;
  7087. + }
  7088. + 
  7089. + static void twaddle(void)
  7090. + {
  7091. +-    cli();
  7092. +-#if 0
  7093. ++    if (DP->select_delay)
  7094. ++        return;
  7095. +     outb_p(FDCS->dor & ~(0x10<<UNIT(current_drive)),FD_DOR);
  7096. +     outb_p(FDCS->dor, FD_DOR);
  7097. +-#else
  7098. +-    arm_set_dor(FDCS->dor);
  7099. +-#endif
  7100. +-    sti();
  7101. ++    DRS->select_date = jiffies;
  7102. + }
  7103. + 
  7104. + /* reset all driver information about the current fdc. This is needed after
  7105. +@@ -613,7 +628,6 @@
  7106. +     FDCS->rawcmd = 0;
  7107. +     for ( drive = 0; drive < N_DRIVE; drive++)
  7108. +         if (FDC(drive) == fdc &&
  7109. +-            UDRS->track != PROVEN_ABSENT &&
  7110. +             ( mode || UDRS->track != NEED_1_RECAL))
  7111. +             UDRS->track = NEED_2_RECAL;
  7112. + }
  7113. +@@ -621,30 +635,28 @@
  7114. + /* selects the fdc and drive, and enables the fdc's input/dma. */
  7115. + static void set_fdc(int drive)
  7116. + {
  7117. +-    if ( drive >= 0 ){
  7118. ++    if (drive >= 0 && drive < N_DRIVE){
  7119. +         fdc = FDC(drive);
  7120. +         current_drive = drive;
  7121. +     }
  7122. +     set_dor(fdc,~0,8);
  7123. +-#ifdef HAVE_2_CONTROLLERS
  7124. +     set_dor(1-fdc, ~8, 0);
  7125. +-#endif
  7126. +     if ( FDCS->rawcmd == 2 )
  7127. +         reset_fdc_info(1);
  7128. +     if( inb_p(FD_STATUS) != STATUS_READY )
  7129. +         FDCS->reset = 1;
  7130. + }
  7131. + 
  7132. +-static int usage_count = 0;
  7133. + /* locks the driver */
  7134. + static int lock_fdc(int drive, int interruptible)
  7135. + {
  7136. +-
  7137. +     if(!usage_count){
  7138. +         printk("trying to lock fdc while usage count=0\n");
  7139. +         return -1;
  7140. +     }
  7141. +     floppy_grab_irq_and_dma();
  7142. ++    if (!current->pid)
  7143. ++        run_task_queue(&tq_timer);
  7144. +     cli();
  7145. +     while (fdc_busy && NO_SIGNAL)
  7146. +         interruptible_sleep_on(&fdc_wait);
  7147. +@@ -662,6 +674,10 @@
  7148. + #define LOCK_FDC(drive,interruptible) \
  7149. + if(lock_fdc(drive,interruptible)) return -EINTR;
  7150. + 
  7151. ++typedef void (*timeout_fn)(unsigned long);
  7152. ++static struct timer_list fd_timeout ={ NULL, NULL, 0, 0, 
  7153. ++                           (timeout_fn) floppy_shutdown };
  7154. ++
  7155. + /* unlocks the driver */
  7156. + static inline void unlock_fdc(void)
  7157. + {
  7158. +@@ -672,7 +688,7 @@
  7159. +         DPRINT1("device interrupt still active at FDC release: %p!\n",
  7160. +             DEVICE_INTR);
  7161. +     command_status = FD_COMMAND_NONE;
  7162. +-    timer_active &= ~(1 << FLOPPY_TIMER);
  7163. ++    del_timer(&fd_timeout);
  7164. +     fdc_busy = 0;
  7165. +     floppy_release_irq_and_dma();
  7166. +     wake_up(&fdc_wait);
  7167. +@@ -683,47 +699,40 @@
  7168. + {
  7169. +     unsigned char mask = ~(0x10 << UNIT(nr));
  7170. + 
  7171. +-    if(locked)
  7172. +-        floppy_off(nr);
  7173. +-    else
  7174. +-        set_dor( FDC(nr), mask, 0 );
  7175. ++    set_dor( FDC(nr), mask, 0 );
  7176. + }
  7177. + 
  7178. + static struct timer_list motor_off_timer[N_DRIVE] = {
  7179. +     { NULL, NULL, 0, 0, motor_off_callback },
  7180. +     { NULL, NULL, 0, 1, motor_off_callback },
  7181. +     { NULL, NULL, 0, 2, motor_off_callback },
  7182. +-    { NULL, NULL, 0, 3, motor_off_callback }
  7183. +-#ifdef HAVE_2_CONTROLLERS
  7184. +-    ,
  7185. ++    { NULL, NULL, 0, 3, motor_off_callback },
  7186. +     { NULL, NULL, 0, 4, motor_off_callback },
  7187. +     { NULL, NULL, 0, 5, motor_off_callback },
  7188. +     { NULL, NULL, 0, 6, motor_off_callback },
  7189. +     { NULL, NULL, 0, 7, motor_off_callback }
  7190. +-#endif
  7191. + };
  7192. + 
  7193. + /* schedules motor off */
  7194. +-static void floppy_off(unsigned int nr)
  7195. ++static void floppy_off(unsigned int drive)
  7196. + {
  7197. +     unsigned long volatile delta;
  7198. +-    register int fdc=FDC(nr);
  7199. ++    register int fdc=FDC(drive);
  7200. + 
  7201. +-    if( !(FDCS->dor & ( 0x10 << UNIT(nr))))
  7202. ++    if( !(FDCS->dor & ( 0x10 << UNIT(drive))))
  7203. +         return;
  7204. + 
  7205. +-    del_timer(motor_off_timer+nr);
  7206. ++    del_timer(motor_off_timer+drive);
  7207. + 
  7208. +     /* make spindle stop in a position which minimizes spinup time
  7209. +      * next time */
  7210. +-    if ( drive_params[nr].rps ){
  7211. +-        delta = jiffies - drive_state[nr].first_read_date + HZ -
  7212. +-            drive_params[nr].spindown_offset;
  7213. +-        delta = (( delta * drive_params[nr].rps) % HZ ) /
  7214. +-            drive_params[nr].rps;
  7215. +-        motor_off_timer[nr].expires = drive_params[nr].spindown - delta;
  7216. ++    if (UDP->rps ){
  7217. ++        delta = jiffies - UDRS->first_read_date + HZ -
  7218. ++            UDP->spindown_offset;
  7219. ++        delta = (( delta * UDP->rps) % HZ ) / UDP->rps;
  7220. ++        motor_off_timer[drive].expires = UDP->spindown - delta;
  7221. +     }
  7222. +-    add_timer(motor_off_timer+nr);
  7223. ++    add_timer(motor_off_timer+drive);
  7224. + }
  7225. + 
  7226. + /*
  7227. +@@ -734,36 +743,41 @@
  7228. + static void scandrives(void)
  7229. + {
  7230. +     int i, drive, saved_drive;
  7231. ++    
  7232. ++    if (DP->select_delay)
  7233. ++        return;
  7234. + 
  7235. +-    saved_drive = current_drive % N_DRIVE;
  7236. ++    saved_drive = current_drive;
  7237. +     for(i=0; i< N_DRIVE; i++){
  7238. +         drive = (saved_drive + i + 1 ) % N_DRIVE;
  7239. +-        if ( UDRS->fd_ref == 0 )
  7240. ++        if ( UDRS->fd_ref == 0 || UDP->select_delay != 0)
  7241. +             continue; /* skip closed drives */
  7242. +         set_fdc(drive);
  7243. +-        if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
  7244. +-            ((FDCS->dor & 0x3) != UNIT(drive)))
  7245. +-            UDRS->select_date = jiffies;
  7246. +         if(! (set_dor( fdc, ~3, UNIT(drive) | ( 0x10 << UNIT(drive))) &
  7247. +               (0x10 << UNIT(drive))))
  7248. +             /* switch the motor off again, if it was off to
  7249. +              * begin with */
  7250. +             set_dor( fdc, ~( 0x10 << UNIT(drive) ), 0 );
  7251. +     }
  7252. +-    current_drive = saved_drive;
  7253. ++    set_fdc(saved_drive);
  7254. + }
  7255. + 
  7256. +-typedef void (*timeout_fn)(unsigned long);
  7257. + static struct timer_list fd_timer ={ NULL, NULL, 0, 0, 0 };
  7258. + 
  7259. + /* this function makes sure that the disk stays in the drive during the
  7260. +  * transfer */
  7261. + static void fd_watchdog(void)
  7262. + {
  7263. ++#ifdef DCL_DEBUG
  7264. ++    if (DP->flags & FD_DEBUG){
  7265. ++        DPRINT("calling disk change from watchdog\n");
  7266. ++    }
  7267. ++#endif
  7268. ++
  7269. +     if ( disk_change(current_drive) ){
  7270. +         DPRINT("disk removed during i/o\n");
  7271. +         floppy_shutdown();
  7272. +-    } else {
  7273. ++    } else {        
  7274. +         del_timer(&fd_timer);
  7275. +         fd_timer.function = (timeout_fn) fd_watchdog;
  7276. +         fd_timer.expires = 10;
  7277. +@@ -778,7 +792,7 @@
  7278. + }
  7279. + 
  7280. + /* waits for a delay (spinup or select) to pass */
  7281. +-static int wait_for_completion(int nr, int delay, timeout_fn function)
  7282. ++static int wait_for_completion(int delay, timeout_fn function)
  7283. + {
  7284. +     if ( FDCS->reset ){
  7285. +         reset_fdc(); /* do the reset during sleep to win time
  7286. +@@ -797,9 +811,50 @@
  7287. +     return 0;
  7288. + }
  7289. + 
  7290. ++static int hlt_disabled=0;
  7291. ++static void floppy_disable_hlt(void)
  7292. ++{
  7293. ++    unsigned long flags;
  7294. ++    save_flags(flags);
  7295. ++    cli();
  7296. ++    if(!hlt_disabled){
  7297. ++        hlt_disabled=1;
  7298. ++#ifdef HAVE_DISABLE_HLT
  7299. ++        disable_hlt();
  7300. ++#endif
  7301. ++    }
  7302. ++    restore_flags(flags);
  7303. ++}
  7304. ++
  7305. ++static void floppy_enable_hlt(void)
  7306. ++{
  7307. ++    unsigned long flags;
  7308. ++    save_flags(flags);
  7309. ++    cli();
  7310. ++    if(hlt_disabled){
  7311. ++        hlt_disabled=0;
  7312. ++#ifdef HAVE_DISABLE_HLT
  7313. ++        enable_hlt();
  7314. ++#endif
  7315. ++    }
  7316. ++    restore_flags(flags);
  7317. ++}
  7318. ++        
  7319. ++
  7320. + static void setup_DMA(void)
  7321. + {
  7322. +-#ifdef SANITY
  7323. ++#ifdef CONFIG_FLOPPY_SANITY
  7324. ++    if (raw_cmd.length == 0){
  7325. ++        int i;
  7326. ++
  7327. ++        printk("zero dma transfer size:");
  7328. ++        for(i=0; i< raw_cmd.cmd_count; i++)
  7329. ++            printk("%x,", raw_cmd.cmd[i]);
  7330. ++        printk("\n");
  7331. ++        cont->done(0);
  7332. ++        FDCS->reset = 1;
  7333. ++        return;
  7334. ++    }
  7335. +     if ((!CURRENT ||
  7336. +          CURRENT->buffer != current_addr ||
  7337. +          raw_cmd.length > 512 * CURRENT->nr_sectors) &&
  7338. +@@ -817,7 +872,6 @@
  7339. +         FDCS->reset=1;
  7340. +         return;
  7341. +     }
  7342. +-#if 0
  7343. +     if ((long) current_addr % 512 ){
  7344. +         printk("non aligned address: %p\n", current_addr );
  7345. +         cont->done(0);
  7346. +@@ -832,7 +886,7 @@
  7347. +         FDCS->reset=1;
  7348. +         return;
  7349. +     }
  7350. +-#endif
  7351. ++
  7352. + #endif
  7353. +     cli();
  7354. +     disable_dma(FLOPPY_DMA);
  7355. +@@ -844,6 +898,7 @@
  7356. +     set_dma_count(FLOPPY_DMA, raw_cmd.length);
  7357. +     enable_dma(FLOPPY_DMA);
  7358. +     sti();
  7359. ++    floppy_disable_hlt();
  7360. + }
  7361. + 
  7362. + /* sends a command byte to the fdc */
  7363. +@@ -856,13 +911,13 @@
  7364. +         return -1;
  7365. +     for(counter = 0 ; counter < 10000 && !FDCS->reset ; counter++) {
  7366. +         status = inb_p(FD_STATUS) &(STATUS_READY|STATUS_DIR|STATUS_DMA);
  7367. ++        if (!(status & STATUS_READY))
  7368. ++            continue;
  7369. +         if (status == STATUS_READY){
  7370. +             outb_p(byte,FD_DATA);
  7371. +             return 0;
  7372. +-        }
  7373. +-        if (!(status & STATUS_READY))
  7374. +-            continue;
  7375. +-        break;
  7376. ++        } else
  7377. ++            break;
  7378. +     }
  7379. +     FDCS->reset = 1;
  7380. +     if ( !initialising )
  7381. +@@ -930,7 +985,7 @@
  7382. +         }
  7383. +     } else
  7384. +         perp_mode = 0;
  7385. +-
  7386. ++            
  7387. +     if ( FDCS->perp_mode == perp_mode )
  7388. +         return;
  7389. +     if (FDCS->version >= FDC_82077_ORIG && FDCS->has_fifo) {
  7390. +@@ -979,7 +1034,7 @@
  7391. +         /* TODO: lock this in via LOCK during initialization */
  7392. +         output_byte(FD_CONFIGURE);
  7393. +         output_byte(0);
  7394. +-        output_byte(0x1A);    /* FIFO on, polling off, 10 byte threshold */
  7395. ++        output_byte(0x2A);    /* FIFO on, polling off, 10 byte threshold */
  7396. +         output_byte(0);        /* precompensation from track 0 upwards */
  7397. +         if ( FDCS->reset ){
  7398. +             FDCS->has_fifo=0;
  7399. +@@ -1042,22 +1097,23 @@
  7400. +  * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
  7401. +  * of the specify command (i.e. using the fdc_specify function).
  7402. +  */
  7403. +-static void fdc_dtr(void)
  7404. ++static int fdc_dtr(void)
  7405. + {
  7406. +     /* If data rate not already set to desired value, set it. */
  7407. +     if ( raw_cmd.rate == FDCS->dtr)
  7408. +-        return;
  7409. +-
  7410. ++        return 0;
  7411. ++    
  7412. +     /* Set dtr */
  7413. +     outb_p(raw_cmd.rate, FD_DCR);
  7414. +-
  7415. ++    
  7416. +     /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
  7417. +      * need a stabilization period of several milliseconds to be
  7418. +      * enforced after data rate changes before R/W operations.
  7419. +-     * Pause 5 msec to avoid trouble.
  7420. ++     * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
  7421. +      */
  7422. +-    udelay(5000);
  7423. +     FDCS->dtr = raw_cmd.rate;
  7424. ++    return(wait_for_completion(jiffies+2,
  7425. ++                   (timeout_fn) floppy_ready));
  7426. + } /* fdc_dtr */
  7427. + 
  7428. + static void tell_sector(void)
  7429. +@@ -1077,8 +1133,7 @@
  7430. + static int interpret_errors(void)
  7431. + {
  7432. +     char bad;
  7433. +-int res = get_dma_residue(FLOPPY_DMA);
  7434. +-if(res) {printk("\n-- DMA residue (%d)",res); tell_sector(); printk("\n");}
  7435. ++
  7436. +     if (inr!=7) {
  7437. +         DPRINT("-- FDC reply error");
  7438. +         FDCS->reset = 1;
  7439. +@@ -1087,15 +1142,15 @@
  7440. + 
  7441. +     /* check IC to find cause of interrupt */
  7442. +     switch ((ST0 & ST0_INTR)>>6) {
  7443. +-        case 1:    /* error occured during command execution */
  7444. ++        case 1:    /* error occurred during command execution */
  7445. +             bad = 1;
  7446. +             if (ST1 & ST1_WP) {
  7447. +                 DPRINT("Drive is write protected\n");
  7448. +-                DRS->flags &= ~FD_DISK_WRITABLE;
  7449. ++                CLEARF(FD_DISK_WRITABLE);
  7450. +                 cont->done(0);
  7451. +                 bad = 2;
  7452. +             } else if (ST1 & ST1_ND) {
  7453. +-                DRS->flags |= FD_NEED_TWADDLE;
  7454. ++                SETF(FD_NEED_TWADDLE);
  7455. +             } else if (ST1 & ST1_OR) {
  7456. +                 if (DP->flags & FTD_MSG )
  7457. +                     DPRINT("Over/Underrun - retrying\n");
  7458. +@@ -1128,11 +1183,8 @@
  7459. + 
  7460. +             }
  7461. +             if ( ST2 & ST2_WC || ST2 & ST2_BC)
  7462. +-{
  7463. +-printk("Wrong cylinder!\n");
  7464. +                 /* wrong cylinder => recal */
  7465. +                 DRS->track = NEED_2_RECAL;
  7466. +-}
  7467. +             return bad;
  7468. +         case 2: /* invalid command given */
  7469. +             DPRINT("Invalid FDC command given!\n");
  7470. +@@ -1162,7 +1214,7 @@
  7471. +         flags |= FD_RAW_INTR;
  7472. + 
  7473. +     if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)){
  7474. +-        ready_date = DRS->spinup_date + DP->spinup;
  7475. ++        ready_date = DRS->spinup_date + DP->spinup;        
  7476. +         /* If spinup will take a long time, rerun scandrives
  7477. +          * again just before spinup completion. Beware that
  7478. +          * after scandrives, we must again wait for selection.
  7479. +@@ -1174,14 +1226,14 @@
  7480. +             function = (timeout_fn) setup_rw_floppy;
  7481. + 
  7482. +         /* wait until the floppy is spinning fast enough */
  7483. +-        if (wait_for_completion(current_drive,ready_date,function))
  7484. ++        if (wait_for_completion(ready_date,function))
  7485. +             return;
  7486. +     }
  7487. +     dflags = DRS->flags;
  7488. + 
  7489. +     if ( (flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
  7490. +         setup_DMA();
  7491. +-
  7492. ++    
  7493. +     if ( flags & FD_RAW_INTR )
  7494. +         SET_INTR(main_command_interrupt);
  7495. + 
  7496. +@@ -1204,9 +1256,7 @@
  7497. +         fd_watchdog();
  7498. + }
  7499. + 
  7500. +-#ifdef SILENT_DC_CLEAR
  7501. + static int blind_seek;
  7502. +-#endif
  7503. + 
  7504. + /*
  7505. +  * This is the routine called after every seek (or recalibrate) interrupt
  7506. +@@ -1217,9 +1267,6 @@
  7507. + #ifdef DEBUGT
  7508. +     debugt("seek interrupt:");
  7509. + #endif
  7510. +-#ifdef SILENT_DC_CLEAR
  7511. +-    set_dor(fdc, ~0,  (0x10 << UNIT(current_drive)));
  7512. +-#endif
  7513. +     if (inr != 2 || (ST0 & 0xF8) != 0x20 ) {
  7514. +         DPRINT("seek failed\n");
  7515. +         DRS->track = NEED_2_RECAL;
  7516. +@@ -1227,20 +1274,23 @@
  7517. +         cont->redo();
  7518. +         return;
  7519. +     }
  7520. +-    if (DRS->track >= 0 && DRS->track != ST1
  7521. +-#ifdef SILENT_DC_CLEAR
  7522. +-        && !blind_seek
  7523. ++    if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek){
  7524. ++#ifdef DCL_DEBUG
  7525. ++        if (DP->flags & FD_DEBUG){
  7526. ++            DPRINT("clearing NEWCHANGE flag because of effective seek\n");
  7527. ++            DPRINT1("jiffies=%ld\n", jiffies);
  7528. ++        }
  7529. + #endif
  7530. +-        )
  7531. +-        DRS->flags &= ~FD_DISK_NEWCHANGE; /* effective seek */
  7532. ++        CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
  7533. ++        DRS->select_date = jiffies;
  7534. ++    }
  7535. +     DRS->track = ST1;
  7536. +-    DRS->select_date = jiffies;
  7537. +-    seek_floppy();
  7538. ++    floppy_ready();
  7539. + }
  7540. + 
  7541. + static void check_wp(void)
  7542. + {
  7543. +-    if (DRS->flags & FD_VERIFY) {
  7544. ++    if (TESTF(FD_VERIFY)) {
  7545. +         /* check write protection */
  7546. +         output_byte( FD_GETSTATUS );
  7547. +         output_byte( UNIT(current_drive) );
  7548. +@@ -1248,10 +1298,18 @@
  7549. +             FDCS->reset = 1;
  7550. +             return;
  7551. +         }
  7552. +-        DRS->flags &= ~(FD_VERIFY | FD_DISK_WRITABLE | FD_NEED_TWADDLE);
  7553. +-
  7554. ++        CLEARF(FD_VERIFY);
  7555. ++        CLEARF(FD_NEED_TWADDLE);
  7556. ++#ifdef DCL_DEBUG
  7557. ++        if (DP->flags & FD_DEBUG){
  7558. ++            DPRINT("checking whether disk is write protected\n");
  7559. ++            DPRINT1("wp=%x\n",ST3 & 0x40);
  7560. ++        }
  7561. ++#endif
  7562. +         if (!( ST3  & 0x40))
  7563. +-            DRS->flags |= FD_DISK_WRITABLE;
  7564. ++            SETF(FD_DISK_WRITABLE);
  7565. ++        else
  7566. ++            CLEARF(FD_DISK_WRITABLE);
  7567. +     }
  7568. + }
  7569. + 
  7570. +@@ -1259,16 +1317,22 @@
  7571. + {
  7572. +     int track;
  7573. + 
  7574. +-#ifdef SILENT_DC_CLEAR
  7575. +     blind_seek=0;
  7576. ++
  7577. ++#ifdef DCL_DEBUG
  7578. ++    if (DP->flags & FD_DEBUG){
  7579. ++        DPRINT("calling disk change from seek\n");
  7580. ++    }
  7581. + #endif
  7582. +-    disk_change(current_drive);
  7583. +-    if ((raw_cmd.flags & FD_RAW_NEED_DISK) &&
  7584. +-        test_bit(current_drive,&changed_floppies)){
  7585. ++
  7586. ++    if (!TESTF(FD_DISK_NEWCHANGE) &&
  7587. ++        disk_change(current_drive) &&
  7588. ++        (raw_cmd.flags & FD_RAW_NEED_DISK)){
  7589. +         /* the media changed flag should be cleared after the seek.
  7590. +          * If it isn't, this means that there is really no disk in
  7591. +          * the drive.
  7592. +          */
  7593. ++        SETF(FD_DISK_CHANGED);
  7594. +         cont->done(0);
  7595. +         cont->redo();
  7596. +         return;
  7597. +@@ -1276,7 +1340,7 @@
  7598. +     if ( DRS->track <= NEED_1_RECAL ){
  7599. +         recalibrate_floppy();
  7600. +         return;
  7601. +-    } else if ((DRS->flags & FD_DISK_NEWCHANGE) &&
  7602. ++    } else if (TESTF(FD_DISK_NEWCHANGE) &&
  7603. +            (raw_cmd.flags & FD_RAW_NEED_DISK) &&
  7604. +            (DRS->track <= NO_TRACK || DRS->track == raw_cmd.track)) {
  7605. +         /* we seek to clear the media-changed condition. Does anybody
  7606. +@@ -1284,15 +1348,17 @@
  7607. +         if ( raw_cmd.track )
  7608. +             track = raw_cmd.track - 1;
  7609. +         else {
  7610. +-#ifdef SILENT_DC_CLEAR
  7611. +-            set_dor(fdc, ~ (0x10 << UNIT(current_drive)), 0);
  7612. +-            blind_seek = 1;
  7613. +-#endif
  7614. ++            if(DP->flags & FD_SILENT_DCL_CLEAR){
  7615. ++                set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
  7616. ++                blind_seek = 1;
  7617. ++                raw_cmd.flags |= FD_RAW_NEED_SEEK;
  7618. ++            }
  7619. +             track = 1;
  7620. +         }
  7621. +     } else {
  7622. +         check_wp();
  7623. +-        if (raw_cmd.track != DRS->track)
  7624. ++        if (raw_cmd.track != DRS->track &&
  7625. ++            (raw_cmd.flags & FD_RAW_NEED_SEEK))
  7626. +             track = raw_cmd.track;
  7627. +         else {
  7628. +             setup_rw_floppy();
  7629. +@@ -1300,23 +1366,13 @@
  7630. +         }
  7631. +     }
  7632. + 
  7633. +-#ifndef SILENT_DC_CLEAR
  7634. +-    if ( !track && DRS->track >= 0 && DRS->track < 80 ){
  7635. +-        DRS->flags &= ~FD_DISK_NEWCHANGE;
  7636. +-        /* if we go to track 0 anyways, we can just as well use
  7637. +-         * recalibrate */
  7638. +-        recalibrate_floppy();
  7639. +-    } else
  7640. +-#endif
  7641. +-    {
  7642. +-        SET_INTR(seek_interrupt);
  7643. +-        output_byte(FD_SEEK);
  7644. +-        output_byte(UNIT(current_drive));
  7645. +-        LAST_OUT(track);
  7646. ++    SET_INTR(seek_interrupt);
  7647. ++    output_byte(FD_SEEK);
  7648. ++    output_byte(UNIT(current_drive));
  7649. ++    LAST_OUT(track);
  7650. + #ifdef DEBUGT
  7651. +-        debugt("seek command:");
  7652. ++    debugt("seek command:");
  7653. + #endif
  7654. +-    }
  7655. + }
  7656. + 
  7657. + static void recal_interrupt(void)
  7658. +@@ -1328,18 +1384,13 @@
  7659. +         FDCS->reset = 1;
  7660. +     else if (ST0 & ST0_ECE) {
  7661. +                switch(DRS->track){
  7662. +-        case PROVEN_ABSENT:
  7663. +-#ifdef DEBUGT
  7664. +-            debugt("recal interrupt proven absent:");
  7665. +-#endif
  7666. +-            /* fall through */
  7667. +                case NEED_1_RECAL:
  7668. + #ifdef DEBUGT
  7669. +             debugt("recal interrupt need 1 recal:");
  7670. + #endif
  7671. +             /* after a second recalibrate, we still haven't
  7672. +              * reached track 0. Probably no drive. Raise an
  7673. +-             * error, as failing immediately might upset
  7674. ++             * error, as failing immediately might upset 
  7675. +              * computers possessed by the Devil :-) */
  7676. +             cont->error();
  7677. +             cont->redo();
  7678. +@@ -1353,7 +1404,14 @@
  7679. +              * not to move at recalibration is to be already at
  7680. +              * track 0.) Clear the new change flag
  7681. +              */
  7682. +-            DRS->flags &= ~FD_DISK_NEWCHANGE;
  7683. ++#ifdef DCL_DEBUG
  7684. ++            if (DP->flags & FD_DEBUG){
  7685. ++                DPRINT("clearing NEWCHANGE flag because of second recalibrate\n");
  7686. ++            }
  7687. ++#endif
  7688. ++
  7689. ++            CLEARF(FD_DISK_NEWCHANGE);
  7690. ++            DRS->select_date = jiffies;
  7691. +             /* fall through */
  7692. +         default:
  7693. + #ifdef DEBUGT
  7694. +@@ -1369,7 +1427,7 @@
  7695. +         }
  7696. +     } else
  7697. +         DRS->track = ST1;
  7698. +-    seek_floppy();
  7699. ++    floppy_ready();
  7700. + }
  7701. + 
  7702. + /*
  7703. +@@ -1381,34 +1439,41 @@
  7704. +     int i;
  7705. +     if ( initialising )
  7706. +         return;
  7707. +-    cli();
  7708. +-    DPRINT("unexpected interrupt\n");
  7709. +-    if ( inr >= 0 )
  7710. +-        for(i=0; i<inr; i++)
  7711. +-            printk("%d %x\n", i, reply_buffer[i] );
  7712. ++    if(print_unex){
  7713. ++        DPRINT("unexpected interrupt\n");
  7714. ++        if ( inr >= 0 )
  7715. ++            for(i=0; i<inr; i++)
  7716. ++                printk("%d %x\n", i, reply_buffer[i] );
  7717. ++    }
  7718. +     while(1){
  7719. +         output_byte(FD_SENSEI);
  7720. +         inr=result();
  7721. +         if ( inr != 2 )
  7722. +             break;
  7723. +-        printk("sensei\n");
  7724. +-        for(i=0; i<inr; i++)
  7725. +-            printk("%d %x\n", i, reply_buffer[i] );
  7726. ++        if(print_unex){
  7727. ++            printk("sensei\n");
  7728. ++            for(i=0; i<inr; i++)
  7729. ++                printk("%d %x\n", i, reply_buffer[i] );
  7730. ++        }
  7731. +     }
  7732. +     FDCS->reset = 1;
  7733. + }
  7734. + 
  7735. +-struct tq_struct floppy_tq =
  7736. +-{ 0, 0, (void (*) (void *)) unexpected_floppy_interrupt, 0 };
  7737. ++struct tq_struct floppy_tq = 
  7738. ++{ 0, 0, (void *) (void *) unexpected_floppy_interrupt, 0 };
  7739. + 
  7740. + /* interrupt handler */
  7741. +-static void floppy_interrupt(int unused, struct pt_regs *regs)
  7742. ++static void floppy_interrupt(int irq, struct pt_regs * regs)
  7743. + {
  7744. +     void (*handler)(void) = DEVICE_INTR;
  7745. + 
  7746. ++    floppy_enable_hlt();
  7747. +     CLEAR_INTR;
  7748. +-    if ( fdc >= N_FDC ){ /* we don't even know which FDC is the culprit */
  7749. +-        printk("floppy interrupt on bizarre fdc\n");
  7750. ++    if ( fdc >= N_FDC || FDCS->address == -1){
  7751. ++        /* we don't even know which FDC is the culprit */
  7752. ++        printk("DOR0=%x\n", fdc_state[0].dor);
  7753. ++        printk("floppy interrupt on bizarre fdc %d\n",fdc);
  7754. ++        printk("handler=%p\n", handler);
  7755. +         return;
  7756. +     }
  7757. +     inr = result();
  7758. +@@ -1422,7 +1487,7 @@
  7759. +             inr = result();
  7760. +         } while ( (ST0 & 0x83) != UNIT(current_drive) && inr == 2);
  7761. +     }
  7762. +-    floppy_tq.routine = (void (*)(void *)) handler;
  7763. ++    floppy_tq.routine = (void *)(void *) handler;
  7764. +     queue_task_irq(&floppy_tq, &tq_timer);
  7765. + }
  7766. + 
  7767. +@@ -1463,9 +1528,9 @@
  7768. +     if ( FDCS->version >= FDC_82077 )
  7769. +         outb_p(0x80 | ( FDCS->dtr &3), FD_STATUS);
  7770. +     else {
  7771. +-        arm_set_dor(FDCS->dor & ~0x04);
  7772. ++        outb_p(FDCS->dor & ~0x04, FD_DOR);
  7773. +         udelay(FD_RESET_DELAY);
  7774. +-        arm_set_dor(FDCS->dor);
  7775. ++        outb(FDCS->dor, FD_DOR);
  7776. +     }
  7777. + }
  7778. + 
  7779. +@@ -1481,9 +1546,11 @@
  7780. +     printk("floppy driver state\n");
  7781. +     printk("-------------------\n");
  7782. +     for(i=0; i<N_FDC; i++){
  7783. +-        printk("dor %d = %x\n", i, fdc_state[i].dor );
  7784. +-        outb_p(fdc_state[i].address+2, fdc_state[i].dor);
  7785. +-        udelay(1000); /* maybe we'll catch an interrupt... */
  7786. ++        if(FDCS->address != -1){
  7787. ++            printk("dor %d = %x\n", i, fdc_state[i].dor );
  7788. ++            outb_p(fdc_state[i].address+2, fdc_state[i].dor);
  7789. ++            udelay(1000); /* maybe we'll catch an interrupt... */
  7790. ++        }
  7791. +     }
  7792. +     printk("status=%x\n", inb_p(FD_STATUS));
  7793. +     printk("fdc_busy=%d\n", fdc_busy);
  7794. +@@ -1493,9 +1560,9 @@
  7795. +         printk("floppy_tq.routine=%p\n", floppy_tq.routine);
  7796. +     if(fd_timer.prev)
  7797. +         printk("fd_timer.function=%p\n", fd_timer.function);
  7798. +-    if( timer_active & (1 << FLOPPY_TIMER)){
  7799. +-        printk("timer_table=%p\n",timer_table[FLOPPY_TIMER].fn);
  7800. +-        printk("expires=%ld\n",timer_table[FLOPPY_TIMER].expires);
  7801. ++    if(fd_timeout.prev){
  7802. ++        printk("timer_table=%p\n",fd_timeout.function);
  7803. ++        printk("expires=%ld\n",fd_timeout.expires);
  7804. +         printk("now=%ld\n",jiffies);
  7805. +     }
  7806. +     printk("cont=%p\n", cont);
  7807. +@@ -1507,30 +1574,28 @@
  7808. + static void floppy_shutdown(void)
  7809. + {
  7810. +     CLEAR_INTR;
  7811. +-    floppy_tq.routine = (void (*)(void *)) empty;
  7812. ++    floppy_tq.routine = (void *)(void *) empty;
  7813. +     del_timer( &fd_timer);
  7814. ++
  7815. ++    floppy_enable_hlt();
  7816. +     disable_dma(FLOPPY_DMA);
  7817. +     /* avoid dma going to a random drive after shutdown */
  7818. ++
  7819. +     if(!initialising)
  7820. +         DPRINT("floppy timeout\n");
  7821. +     FDCS->reset = 1;
  7822. +     cont->done(0);
  7823. +     cont->redo(); /* this will recall reset when needed */
  7824. + }
  7825. ++/*typedef void (*timeout_fn)(unsigned long);*/
  7826. + 
  7827. + /* start motor, check media-changed condition and write protection */
  7828. +-static void start_motor(void)
  7829. ++static int start_motor( void (*function)(void)  )
  7830. + {
  7831. +     int mask, data;
  7832. + 
  7833. +     mask = 0xfc;
  7834. +     data = UNIT(current_drive);
  7835. +-
  7836. +-    if ( (FDCS->dor & 0x03) != UNIT(current_drive) ||
  7837. +-        !(FDCS->dor & ( 0x10 << UNIT(current_drive) ) ))
  7838. +-        /* notes select time if floppy is not yet selected */
  7839. +-        DRS->select_date = jiffies;
  7840. +-
  7841. +     if (!(raw_cmd.flags & FD_RAW_NO_MOTOR)){
  7842. +         if(!(FDCS->dor & ( 0x10 << UNIT(current_drive) ) )){
  7843. +             set_debugt();
  7844. +@@ -1547,26 +1612,31 @@
  7845. +     /* starts motor and selects floppy */
  7846. +     del_timer(motor_off_timer + current_drive);
  7847. +     set_dor( fdc, mask, data);
  7848. +-    if( raw_cmd.flags & FD_RAW_NO_MOTOR)
  7849. +-        return;
  7850. + 
  7851. +-    disk_change(current_drive);
  7852. +-
  7853. +-    return;
  7854. ++    /* wait_for_completion also schedules reset if needed. */
  7855. ++    return(wait_for_completion(DRS->select_date+DP->select_delay,
  7856. ++                   (timeout_fn) function));
  7857. + }
  7858. + 
  7859. + static void floppy_ready(void)
  7860. + {
  7861. +     CHECK_RESET;
  7862. +-    start_motor();
  7863. ++    if(start_motor(floppy_ready)) return;
  7864. ++    if(fdc_dtr()) return;
  7865. + 
  7866. +-    /* wait_for_completion also schedules reset if needed. */
  7867. +-    if(wait_for_completion(current_drive,
  7868. +-                   DRS->select_date+DP->select_delay,
  7869. +-                   (timeout_fn) floppy_ready))
  7870. +-        return;
  7871. +-    fdc_dtr();
  7872. +-    if ( raw_cmd.flags & FD_RAW_NEED_SEEK ){
  7873. ++#ifdef DCL_DEBUG
  7874. ++    if (DP->flags & FD_DEBUG){
  7875. ++        DPRINT("calling disk change from floppy_ready\n");
  7876. ++    }
  7877. ++#endif
  7878. ++
  7879. ++    if(!(raw_cmd.flags & FD_RAW_NO_MOTOR) &&
  7880. ++       disk_change(current_drive) &&
  7881. ++       !DP->select_delay)
  7882. ++        twaddle(); /* this clears the dcl on certain drive/controller
  7883. ++                * combinations */
  7884. ++
  7885. ++    if ( raw_cmd.flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)){
  7886. +         perpendicular_mode();
  7887. +         fdc_specify(); /* must be done here because of hut, hlt ... */
  7888. +         seek_floppy();
  7889. +@@ -1576,9 +1646,17 @@
  7890. + 
  7891. + static void floppy_start(void)
  7892. + {
  7893. +-    timer_table[FLOPPY_TIMER].expires = jiffies + DP->timeout;
  7894. +-    timer_active |= 1 << FLOPPY_TIMER;
  7895. ++    del_timer(&fd_timeout);
  7896. ++    fd_timeout.expires = DP->timeout;
  7897. ++    add_timer(&fd_timeout);
  7898. ++
  7899. +     scandrives();
  7900. ++#ifdef DCL_DEBUG
  7901. ++        if (DP->flags & FD_DEBUG){
  7902. ++            DPRINT("setting NEWCHANGE in floppy_start\n");
  7903. ++        }
  7904. ++#endif
  7905. ++    SETF(FD_DISK_NEWCHANGE);
  7906. +     floppy_ready();
  7907. + }
  7908. + 
  7909. +@@ -1598,7 +1676,7 @@
  7910. + 
  7911. + static void do_wakeup(void)
  7912. + {
  7913. +-    timer_active &= ~(1 << FLOPPY_TIMER);
  7914. ++    del_timer(&fd_timeout);
  7915. +     cont = 0;
  7916. +     command_status += 2;
  7917. +     wake_up(&command_done);
  7918. +@@ -1615,7 +1693,7 @@
  7919. + {
  7920. +     int ret;
  7921. + 
  7922. +-    floppy_tq.routine = (void (*)(void *)) handler;
  7923. ++    floppy_tq.routine = (void *)(void *) handler;
  7924. +     queue_task(&floppy_tq, &tq_timer);
  7925. + 
  7926. +     cli();
  7927. +@@ -1630,7 +1708,7 @@
  7928. +     if(command_status < 2){
  7929. +         sti();
  7930. +         floppy_shutdown();
  7931. +-        redo_fd_request();
  7932. ++        process_fd_request();
  7933. +         return -EINTR;
  7934. +     }
  7935. +     sti();
  7936. +@@ -1681,9 +1759,10 @@
  7937. + static int next_valid_format(void)
  7938. + {
  7939. +     int probed_format;
  7940. ++
  7941. ++    probed_format = DRS->probed_format;
  7942. +     while(1){
  7943. +-        probed_format = DRS->probed_format;
  7944. +-        if ( probed_format > 8 ||
  7945. ++        if ( probed_format >= 8 ||
  7946. +             ! DP->autodetect[probed_format] ){
  7947. +             DRS->probed_format = 0;
  7948. +             return 1;
  7949. +@@ -1738,6 +1817,7 @@
  7950. +     }
  7951. +     cont->redo();
  7952. + }
  7953. ++
  7954. + #define CODE2SIZE (ssize = ( ( 1 << SIZECODE ) + 3 ) >> 2)
  7955. + #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80 ) >>1))
  7956. + #define CT(x) ( (x) | 0x40 )
  7957. +@@ -1804,7 +1884,6 @@
  7958. +     raw_cmd.track = format_req.track << floppy->stretch;
  7959. +     buffer_track = -1;
  7960. +     setup_format_params();
  7961. +-    clear_bit(current_drive, &changed_floppies);
  7962. +     floppy_start();
  7963. + #ifdef DEBUGT
  7964. +     debugt("queue format request");
  7965. +@@ -1819,23 +1898,27 @@
  7966. + 
  7967. + static int do_format(int device, struct format_descr *tmp_format_req)
  7968. + {
  7969. +-    int okay;
  7970. ++    int ret;
  7971. ++    int drive=DRIVE(device);
  7972. + 
  7973. +-    LOCK_FDC(DRIVE(device),1);
  7974. ++    LOCK_FDC(drive,1);
  7975. +     set_floppy(device);
  7976. +     if (!floppy ||
  7977. ++        floppy->track > DP->tracks ||
  7978. +         tmp_format_req->track >= floppy->track ||
  7979. +-        tmp_format_req->head >= floppy->head){
  7980. +-        redo_fd_request();
  7981. ++        tmp_format_req->head >= floppy->head ||
  7982. ++        (floppy->sect << 2) % (1 <<  FD_SIZECODE(floppy)) ||
  7983. ++        !floppy->fmt_gap) {
  7984. ++        process_fd_request();
  7985. +         return -EINVAL;
  7986. +     }
  7987. +     format_req = *tmp_format_req;
  7988. +     format_errors = 0;
  7989. +     cont = &format_cont;
  7990. +     errors = &format_errors;
  7991. +-    CALL(okay=wait_til_done(redo_format,1));
  7992. +-    redo_fd_request();
  7993. +-    return okay;
  7994. ++    IWAIT(redo_format);
  7995. ++    process_fd_request();
  7996. ++    return ret;
  7997. + }
  7998. + 
  7999. + /*
  8000. +@@ -1850,7 +1933,7 @@
  8001. +     int block;
  8002. + 
  8003. +     probing = 0;
  8004. +-    timer_active &= ~(1 << FLOPPY_TIMER);
  8005. ++    del_timer(&fd_timeout);
  8006. + 
  8007. +     if (!CURRENT){
  8008. +         DPRINT("request list destroyed in floppy request done\n");
  8009. +@@ -1914,7 +1997,7 @@
  8010. +         floppy->sect + ((R_SECTOR-SECTOR) <<  SIZECODE >> 2) -
  8011. +             (sector_t % floppy->sect) % ssize;
  8012. + 
  8013. +-#ifdef SANITY
  8014. ++#ifdef CONFIG_FLOPPY_SANITY
  8015. +     if ( nr_sectors > current_count_sectors + ssize -
  8016. +         (current_count_sectors + sector_t) % ssize +
  8017. +         sector_t % ssize){
  8018. +@@ -1987,7 +2070,7 @@
  8019. +     size = CURRENT->current_nr_sectors << 9;
  8020. +     bh = CURRENT->bh;
  8021. + 
  8022. +-    if(bh){
  8023. ++    if (bh){
  8024. +         bh = bh->b_reqnext;
  8025. +         while ( bh && bh->b_data == base + size ){
  8026. +             size += bh->b_size;
  8027. +@@ -2034,8 +2117,8 @@
  8028. +             current_count_sectors = CURRENT->nr_sectors;
  8029. +     }
  8030. +     remaining = current_count_sectors << 9;
  8031. +-#ifdef SANITY
  8032. +-    if ((remaining >> 9) > CURRENT->nr_sectors  &&
  8033. ++#ifdef CONFIG_FLOPPY_SANITY
  8034. ++    if ((remaining >> 9) > CURRENT->nr_sectors  && 
  8035. +         CT(COMMAND) == FD_WRITE ){
  8036. +         DPRINT("in copy buffer\n");
  8037. +         printk("current_count_sectors=%ld\n", current_count_sectors);
  8038. +@@ -2060,12 +2143,12 @@
  8039. +     while ( remaining > 0){
  8040. +         if ( size > remaining )
  8041. +             size = remaining;
  8042. +-#ifdef SANITY
  8043. ++#ifdef CONFIG_FLOPPY_SANITY
  8044. +         if (dma_buffer + size >
  8045. +             floppy_track_buffer + (max_buffer_sectors << 10) ||
  8046. +             dma_buffer < floppy_track_buffer ){
  8047. +             DPRINT1("buffer overrun in copy buffer %d\n",
  8048. +-                (floppy_track_buffer - dma_buffer) >>9);
  8049. ++                (int) ((floppy_track_buffer - dma_buffer) >>9));
  8050. +             printk("sector_t=%d buffer_min=%d\n",
  8051. +                    sector_t, buffer_min);
  8052. +             printk("current_count_sectors=%ld\n",
  8053. +@@ -2076,7 +2159,7 @@
  8054. +                 printk("write\n");
  8055. +             break;
  8056. +         }
  8057. +-        if ( ((int)buffer) % 512 )
  8058. ++        if ( ((unsigned long)buffer) % 512 )
  8059. +             DPRINT1("%p buffer not aligned\n", buffer);
  8060. + #endif
  8061. +         if ( CT(COMMAND) == FD_READ )
  8062. +@@ -2089,7 +2172,7 @@
  8063. + 
  8064. +         dma_buffer += size;
  8065. +         bh = bh->b_reqnext;
  8066. +-#ifdef SANITY
  8067. ++#ifdef CONFIG_FLOPPY_SANITY
  8068. +         if ( !bh){
  8069. +             DPRINT("bh=null in copy buffer after copy\n");
  8070. +             break;
  8071. +@@ -2098,7 +2181,7 @@
  8072. +         size = bh->b_size;
  8073. +         buffer = bh->b_data;
  8074. +     }
  8075. +-#ifdef SANITY
  8076. ++#ifdef CONFIG_FLOPPY_SANITY
  8077. +     if ( remaining ){
  8078. +         if ( remaining > 0 )
  8079. +             max_sector -= remaining >> 9;
  8080. +@@ -2122,7 +2205,7 @@
  8081. +     int aligned_sector_t;
  8082. +     int max_sector, max_size, tracksize, ssize;
  8083. + 
  8084. +-    current_drive = DRIVE(CURRENT->dev);
  8085. ++    set_fdc(DRIVE(CURRENT->dev));
  8086. + 
  8087. +     raw_cmd.flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
  8088. +         FD_RAW_NEED_SEEK;
  8089. +@@ -2145,7 +2228,7 @@
  8090. +         return 0;
  8091. +     HEAD = sector_t / floppy->sect;
  8092. + 
  8093. +-    if ( (DRS->flags & FD_NEED_TWADDLE) && sector_t < floppy->sect )
  8094. ++    if ( TESTF( FD_NEED_TWADDLE) && sector_t < floppy->sect )
  8095. +         max_sector = floppy->sect;
  8096. + 
  8097. +     /* 2M disks have phantom sectors on the first track */
  8098. +@@ -2213,22 +2296,19 @@
  8099. +         raw_cmd.flags &= ~FD_RAW_WRITE;
  8100. +         raw_cmd.flags |= FD_RAW_READ;
  8101. +         COMMAND = FM_MODE(floppy,FD_READ);
  8102. +-    }
  8103. +-    else if ((long)CURRENT->buffer <= LAST_DMA_ADDR ) {
  8104. ++    } else if ((long)CURRENT->buffer <= LAST_DMA_ADDR ) {
  8105. +         int direct, indirect;
  8106. + 
  8107. +         indirect= transfer_size(ssize,max_sector,max_buffer_sectors*2) -
  8108. +             sector_t;
  8109. + 
  8110. +         max_size = buffer_chain_size();
  8111. +-#if 0
  8112. +         if ( max_size > ( LAST_DMA_ADDR - ((long) CURRENT->buffer))>>9)
  8113. +             max_size=(LAST_DMA_ADDR - ((long)CURRENT->buffer))>>9;
  8114. +         /* 64 kb boundaries */
  8115. +         if ( ((max_size << 9) + ((long) CURRENT->buffer)) / K_64 !=
  8116. +              ((long) CURRENT->buffer ) / K_64 )
  8117. +             max_size = ( K_64 - ((long) CURRENT->buffer) % K_64)>>9;
  8118. +-#endif
  8119. +         direct = transfer_size(ssize,max_sector,max_size) - sector_t;
  8120. +         /*
  8121. +          * We try to read tracks, but if we get too many errors, we
  8122. +@@ -2237,15 +2317,21 @@
  8123. +          * This means we should be able to read a sector even if there
  8124. +          * are other bad sectors on this track.
  8125. +          */
  8126. +-        if ((indirect - sector_t) * 2 > (direct - sector_t) * 3 &&
  8127. +-            *errors < DP->max_errors.read_track &&
  8128. +-            /*!(DRS->flags & FD_NEED_TWADDLE) &&*/
  8129. +-            ( ( !probing || (DP->read_track &
  8130. +-               (1 <<DRS->probed_format))))){
  8131. ++        if (!direct ||
  8132. ++            (indirect * 2 > direct * 3 &&
  8133. ++             *errors < DP->max_errors.read_track &&
  8134. ++             /*!TESTF( FD_NEED_TWADDLE) &&*/
  8135. ++             ((!probing || (DP->read_track&(1<<DRS->probed_format)))))){
  8136. +             max_size = CURRENT->nr_sectors;
  8137. +         } else {
  8138. +             current_addr = CURRENT->buffer;
  8139. +             raw_cmd.length = current_count_sectors << 9;
  8140. ++            if (raw_cmd.length == 0){
  8141. ++                DPRINT("zero dma transfer attempted from make_raw_request\n");
  8142. ++                DPRINT3("indirect=%d direct=%d sector_t=%d",
  8143. ++                    indirect, direct, sector_t);
  8144. ++                return 0;
  8145. ++            }
  8146. +             return 2;
  8147. +         }
  8148. +     }
  8149. +@@ -2256,6 +2342,7 @@
  8150. +     /* claim buffer track if needed */
  8151. +     if (buffer_track != raw_cmd.track ||  /* bad track */
  8152. +         buffer_drive !=current_drive || /* bad drive */
  8153. ++        sector_t > buffer_max ||
  8154. +         sector_t < buffer_min ||
  8155. +         ((CT(COMMAND) == FD_READ ||
  8156. +           (aligned_sector_t == sector_t && CURRENT->nr_sectors >= ssize ))&&
  8157. +@@ -2273,7 +2360,7 @@
  8158. +          * if we get here, we know that the write
  8159. +          * is either aligned or the data already in the buffer
  8160. +          * (buffer will be overwritten) */
  8161. +-#ifdef SANITY
  8162. ++#ifdef CONFIG_FLOPPY_SANITY
  8163. +         if (sector_t != aligned_sector_t && buffer_track == -1 )
  8164. +             DPRINT("internal error offset !=0 on write\n");
  8165. + #endif
  8166. +@@ -2288,8 +2375,7 @@
  8167. +     raw_cmd.length = sector_t+current_count_sectors-aligned_sector_t;
  8168. +     raw_cmd.length = ((raw_cmd.length -1)|(ssize-1))+1;
  8169. +     raw_cmd.length <<= 9;
  8170. +-
  8171. +-#ifdef SANITY
  8172. ++#ifdef CONFIG_FLOPPY_SANITY
  8173. +     if ((raw_cmd.length < current_count_sectors << 9) ||
  8174. +         (current_addr != CURRENT->buffer &&
  8175. +          CT(COMMAND) == FD_WRITE &&
  8176. +@@ -2301,7 +2387,7 @@
  8177. +             raw_cmd.length, current_count_sectors);
  8178. +         if ( current_addr != CURRENT->buffer )
  8179. +             printk("addr=%d, length=%ld\n",
  8180. +-                   (current_addr - floppy_track_buffer ) >> 9,
  8181. ++                   (int) ((current_addr - floppy_track_buffer ) >> 9),
  8182. +                    current_count_sectors);
  8183. +         printk("st=%d ast=%d mse=%d msi=%d\n",
  8184. +                sector_t, aligned_sector_t, max_sector, max_size);
  8185. +@@ -2342,28 +2428,27 @@
  8186. +         printk("bytes=%ld\n", raw_cmd.length >> 9 );
  8187. +         printk("sectors=%ld\n", current_count_sectors);
  8188. +     }
  8189. ++    if (raw_cmd.length == 0){
  8190. ++        DPRINT("zero dma transfer attempted from make_raw_request\n");
  8191. ++        return 0;
  8192. ++    }
  8193. + #endif
  8194. +     return 2;
  8195. + }
  8196. + 
  8197. +-static struct cont_t rw_cont={
  8198. +-    rw_interrupt,
  8199. +-    redo_fd_request,
  8200. +-    bad_flp_intr,
  8201. +-    request_done };
  8202. +-
  8203. + static void redo_fd_request(void)
  8204. + {
  8205. + #define REPEAT {request_done(0); continue; }
  8206. +     int device;
  8207. +     int tmp;
  8208. ++    int error;
  8209. + 
  8210. ++    error = -1;
  8211. +     if (current_drive < N_DRIVE)
  8212. +         floppy_off(current_drive);
  8213. + 
  8214. +     if (CURRENT && CURRENT->dev < 0) return;
  8215. + 
  8216. +-    cont = &rw_cont;
  8217. +     while(1){
  8218. +         if (!CURRENT) {
  8219. +             CLEAR_INTR;
  8220. +@@ -2374,20 +2459,29 @@
  8221. +             panic(DEVICE_NAME ": request list destroyed");
  8222. +         if (CURRENT->bh && !CURRENT->bh->b_lock)
  8223. +             panic(DEVICE_NAME ": block not locked");
  8224. +-
  8225. ++#if 0
  8226. ++        if (!CURRENT->bh->b_count && 
  8227. ++            (CURRENT->errors || error == CURRENT->dev)){
  8228. ++            error=CURRENT->dev;
  8229. ++            DPRINT("skipping read ahead buffer\n");
  8230. ++            REPEAT;
  8231. ++        }
  8232. ++#endif
  8233. ++        error=-1;
  8234. +         device = CURRENT->dev;
  8235. +         set_fdc( DRIVE(device));
  8236. + 
  8237. +-        timer_table[FLOPPY_TIMER].expires = jiffies + DP->timeout;
  8238. +-        timer_active |= 1 << FLOPPY_TIMER;
  8239. +-        raw_cmd.flags=0;
  8240. +-        start_motor();
  8241. +-        if(test_bit( DRIVE(device), &fake_change) ||
  8242. +-           test_bit( DRIVE(device), &changed_floppies)){
  8243. ++        del_timer(&fd_timeout);
  8244. ++        fd_timeout.expires = DP->timeout;
  8245. ++        add_timer(&fd_timeout);
  8246. ++
  8247. ++        set_floppy(device);
  8248. ++        if(start_motor(redo_fd_request)) return;
  8249. ++        if(test_bit(current_drive, &fake_change) ||
  8250. ++           TESTF(FD_DISK_CHANGED)){
  8251. +             DPRINT("disk absent or changed during operation\n");
  8252. +             REPEAT;
  8253. +         }
  8254. +-        set_floppy(device);
  8255. +         if (!floppy) { /* Autodetection */
  8256. +             if (!probing){
  8257. +                 DRS->probed_format = 0;
  8258. +@@ -2408,7 +2502,9 @@
  8259. +             continue;
  8260. +         }
  8261. + 
  8262. +-        floppy_tq.routine = (void (*)(void *)) floppy_start;
  8263. ++        if (TESTF(FD_NEED_TWADDLE))
  8264. ++            twaddle();
  8265. ++        floppy_tq.routine = (void *)(void *) floppy_start;
  8266. +         queue_task(&floppy_tq, &tq_timer);
  8267. + #ifdef DEBUGT
  8268. +         debugt("queue fd request");
  8269. +@@ -2418,7 +2514,22 @@
  8270. + #undef REPEAT
  8271. + }
  8272. + 
  8273. +-void do_fd_request(void)
  8274. ++static struct cont_t rw_cont={
  8275. ++    rw_interrupt,
  8276. ++    redo_fd_request,
  8277. ++    bad_flp_intr,
  8278. ++    request_done };
  8279. ++
  8280. ++struct tq_struct request_tq = 
  8281. ++{ 0, 0, (void *) (void *) redo_fd_request, 0 };
  8282. ++
  8283. ++static void process_fd_request(void)
  8284. ++{
  8285. ++    cont = &rw_cont;
  8286. ++    queue_task(&request_tq, &tq_timer);
  8287. ++}
  8288. ++
  8289. ++static void do_fd_request(void)
  8290. + {
  8291. +     if (fdc_busy)
  8292. +         /* fdc busy, this new request will be treated when the
  8293. +@@ -2427,7 +2538,30 @@
  8294. +     /* fdc_busy cannot be set by an interrupt or a bh */
  8295. +     floppy_grab_irq_and_dma();
  8296. +     fdc_busy=1;
  8297. +-    redo_fd_request();
  8298. ++    process_fd_request();
  8299. ++}
  8300. ++
  8301. ++static struct cont_t poll_cont={
  8302. ++    success_and_wakeup,
  8303. ++    floppy_ready,
  8304. ++    generic_failure,
  8305. ++    generic_done };
  8306. ++
  8307. ++static int poll_drive(int interruptible, int flag){
  8308. ++    int ret;
  8309. ++    /* no auto-sense, just clear dcl */
  8310. ++    raw_cmd.flags= flag;
  8311. ++    raw_cmd.track=0;
  8312. ++    raw_cmd.cmd_count=0;
  8313. ++    cont = &poll_cont;
  8314. ++#ifdef DCL_DEBUG
  8315. ++        if (DP->flags & FD_DEBUG){
  8316. ++            DPRINT("setting NEWCHANGE in poll_drive\n");
  8317. ++        }
  8318. ++#endif
  8319. ++    SETF(FD_DISK_NEWCHANGE);
  8320. ++    WAIT(floppy_ready);
  8321. ++    return ret;
  8322. + }
  8323. + 
  8324. + /*
  8325. +@@ -2448,29 +2582,23 @@
  8326. + 
  8327. + static int user_reset_fdc(int drive, int arg, int interruptible)
  8328. + {
  8329. +-    int result;
  8330. ++    int ret;
  8331. + 
  8332. +-    result=0;
  8333. ++    ret=0;
  8334. ++    if(arg == FD_RESET_IF_NEEDED && !FDCS->reset)
  8335. ++        return 0;
  8336. +     LOCK_FDC(drive,interruptible);
  8337. +-    switch(arg){
  8338. +-    case FD_RESET_ALWAYS:
  8339. ++    if(arg == FD_RESET_ALWAYS)
  8340. +         FDCS->reset=1;
  8341. +-        break;
  8342. +-    case FD_RESET_IF_RAWCMD:
  8343. +-        if(FDCS->rawcmd == 2 )
  8344. +-            reset_fdc_info(1);
  8345. +-        break;
  8346. +-    }
  8347. +     if ( FDCS->reset ){
  8348. +         cont = &reset_cont;
  8349. +-        timer_table[FLOPPY_TIMER].expires = jiffies + 5;
  8350. +-        timer_active |= 1 << FLOPPY_TIMER;
  8351. +-        CALL(result=wait_til_done(reset_fdc,interruptible));
  8352. +-    }
  8353. +-    if ( UDRS->track == PROVEN_ABSENT )
  8354. +-        UDRS->track = NEED_2_RECAL;
  8355. +-    redo_fd_request();
  8356. +-    return result;
  8357. ++        del_timer(&fd_timeout);
  8358. ++        fd_timeout.expires = DP->timeout;
  8359. ++        add_timer(&fd_timeout);
  8360. ++        WAIT(reset_fdc);
  8361. ++    }
  8362. ++    process_fd_request();
  8363. ++    return ret;
  8364. + }
  8365. + 
  8366. + /*
  8367. +@@ -2493,7 +2621,7 @@
  8368. + 
  8369. + static char *drive_name(int type, int drive )
  8370. + {
  8371. +-    struct floppy_struct *floppy;
  8372. ++    struct floppy_struct *floppy;    
  8373. + 
  8374. +     if ( type )
  8375. +         floppy = floppy_type + type;
  8376. +@@ -2516,21 +2644,21 @@
  8377. +     generic_failure,
  8378. +     generic_done };
  8379. + 
  8380. +-static int raw_cmd_ioctl(int drive, void *param)
  8381. ++static int raw_cmd_ioctl(void *param)
  8382. + {
  8383. +-    int i, count, ret;
  8384. ++    int i, drive, count, ret;
  8385. + 
  8386. +     if ( FDCS->rawcmd <= 1 )
  8387. +         FDCS->rawcmd = 1;
  8388. +-    for ( i= 0; i < N_DRIVE; i++){
  8389. +-        if ( FDC(i) != fdc)
  8390. ++    for ( drive= 0; drive < N_DRIVE; drive++){
  8391. ++        if ( FDC(drive) != fdc)
  8392. +             continue;
  8393. +-        if ( i == drive ){
  8394. +-            if ( drive_state[i].fd_ref > 1 ){
  8395. ++        if ( drive == current_drive ){
  8396. ++            if ( UDRS->fd_ref > 1 ){
  8397. +                 FDCS->rawcmd = 2;
  8398. +                 break;
  8399. +             }
  8400. +-        } else if ( drive_state[i].fd_ref ){
  8401. ++        } else if ( UDRS->fd_ref ){
  8402. +             FDCS->rawcmd = 2;
  8403. +             break;
  8404. +         }
  8405. +@@ -2540,11 +2668,15 @@
  8406. +         return -EIO;
  8407. + 
  8408. +     COPYIN(raw_cmd);
  8409. +-    raw_cmd.rate &= 0x03;
  8410. ++    raw_cmd.rate &= 0x03;    
  8411. +     count = raw_cmd.length;
  8412. +     if (raw_cmd.flags & (FD_RAW_WRITE | FD_RAW_READ)){
  8413. +         if(count > max_buffer_sectors * 1024 )
  8414. +             return -ENOMEM;
  8415. ++        if(count == 0){
  8416. ++            printk("attempt to do a 0 byte dma transfer\n");
  8417. ++            return -EINVAL;
  8418. ++        }
  8419. +         buffer_track = -1;
  8420. +     }
  8421. +     if ( raw_cmd.flags & FD_RAW_WRITE ){
  8422. +@@ -2556,13 +2688,18 @@
  8423. + 
  8424. +     current_addr = floppy_track_buffer;
  8425. +     cont = &raw_cmd_cont;
  8426. +-    CALL(ret=wait_til_done(floppy_start,1));
  8427. ++    IWAIT(floppy_start);
  8428. ++#ifdef DCL_DEBUG
  8429. ++    if (DP->flags & FD_DEBUG){
  8430. ++        DPRINT("calling disk change from raw_cmd ioctl\n");
  8431. ++    }
  8432. ++#endif
  8433. +     if( disk_change(current_drive) )
  8434. +         raw_cmd.flags |= FD_RAW_DISK_CHANGE;
  8435. +     else
  8436. +         raw_cmd.flags &= ~FD_RAW_DISK_CHANGE;
  8437. +     if(raw_cmd.flags & FD_RAW_NO_MOTOR_AFTER)
  8438. +-        motor_off_callback(drive);
  8439. ++        motor_off_callback(current_drive);    
  8440. + 
  8441. +     if ( !ret && !FDCS->reset ){
  8442. +         raw_cmd.reply_count = inr;
  8443. +@@ -2572,7 +2709,6 @@
  8444. +             raw_cmd.length = get_dma_residue(FLOPPY_DMA);
  8445. +     } else
  8446. +         ret = -EIO;
  8447. +-
  8448. +     DRS->track = NO_TRACK;
  8449. +     if ( ret )
  8450. +         return ret;
  8451. +@@ -2582,7 +2718,7 @@
  8452. +         if (i)
  8453. +             return i;
  8454. +     }
  8455. +-
  8456. ++       
  8457. +     return COPYOUT(raw_cmd);
  8458. + }
  8459. + 
  8460. +@@ -2590,7 +2726,7 @@
  8461. + {
  8462. +     /* invalidate the buffer track to force a reread */
  8463. +     set_bit( DRIVE(rdev), &fake_change);
  8464. +-    redo_fd_request();
  8465. ++    process_fd_request();
  8466. +     check_disk_change(rdev);
  8467. +     return 0;
  8468. + }
  8469. +@@ -2599,6 +2735,7 @@
  8470. +     unsigned long param)
  8471. + {
  8472. + #define IOCTL_MODE_BIT 8
  8473. ++#define OPEN_WRITE_BIT 16
  8474. + #define IOCTL_ALLOWED (filp && (filp->f_mode & IOCTL_MODE_BIT))
  8475. + 
  8476. +     struct floppy_struct newparams;
  8477. +@@ -2636,7 +2773,9 @@
  8478. +             return -ENODEV;
  8479. +         return COPYOUT(this_floppy[0]);
  8480. +     case FDPOLLDRVSTAT:
  8481. +-        check_disk_change(device);
  8482. ++        LOCK_FDC(drive,1);
  8483. ++        CALL(poll_drive(1, FD_RAW_NEED_DISK));
  8484. ++        process_fd_request();
  8485. +         /* fall through */
  8486. +     case FDGETDRVSTAT:
  8487. +         return COPYOUT(*UDRS);
  8488. +@@ -2647,10 +2786,8 @@
  8489. +     case FDWERRORGET:
  8490. +         return COPYOUT(*UDRWE);
  8491. +     }
  8492. +-
  8493. +     if (!IOCTL_ALLOWED)
  8494. +         return -EPERM;
  8495. +-
  8496. +     switch (cmd) {
  8497. +     case FDWERRORCLR:
  8498. +                 UDRWE->write_errors = 0;
  8499. +@@ -2665,14 +2802,12 @@
  8500. +             return -EINVAL;
  8501. +         LOCK_FDC(drive,1);
  8502. +         set_floppy(device);
  8503. +-        CALL(i = raw_cmd_ioctl(drive, (void *) param));
  8504. +-        redo_fd_request();
  8505. ++        CALL(i = raw_cmd_ioctl((void *) param));
  8506. ++        process_fd_request();
  8507. +         return i;
  8508. +     case FDFMTTRK:
  8509. +         if (UDRS->fd_ref != 1)
  8510. +             return -EBUSY;
  8511. +-        if (UDRS->track == PROVEN_ABSENT)
  8512. +-            return -ENXIO;
  8513. +         COPYIN(tmp_format_req);
  8514. +         return do_format(device, &tmp_format_req);
  8515. +     case FDSETMAXERRS:
  8516. +@@ -2682,7 +2817,7 @@
  8517. +     case FDCLRPRM:
  8518. +         LOCK_FDC(drive,1);
  8519. +         current_type[drive] = NULL;
  8520. +-        floppy_sizes[drive] = 2;
  8521. ++        floppy_sizes[drive] = MAX_DISK_SIZE;
  8522. +         UDRS->keep_data = 0;
  8523. +         return invalidate_drive(device);
  8524. +     case FDFMTEND:
  8525. +@@ -2702,7 +2837,7 @@
  8526. +         if ( type){
  8527. +             if ( !suser() )
  8528. +                 return -EPERM;
  8529. +-            LOCK_FDC(-1,1);
  8530. ++            LOCK_FDC(drive,1);
  8531. +             for ( cnt = 0; cnt < N_DRIVE; cnt++){
  8532. +                 if (TYPE(drive_state[cnt].fd_device) == type &&
  8533. +                     drive_state[cnt].fd_ref)
  8534. +@@ -2714,11 +2849,9 @@
  8535. +                  cnt < (type << 2 ) + 4 ;
  8536. +                  cnt++)
  8537. +                 floppy_sizes[cnt]=
  8538. +-#ifdef HAVE_2_CONTROLLERS
  8539. +                     floppy_sizes[cnt+0x80]=
  8540. +-#endif
  8541. +                         floppy_type[type].size>>1;
  8542. +-            redo_fd_request();
  8543. ++            process_fd_request();
  8544. +             for ( cnt = 0; cnt < N_DRIVE; cnt++){
  8545. +                 if (TYPE(drive_state[cnt].fd_device) == type &&
  8546. +                     drive_state[cnt].fd_ref)
  8547. +@@ -2729,12 +2862,10 @@
  8548. +         }
  8549. + 
  8550. +         LOCK_FDC(drive,1);
  8551. +-        if ( cmd != FDDEFPRM ){
  8552. ++        if ( cmd != FDDEFPRM )
  8553. +             /* notice a disk change immediately, else
  8554. +              * we loose our settings immediately*/
  8555. +-            raw_cmd.flags = 0;
  8556. +-            start_motor();
  8557. +-        }
  8558. ++            CALL(poll_drive(1,0));
  8559. +         user_params[drive] = newparams;
  8560. +         if (buffer_drive == drive &&
  8561. +             buffer_max > user_params[drive].sect)
  8562. +@@ -2755,7 +2886,7 @@
  8563. +             DRS->maxtrack )
  8564. +             invalidate_drive(device);
  8565. +         else
  8566. +-            redo_fd_request();
  8567. ++            process_fd_request();
  8568. +         return 0;
  8569. +     case FDRESET:
  8570. +         return user_reset_fdc( drive, (int)param, 1);
  8571. +@@ -2772,7 +2903,7 @@
  8572. +     case FDTWADDLE:
  8573. +         LOCK_FDC(drive,1);
  8574. +         twaddle();
  8575. +-        redo_fd_request();
  8576. ++        process_fd_request();
  8577. +     }
  8578. +     if ( ! suser() )
  8579. +         return -EPERM;
  8580. +@@ -2786,70 +2917,89 @@
  8581. + #undef IOCTL_ALLOWED
  8582. + }
  8583. + 
  8584. +-static void set_base_type(int drive, int code)
  8585. +-{
  8586. +-    if(code>0 && code <= NUMBER(default_drive_params)+1) {
  8587. +-        memcpy((char *)UDP,
  8588. +-            (char *)(&default_drive_params[code-1].params),
  8589. +-            sizeof(struct floppy_drive_params));
  8590. +-        printk("fd%d is %s", drive, default_drive_params[code-1].name);
  8591. +-        return;
  8592. +-    }
  8593. +-    else if (!code)
  8594. +-        printk("fd%d is not installed", drive);
  8595. +-    else
  8596. +-        printk("fd%d is unknown type %d", drive, code);
  8597. +-}
  8598. +-
  8599. + static void config_types(void)
  8600. + {
  8601. ++    int first=1;
  8602. +     int drive;
  8603. + 
  8604. +-    for (drive=0; drive<N_DRIVE ; drive++){
  8605. +-          /* default type for unidentifiable drives */
  8606. +-          memcpy((char *) UDP, (char *) (&default_drive_params->params),
  8607. +-              sizeof( struct floppy_drive_params ));
  8608. +-    }
  8609. +-    printk("Floppy drive(s): ");
  8610. +-    for(drive=0; drive<no_floppies; drive++)
  8611. +-    {
  8612. +-      set_base_type(drive, 1+4);
  8613. +-      if(drive < no_floppies-1)
  8614. +-        printk(", ");
  8615. ++    /* read drive info out of physical cmos */
  8616. ++    drive=0;
  8617. ++    if (!UDP->cmos )
  8618. ++        UDP->cmos= FLOPPY0_TYPE;
  8619. ++    drive=1;
  8620. ++    if (!UDP->cmos && FLOPPY1_TYPE)
  8621. ++        UDP->cmos = FLOPPY1_TYPE;
  8622. ++
  8623. ++    /* XXX */
  8624. ++    /* additional physical CMOS drive detection should go here */
  8625. ++
  8626. ++    for (drive=0; drive < N_DRIVE; drive++){
  8627. ++        if (UDP->cmos >= 0 && UDP->cmos <= NUMBER(default_drive_params))
  8628. ++            memcpy((char *) UDP,
  8629. ++                   (char *) (&default_drive_params[(int)UDP->cmos].params),
  8630. ++                   sizeof(struct floppy_drive_params));
  8631. ++        if (UDP->cmos){
  8632. ++            if (first)
  8633. ++                printk("Floppy drive(s): ");
  8634. ++            else
  8635. ++                printk(", ");
  8636. ++            first=0;
  8637. ++            if (UDP->cmos > 0 ){
  8638. ++                ALLOWED_DRIVE_MASK |= 1 << drive;
  8639. ++                printk("fd%d is %s", drive,
  8640. ++                       default_drive_params[(int)UDP->cmos].name);
  8641. ++            } else
  8642. ++                printk("fd%d is unknown type %d",drive,
  8643. ++                       UDP->cmos);
  8644. ++        }
  8645. +     }
  8646. +-    printk("\n");
  8647. ++    if(!first)
  8648. ++        printk("\n");
  8649. + }
  8650. + 
  8651. +-int floppy_is_wp( int minor)
  8652. ++static int floppy_read(struct inode * inode, struct file * filp,
  8653. ++               char * buf, int count)
  8654. + {
  8655. +-    check_disk_change(minor + (MAJOR_NR << 8));
  8656. +-    return ! ( drive_state[ DRIVE(minor) ].flags & FD_DISK_WRITABLE );
  8657. ++    int drive = DRIVE(inode->i_rdev);
  8658. ++
  8659. ++    check_disk_change(inode->i_rdev);
  8660. ++    if (UTESTF(FD_DISK_CHANGED))
  8661. ++        return -ENXIO;
  8662. ++    return block_read(inode, filp, buf, count);
  8663. + }
  8664. + 
  8665. ++static int floppy_write(struct inode * inode, struct file * filp,
  8666. ++            char * buf, int count)
  8667. ++{
  8668. ++    int block;
  8669. ++    int ret;
  8670. ++    int drive = DRIVE(inode->i_rdev);
  8671. + 
  8672. +-#define WRAPPER(op) \
  8673. +-static int floppy_##op(struct inode * inode, struct file * filp, \
  8674. +-             char * buf, int count) \
  8675. +-{ \
  8676. +-    check_disk_change(inode->i_rdev); \
  8677. +-    if ( drive_state[DRIVE(inode->i_rdev)].track == PROVEN_ABSENT ) \
  8678. +-         return -ENXIO; \
  8679. +-    if ( test_bit(DRIVE(inode->i_rdev),&changed_floppies)) \
  8680. +-        return -ENXIO; \
  8681. +-    return block_##op(inode, filp, buf, count); \
  8682. ++    if(!UDRS->maxblock)
  8683. ++        UDRS->maxblock=1;/* make change detectable */
  8684. ++    check_disk_change(inode->i_rdev);
  8685. ++    if (UTESTF(FD_DISK_CHANGED)) 
  8686. ++        return -ENXIO;
  8687. ++    if(!UTESTF(FD_DISK_WRITABLE))
  8688. ++        return -EROFS;
  8689. ++    block = (filp->f_pos + count) >> 9;
  8690. ++    if(block > UDRS->maxblock)
  8691. ++        UDRS->maxblock = block;
  8692. ++    ret= block_write(inode, filp, buf, count);
  8693. ++    return ret;
  8694. + }
  8695. + 
  8696. +-WRAPPER(read)
  8697. +-WRAPPER(write)
  8698. +-
  8699. + static void floppy_release(struct inode * inode, struct file * filp)
  8700. + {
  8701. +     int drive;
  8702. +-
  8703. ++    
  8704. +     drive = DRIVE(inode->i_rdev);
  8705. + 
  8706. +-    fsync_dev(inode->i_rdev);
  8707. +-
  8708. ++    if( !filp || (filp->f_mode & (2 | OPEN_WRITE_BIT)))
  8709. ++        /* if the file is mounted OR (writable now AND writable at
  8710. ++         * open time) Linus: Does this cover all cases? */
  8711. ++        block_fsync(inode,filp);
  8712. ++            
  8713. +     if (UDRS->fd_ref < 0)
  8714. +         UDRS->fd_ref=0;
  8715. +     else if (!UDRS->fd_ref--) {
  8716. +@@ -2879,20 +3029,22 @@
  8717. +     }
  8718. + 
  8719. +     drive = DRIVE(inode->i_rdev);
  8720. +-    if ( drive >= N_DRIVE || !( ALLOWED_DRIVE_MASK & ( 1 << drive)) )
  8721. ++    if (drive >= N_DRIVE || 
  8722. ++        !( ALLOWED_DRIVE_MASK & ( 1 << drive)) ||
  8723. ++        fdc_state[FDC(drive)].version == FDC_NONE)
  8724. +         return -ENXIO;
  8725. + 
  8726. +     if (TYPE(inode->i_rdev) >= NUMBER(floppy_type))
  8727. +         return -ENXIO;
  8728. +-
  8729. +-    if ((filp->f_mode & 3)  &&
  8730. +-        UDRS->track == PROVEN_ABSENT )
  8731. +-        return -ENXIO;
  8732. +-
  8733. +     old_dev = UDRS->fd_device;
  8734. +     if (UDRS->fd_ref && old_dev != inode->i_rdev)
  8735. +         return -EBUSY;
  8736. + 
  8737. ++    if(!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)){
  8738. ++        USETF(FD_DISK_CHANGED);
  8739. ++        USETF(FD_VERIFY);
  8740. ++    }
  8741. ++
  8742. +     if(UDRS->fd_ref == -1 ||
  8743. +        (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
  8744. +         return -EBUSY;
  8745. +@@ -2900,7 +3052,7 @@
  8746. +     if (floppy_grab_irq_and_dma())
  8747. +         return -EBUSY;
  8748. + 
  8749. +-    if(filp->f_flags & O_EXCL)
  8750. ++    if (filp->f_flags & O_EXCL)
  8751. +         UDRS->fd_ref = -1;
  8752. +     else
  8753. +         UDRS->fd_ref++;
  8754. +@@ -2916,30 +3068,21 @@
  8755. +     /* Allow ioctls if we have write-permissions even if read-only open */
  8756. +     if ((filp->f_mode & 2) || (permission(inode,2) == 0))
  8757. +         filp->f_mode |= IOCTL_MODE_BIT;
  8758. ++    if (filp->f_mode & 2)
  8759. ++        filp->f_mode |= OPEN_WRITE_BIT;
  8760. + 
  8761. +     if (UFDCS->rawcmd == 1)
  8762. +            UFDCS->rawcmd = 2;
  8763. + 
  8764. +     if (filp->f_flags & O_NDELAY)
  8765. +         return 0;
  8766. +-
  8767. +-    if (filp->f_mode && UDRS->track == PROVEN_ABSENT )
  8768. +-        RETERR(ENXIO);
  8769. +-
  8770. +-    if (user_reset_fdc(drive, FD_RESET_IF_NEEDED,0))
  8771. +-        RETERR(EIO);
  8772. +-
  8773. +     if (filp->f_mode & 3) {
  8774. +         UDRS->last_checked = 0;
  8775. +         check_disk_change(inode->i_rdev);
  8776. +-        if (test_bit(drive,&changed_floppies))
  8777. ++        if (UTESTF(FD_DISK_CHANGED))
  8778. +             RETERR(ENXIO);
  8779. +     }
  8780. +-
  8781. +-    if (filp->f_mode && UDRS->track == PROVEN_ABSENT )
  8782. +-        RETERR(ENXIO);
  8783. +-
  8784. +-    if ((filp->f_mode & 2) && !(UDRS->flags & FD_DISK_WRITABLE))
  8785. ++    if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
  8786. +         RETERR(EROFS);
  8787. +     return 0;
  8788. + #undef RETERR
  8789. +@@ -2957,45 +3100,38 @@
  8790. +         return 0;
  8791. +     }
  8792. + 
  8793. +-    if(test_bit(drive, &changed_floppies))
  8794. ++    if (UTESTF(FD_DISK_CHANGED))
  8795. +         return 1;
  8796. + 
  8797. +     if(UDRS->last_checked + UDP->checkfreq < jiffies){
  8798. +         lock_fdc(drive,0);
  8799. +-        start_motor();
  8800. +-        redo_fd_request();
  8801. ++        poll_drive(0,0);
  8802. ++        process_fd_request();
  8803. +     }
  8804. +-
  8805. +-    if(test_bit(drive, &changed_floppies))
  8806. +-        return 1;
  8807. +-    if(test_bit(drive, &fake_change))
  8808. ++        
  8809. ++    if(UTESTF(FD_DISK_CHANGED) ||
  8810. ++       test_bit(drive, &fake_change) ||
  8811. ++       (!TYPE(dev) && !current_type[drive]))
  8812. +         return 1;
  8813. +     return 0;
  8814. + }
  8815. + 
  8816. +-static struct cont_t poll_cont={
  8817. +-    success_and_wakeup,
  8818. +-    floppy_ready,
  8819. +-    generic_failure,
  8820. +-    generic_done };
  8821. +-
  8822. +-
  8823. + /* revalidate the floppy disk, i.e. trigger format autodetection by reading
  8824. +- * the bootblock (block 0). "Autodetection" is also needed to check wether
  8825. ++ * the bootblock (block 0). "Autodetection" is also needed to check whether
  8826. +  * there is a disk in the drive at all... Thus we also do it for fixed
  8827. +  * geometry formats */
  8828. + static int floppy_revalidate(dev_t dev)
  8829. + {
  8830. ++#define NO_GEOM (!current_type[drive] && !TYPE(dev))
  8831. +     struct buffer_head * bh;
  8832. +     int drive=DRIVE(dev);
  8833. +     int cf;
  8834. + 
  8835. +-    cf = test_bit(drive, &changed_floppies);
  8836. +-    if(cf || test_bit(drive, &fake_change)){
  8837. ++    if(UTESTF(FD_DISK_CHANGED) || test_bit(drive, &fake_change) || NO_GEOM){
  8838. +         lock_fdc(drive,0);
  8839. +-        cf = test_bit(drive, &changed_floppies);
  8840. +-        if(! (cf || test_bit(drive, &fake_change))){
  8841. +-            redo_fd_request(); /* already done by another thread */
  8842. ++        cf = UTESTF(FD_DISK_CHANGED);
  8843. ++        if(! (cf || test_bit(drive, &fake_change) || NO_GEOM)){
  8844. ++            process_fd_request(); /*already done by another thread*/
  8845. +             return 0;
  8846. +         }
  8847. +         UDRS->maxblock = 0;
  8848. +@@ -3003,31 +3139,28 @@
  8849. +         if ( buffer_drive == drive)
  8850. +             buffer_track = -1;
  8851. +         clear_bit(drive, &fake_change);
  8852. +-        clear_bit(drive, &changed_floppies);
  8853. +-        if(cf){
  8854. ++        UCLEARF(FD_DISK_CHANGED);
  8855. ++        if(cf)
  8856. +             UDRS->generation++;
  8857. +-            if(!current_type[drive] && !TYPE(dev)){
  8858. +-                /* auto-sensing */
  8859. +-                if (!(bh = getblk(dev,0,1024))){
  8860. +-                    redo_fd_request();
  8861. +-                    return 1;
  8862. +-                }
  8863. +-                if ( bh && ! bh->b_uptodate)
  8864. +-                    ll_rw_block(READ, 1, &bh);
  8865. +-                redo_fd_request();
  8866. +-                wait_on_buffer(bh);
  8867. +-                brelse(bh);
  8868. +-                return 0;
  8869. +-            } else {
  8870. +-                /* no auto-sense, just clear dcl */
  8871. +-                raw_cmd.flags=FD_RAW_NEED_SEEK|FD_RAW_NEED_DISK;
  8872. +-                raw_cmd.track=0;
  8873. +-                raw_cmd.cmd_count=0;
  8874. +-                cont = &poll_cont;
  8875. +-                wait_til_done(floppy_ready,0);
  8876. ++        if(NO_GEOM){
  8877. ++            /* auto-sensing */
  8878. ++            int size = floppy_blocksizes[MINOR(dev)];
  8879. ++            if (!size)
  8880. ++                size = 1024;
  8881. ++            if (!(bh = getblk(dev,0,size))){
  8882. ++                process_fd_request();
  8883. ++                return 1;
  8884. +             }
  8885. +-        }
  8886. +-        redo_fd_request();
  8887. ++            if ( bh && ! bh->b_uptodate)
  8888. ++                ll_rw_block(READ, 1, &bh);
  8889. ++            process_fd_request();
  8890. ++            wait_on_buffer(bh);
  8891. ++            brelse(bh);
  8892. ++            return 0;
  8893. ++        } 
  8894. ++        if(cf)
  8895. ++                poll_drive(0, FD_RAW_NEED_DISK);
  8896. ++        process_fd_request();
  8897. +     }
  8898. +     return 0;
  8899. + }
  8900. +@@ -3094,17 +3227,145 @@
  8901. +     }
  8902. +     printk("FDC %d is a post-1991 82077\n",fdc);
  8903. +     return FDC_82077;    /* Revised 82077AA passes all the tests */
  8904. +-} /* fdc_init */
  8905. ++} /* get_fdc_version */
  8906. + 
  8907. +-void floppy_init(void)
  8908. ++/* lilo configuration */
  8909. ++
  8910. ++/* we make the invert_dcl function global. One day, somebody might
  8911. ++want to centralize all thinkpad related options into one lilo option,
  8912. ++there are just so many thinkpad related quirks! */
  8913. ++void floppy_invert_dcl(int *ints,int param)
  8914. ++{
  8915. ++    int i;
  8916. ++    
  8917. ++    for (i=0; i < ARRAY_SIZE(default_drive_params); i++){
  8918. ++        if (param)
  8919. ++            default_drive_params[i].params.flags |= 0x80;
  8920. ++        else
  8921. ++            default_drive_params[i].params.flags &= ~0x80;
  8922. ++    }
  8923. ++    DPRINT("Configuring drives for inverted dcl\n");
  8924. ++}
  8925. ++
  8926. ++static void daring(int *ints,int param)
  8927. + {
  8928. +     int i;
  8929. + 
  8930. ++    for (i=0; i < ARRAY_SIZE(default_drive_params); i++){
  8931. ++        if (param){
  8932. ++            default_drive_params[i].params.select_delay = 0;
  8933. ++            default_drive_params[i].params.flags |= FD_SILENT_DCL_CLEAR;
  8934. ++        } else {
  8935. ++            default_drive_params[i].params.select_delay = 2*HZ/100;
  8936. ++            default_drive_params[i].params.flags &= ~FD_SILENT_DCL_CLEAR;
  8937. ++        }
  8938. ++    }
  8939. ++    DPRINT1("Assuming %s floppy hardware\n", param ? "standard" : "broken");
  8940. ++}
  8941. ++
  8942. ++static void allow_drives(int *ints, int param)
  8943. ++{
  8944. ++    ALLOWED_DRIVE_MASK=param;
  8945. ++    DPRINT1("setting allowed_drive_mask to 0x%x\n", param);
  8946. ++}
  8947. ++
  8948. ++static void fdc2_adr(int *ints, int param)
  8949. ++{
  8950. ++    FDC2 = param;
  8951. ++    if(param)
  8952. ++        DPRINT1("enabling second fdc at address 0x%3x\n", FDC2);
  8953. ++    else
  8954. ++        DPRINT("disabling second fdc\n");
  8955. ++}
  8956. ++
  8957. ++static void unex(int *ints,int param)
  8958. ++{
  8959. ++    print_unex = param;
  8960. ++    DPRINT1("%sprinting messages for unexpected interrupts\n",
  8961. ++        param ? "" : "not ");
  8962. ++}
  8963. ++
  8964. ++static void set_cmos(int *ints, int dummy)
  8965. ++{
  8966. ++    int current_drive=0;
  8967. ++
  8968. ++    if ( ints[0] != 2 ){
  8969. ++        DPRINT("wrong number of parameter for cmos\n");
  8970. ++        return;
  8971. ++    }
  8972. ++    current_drive = ints[1];
  8973. ++    if (current_drive < 0 || current_drive >= 8 ){
  8974. ++        DPRINT("bad drive for set_cmos\n");
  8975. ++        return;
  8976. ++    }
  8977. ++    if(ints[2] <= 0 || ints[2] >= NUMBER(default_drive_params)){
  8978. ++        DPRINT1("bad cmos code %d\n", ints[2]);
  8979. ++        return;
  8980. ++    }
  8981. ++    DP->cmos = ints[2];
  8982. ++    DPRINT1("setting cmos code to %d\n", ints[2]);
  8983. ++}
  8984. ++        
  8985. ++static struct param_table {
  8986. ++    char *name;
  8987. ++    void (*fn)(int *ints, int param);
  8988. ++    int def_param;
  8989. ++} config_params[]={
  8990. ++{ "allowed_drive_mask", allow_drives, 0xff },
  8991. ++{ "all_drives", allow_drives, 0xff },
  8992. ++{ "asus_pci", allow_drives, 0x33 },
  8993. ++
  8994. ++{ "daring", daring, 1},
  8995. ++
  8996. ++{ "two_fdc", fdc2_adr, 0x370 },
  8997. ++{ "one_fdc", fdc2_adr, 0 },
  8998. ++
  8999. ++{ "thinkpad", floppy_invert_dcl, 1 },
  9000. ++
  9001. ++{ "cmos", set_cmos, 0 },
  9002. ++
  9003. ++{ "unexpected_interrupts", unex, 1 },
  9004. ++{ "no_unexpected_interrupts", unex, 0 },
  9005. ++{ "L40SX", unex, 0 } };
  9006. ++
  9007. ++#define FLOPPY_SETUP
  9008. ++void floppy_setup(char *str, int *ints)
  9009. ++{
  9010. ++    int i;
  9011. ++    int param;
  9012. ++    if(!str)
  9013. ++        return;
  9014. ++    for(i=0; i< ARRAY_SIZE(config_params); i++){
  9015. ++        if (strcmp(str,config_params[i].name) == 0 ){
  9016. ++            if (ints[0] )
  9017. ++                param = ints[1];
  9018. ++            else
  9019. ++                param = config_params[i].def_param;
  9020. ++            config_params[i].fn(ints,param);
  9021. ++            return;
  9022. ++        }
  9023. ++    }
  9024. ++    DPRINT1("unknown floppy option %s\n", str);
  9025. ++    DPRINT("allowed options are:");
  9026. ++    for(i=0; i< ARRAY_SIZE(config_params); i++)
  9027. ++        printk(" %s",config_params[i].name);
  9028. ++    printk("\n");
  9029. ++    DPRINT("Read linux/drivers/block/README.fd\n");
  9030. ++}
  9031. ++
  9032. ++#ifdef FD_MODULE
  9033. ++static
  9034. ++#endif
  9035. ++int new_floppy_init(void)
  9036. ++{
  9037. ++    int i,drive;
  9038. ++    int have_no_fdc=0;
  9039. ++
  9040. +     sti();
  9041. + 
  9042. +     if (register_blkdev(MAJOR_NR,"fd",&floppy_fops)) {
  9043. +         printk("Unable to get major %d for floppy\n",MAJOR_NR);
  9044. +-        return;
  9045. ++        return -EBUSY;
  9046. +     }
  9047. + 
  9048. +     for(i=0; i<256; i++)
  9049. +@@ -3114,55 +3375,63 @@
  9050. +             floppy_sizes[i] = MAX_DISK_SIZE;
  9051. + 
  9052. +     blk_size[MAJOR_NR] = floppy_sizes;
  9053. ++    blksize_size[MAJOR_NR] = floppy_blocksizes;
  9054. +     blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  9055. +-    hardsect_size[MAJOR_NR] = fd_sectsizes;
  9056. +-    timer_table[FLOPPY_TIMER].fn = floppy_shutdown;
  9057. +-    timer_active &= ~(1 << FLOPPY_TIMER);
  9058. ++    del_timer(&fd_timeout);
  9059. +     config_types();
  9060. + 
  9061. +-    for(i = 0; i<256; i++)
  9062. +-        fd_sectsizes[i] = 1024;            /* patch for msdos driver */
  9063. +-
  9064. +-    fdc_state[0].address = 0x3f0;
  9065. ++    fdc_state[0].address = FDC1;
  9066. ++    fdc_state[0].dor = 0;
  9067. + #if N_FDC > 1
  9068. +-    fdc_state[1].address = 0x370;
  9069. ++    fdc_state[1].address = FDC2;
  9070. ++    fdc_state[1].dor = 0;
  9071. + #endif
  9072. ++
  9073. +     for (i = 0 ; i < N_FDC ; i++) {
  9074. +         fdc = i;
  9075. +         FDCS->dtr = -1;
  9076. +-        FDCS->dor = 0;
  9077. ++        FDCS->dor = 0x4;
  9078. +         FDCS->reset = 0;
  9079. +         FDCS->version = FDC_NONE;
  9080. +-        set_dor(fdc, ~0, 0xc );
  9081. ++    }
  9082. ++
  9083. ++    if(floppy_grab_irq_and_dma()){
  9084. ++        unregister_blkdev(MAJOR_NR,"fd");
  9085. ++        return -EBUSY;
  9086. +     }
  9087. + 
  9088. +     /* initialise drive state */
  9089. +-    for (i = 0; i < N_DRIVE ; i++) {
  9090. +-        current_drive = i;
  9091. +-        DRS->flags = FD_VERIFY | FD_DISK_NEWCHANGE;
  9092. +-        DRS->generation = 0;
  9093. +-        DRS->keep_data = 0;
  9094. +-        DRS->fd_ref = 0;
  9095. +-        DRS->fd_device = 0;
  9096. +-        DRWE->write_errors = 0;
  9097. +-        DRWE->first_error_sector = 0;
  9098. +-        DRWE->first_error_generation = 0;
  9099. +-        DRWE->last_error_sector = 0;
  9100. +-        DRWE->last_error_generation = 0;
  9101. +-        DRWE->badness = 0;
  9102. ++    for (drive = 0; drive < N_DRIVE ; drive++) {
  9103. ++        UDRS->flags = FD_VERIFY | FD_DISK_NEWCHANGE | FD_DISK_CHANGED;
  9104. ++        UDRS->generation = 0;
  9105. ++        UDRS->keep_data = 0;
  9106. ++        UDRS->fd_ref = 0;
  9107. ++        UDRS->fd_device = 0;
  9108. ++        UDRWE->write_errors = 0;
  9109. ++        UDRWE->first_error_sector = 0;
  9110. ++        UDRWE->first_error_generation = 0;
  9111. ++        UDRWE->last_error_sector = 0;
  9112. ++        UDRWE->last_error_generation = 0;
  9113. ++        UDRWE->badness = 0;
  9114. +     }
  9115. + 
  9116. +-    floppy_grab_irq_and_dma();
  9117. +     for (i = 0 ; i < N_FDC ; i++) {
  9118. +         fdc = i;
  9119. ++        if (FDCS->address == -1 )
  9120. ++            continue;
  9121. +         FDCS->rawcmd = 2;
  9122. +-        if(user_reset_fdc(-1,FD_RESET_IF_NEEDED,0))
  9123. ++        if(user_reset_fdc(-1,FD_RESET_IF_NEEDED,0)){
  9124. ++            FDCS->address = -1;
  9125. +             continue;
  9126. ++        }
  9127. +         /* Try to determine the floppy controller type */
  9128. +         FDCS->version = get_fdc_version();
  9129. +-        if (FDCS->version == FDC_NONE)
  9130. ++        if (FDCS->version == FDC_NONE){
  9131. ++            FDCS->address = -1;
  9132. +             continue;
  9133. ++        }
  9134. + 
  9135. ++        have_no_fdc = 0;
  9136. +         /* Not all FDCs seem to be able to handle the version command
  9137. +          * properly, so force a reset for the standard FDC clones,
  9138. +          * to avoid interrupt garbage.
  9139. +@@ -3174,6 +3443,15 @@
  9140. +     current_drive = 0;
  9141. +     floppy_release_irq_and_dma();
  9142. +     initialising=0;
  9143. ++    if(have_no_fdc)
  9144. ++        unregister_blkdev(MAJOR_NR,"fd");
  9145. ++    return have_no_fdc;
  9146. ++}
  9147. ++
  9148. ++/* stupid compatibility hack... */
  9149. ++void floppy_init(void)
  9150. ++{
  9151. ++    new_floppy_init();
  9152. + }
  9153. + 
  9154. + static int floppy_grab_irq_and_dma(void)
  9155. +@@ -3185,13 +3463,17 @@
  9156. +         return 0;
  9157. +     }
  9158. +     sti();
  9159. +-
  9160. ++#ifdef FD_MODULE
  9161. ++    MOD_INC_USE_COUNT;
  9162. ++#endif
  9163. +     for(i=0; i< N_FDC; i++){
  9164. +-        fdc = i;
  9165. +-        reset_fdc_info(1);
  9166. +-        arm_set_dor(FDCS->dor);
  9167. ++        if(FDCS->address != -1){    
  9168. ++            fdc = i;
  9169. ++            reset_fdc_info(1);
  9170. ++            outb_p(FDCS->dor, FD_DOR);
  9171. ++        }
  9172. +     }
  9173. +-    set_dor(0, ~0, 8); /* avoid immediate interrupt */
  9174. ++    set_dor(0, ~0, 8);  /* avoid immediate interrupt */
  9175. + 
  9176. +     if (request_irq(FLOPPY_IRQ, floppy_interrupt, SA_INTERRUPT, "floppy")) {
  9177. +         DPRINT1("Unable to grab IRQ%d for the floppy driver\n",
  9178. +@@ -3204,24 +3486,49 @@
  9179. +         free_irq(FLOPPY_IRQ);
  9180. +         return -1;
  9181. +     }
  9182. ++    for(fdc = 0; fdc < N_FDC ; fdc++)
  9183. ++        if(FDCS->address != -1)
  9184. ++            outb_p(FDCS->dor, FD_DOR);
  9185. ++    fdc = 0;
  9186. +     enable_irq(FLOPPY_IRQ);
  9187. +     return 0;
  9188. + }
  9189. + 
  9190. + static void floppy_release_irq_and_dma(void)
  9191. + {
  9192. +-    int i;
  9193. ++#ifdef CONFIG_FLOPPY_SANITY
  9194. ++    int drive;
  9195. ++#endif
  9196. +     cli();
  9197. +     if (--usage_count){
  9198. +         sti();
  9199. +         return;
  9200. +     }
  9201. +     sti();
  9202. ++#ifdef FD_MODULE
  9203. ++    MOD_DEC_USE_COUNT;
  9204. ++#endif
  9205. +     disable_dma(FLOPPY_DMA);
  9206. +     free_dma(FLOPPY_DMA);
  9207. +     disable_irq(FLOPPY_IRQ);
  9208. +     free_irq(FLOPPY_IRQ);
  9209. +-    /* switch off dma gates */
  9210. +-    for(i=0; i< N_FDC; i++)
  9211. +-        set_dor(i, ~8, 0);
  9212. ++
  9213. ++    set_dor(0, ~0, 8);
  9214. ++#if N_FDC > 1
  9215. ++    set_dor(1, ~8, 0);
  9216. ++#endif
  9217. ++    floppy_enable_hlt();
  9218. ++#ifdef CONFIG_FLOPPY_SANITY
  9219. ++    for(drive=0; drive < N_FDC * 4; drive++)
  9220. ++        if( motor_off_timer[drive].next )
  9221. ++            printk("motor off timer %d still active\n", drive);
  9222. ++    
  9223. ++    if(fd_timeout.next)
  9224. ++        printk("floppy timer still active\n");
  9225. ++    if (fd_timer.next)
  9226. ++        printk("auxiliary floppy timer still active\n");
  9227. ++    if(floppy_tq.sync)
  9228. ++        printk("task queue still active\n");
  9229. ++#endif
  9230. + }
  9231. ++
  9232. diff -r -u -N linux.orig/arch/arm/drivers/block/hdsrch.c linux.arm/arch/arm/drivers/block/hdsrch.c
  9233. --- linux.orig/arch/arm/drivers/block/hdsrch.c    Thu Jan  1 01:00:00 1970
  9234. +++ linux.arm/arch/arm/drivers/block/hdsrch.c    Fri Oct 27 23:14:44 1995
  9235. @@ -0,0 +1,654 @@
  9236. +#include <linux/config.h>
  9237. +#include <linux/ctype.h>
  9238. +#include <linux/kernel.h>
  9239. +#include <linux/mm.h>
  9240. +#include <linux/malloc.h>
  9241. +#include <linux/string.h>
  9242. +#include <linux/genhd.h>
  9243. +
  9244. +#pragma no_check_stack
  9245. +
  9246. +#define RECSIZE 60
  9247. +
  9248. +#define MAX_BLK_FRAGS 64
  9249. +
  9250. +struct boot_block
  9251. +{
  9252. +  unsigned char  log2secsize;
  9253. +  unsigned char  secspertrack;
  9254. +  unsigned char  heads;
  9255. +  unsigned char  density;
  9256. +  unsigned char  idlen;
  9257. +  unsigned char  log2bpmb;
  9258. +  unsigned char  shew;
  9259. +  unsigned char  bootoption;
  9260. +  unsigned char  lowsector;
  9261. +  unsigned char  nzones;
  9262. +  unsigned short zone_spare;
  9263. +  unsigned long  root;
  9264. +  unsigned long  disc_size;
  9265. +  unsigned short disc_id;
  9266. +  unsigned char  disc_name[32-22];
  9267. +  unsigned long  disctype;
  9268. +};
  9269. +
  9270. +static struct boot_block *boot=NULL;
  9271. +static unsigned int zonesize;
  9272. +static unsigned int idsperzone;
  9273. +static long rootaddr;
  9274. +static long mapaddr;
  9275. +static long maplen;
  9276. +static void *map=NULL;
  9277. +#if 0
  9278. +static long *pages=NULL;
  9279. +#endif
  9280. +static char ignoring;
  9281. +
  9282. +static int read_sectors(int dev,void *ptr,long address,int size)
  9283. +{
  9284. +  struct buffer_head *bh;
  9285. +  char *p=ptr;
  9286. +  while(size>0)
  9287. +  {
  9288. +    if((bh=bread(dev,address/1024,1024)))
  9289. +    {
  9290. +      memcpy(p,bh->b_data+((address & 0x200)?512:0),(address & 0x200 || size<1024)?512:1024);
  9291. +      if(address & 0x200)
  9292. +        address-=0x200;
  9293. +    }
  9294. +    else
  9295. +    {
  9296. +      printk("hda%c: bread failed\n",'a'+((dev & 0xc0)>>6));
  9297. +      return 0;
  9298. +    }
  9299. +    brelse(bh);
  9300. +    p+=1024;
  9301. +    address+=1024;
  9302. +    size-=1024;
  9303. +  }
  9304. +  return 1;
  9305. +}
  9306. +
  9307. +/* + Read boot block at disc address &C00 (sector 6)
  9308. + * + Calculate map address & length
  9309. + */
  9310. +
  9311. +static int getdiskinfo(int dev)
  9312. +{
  9313. +  char *ptr;
  9314. +  extern void set_hdinfo(int,unsigned char,unsigned char,unsigned long,unsigned int);
  9315. +
  9316. +  if(boot)
  9317. +      return 1;
  9318. +
  9319. +  boot=(struct boot_block *)kmalloc(sizeof(struct boot_block),GFP_KERNEL);
  9320. +  if(!boot)
  9321. +  {
  9322. +    printk("hda%c: out of memory for bootblock\n",(dev>>6)+'a');
  9323. +    return 0;
  9324. +  }
  9325. +
  9326. +  ptr=(char *)kmalloc(1024,GFP_KERNEL);
  9327. +  if(!ptr)
  9328. +  {
  9329. +    printk("hda%c: out of memory for bootblock\n",(dev>>6)+'a');
  9330. +    return 0;
  9331. +  }
  9332. +
  9333. +  if(!read_sectors(dev,ptr,0xC00,1024))
  9334. +  {
  9335. +    kfree_s(ptr,1024);
  9336. +    return 0;
  9337. +  }
  9338. +  memcpy(boot,(ptr+0x1C0),sizeof(struct boot_block));
  9339. +  kfree_s(ptr,1024);
  9340. +
  9341. +  set_hdinfo(dev,boot->secspertrack,boot->heads,boot->disc_size,1<<boot->log2secsize);
  9342. +
  9343. +  zonesize=(8<<boot->log2secsize)-boot->zone_spare;
  9344. +  idsperzone=zonesize/(boot->idlen+1);
  9345. +  mapaddr=((boot->nzones>>1)*zonesize-((boot->nzones>1)?RECSIZE*8:0))<<boot->log2bpmb;
  9346. +  maplen=boot->nzones<<boot->log2secsize;
  9347. +  return 1;
  9348. +}
  9349. +
  9350. +static unsigned char map_cross_valid_byte(void)
  9351. +{
  9352. +  unsigned char const *const map_base=map;
  9353. +  unsigned int check=0;
  9354. +  unsigned int i;
  9355. +
  9356. +  for(i=0;i<boot->nzones;i++)
  9357. +    check^=map_base[(i<<boot->log2secsize)+3];
  9358. +
  9359. +  return check;
  9360. +}
  9361. +
  9362. +static int get_map(int dev)
  9363. +{
  9364. +  if(!getdiskinfo(dev))
  9365. +    return 0;
  9366. +
  9367. +  if(map)
  9368. +    return 1;
  9369. +
  9370. +  map = (unsigned long *)vmalloc(maplen);
  9371. +  if(!map)
  9372. +    return 0;
  9373. +
  9374. +  if(!read_sectors(dev,map,mapaddr,maplen))
  9375. +    return 0;
  9376. +  if(map_cross_valid_byte()!=0xFF)
  9377. +  {
  9378. +    printk("Map 1 has invalid cross check - trying second map\n");
  9379. +    if(!read_sectors(dev,map,mapaddr+maplen,maplen))
  9380. +      return 0;
  9381. +    if(map_cross_valid_byte()!=0xFF)
  9382. +    {
  9383. +      printk("Map 2 has invalid cross check - ignoring drive\n");
  9384. +      ignoring=dev;
  9385. +      return 0;
  9386. +    }
  9387. +  }
  9388. +
  9389. +  memcpy(boot,(char*)map+4,sizeof(struct boot_block));
  9390. +
  9391. +  rootaddr=mapaddr+2*maplen;
  9392. +  return 1;
  9393. +}
  9394. +
  9395. +static int readmap(int sin,int *fzone,int *fstart,int *fend,int max_frags)
  9396. +{
  9397. +    static int startzone;    /* Start zone             */
  9398. +    static int fragment;    /* Fragment id to look for     */
  9399. +    static int curzone;    /* Current zone             */
  9400. +    static int curmapp;    /* Current map bit position     */
  9401. +  
  9402. +    register unsigned int t,z,frag,czone,cmap;
  9403. +    register unsigned char const *mapaddr;
  9404. +    register int *fz,*fs,*fe;
  9405. +    register unsigned char n;
  9406. +    
  9407. +  
  9408. +    if(sin)
  9409. +    {/* If we have new address, start from new position */
  9410. +        fragment = sin >> 8;
  9411. +        curzone = startzone = fragment / idsperzone;
  9412. +        curmapp=0;
  9413. +    }
  9414. +    if(curzone == -1)
  9415. +        return 0;
  9416. +    frag = fragment;
  9417. +    czone = curzone;
  9418. +    cmap = curmapp;
  9419. +    fz = fzone;
  9420. +    fs = fstart;
  9421. +    fe = fend;
  9422. +
  9423. +/*   printk("readmap: internal_address: %p, fragment: %p, zone: %p\n",sin,frag, */
  9424. +/*     czone); */
  9425. +
  9426. +    while(1)
  9427. +    {
  9428. +        mapaddr=(unsigned char const *)map+
  9429. +                (czone<<boot->log2secsize)+4+((czone==0)?RECSIZE:0);
  9430. +        while(cmap<zonesize-((czone==0)?RECSIZE*8:0))/* ? */
  9431. +        {
  9432. +            *fs=cmap;
  9433. +            z=cmap>>3;
  9434. +            t=((mapaddr[z]|(mapaddr[z+1]<<8)|(mapaddr[z+2]<<16))>>(cmap & 7)) &
  9435. +                ((1<<boot->idlen)-1);
  9436. +            cmap+=boot->idlen;
  9437. +            
  9438. +            while((cmap & 7)!=0 && (mapaddr[cmap>>3] & (1<<(cmap & 7)))==0)
  9439. +                cmap+=1;
  9440. +
  9441. +            while((n=mapaddr[cmap>>3]) == 0)
  9442. +                cmap+=8;
  9443. +
  9444. +            while((n & (1<<(cmap & 7)))==0)
  9445. +                cmap+=1;
  9446. +            cmap+=1;
  9447. +            if(t==frag)
  9448. +            {
  9449. +                *fz++=czone;
  9450. +                *fe++=cmap;
  9451. +                fs++;
  9452. +                if(!--max_frags)
  9453. +                {
  9454. +/*                     printf("Breaking out\n"); */
  9455. +                    curmapp = cmap;
  9456. +                    curzone = czone;
  9457. +                    return fs - fstart;
  9458. +                }
  9459. +            }
  9460. +        }
  9461. +        czone+=1;
  9462. +        if(czone==boot->nzones)
  9463. +            czone=0;
  9464. +        if(czone==startzone)
  9465. +            break;
  9466. +        cmap=0;
  9467. +    }
  9468. +    curzone = -1;
  9469. +    return fs - fstart;
  9470. +}
  9471. +
  9472. +static unsigned long calcaddr(int zone,int offset)
  9473. +{
  9474. +  if(zone)
  9475. +    return (zone*zonesize-RECSIZE*8+offset)<<boot->log2bpmb;
  9476. +  else
  9477. +    return offset<<boot->log2bpmb;
  9478. +}
  9479. +
  9480. +static void scan_name(char *name,int len)
  9481. +{
  9482. +  int i;
  9483. +  for(i=0;i<len+1;i++)
  9484. +  {
  9485. +    if(name[i]<32 || name[i]=='.' || i==len)
  9486. +    {
  9487. +      name[i]=0;
  9488. +      break;
  9489. +    }
  9490. +    if(islower(name[i]))
  9491. +      name[i]=toupper(name[i]);
  9492. +  }
  9493. +}
  9494. +
  9495. +static unsigned long scandir(int dev,unsigned long diraddress,char *file,int *type,
  9496. +       unsigned long *length)
  9497. +{
  9498. +  unsigned char *dir;
  9499. +  unsigned char *dd;
  9500. +  unsigned long addr;
  9501. +
  9502. +  scan_name(file,10);
  9503. +
  9504. +  dir=(unsigned char *)kmalloc(2048,GFP_KERNEL);
  9505. +
  9506. +  read_sectors(dev,dir,diraddress,2048);
  9507. +
  9508. +  if(strncmp((char*)dir+1,"Nick",4)!=0 && strncmp((char*)dir+1,"Hugo",4)!=0)
  9509. +  {
  9510. +    printk("Broken directory - skipping\n");
  9511. +    return 0;
  9512. +  }
  9513. +
  9514. +  dd=dir+5-26;
  9515. +  do
  9516. +  {
  9517. +    dd+=26;
  9518. +    scan_name((char*)dd,10);
  9519. +    if(strcmp(file,(char*)dd)==0)
  9520. +      break;
  9521. +  }
  9522. +  while(*dd!=0);
  9523. +  if(*dd==0)
  9524. +    return 0;
  9525. +  else
  9526. +  if(dd[25] & 8)
  9527. +    *type=0;
  9528. +  *length=(unsigned long)dd[18]|(dd[19]<<8)|(dd[20]<<16)|(dd[21]<<24);
  9529. +  addr=(unsigned long)dd[22]|(dd[23]<<8)|(dd[24]<<16);
  9530. +
  9531. +  kfree_s(dir,2048);
  9532. +
  9533. +  return addr;
  9534. +}
  9535. +
  9536. +static int search_path(int dev,char *path,unsigned long *start,unsigned long *length, int maxbits)
  9537. +{
  9538. +  unsigned long dir,iad,len;
  9539. +  int type,i,n,fzones[MAX_BLK_FRAGS],fstart[MAX_BLK_FRAGS],fend[MAX_BLK_FRAGS];
  9540. +  char *p;
  9541. +
  9542. +/*   p=strchr(path,':'); */
  9543. +/*   if(p!=NULL) */
  9544. +/*   { */
  9545. +/*     drive=p[1]-'0'; */
  9546. +/*     if(drive<4 || drive>5) */
  9547. +/*       return 0; */
  9548. +/*     p=strchr(p,'.'); */
  9549. +/*     if(p==NULL) */
  9550. +/*       return 0; */
  9551. +/*     path=p+1; */
  9552. +/*   } */
  9553. +  if(!get_map(dev))
  9554. +    return 0;
  9555. +
  9556. +  dir=rootaddr;
  9557. +  while(path)
  9558. +  {
  9559. +    type=1;
  9560. +    p=strchr(path,'.');
  9561. +    if(p!=NULL)
  9562. +    {
  9563. +      p[0]=0;
  9564. +    }
  9565. +    if(path[0]!='\0')
  9566. +    {
  9567. +      iad=scandir(dev,dir,path,&type,&len);
  9568. +      if(iad==0)
  9569. +      {
  9570. +        printk("%s '%s' not found - skipping\n",p==NULL?"File":"Directory",path);
  9571. +        return 0;
  9572. +      }
  9573. +      if(type==0)
  9574. +      {
  9575. +        n=readmap(iad,fzones,fstart,fend,1);
  9576. +        dir=calcaddr(fzones[0],fstart[0]);
  9577. +      }
  9578. +      else
  9579. +      if(p!=NULL)
  9580. +      {
  9581. +        printk("'%s' is a directory - skipping\n",path);
  9582. +        return 0;
  9583. +      }
  9584. +      else
  9585. +      {
  9586. +        int j=0;
  9587. +        unsigned int secoff;
  9588. +        secoff=(iad & 0xFF)?(unsigned int)((iad & 0xFF)-1)<<boot->log2secsize:0;
  9589. +        len=((len-1)|((1<<boot->log2secsize)-1))+1;
  9590. +        n=readmap(iad,fzones,fstart,fend,MAX_BLK_FRAGS); /* Handle 64 entries at a time */
  9591. +        do
  9592. +        {
  9593. +          for(i=0;i<n;i++)
  9594. +          {
  9595. +            start[j]=calcaddr(fzones[i],fstart[i]);
  9596. +            length[j]=calcaddr(fzones[i],fend[i])-start[j];
  9597. +            if(secoff!=0)
  9598. +            {
  9599. +              if(length[j]>secoff)
  9600. +              {
  9601. +                start[j]+=secoff;
  9602. +                length[j]-=secoff;
  9603. +                secoff=0;
  9604. +              }
  9605. +              else
  9606. +              {
  9607. +                secoff-=length[j];
  9608. +                continue;
  9609. +              }
  9610. +            }
  9611. +        
  9612. +            if(j > 0 && start[j]==(start[j-1]+length[j-1]))
  9613. +            {/* Combine parts */
  9614. +              len += length[j-1];
  9615. +              length[j-1]+=length[j];
  9616. +              j--;
  9617. +            }
  9618. +        
  9619. +            if(length[j]>len)
  9620. +            {
  9621. +              length[j]=len;
  9622. +              j++;
  9623. +              break;
  9624. +            }
  9625. +            else
  9626. +              len-=length[j];
  9627. +            j++;
  9628. +            if(j >= maxbits)
  9629. +            {
  9630. +#ifdef NOT_YET_TESTED
  9631. +        unsigned long **sn,**ln;
  9632. +        sn=(unsigned long*)kmalloc(maxbits+BLK_INCREMENT,GFP_KERNEL);
  9633. +        ln=(unsigned long*)kmalloc(maxbits+BLK_INCREMENT,GFP_KERNEL);
  9634. +        if(maxbits && start && length)
  9635. +        {
  9636. +          memcpy(sn,start,maxbits);
  9637. +          memcpy(ln,length,maxbits);
  9638. +          kfree_s((void *)start, maxbits);
  9639. +          kfree_s((void *)length, maxbits);
  9640. +        }
  9641. +        maxbits+=BLK_INCREMENT;
  9642. +#else
  9643. +                printk("**** EEEK!!!! - Image file is in too many chunks!\n");
  9644. +                return 0;
  9645. +#endif
  9646. +            }
  9647. +          }
  9648. +        }
  9649. +        while((n=readmap(0,fzones,fstart,fend,MAX_BLK_FRAGS))>0);
  9650. +        return j;
  9651. +      }
  9652. +    }
  9653. +    if(p)
  9654. +    {
  9655. +      path=p+1;
  9656. +      p[0]='.';
  9657. +    }
  9658. +    else
  9659. +      path=0;
  9660. +  }
  9661. +  printk("Pathname invalid?!?\n");
  9662. +  return 0;
  9663. +}
  9664. +
  9665. +#define MAX_HD_IMAGES    8
  9666. +#define TWO_HDS
  9667. +#define MAX_HD_BITS    128
  9668. +
  9669. +static int initialised[MAX_HD_IMAGES];
  9670. +static int maxblock[MAX_HD_IMAGES];
  9671. +static unsigned long startchk[MAX_HD_IMAGES],lengthchk[MAX_HD_IMAGES];
  9672. +#ifndef NOT_YET_TESTED
  9673. +static unsigned long startaddr[MAX_HD_IMAGES][MAX_HD_BITS],
  9674. +            lengthaddr[MAX_HD_IMAGES][MAX_HD_BITS];
  9675. +#else
  9676. +static unsigned long *startaddr[MAX_HD_IMAGES],
  9677. +                    *lengthaddr[MAX_HD_IMAGES];
  9678. +#endif
  9679. +
  9680. +/* --------------------------------------------------------------------------------- */
  9681. +/*  Externally visible functions/variables
  9682. + * --------------------------------------------------------------------------------- */
  9683. +
  9684. +char arc_hd_files[MAX_HD_IMAGES][128]=
  9685. +{
  9686. +  {0,},
  9687. +  {0,},
  9688. +  {0,},
  9689. +  {0,}
  9690. +};
  9691. +
  9692. +/*
  9693. + * Get the sectors used by device 'dev'
  9694. + */
  9695. +int image_allocate_list(int dev,int devno,struct hd_struct *part)
  9696. +{
  9697. +    unsigned long chk1=0,chk2=0;
  9698. +    int i,sects=0;
  9699. +
  9700. +#ifndef TWO_HDS
  9701. +    if(dev!=0x300)
  9702. +    {
  9703. +        printk("Can't cope with >1 hd!\n");
  9704. +        return 0;
  9705. +    }
  9706. +#else
  9707. +    if(dev!=0x300 && dev!=0x340)
  9708. +    {
  9709. +        printk("Can't cope with >2 hds! (device %02X:%02X)\n",dev>>8,dev & 255);
  9710. +        return 0;
  9711. +    }
  9712. +    if(dev == 0x340)
  9713. +      devno=(devno & 0x3f) + 4;
  9714. +#endif
  9715. +
  9716. +    if(ignoring==dev)
  9717. +        return 0;
  9718. +
  9719. +    devno--;
  9720. +
  9721. +    if(devno > MAX_HD_IMAGES)
  9722. +        return 0;
  9723. +
  9724. +    if(!arc_hd_files[devno][0])
  9725. +        return 0;
  9726. +
  9727. +#ifndef NOT_YET_TESTED
  9728. +    maxblock[devno]=search_path(dev,arc_hd_files[devno],startaddr[devno],lengthaddr[devno],MAX_HD_BITS);
  9729. +#else
  9730. +    maxblock[devno]=search_path(dev,arc_hd_files[devno],startaddr[devno],lengthaddr[devno],0);
  9731. +#endif
  9732. +    if(maxblock[devno]>MAX_HD_BITS)
  9733. +        panic("image allocator: image file is too fragmented\n");
  9734. +    if(!maxblock[devno])
  9735. +        return 0;
  9736. +
  9737. +    for(i=0; i<maxblock[devno]; i++)
  9738. +    {
  9739. +        /* convert to blocks & calculate checksums */
  9740. +#define ADDR2BLOCK(x) ((x)>>9)
  9741. +        startaddr[devno][i]=ADDR2BLOCK(startaddr[devno][i]);
  9742. +        lengthaddr[devno][i]=ADDR2BLOCK(lengthaddr[devno][i]);
  9743. +        chk1^=startaddr[devno][i];
  9744. +        chk2^=lengthaddr[devno][i];
  9745. +        sects+=lengthaddr[devno][i];
  9746. +    }
  9747. +    startchk[devno]=chk1;
  9748. +    lengthchk[devno]=chk2;
  9749. +    initialised[devno]=1;
  9750. +    part->start_sect=0;
  9751. +    part->nr_sects=sects;
  9752. +
  9753. +#ifdef DEBUG
  9754. +    for(i=0;i<n;i++)
  9755. +        printk("%10X : %10X\n",start[devno][i],length[devno][i]);
  9756. +#endif
  9757. +    return 1;
  9758. +}
  9759. +
  9760. +/*
  9761. + * This is called to release all the memory with this device
  9762. + *
  9763. + * This must be called before accessing a new device
  9764. + */
  9765. +
  9766. +void image_release_dev(int dev)
  9767. +{
  9768. +  if(boot)
  9769. +  {
  9770. +    kfree_s(boot,sizeof(struct boot_block));
  9771. +    boot=NULL;
  9772. +  }
  9773. +
  9774. +  if(map)
  9775. +  {
  9776. +    vfree(map);
  9777. +    map = NULL;
  9778. +  }
  9779. +
  9780. +  ignoring=0;
  9781. +}
  9782. +
  9783. +/* 
  9784. + * This macro maps a device major/minor to the internal image file number
  9785. + */
  9786. +#ifndef TWO_HDS
  9787. +#define GET_DEV(dev) \
  9788. +    if((dev)<0x301 || (dev)>0x314) \
  9789. +    { \
  9790. +        printk("Bad device %X passed to image_file_check\n",(dev)); \
  9791. +        return 0; \
  9792. +    } \
  9793. +    (dev)=((dev)-1) & 3;
  9794. +#else
  9795. +#define GET_DEV(dev) \
  9796. +    if(((dev) & 0x33F)<0x301 || ((dev) & 0x33F)>0x314) \
  9797. +    { \
  9798. +        printk("Bad device %X passed to image_file_check\n",(dev)); \
  9799. +        return 0; \
  9800. +    } \
  9801. +    switch((dev) & 0xC0) \
  9802. +    { \
  9803. +        case 0x00: (dev)=((dev) -1) & 3;     break;\
  9804. +        case 0x40: (dev)=(((dev) -1) & 3)+4; break;\
  9805. +    }
  9806. +#endif
  9807. +
  9808. +/* 
  9809. + * This function is called to perform checks on the image file.
  9810. + *  Checks made: Image file has been initialised, and
  9811. + *     for writes, the checksums on the start/length data are correct.
  9812. + */
  9813. +int image_file_check(int dev,int cmd)
  9814. +{
  9815. +    long chk1=0,chk2=0;
  9816. +    int i;
  9817. +
  9818. +    GET_DEV(dev);
  9819. +
  9820. +    if(!initialised[dev])
  9821. +    {
  9822. +        printk("hd%c%d: %s of uninitialised image file.\n",(dev>>6)+'a',dev & 0x3f,
  9823. +          cmd==WRITE?"write":"read");
  9824. +        return 0;
  9825. +    }
  9826. +
  9827. +    if(cmd==WRITE)
  9828. +    {
  9829. +/* Check the table! Just in case. We don't want to write to a part of the HD that
  9830. + * is not allocated to us! It might be the map or something!
  9831. + */
  9832. +        for(i=0; i<maxblock[dev]; i++)
  9833. +        {
  9834. +              chk1^=startaddr[dev][i];
  9835. +              chk2^=lengthaddr[dev][i];
  9836. +        }
  9837. +        if(chk1!=startchk[dev] || chk2!=lengthchk[dev])
  9838. +        {
  9839. +            printk("hda%c%d: mapping tables corrupted on write.",
  9840. +                (dev>>6)+'a',dev & 0x3f);
  9841. +            return 0;
  9842. +        }
  9843. +    }
  9844. +    return 1;
  9845. +}
  9846. +
  9847. +/*
  9848. + * Map an image file block to a physical device returns 0 on error,
  9849. + * or the number of entries.  This is called quite often when accessing
  9850. + * image files.
  9851. + */
  9852. +int image_file_map(int dev,unsigned long reqblock,unsigned long reqlength,
  9853. +            unsigned long max_reqs,
  9854. +                    unsigned long *block,unsigned long *length)
  9855. +{
  9856. +    int i,num=0;
  9857. +    unsigned long blk=reqblock,totlen=0;
  9858. +
  9859. +    GET_DEV(dev);
  9860. +
  9861. +    for(i=0; i<maxblock[dev]; i++)
  9862. +    {
  9863. +        long remainder;
  9864. +        totlen+=lengthaddr[dev][i];
  9865. +        if(reqblock >= lengthaddr[dev][i])
  9866. +        {
  9867. +            reqblock-=lengthaddr[dev][i];
  9868. +            continue;
  9869. +        }
  9870. +        block[num]=reqblock+startaddr[dev][i];
  9871. +        remainder=reqblock+reqlength-lengthaddr[dev][i];
  9872. +        if(remainder<=0)
  9873. +        {
  9874. +            length[num]=reqlength;
  9875. +            return num+1;
  9876. +        }
  9877. +        length[num]=lengthaddr[dev][i]-reqblock;
  9878. +        if(num+1 >= max_reqs)
  9879. +            return num+1;
  9880. +        reqblock=0;
  9881. +        reqlength=remainder;
  9882. +        num++;
  9883. +    }
  9884. +
  9885. +    printk("hd%c%d: attempted read for sector %ld past end if image file at %ld.\n",
  9886. +        (dev>>6)+'a',dev & 0x3f,blk,totlen);
  9887. +        /* Should never happen! */
  9888. +    return 0;
  9889. +}
  9890. diff -r -u -N linux.orig/arch/arm/drivers/block/ll_rw_blk.c linux.arm/arch/arm/drivers/block/ll_rw_blk.c
  9891. --- linux.orig/arch/arm/drivers/block/ll_rw_blk.c    Thu Jan  1 01:00:00 1970
  9892. +++ linux.arm/arch/arm/drivers/block/ll_rw_blk.c    Fri Oct 27 23:14:45 1995
  9893. @@ -0,0 +1,568 @@
  9894. +/*
  9895. + *  linux/drivers/block/ll_rw_blk.c
  9896. + *
  9897. + * Copyright (C) 1991, 1992 Linus Torvalds
  9898. + * Copyright (C) 1994,      Karl Keyte: Added support for disk statistics
  9899. + */
  9900. +
  9901. +/*
  9902. + * This handles all read/write requests to block devices
  9903. + */
  9904. +#include <linux/sched.h>
  9905. +#include <linux/kernel.h>
  9906. +#include <linux/kernel_stat.h>
  9907. +#include <linux/errno.h>
  9908. +#include <linux/string.h>
  9909. +#include <linux/config.h>
  9910. +#include <linux/locks.h>
  9911. +#include <linux/mm.h>
  9912. +
  9913. +#include <asm/system.h>
  9914. +#include <asm/io.h>
  9915. +#include "blk.h"
  9916. +
  9917. +/*
  9918. + * The request-struct contains all necessary data
  9919. + * to load a nr of sectors into memory
  9920. + */
  9921. +static struct request all_requests[NR_REQUEST];
  9922. +
  9923. +/*
  9924. + * used to wait on when there are no free requests
  9925. + */
  9926. +struct wait_queue * wait_for_request = NULL;
  9927. +
  9928. +/* This specifies how many sectors to read ahead on the disk.  */
  9929. +
  9930. +int read_ahead[MAX_BLKDEV] = {0, };
  9931. +
  9932. +/* blk_dev_struct is:
  9933. + *    do_request-address
  9934. + *    next-request
  9935. + */
  9936. +struct blk_dev_struct blk_dev[MAX_BLKDEV] = {
  9937. +    { NULL, NULL },        /* 0 no_dev */
  9938. +    { NULL, NULL },        /* 1 dev mem */
  9939. +    { NULL, NULL },        /* 2 dev fd */
  9940. +    { NULL, NULL },        /* 3 dev ide0 or hd */
  9941. +    { NULL, NULL },        /* 4 dev ttyx */
  9942. +    { NULL, NULL },        /* 5 dev tty */
  9943. +    { NULL, NULL },        /* 6 dev lp */
  9944. +    { NULL, NULL },        /* 7 dev pipes */
  9945. +    { NULL, NULL },        /* 8 dev sd */
  9946. +    { NULL, NULL },        /* 9 dev st */
  9947. +    { NULL, NULL },        /* 10 */
  9948. +    { NULL, NULL },        /* 11 */
  9949. +    { NULL, NULL },        /* 12 */
  9950. +    { NULL, NULL },        /* 13 */
  9951. +    { NULL, NULL },        /* 14 */
  9952. +    { NULL, NULL },        /* 15 */
  9953. +    { NULL, NULL },        /* 16 */
  9954. +    { NULL, NULL },        /* 17 */
  9955. +    { NULL, NULL },        /* 18 */
  9956. +    { NULL, NULL },        /* 19 */
  9957. +    { NULL, NULL },        /* 20 */
  9958. +    { NULL, NULL },        /* 21 */
  9959. +    { NULL, NULL }        /* 22 dev ide1 */
  9960. +};
  9961. +
  9962. +/*
  9963. + * blk_size contains the size of all block-devices in units of 1024 byte
  9964. + * sectors:
  9965. + *
  9966. + * blk_size[MAJOR][MINOR]
  9967. + *
  9968. + * if (!blk_size[MAJOR]) then no minor size checking is done.
  9969. + */
  9970. +int * blk_size[MAX_BLKDEV] = { NULL, NULL, };
  9971. +
  9972. +/*
  9973. + * blksize_size contains the size of all block-devices:
  9974. + *
  9975. + * blksize_size[MAJOR][MINOR]
  9976. + *
  9977. + * if (!blksize_size[MAJOR]) then 1024 bytes is assumed.
  9978. + */
  9979. +int * blksize_size[MAX_BLKDEV] = { NULL, NULL, };
  9980. +
  9981. +/*
  9982. + * hardsect_size contains the size of the hardware sector of a device.
  9983. + *
  9984. + * hardsect_size[MAJOR][MINOR]
  9985. + *
  9986. + * if (!hardsect_size[MAJOR])
  9987. + *        then 512 bytes is assumed.
  9988. + * else
  9989. + *        sector_size is hardsect_size[MAJOR][MINOR]
  9990. + * This is currently set by some scsi device and read by the msdos fs driver
  9991. + * This might be a some uses later.
  9992. + */
  9993. +int * hardsect_size[MAX_BLKDEV] = { NULL, NULL, };
  9994. +
  9995. +/*
  9996. + * look for a free request in the first N entries.
  9997. + * NOTE: interrupts must be disabled on the way in, and will still
  9998. + *       be disabled on the way out.
  9999. + */
  10000. +static inline struct request * get_request(int n, int dev)
  10001. +{
  10002. +    static struct request *prev_found = NULL, *prev_limit = NULL;
  10003. +    register struct request *req, *limit;
  10004. +
  10005. +    if (n <= 0)
  10006. +        panic("get_request(%d): impossible!\n", n);
  10007. +
  10008. +    limit = all_requests + n;
  10009. +    if (limit != prev_limit) {
  10010. +        prev_limit = limit;
  10011. +        prev_found = all_requests;
  10012. +    }
  10013. +    req = prev_found;
  10014. +    for (;;) {
  10015. +        req = ((req > all_requests) ? req : limit) - 1;
  10016. +        if (req->dev < 0)
  10017. +            break;
  10018. +        if (req == prev_found)
  10019. +            return NULL;
  10020. +    }
  10021. +    prev_found = req;
  10022. +    req->dev = dev;
  10023. +    return req;
  10024. +}
  10025. +
  10026. +/*
  10027. + * wait until a free request in the first N entries is available.
  10028. + * NOTE: interrupts must be disabled on the way in, and will still
  10029. + *       be disabled on the way out.
  10030. + */
  10031. +static inline struct request * get_request_wait(int n, int dev)
  10032. +{
  10033. +    register struct request *req;
  10034. +
  10035. +    while ((req = get_request(n, dev)) == NULL)
  10036. +        sleep_on(&wait_for_request);
  10037. +    return req;
  10038. +}
  10039. +
  10040. +/* RO fail safe mechanism */
  10041. +
  10042. +static long ro_bits[MAX_BLKDEV][8];
  10043. +
  10044. +int is_read_only(int dev)
  10045. +{
  10046. +    int minor,major;
  10047. +
  10048. +    major = MAJOR(dev);
  10049. +    minor = MINOR(dev);
  10050. +    if (major < 0 || major >= MAX_BLKDEV) return 0;
  10051. +    return ro_bits[major][minor >> 5] & (1 << (minor & 31));
  10052. +}
  10053. +
  10054. +void set_device_ro(int dev,int flag)
  10055. +{
  10056. +    int minor,major;
  10057. +
  10058. +    major = MAJOR(dev);
  10059. +    minor = MINOR(dev);
  10060. +    if (major < 0 || major >= MAX_BLKDEV) return;
  10061. +    if (flag) ro_bits[major][minor >> 5] |= 1 << (minor & 31);
  10062. +    else ro_bits[major][minor >> 5] &= ~(1 << (minor & 31));
  10063. +}
  10064. +
  10065. +/*
  10066. + * add-request adds a request to the linked list.
  10067. + * It disables interrupts so that it can muck with the
  10068. + * request-lists in peace.
  10069. + */
  10070. +static void add_request(struct blk_dev_struct * dev, struct request * req)
  10071. +{
  10072. +    struct request * tmp;
  10073. +    short         disk_index;
  10074. +
  10075. +    switch (MAJOR(req->dev)) {
  10076. +        case SCSI_DISK_MAJOR:    disk_index = (MINOR(req->dev) & 0x0070) >> 4;
  10077. +                    if (disk_index < 4)
  10078. +                        kstat.dk_drive[disk_index]++;
  10079. +                    break;
  10080. +        case HD_MAJOR:
  10081. +        case XT_DISK_MAJOR:    disk_index = (MINOR(req->dev) & 0x0040) >> 6;
  10082. +                    kstat.dk_drive[disk_index]++;
  10083. +                    break;
  10084. +        case IDE1_MAJOR:    disk_index = ((MINOR(req->dev) & 0x0040) >> 6) + 2;
  10085. +                    kstat.dk_drive[disk_index]++;
  10086. +        default:        break;
  10087. +    }
  10088. +
  10089. +    req->next = NULL;
  10090. +    cli();
  10091. +    if (req->bh)
  10092. +        mark_buffer_clean(req->bh);
  10093. +    if (!(tmp = dev->current_request)) {
  10094. +        dev->current_request = req;
  10095. +        (dev->request_fn)();
  10096. +        sti();
  10097. +        return;
  10098. +    }
  10099. +    for ( ; tmp->next ; tmp = tmp->next) {
  10100. +        if ((IN_ORDER(tmp,req) ||
  10101. +            !IN_ORDER(tmp,tmp->next)) &&
  10102. +            IN_ORDER(req,tmp->next))
  10103. +            break;
  10104. +    }
  10105. +    req->next = tmp->next;
  10106. +    tmp->next = req;
  10107. +
  10108. +/* for SCSI devices, call request_fn unconditionally */
  10109. +    if (scsi_major(MAJOR(req->dev)))
  10110. +        (dev->request_fn)();
  10111. +
  10112. +    sti();
  10113. +}
  10114. +
  10115. +static void make_request(int major,int rw, struct buffer_head * bh)
  10116. +{
  10117. +    unsigned int sector, count;
  10118. +    struct request * req;
  10119. +    int rw_ahead, max_req;
  10120. +
  10121. +/* WRITEA/READA is special case - it is not really needed, so if the */
  10122. +/* buffer is locked, we just forget about it, else it's a normal read */
  10123. +    rw_ahead = (rw == READA || rw == WRITEA);
  10124. +    if (rw_ahead) {
  10125. +        if (bh->b_lock)
  10126. +            return;
  10127. +        if (rw == READA)
  10128. +            rw = READ;
  10129. +        else
  10130. +            rw = WRITE;
  10131. +    }
  10132. +    if (rw!=READ && rw!=WRITE) {
  10133. +        printk("Bad block dev command, must be R/W/RA/WA\n");
  10134. +        return;
  10135. +    }
  10136. +    count = bh->b_size >> 9;
  10137. +    sector = bh->b_blocknr * count;
  10138. +    if (blk_size[major])
  10139. +        if (blk_size[major][MINOR(bh->b_dev)] < (sector + count)>>1) {
  10140. +            bh->b_dirt = bh->b_uptodate = 0;
  10141. +            bh->b_req = 0;
  10142. +            return;
  10143. +        }
  10144. +    /* Uhhuh.. Nasty dead-lock possible here.. */
  10145. +    if (bh->b_lock)
  10146. +        return;
  10147. +    /* Maybe the above fixes it, and maybe it doesn't boot. Life is interesting */
  10148. +    lock_buffer(bh);
  10149. +    if ((rw == WRITE && !bh->b_dirt) || (rw == READ && bh->b_uptodate)) {
  10150. +        unlock_buffer(bh);
  10151. +        return;
  10152. +    }
  10153. +
  10154. +/* we don't allow the write-requests to fill up the queue completely:
  10155. + * we want some room for reads: they take precedence. The last third
  10156. + * of the requests are only for reads.
  10157. + */
  10158. +    max_req = (rw == READ) ? NR_REQUEST : ((NR_REQUEST*2)/3);
  10159. +
  10160. +/* big loop: look for a free request. */
  10161. +
  10162. +repeat:
  10163. +    cli();
  10164. +
  10165. +/* The scsi disk drivers and the IDE driver completely remove the request
  10166. + * from the queue when they start processing an entry.  For this reason
  10167. + * it is safe to continue to add links to the top entry for those devices.
  10168. + */
  10169. +    if ((   major == IDE0_MAJOR    /* same as HD_MAJOR */
  10170. +         || major == IDE1_MAJOR
  10171. +         || major == FLOPPY_MAJOR
  10172. +         || major == SCSI_DISK_MAJOR
  10173. +         || major == SCSI_CDROM_MAJOR)
  10174. +        && (req = blk_dev[major].current_request))
  10175. +    {
  10176. +#ifdef CONFIG_BLK_DEV_HD
  10177. +            if (major == HD_MAJOR || major == FLOPPY_MAJOR)
  10178. +#else
  10179. +        if (major == FLOPPY_MAJOR)
  10180. +#endif CONFIG_BLK_DEV_HD
  10181. +            req = req->next;
  10182. +        while (req) {
  10183. +            if (req->dev == bh->b_dev &&
  10184. +                !req->sem &&
  10185. +                req->cmd == rw &&
  10186. +                req->sector + req->nr_sectors == sector &&
  10187. +                req->nr_sectors < 244)
  10188. +            {
  10189. +                req->bhtail->b_reqnext = bh;
  10190. +                req->bhtail = bh;
  10191. +                req->nr_sectors += count;
  10192. +                mark_buffer_clean(bh);
  10193. +                sti();
  10194. +                return;
  10195. +            }
  10196. +
  10197. +            if (req->dev == bh->b_dev &&
  10198. +                !req->sem &&
  10199. +                req->cmd == rw &&
  10200. +                req->sector - count == sector &&
  10201. +                req->nr_sectors < 244)
  10202. +            {
  10203. +                    req->nr_sectors += count;
  10204. +                    bh->b_reqnext = req->bh;
  10205. +                    req->buffer = bh->b_data;
  10206. +                    req->current_nr_sectors = count;
  10207. +                    req->sector = sector;
  10208. +                mark_buffer_clean(bh);
  10209. +                    req->bh = bh;
  10210. +                    sti();
  10211. +                    return;
  10212. +            }    
  10213. +
  10214. +            req = req->next;
  10215. +        }
  10216. +    }
  10217. +
  10218. +/* find an unused request. */
  10219. +    req = get_request(max_req, bh->b_dev);
  10220. +
  10221. +/* if no request available: if rw_ahead, forget it; otherwise try again. */
  10222. +    if (! req) {
  10223. +        if (rw_ahead) {
  10224. +            sti();
  10225. +            unlock_buffer(bh);
  10226. +            return;
  10227. +        }
  10228. +        sleep_on(&wait_for_request);
  10229. +        sti();
  10230. +        goto repeat;
  10231. +    }
  10232. +
  10233. +/* we found a request. */
  10234. +    sti();
  10235. +
  10236. +/* fill up the request-info, and add it to the queue */
  10237. +    req->cmd = rw;
  10238. +    req->errors = 0;
  10239. +    req->sector = sector;
  10240. +    req->nr_sectors = count;
  10241. +    req->current_nr_sectors = count;
  10242. +    req->buffer = bh->b_data;
  10243. +    req->sem = NULL;
  10244. +    req->bh = bh;
  10245. +    req->bhtail = bh;
  10246. +    req->next = NULL;
  10247. +    add_request(major+blk_dev,req);
  10248. +}
  10249. +
  10250. +void ll_rw_page(int rw, int dev, int page, char * buffer)
  10251. +{
  10252. +    struct request * req;
  10253. +    unsigned int major = MAJOR(dev);
  10254. +    struct semaphore sem = MUTEX_LOCKED;
  10255. +
  10256. +    if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  10257. +        printk("Trying to read nonexistent block-device %04x (%d)\n",dev,page*8);
  10258. +        return;
  10259. +    }
  10260. +    if (rw!=READ && rw!=WRITE)
  10261. +        panic("Bad block dev command, must be R/W");
  10262. +    if (rw == WRITE && is_read_only(dev)) {
  10263. +        printk("Can't page to read-only device 0x%X\n",dev);
  10264. +        return;
  10265. +    }
  10266. +    cli();
  10267. +    req = get_request_wait(NR_REQUEST, dev);
  10268. +    sti();
  10269. +/* fill up the request-info, and add it to the queue */
  10270. +    req->cmd = rw;
  10271. +    req->errors = 0;
  10272. +    req->sector = page << (PAGE_SHIFT-9);
  10273. +    req->nr_sectors = 1 << (PAGE_SHIFT-9);
  10274. +    req->current_nr_sectors = 1 << (PAGE_SHIFT-9);
  10275. +    req->buffer = buffer;
  10276. +    req->sem = &sem;
  10277. +    req->bh = NULL;
  10278. +    req->next = NULL;
  10279. +    add_request(major+blk_dev,req);
  10280. +    down(&sem);
  10281. +}
  10282. +
  10283. +/* This function can be used to request a number of buffers from a block
  10284. +   device. Currently the only restriction is that all buffers must belong to
  10285. +   the same device */
  10286. +
  10287. +void ll_rw_block(int rw, int nr, struct buffer_head * bh[])
  10288. +{
  10289. +    unsigned int major;
  10290. +    struct request plug;
  10291. +    int plugged;
  10292. +    int correct_size;
  10293. +    struct blk_dev_struct * dev;
  10294. +    int i;
  10295. +
  10296. +    /* Make sure that the first block contains something reasonable */
  10297. +    while (!*bh) {
  10298. +        bh++;
  10299. +        if (--nr <= 0)
  10300. +            return;
  10301. +    };
  10302. +
  10303. +    dev = NULL;
  10304. +    if ((major = MAJOR(bh[0]->b_dev)) < MAX_BLKDEV)
  10305. +        dev = blk_dev + major;
  10306. +    if (!dev || !dev->request_fn) {
  10307. +        printk(
  10308. +    "ll_rw_block: Trying to read nonexistent block-device %04lX (%ld)\n",
  10309. +               (unsigned long) bh[0]->b_dev, bh[0]->b_blocknr);
  10310. +        goto sorry;
  10311. +    }
  10312. +
  10313. +    /* Determine correct block size for this device.  */
  10314. +    correct_size = BLOCK_SIZE;
  10315. +    if (blksize_size[major]) {
  10316. +        i = blksize_size[major][MINOR(bh[0]->b_dev)];
  10317. +        if (i)
  10318. +            correct_size = i;
  10319. +    }
  10320. +
  10321. +    /* Verify requested block sizes.  */
  10322. +    for (i = 0; i < nr; i++) {
  10323. +        if (bh[i] && bh[i]->b_size != correct_size) {
  10324. +            printk(
  10325. +            "ll_rw_block: only %d-char blocks implemented (%lu)\n",
  10326. +                   correct_size, bh[i]->b_size);
  10327. +            goto sorry;
  10328. +        }
  10329. +    }
  10330. +
  10331. +    if ((rw == WRITE || rw == WRITEA) && is_read_only(bh[0]->b_dev)) {
  10332. +        printk("Can't write to read-only device 0x%X\n",bh[0]->b_dev);
  10333. +        goto sorry;
  10334. +    }
  10335. +
  10336. +    /* If there are no pending requests for this device, then we insert
  10337. +       a dummy request for that device.  This will prevent the request
  10338. +       from starting until we have shoved all of the blocks into the
  10339. +       queue, and then we let it rip.  */
  10340. +
  10341. +    plugged = 0;
  10342. +    cli();
  10343. +    if (!dev->current_request && nr > 1) {
  10344. +        dev->current_request = &plug;
  10345. +        plug.dev = -1;
  10346. +        plug.next = NULL;
  10347. +        plugged = 1;
  10348. +    }
  10349. +    sti();
  10350. +    for (i = 0; i < nr; i++) {
  10351. +        if (bh[i]) {
  10352. +            bh[i]->b_req = 1;
  10353. +            make_request(major, rw, bh[i]);
  10354. +            if (rw == READ || rw == READA)
  10355. +                kstat.pgpgin++;
  10356. +            else
  10357. +                kstat.pgpgout++;
  10358. +        }
  10359. +    }
  10360. +    if (plugged) {
  10361. +        cli();
  10362. +        dev->current_request = plug.next;
  10363. +        (dev->request_fn)();
  10364. +        sti();
  10365. +    }
  10366. +    return;
  10367. +
  10368. +      sorry:
  10369. +    for (i = 0; i < nr; i++) {
  10370. +        if (bh[i])
  10371. +            bh[i]->b_dirt = bh[i]->b_uptodate = 0;
  10372. +    }
  10373. +    return;
  10374. +}
  10375. +
  10376. +void ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buf)
  10377. +{
  10378. +    int i;
  10379. +    int buffersize;
  10380. +    struct request * req;
  10381. +    unsigned int major = MAJOR(dev);
  10382. +    struct semaphore sem = MUTEX_LOCKED;
  10383. +
  10384. +    if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  10385. +        printk("ll_rw_swap_file: trying to swap nonexistent block-device\n");
  10386. +        return;
  10387. +    }
  10388. +
  10389. +    if (rw!=READ && rw!=WRITE) {
  10390. +        printk("ll_rw_swap: bad block dev command, must be R/W");
  10391. +        return;
  10392. +    }
  10393. +    if (rw == WRITE && is_read_only(dev)) {
  10394. +        printk("Can't swap to read-only device 0x%X\n",dev);
  10395. +        return;
  10396. +    }
  10397. +    printk("ll_rw_swap: cannot swap to a swapfile!\n");
  10398. +
  10399. +    return;
  10400. +    buffersize = PAGE_SIZE / nb;
  10401. +
  10402. +    for (i=0; i<nb; i++, buf += buffersize)
  10403. +    {
  10404. +        cli();
  10405. +        req = get_request_wait(NR_REQUEST, dev);
  10406. +        sti();
  10407. +        req->cmd = rw;
  10408. +        req->errors = 0;
  10409. +        req->sector = (b[i] * buffersize) >> 9;
  10410. +        req->nr_sectors = buffersize >> 9;
  10411. +        req->current_nr_sectors = buffersize >> 9;
  10412. +        req->buffer = buf;
  10413. +        req->sem = &sem;
  10414. +        req->bh = NULL;
  10415. +        req->next = NULL;
  10416. +        add_request(major+blk_dev,req);
  10417. +        down(&sem);
  10418. +    }
  10419. +}
  10420. +
  10421. +long blk_dev_init(long mem_start, long mem_end)
  10422. +{
  10423. +    struct request * req;
  10424. +
  10425. +    req = all_requests + NR_REQUEST;
  10426. +    while (--req >= all_requests) {
  10427. +        req->dev = -1;
  10428. +        req->next = NULL;
  10429. +    }
  10430. +    memset(ro_bits,0,sizeof(ro_bits));
  10431. +#ifdef CONFIG_BLK_DEV_HD
  10432. +    mem_start = hd_init(mem_start,mem_end);
  10433. +#endif
  10434. +#ifdef CONFIG_BLK_DEV_IDE
  10435. +    mem_start = ide_init(mem_start,mem_end);
  10436. +#endif
  10437. +#ifdef CONFIG_BLK_DEV_XD
  10438. +    mem_start = xd_init(mem_start,mem_end);
  10439. +#endif
  10440. +#ifdef CONFIG_CDU31A
  10441. +    mem_start = cdu31a_init(mem_start,mem_end);
  10442. +#endif
  10443. +#ifdef CONFIG_CDU535
  10444. +    mem_start = sony535_init(mem_start,mem_end);
  10445. +#endif
  10446. +#ifdef CONFIG_MCD
  10447. +    mem_start = mcd_init(mem_start,mem_end);
  10448. +#endif
  10449. +#ifdef CONFIG_AZTCD
  10450. +        mem_start = aztcd_init(mem_start,mem_end);
  10451. +#endif
  10452. +#ifdef CONFIG_BLK_DEV_FD
  10453. +    floppy_init();
  10454. +#endif
  10455. +#ifdef CONFIG_SBPCD
  10456. +    mem_start = sbpcd_init(mem_start, mem_end);
  10457. +#endif CONFIG_SBPCD
  10458. +    if (ramdisk_size)
  10459. +        mem_start += rd_init(mem_start, ramdisk_size*1024);
  10460. +    return mem_start;
  10461. +}
  10462. diff -r -u -N linux.orig/arch/arm/drivers/block/ll_rw_blk.c.old linux.arm/arch/arm/drivers/block/ll_rw_blk.c.old
  10463. --- linux.orig/arch/arm/drivers/block/ll_rw_blk.c.old    Thu Jan  1 01:00:00 1970
  10464. +++ linux.arm/arch/arm/drivers/block/ll_rw_blk.c.old    Fri Oct 27 23:14:50 1995
  10465. @@ -0,0 +1,519 @@
  10466. +/*
  10467. + *  linux/drivers/block/ll_rw_blk.c
  10468. + *
  10469. + * Copyright (C) 1991, 1992 Linus Torvalds
  10470. + * Copyright (C) 1994,      Karl Keyte: Added support for disk statistics
  10471. + */
  10472. +
  10473. +/*
  10474. + * This handles all read/write requests to block devices
  10475. + */
  10476. +#include <linux/sched.h>
  10477. +#include <linux/kernel.h>
  10478. +#include <linux/kernel_stat.h>
  10479. +#include <linux/errno.h>
  10480. +#include <linux/string.h>
  10481. +#include <linux/config.h>
  10482. +#include <linux/locks.h>
  10483. +
  10484. +#include <asm/system.h>
  10485. +#include <asm/io.h>
  10486. +#include <asm/pgtable.h>
  10487. +#include "blk.h"
  10488. +
  10489. +/*
  10490. + * The request-struct contains all necessary data
  10491. + * to load a nr of sectors into memory
  10492. + */
  10493. +static struct request all_requests[NR_REQUEST];
  10494. +
  10495. +/*
  10496. + * used to wait on when there are no free requests
  10497. + */
  10498. +struct wait_queue * wait_for_request = NULL;
  10499. +
  10500. +/* This specifies how many sectors to read ahead on the disk.  */
  10501. +
  10502. +int read_ahead[MAX_BLKDEV] = {0, };
  10503. +
  10504. +/* blk_dev_struct is:
  10505. + *    do_request-address
  10506. + *    next-request
  10507. + */
  10508. +struct blk_dev_struct blk_dev[MAX_BLKDEV] = {
  10509. +    { NULL, NULL },        /* no_dev */
  10510. +    { NULL, NULL },        /* dev mem */
  10511. +    { NULL, NULL },        /* dev fd */
  10512. +    { NULL, NULL },        /* dev hd */
  10513. +    { NULL, NULL },        /* dev ttyx */
  10514. +    { NULL, NULL },        /* dev tty */
  10515. +    { NULL, NULL },        /* dev lp */
  10516. +    { NULL, NULL },        /* dev pipes */
  10517. +    { NULL, NULL },        /* dev sd */
  10518. +    { NULL, NULL }        /* dev st */
  10519. +};
  10520. +
  10521. +/*
  10522. + * blk_size contains the size of all block-devices in units of 1024 byte
  10523. + * sectors:
  10524. + *
  10525. + * blk_size[MAJOR][MINOR]
  10526. + *
  10527. + * if (!blk_size[MAJOR]) then no minor size checking is done.
  10528. + */
  10529. +int * blk_size[MAX_BLKDEV] = { NULL, NULL, };
  10530. +
  10531. +/*
  10532. + * blksize_size contains the size of all block-devices:
  10533. + *
  10534. + * blksize_size[MAJOR][MINOR]
  10535. + *
  10536. + * if (!blksize_size[MAJOR]) then 1024 bytes is assumed.
  10537. + */
  10538. +int * blksize_size[MAX_BLKDEV] = { NULL, NULL, };
  10539. +
  10540. +/*
  10541. + * look for a free request in the first N entries.
  10542. + * NOTE: interrupts must be disabled on the way in, and will still
  10543. + *       be disabled on the way out.
  10544. + */
  10545. +static inline struct request * get_request(int n, int dev)
  10546. +{
  10547. +    static struct request *prev_found = NULL, *prev_limit = NULL;
  10548. +    register struct request *req, *limit;
  10549. +
  10550. +    if (n <= 0)
  10551. +        panic("get_request(%d): impossible!\n", n);
  10552. +
  10553. +    limit = all_requests + n;
  10554. +    if (limit != prev_limit) {
  10555. +        prev_limit = limit;
  10556. +        prev_found = all_requests;
  10557. +    }
  10558. +    req = prev_found;
  10559. +    for (;;) {
  10560. +        req = ((req > all_requests) ? req : limit) - 1;
  10561. +        if (req->dev < 0)
  10562. +            break;
  10563. +        if (req == prev_found)
  10564. +            return NULL;
  10565. +    }
  10566. +    prev_found = req;
  10567. +    req->dev = dev;
  10568. +    return req;
  10569. +}
  10570. +
  10571. +/*
  10572. + * wait until a free request in the first N entries is available.
  10573. + * NOTE: interrupts must be disabled on the way in, and will still
  10574. + *       be disabled on the way out.
  10575. + */
  10576. +static inline struct request * get_request_wait(int n, int dev)
  10577. +{
  10578. +    register struct request *req;
  10579. +
  10580. +    while ((req = get_request(n, dev)) == NULL)
  10581. +        sleep_on(&wait_for_request);
  10582. +    return req;
  10583. +}
  10584. +
  10585. +/* RO fail safe mechanism */
  10586. +
  10587. +static long ro_bits[MAX_BLKDEV][8];
  10588. +
  10589. +int is_read_only(int dev)
  10590. +{
  10591. +    int minor,major;
  10592. +
  10593. +    major = MAJOR(dev);
  10594. +    minor = MINOR(dev);
  10595. +    if (major < 0 || major >= MAX_BLKDEV) return 0;
  10596. +    return ro_bits[major][minor >> 5] & (1 << (minor & 31));
  10597. +}
  10598. +
  10599. +void set_device_ro(int dev,int flag)
  10600. +{
  10601. +    int minor,major;
  10602. +
  10603. +    major = MAJOR(dev);
  10604. +    minor = MINOR(dev);
  10605. +    if (major < 0 || major >= MAX_BLKDEV) return;
  10606. +    if (flag) ro_bits[major][minor >> 5] |= 1 << (minor & 31);
  10607. +    else ro_bits[major][minor >> 5] &= ~(1 << (minor & 31));
  10608. +}
  10609. +
  10610. +/*
  10611. + * add-request adds a request to the linked list.
  10612. + * It disables interrupts so that it can muck with the
  10613. + * request-lists in peace.
  10614. + */
  10615. +static void add_request(struct blk_dev_struct * dev, struct request * req)
  10616. +{
  10617. +    struct request * tmp;
  10618. +    short         disk_index;
  10619. +
  10620. +    switch (MAJOR(req->dev)) {
  10621. +        case SCSI_DISK_MAJOR:    disk_index = (MINOR(req->dev) & 0x0070) >> 4;
  10622. +                    if (disk_index < 4)
  10623. +                        kstat.dk_drive[disk_index]++;
  10624. +                    break;
  10625. +        case HD_MAJOR:
  10626. +        case XT_DISK_MAJOR:    disk_index = (MINOR(req->dev) & 0x00C0) >> 6;
  10627. +                    if (disk_index < 4)
  10628. +                        kstat.dk_drive[disk_index]++;
  10629. +                    break;
  10630. +        default:        break;
  10631. +    }
  10632. +
  10633. +    req->next = NULL;
  10634. +    cli();
  10635. +    if (req->bh)
  10636. +        mark_buffer_clean(req->bh);
  10637. +    if (!(tmp = dev->current_request)) {
  10638. +        dev->current_request = req;
  10639. +        (dev->request_fn)();
  10640. +        sti();
  10641. +        return;
  10642. +    }
  10643. +    for ( ; tmp->next ; tmp = tmp->next) {
  10644. +        if ((IN_ORDER(tmp,req) ||
  10645. +            !IN_ORDER(tmp,tmp->next)) &&
  10646. +            IN_ORDER(req,tmp->next))
  10647. +            break;
  10648. +    }
  10649. +    req->next = tmp->next;
  10650. +    tmp->next = req;
  10651. +
  10652. +/* for SCSI devices, call request_fn unconditionally */
  10653. +    if (scsi_major(MAJOR(req->dev)))
  10654. +        (dev->request_fn)();
  10655. +
  10656. +    sti();
  10657. +}
  10658. +
  10659. +static void make_request(int major,int rw, struct buffer_head * bh)
  10660. +{
  10661. +    unsigned int sector, count;
  10662. +    struct request * req;
  10663. +    int rw_ahead, max_req;
  10664. +
  10665. +/* WRITEA/READA is special case - it is not really needed, so if the */
  10666. +/* buffer is locked, we just forget about it, else it's a normal read */
  10667. +    rw_ahead = (rw == READA || rw == WRITEA);
  10668. +    if (rw_ahead) {
  10669. +        if (bh->b_lock)
  10670. +            return;
  10671. +        if (rw == READA)
  10672. +            rw = READ;
  10673. +        else
  10674. +            rw = WRITE;
  10675. +    }
  10676. +    if (rw!=READ && rw!=WRITE) {
  10677. +        printk("Bad block dev command, must be R/W/RA/WA\n");
  10678. +        return;
  10679. +    }
  10680. +    count = bh->b_size >> 9;
  10681. +    sector = bh->b_blocknr * count;
  10682. +    if (blk_size[major])
  10683. +        if (blk_size[major][MINOR(bh->b_dev)] < (sector + count)>>1) {
  10684. +            bh->b_dirt = bh->b_uptodate = 0;
  10685. +            bh->b_req = 0;
  10686. +            return;
  10687. +        }
  10688. +    lock_buffer(bh);
  10689. +    if ((rw == WRITE && !bh->b_dirt) || (rw == READ && bh->b_uptodate)) {
  10690. +        unlock_buffer(bh);
  10691. +        return;
  10692. +    }
  10693. +
  10694. +/* we don't allow the write-requests to fill up the queue completely:
  10695. + * we want some room for reads: they take precedence. The last third
  10696. + * of the requests are only for reads.
  10697. + */
  10698. +    max_req = (rw == READ) ? NR_REQUEST : ((NR_REQUEST*2)/3);
  10699. +
  10700. +/* big loop: look for a free request. */
  10701. +
  10702. +repeat:
  10703. +    cli();
  10704. +
  10705. +/* The scsi disk drivers completely remove the request from the queue when
  10706. + * they start processing an entry.  For this reason it is safe to continue
  10707. + * to add links to the top entry for scsi devices.
  10708. + */
  10709. +    if ((major == HD_MAJOR
  10710. +         || major == FLOPPY_MAJOR
  10711. +         || major == SCSI_DISK_MAJOR
  10712. +         || major == SCSI_CDROM_MAJOR)
  10713. +        && (req = blk_dev[major].current_request))
  10714. +    {
  10715. +            if (major == HD_MAJOR || major == FLOPPY_MAJOR)
  10716. +            req = req->next;
  10717. +        while (req) {
  10718. +            if (req->dev == bh->b_dev &&
  10719. +                !req->sem &&
  10720. +                req->cmd == rw &&
  10721. +                req->sector + req->nr_sectors == sector &&
  10722. +                req->nr_sectors < 244)
  10723. +            {
  10724. +                req->bhtail->b_reqnext = bh;
  10725. +                req->bhtail = bh;
  10726. +                req->nr_sectors += count;
  10727. +                mark_buffer_clean(bh);
  10728. +                sti();
  10729. +                return;
  10730. +            }
  10731. +
  10732. +            if (req->dev == bh->b_dev &&
  10733. +                !req->sem &&
  10734. +                req->cmd == rw &&
  10735. +                req->sector - count == sector &&
  10736. +                req->nr_sectors < 244)
  10737. +            {
  10738. +                    req->nr_sectors += count;
  10739. +                    bh->b_reqnext = req->bh;
  10740. +                    req->buffer = bh->b_data;
  10741. +                    req->current_nr_sectors = count;
  10742. +                    req->sector = sector;
  10743. +                mark_buffer_clean(bh);
  10744. +                    req->bh = bh;
  10745. +                    sti();
  10746. +                    return;
  10747. +            }
  10748. +
  10749. +            req = req->next;
  10750. +        }
  10751. +    }
  10752. +
  10753. +/* find an unused request. */
  10754. +    req = get_request(max_req, bh->b_dev);
  10755. +
  10756. +/* if no request available: if rw_ahead, forget it; otherwise try again. */
  10757. +    if (! req) {
  10758. +        if (rw_ahead) {
  10759. +            sti();
  10760. +            unlock_buffer(bh);
  10761. +            return;
  10762. +        }
  10763. +        sleep_on(&wait_for_request);
  10764. +        sti();
  10765. +        goto repeat;
  10766. +    }
  10767. +
  10768. +/* we found a request. */
  10769. +    sti();
  10770. +
  10771. +/* fill up the request-info, and add it to the queue */
  10772. +    req->cmd = rw;
  10773. +    req->errors = 0;
  10774. +    req->sector = sector;
  10775. +    req->nr_sectors = count;
  10776. +    req->current_nr_sectors = count;
  10777. +    req->buffer = bh->b_data;
  10778. +    req->sem = NULL;
  10779. +    req->bh = bh;
  10780. +    req->bhtail = bh;
  10781. +    req->next = NULL;
  10782. +    add_request(major+blk_dev,req);
  10783. +}
  10784. +
  10785. +void ll_rw_page(int rw, int dev, int page, char * buffer)
  10786. +{
  10787. +    struct request * req;
  10788. +    unsigned int major = MAJOR(dev);
  10789. +    struct semaphore sem = MUTEX_LOCKED;
  10790. +
  10791. +    if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  10792. +        printk("Trying to read nonexistent block-device %04x (%d)\n",dev,page*8);
  10793. +        return;
  10794. +    }
  10795. +    if (rw!=READ && rw!=WRITE)
  10796. +        panic("Bad block dev command, must be R/W");
  10797. +    if (rw == WRITE && is_read_only(dev)) {
  10798. +        printk("Can't page to read-only device 0x%X\n",dev);
  10799. +        return;
  10800. +    }
  10801. +    cli();
  10802. +    req = get_request_wait(NR_REQUEST, dev);
  10803. +    sti();
  10804. +/* fill up the request-info, and add it to the queue */
  10805. +    req->cmd = rw;
  10806. +    req->errors = 0;
  10807. +    req->sector = page << (PAGE_SHIFT-9);
  10808. +    req->nr_sectors = 1 << (PAGE_SHIFT-9);
  10809. +    req->current_nr_sectors = 1 << (PAGE_SHIFT-9);
  10810. +    req->buffer = buffer;
  10811. +    req->sem = &sem;
  10812. +    req->bh = NULL;
  10813. +    req->next = NULL;
  10814. +    add_request(major+blk_dev,req);
  10815. +    down(&sem);
  10816. +}
  10817. +
  10818. +/* This function can be used to request a number of buffers from a block
  10819. +   device. Currently the only restriction is that all buffers must belong to
  10820. +   the same device */
  10821. +
  10822. +void ll_rw_block(int rw, int nr, struct buffer_head * bh[])
  10823. +{
  10824. +    unsigned int major;
  10825. +    struct request plug;
  10826. +    int plugged;
  10827. +    int correct_size;
  10828. +    struct blk_dev_struct * dev;
  10829. +    int i;
  10830. +
  10831. +    /* Make sure that the first block contains something reasonable */
  10832. +    while (!*bh) {
  10833. +        bh++;
  10834. +        if (--nr <= 0)
  10835. +            return;
  10836. +    };
  10837. +
  10838. +    dev = NULL;
  10839. +    if ((major = MAJOR(bh[0]->b_dev)) < MAX_BLKDEV)
  10840. +        dev = blk_dev + major;
  10841. +    if (!dev || !dev->request_fn) {
  10842. +        printk(
  10843. +    "ll_rw_block: Trying to read nonexistent block-device %04lX (%ld)\n",
  10844. +               (unsigned long) bh[0]->b_dev, bh[0]->b_blocknr);
  10845. +        goto sorry;
  10846. +    }
  10847. +
  10848. +    /* Determine correct block size for this device.  */
  10849. +    correct_size = BLOCK_SIZE;
  10850. +    if (blksize_size[major]) {
  10851. +        i = blksize_size[major][MINOR(bh[0]->b_dev)];
  10852. +        if (i)
  10853. +            correct_size = i;
  10854. +    }
  10855. +
  10856. +    /* Verify requested block sizes.  */
  10857. +    for (i = 0; i < nr; i++) {
  10858. +        if (bh[i] && bh[i]->b_size != correct_size) {
  10859. +            printk(
  10860. +            "ll_rw_block: only %d-char blocks implemented (%lu)\n",
  10861. +                   correct_size, bh[i]->b_size);
  10862. +            goto sorry;
  10863. +        }
  10864. +    }
  10865. +
  10866. +    if ((rw == WRITE || rw == WRITEA) && is_read_only(bh[0]->b_dev)) {
  10867. +        printk("Can't write to read-only device 0x%X\n",bh[0]->b_dev);
  10868. +        goto sorry;
  10869. +    }
  10870. +
  10871. +    /* If there are no pending requests for this device, then we insert
  10872. +       a dummy request for that device.  This will prevent the request
  10873. +       from starting until we have shoved all of the blocks into the
  10874. +       queue, and then we let it rip.  */
  10875. +
  10876. +    plugged = 0;
  10877. +    cli();
  10878. +    if (!dev->current_request && nr > 1) {
  10879. +        dev->current_request = &plug;
  10880. +        plug.dev = -1;
  10881. +        plug.next = NULL;
  10882. +        plugged = 1;
  10883. +    }
  10884. +    sti();
  10885. +    for (i = 0; i < nr; i++) {
  10886. +        if (bh[i]) {
  10887. +            bh[i]->b_req = 1;
  10888. +            make_request(major, rw, bh[i]);
  10889. +            if (rw == READ || rw == READA)
  10890. +                kstat.pgpgin++;
  10891. +            else
  10892. +                kstat.pgpgout++;
  10893. +        }
  10894. +    }
  10895. +    if (plugged) {
  10896. +        cli();
  10897. +        dev->current_request = plug.next;
  10898. +        (dev->request_fn)();
  10899. +        sti();
  10900. +    }
  10901. +    return;
  10902. +
  10903. +      sorry:
  10904. +    for (i = 0; i < nr; i++) {
  10905. +        if (bh[i])
  10906. +            bh[i]->b_dirt = bh[i]->b_uptodate = 0;
  10907. +    }
  10908. +    return;
  10909. +}
  10910. +
  10911. +void ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buf)
  10912. +{
  10913. +    int i;
  10914. +    int buffersize;
  10915. +    struct request * req;
  10916. +    unsigned int major = MAJOR(dev);
  10917. +    struct semaphore sem = MUTEX_LOCKED;
  10918. +
  10919. +    if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  10920. +        printk("ll_rw_swap_file: trying to swap nonexistent block-device\n");
  10921. +        return;
  10922. +    }
  10923. +
  10924. +    if (rw!=READ && rw!=WRITE) {
  10925. +        printk("ll_rw_swap: bad block dev command, must be R/W");
  10926. +        return;
  10927. +    }
  10928. +    if (rw == WRITE && is_read_only(dev)) {
  10929. +        printk("Can't swap to read-only device 0x%X\n",dev);
  10930. +        return;
  10931. +    }
  10932. +    printk("ll_rw_swap: cannot swap to a swapfile!\n");
  10933. +    return;
  10934. +
  10935. +    buffersize = PAGE_SIZE / nb;
  10936. +
  10937. +    for (i=0; i<nb; i++, buf += buffersize)
  10938. +    {
  10939. +        cli();
  10940. +        req = get_request_wait(NR_REQUEST, dev);
  10941. +        sti();
  10942. +        req->cmd = rw;
  10943. +        req->errors = 0;
  10944. +        req->sector = (b[i] * buffersize) >> 9;
  10945. +        req->nr_sectors = buffersize >> 9;
  10946. +        req->current_nr_sectors = buffersize >> 9;
  10947. +        req->buffer = buf;
  10948. +        req->sem = &sem;
  10949. +        req->bh = NULL;
  10950. +        req->next = NULL;
  10951. +        add_request(major+blk_dev,req);
  10952. +        down(&sem);
  10953. +    }
  10954. +}
  10955. +
  10956. +long blk_dev_init(long mem_start, long mem_end)
  10957. +{
  10958. +    struct request * req;
  10959. +
  10960. +    req = all_requests + NR_REQUEST;
  10961. +    while (--req >= all_requests) {
  10962. +        req->dev = -1;
  10963. +        req->next = NULL;
  10964. +    }
  10965. +    memset(ro_bits,0,sizeof(ro_bits));
  10966. +#ifdef CONFIG_BLK_DEV_HD
  10967. +    mem_start = hd_init(mem_start,mem_end);
  10968. +#endif
  10969. +#ifdef CONFIG_BLK_DEV_XD
  10970. +    mem_start = xd_init(mem_start,mem_end);
  10971. +#endif
  10972. +#ifdef CONFIG_CDU31A
  10973. +    mem_start = cdu31a_init(mem_start,mem_end);
  10974. +#endif
  10975. +#ifdef CONFIG_MCD
  10976. +    mem_start = mcd_init(mem_start,mem_end);
  10977. +#endif
  10978. +#ifdef CONFIG_SBPCD
  10979. +    mem_start = sbpcd_init(mem_start, mem_end);
  10980. +#endif CONFIG_SBPCD
  10981. +    if (ramdisk_size)
  10982. +        mem_start += rd_init(mem_start, ramdisk_size*1024);
  10983. +    return mem_start;
  10984. +}
  10985. diff -r -u -N linux.orig/arch/arm/drivers/block/mfmhd.c linux.arm/arch/arm/drivers/block/mfmhd.c
  10986. --- linux.orig/arch/arm/drivers/block/mfmhd.c    Thu Jan  1 01:00:00 1970
  10987. +++ linux.arm/arch/arm/drivers/block/mfmhd.c    Fri Oct 27 23:14:51 1995
  10988. @@ -0,0 +1,770 @@
  10989. +#ifdef MODULE
  10990. +#include <linux/module.h>
  10991. +#include <linux/version.h>
  10992. +#endif
  10993. +
  10994. +#include <linux/config.h>
  10995. +#include <linux/sched.h>
  10996. +#include <linux/fs.h>
  10997. +#include <linux/kernel.h>
  10998. +#include <linux/timer.h>
  10999. +#include <linux/tqueue.h>
  11000. +#include <linux/mm.h>
  11001. +
  11002. +#include <linux/xd.h>
  11003. +#include <linux/errno.h>
  11004. +#include <linux/genhd.h>
  11005. +#include <linux/major.h>
  11006. +
  11007. +#include <asm/system.h>
  11008. +#include <asm/io.h>
  11009. +#include <asm/segment.h>
  11010. +#include <asm/dma.h>
  11011. +
  11012. +#include <asm/ecard.h>
  11013. +
  11014. +#define MFM_DISK_MAJOR    13
  11015. +#undef  XT_DISK_MAJOR
  11016. +#define XT_DISK_MAJOR    -1
  11017. +#define MAJOR_NR    MFM_DISK_MAJOR
  11018. +#include "blk.h"
  11019. +
  11020. +XD_INFO mfm_info[XD_MAXDRIVES];
  11021. +
  11022. +#define DEBUG
  11023. +
  11024. +#define MFM_COMMAND (mfm_addr + 0)
  11025. +#define MFM_DATAOUT (mfm_addr + 1)
  11026. +#define MFM_STATUS  (mfm_addr + 8)
  11027. +#define MFM_DATAIN  (mfm_addr + 9)
  11028. +
  11029. +static void mfm_geninit (void);
  11030. +static int  mfm_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg);
  11031. +static int  mfm_open (struct inode *inode,struct file *file);
  11032. +static void mfm_release (struct inode *inode, struct file *file);
  11033. +static void mfm_interrupt_handler (int, struct pt_regs *);
  11034. +static void mfm_seek (void);
  11035. +static void mfm_unexpected_interrupt (void);
  11036. +static void mfm_request (void);
  11037. +static int  mfm_reread_partitions (int dev);
  11038. +static void mfm_request (void);
  11039. +
  11040. +#define mfm_init xd_init
  11041. +
  11042. +static struct hd_struct mfm[XD_MAXDRIVES << 6];
  11043. +static int mfm_sizes[XD_MAXDRIVES << 6], mfm_access[XD_MAXDRIVES] = { 0, 0 };
  11044. +static int mfm_blocksizes[XD_MAXDRIVES << 6];
  11045. +static unsigned char mfm_valid[XD_MAXDRIVES] = { -1, };
  11046. +static struct wait_queue *mfm_wait_open = NULL;
  11047. +
  11048. +static int mfm_irq;        /* Interrupt number */
  11049. +static int mfm_addr;        /* Controller address */
  11050. +static int mfm_drives = 0;    /* drives available */
  11051. +static int mfm_status = 0;    /* interrupt status */
  11052. +static char mfm_busy = 0;    /* mfm busy */
  11053. +static int *errors;
  11054. +
  11055. +static struct rawcmd
  11056. +{
  11057. +  unsigned int flags;
  11058. +  unsigned int dev;
  11059. +  unsigned int cylinder;
  11060. +  unsigned int head;
  11061. +  unsigned int sector;
  11062. +  unsigned int cmdtype;
  11063. +  unsigned int cmdcode;
  11064. +  unsigned char cmddata[16];
  11065. +  unsigned int cmdlen;
  11066. +} raw_cmd;
  11067. +
  11068. +#define NEED_SEEK 1
  11069. +unsigned char result[16];
  11070. +unsigned char resultlen;
  11071. +
  11072. +static struct cont
  11073. +{
  11074. +    void (*interrupt)(void);/* interrupt handler */
  11075. +    void (*error)(void);    /* error handler */
  11076. +    void (*redo)(void);    /* redo handler */
  11077. +    void (*done)(int st);    /* done handler */
  11078. +} *cont = NULL;
  11079. +
  11080. +static struct drvparam
  11081. +{
  11082. +    int cylinder;
  11083. +    unsigned int nocylinders;
  11084. +    unsigned int lowcurrentcylinder;
  11085. +    unsigned int precompcylinder;
  11086. +    unsigned char noheads;
  11087. +    unsigned char nosectors;
  11088. +    struct
  11089. +    {
  11090. +        char recal;
  11091. +        char report;
  11092. +        char abort;
  11093. +    } errors;
  11094. +} mfm_drive_param[8] =
  11095. +{
  11096. +    { -1, 616, 616, 129, 4, 32, { 0,0,1 } },
  11097. +    { -1, 616, 616, 129, 4, 32, { 0,0,1 } },
  11098. +    { -1, 616, 616, 129, 4, 32, { 0,0,1 } },
  11099. +    { -1, 616, 616, 129, 4, 32, { 0,0,1 } },
  11100. +    { -1, 616, 616, 129, 4, 32, { 0,0,1 } },
  11101. +    { -1, 616, 616, 129, 4, 32, { 0,0,1 } },
  11102. +    { -1, 616, 616, 129, 4, 32, { 0,0,1 } },
  11103. +    { -1, 616, 616, 129, 4, 32, { 0,0,1 } }
  11104. +};
  11105. +
  11106. +#define MFM_DRV_PARAM mfm_drive_param[raw_cmd.dev]
  11107. +
  11108. +struct tq_struct mfm_tq =
  11109. +{ 0, 0, (void (*) (void *)) mfm_unexpected_interrupt, 0 };
  11110. +
  11111. +#define NO_TRACK -1
  11112. +#define NEED_1_RECAL -2
  11113. +#define NEED_2_RECAL -3
  11114. +
  11115. +
  11116. +/* ------------------------------------------------------------------------------------------ */
  11117. +/*
  11118. + * From the HD63463 data sheet from Hitachi Ltd.
  11119. + */
  11120. +
  11121. +#define CMD_ABT        0xF0        /* Abort */
  11122. +#define CMD_SPC        0xE8        /* Specify */
  11123. +#define CMD_TST        0xE0        /* Test */
  11124. +#define CMD_RCLB    0xC8        /* Recalibrate */
  11125. +#define CMD_SEK        0xC0        /* Seek */
  11126. +#define CMD_WFS        0xAB        /* Write Format Skew */
  11127. +#define CMD_WFM        0xA3        /* Write Format */
  11128. +#define CMD_MTB        0x90        /* Memory to buffer */
  11129. +#define CMD_CMPD    0x88        /* Compare data */
  11130. +#define CMD_WD        0x87        /* Write data */
  11131. +#define CMD_RED        0x70        /* Read erroneous data */
  11132. +#define CMD_RIS        0x68        /* Read ID skew */
  11133. +#define CMD_FID        0x61        /* Find ID */
  11134. +#define CMD_RID        0x60        /* Read ID */
  11135. +#define CMD_BTM        0x50        /* Buffer to memory */
  11136. +#define CMD_CKD        0x48        /* Check data */
  11137. +#define CMD_RD        0x40        /* Read data */
  11138. +#define CMD_OPBW    0x38        /* Open buffer write */
  11139. +#define CMD_OPBR    0x30        /* Open buffer read */
  11140. +#define CMD_CKV        0x28        /* Check drive */
  11141. +#define CMD_CKE        0x20        /* Check ECC */
  11142. +#define CMD_POD        0x18        /* Polling disable */
  11143. +#define CMD_POL        0x10        /* Polling enable */
  11144. +#define CMD_RCAL    0x08        /* Recall */
  11145. +
  11146. +#define STAT_BSY    0x8000        /* Busy */
  11147. +#define STAT_CPR    0x4000        /* Command Parameter Rejection */
  11148. +#define STAT_CED    0x2000        /* Command end */
  11149. +#define STAT_SED    0x1000        /* Seek end */
  11150. +#define STAT_DER    0x0800        /* Drive error */
  11151. +#define STAT_ABN    0x0400        /* Abnormal end */
  11152. +#define STAT_POL    0x0200        /* Polling */
  11153. +
  11154. +/* ------------------------------------------------------------------------------------------ */
  11155. +
  11156. +static struct gendisk mfm_gendisk = {
  11157. +    MAJOR_NR,    /* Major number */
  11158. +    "mfm",        /* Major name */
  11159. +    6,        /* Bits to shift to get real from partition */
  11160. +    1 << 6,        /* Number of partitions per real */
  11161. +    XD_MAXDRIVES,    /* maximum number of real */
  11162. +    mfm_geninit,    /* init function */
  11163. +    mfm,        /* hd struct */
  11164. +    mfm_sizes,    /* block sizes */
  11165. +    0,        /* number */
  11166. +    (void *)mfm_info,/* internal */
  11167. +    NULL        /* next */
  11168. +};
  11169. +
  11170. +static struct file_operations mfm_fops = {
  11171. +    NULL,            /* lseek - default */
  11172. +    block_read,        /* read - general block-dev read */
  11173. +    block_write,        /* write - general block-dev write */
  11174. +    NULL,            /* readdir - bad */
  11175. +    NULL,            /* select */
  11176. +    mfm_ioctl,        /* ioctl */
  11177. +    NULL,            /* mmap */
  11178. +    mfm_open,        /* open */
  11179. +    mfm_release,        /* release */
  11180. +    block_fsync        /* fsync */
  11181. +};
  11182. +
  11183. +static struct expansion_card *ecs;
  11184. +static int mfm_prods[] = { 0x000b };
  11185. +static int mfm_manus[] = { 0x0000 };
  11186. +
  11187. +unsigned long mfm_init (unsigned long mem_start, unsigned long mem_end)
  11188. +{
  11189. +    ecs = ecard_find(0, sizeof(mfm_prods), mfm_prods, mfm_manus);
  11190. +    if(!ecs)
  11191. +        return mem_start;
  11192. +
  11193. +    mfm_irq = ecs->irq;
  11194. +    mfm_addr= ((((int)ecs->r_podaddr) & 0x03eff000) + 0x2000)>>2;
  11195. +
  11196. +    ecard_claim(ecs);
  11197. +
  11198. +    printk("mfm: controller found at address %X, interrupt %d\n", mfm_addr, mfm_irq);
  11199. +
  11200. +    if(register_blkdev(MAJOR_NR, "mfm", &mfm_fops)) {
  11201. +        printk("mfm_init: unable to get major number %d\n", MAJOR_NR);
  11202. +        return mem_start;
  11203. +    }
  11204. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  11205. +    read_ahead[MAJOR_NR] = 8; /* 8 sector (4kB) read ahread */
  11206. +#ifndef MODULE
  11207. +    mfm_gendisk.next = gendisk_head;
  11208. +    gendisk_head = & mfm_gendisk;
  11209. +#endif
  11210. +
  11211. +    return mem_start;
  11212. +}
  11213. +
  11214. +static int mfm_initdrives (void)
  11215. +{
  11216. +    mfm_info[0].heads = 4;
  11217. +    mfm_info[0].cylinders = 615;
  11218. +    mfm_info[0].sectors = 32;
  11219. +    mfm_info[0].control = 0;
  11220. +    return 1;
  11221. +}
  11222. +
  11223. +static void mfm_geninit (void)
  11224. +{
  11225. +    int i;
  11226. +
  11227. +    mfm_drives = mfm_initdrives();
  11228. +    printk("mfm: detected %d hard drive%s\n", mfm_drives, mfm_drives == 1?"":"s");
  11229. +    for(i = 0; i < mfm_drives; i++)
  11230. +        printk("mfm%d: heads = %d, cylinders = %d, sectors = %d\n", i,
  11231. +             mfm_info[i].heads, mfm_info[i].cylinders, mfm_info[i].sectors);
  11232. +
  11233. +    if(request_irq(mfm_irq, mfm_interrupt_handler, SA_INTERRUPT, "MFM harddisk"))
  11234. +        printk("mfm: unable to get IRQ%d\n", mfm_irq);
  11235. +
  11236. +    outw(0x80, mfm_addr + (0x1000 >> 2));
  11237. +
  11238. +    for(i = 0; i < mfm_drives; i++) {
  11239. +        mfm[i << 6].nr_sects = mfm_info[i].heads * mfm_info[i].cylinders *
  11240. +                mfm_info[i].sectors;
  11241. +        mfm[i << 6].start_sect = 0;
  11242. +        mfm_valid[i] = 1;
  11243. +    }
  11244. +    mfm_gendisk.nr_real = mfm_drives;
  11245. +
  11246. +    for(i=0; i<(XD_MAXDRIVES << 6); i++)
  11247. +        mfm_blocksizes[i] = 1024;
  11248. +    blksize_size[MAJOR_NR] = mfm_blocksizes;
  11249. +}
  11250. +
  11251. +static int mfm_open (struct inode *inode,struct file *file)
  11252. +{
  11253. +    int dev = DEVICE_NR(MINOR(inode->i_rdev));
  11254. +
  11255. +    if (dev < mfm_drives) {
  11256. +        while (!mfm_valid[dev])
  11257. +            sleep_on(&mfm_wait_open);
  11258. +
  11259. +        mfm_access[dev]++;
  11260. +
  11261. +        return (0);
  11262. +    }
  11263. +    else
  11264. +        return (-ENODEV);
  11265. +}
  11266. +
  11267. +static int mfm_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
  11268. +{
  11269. +    XD_GEOMETRY *geometry = (XD_GEOMETRY *) arg;
  11270. +    int dev = DEVICE_NR(MINOR(inode->i_rdev)),err;
  11271. +
  11272. +    if (inode && (dev < mfm_drives))
  11273. +        switch (cmd) {
  11274. +            case HDIO_GETGEO:
  11275. +                if (arg) {
  11276. +                    if ((err = verify_area(VERIFY_WRITE, geometry, sizeof(*geometry))))
  11277. +                        return (err);
  11278. +                    put_fs_byte(mfm_info[dev].heads,(char *) &geometry->heads);
  11279. +                    put_fs_byte(mfm_info[dev].sectors,(char *) &geometry->sectors);
  11280. +                    put_fs_word(mfm_info[dev].cylinders,(short *) &geometry->cylinders);
  11281. +                    put_fs_long(mfm[MINOR(inode->i_rdev)].start_sect,(long *) &geometry->start);
  11282. +
  11283. +                    return (0);
  11284. +                }
  11285. +                break;
  11286. +            case BLKRASET:
  11287. +              if(!suser())  return -EACCES;
  11288. +              if(!inode->i_rdev) return -EINVAL;
  11289. +              if(arg > 0xff) return -EINVAL;
  11290. +              read_ahead[MAJOR(inode->i_rdev)] = arg;
  11291. +              return 0;
  11292. +            case BLKGETSIZE:
  11293. +                if (arg) {
  11294. +                    if ((err = verify_area(VERIFY_WRITE,(long *) arg,sizeof(long))))
  11295. +                        return (err);
  11296. +                    put_fs_long(mfm[MINOR(inode->i_rdev)].nr_sects,(long *) arg);
  11297. +
  11298. +                    return (0);
  11299. +                }
  11300. +                break;
  11301. +            case BLKFLSBUF:
  11302. +                if(!suser())  return -EACCES;
  11303. +                if(!inode->i_rdev) return -EINVAL;
  11304. +                fsync_dev(inode->i_rdev);
  11305. +                invalidate_buffers(inode->i_rdev);
  11306. +                return 0;
  11307. +
  11308. +            case BLKRRPART:
  11309. +                return (mfm_reread_partitions(inode->i_rdev));
  11310. +            RO_IOCTLS(inode->i_rdev,arg);
  11311. +        }
  11312. +    return (-EINVAL);
  11313. +}
  11314. +
  11315. +static void mfm_release (struct inode *inode, struct file *file)
  11316. +{
  11317. +    int dev = DEVICE_NR(MINOR(inode->i_rdev));
  11318. +
  11319. +    if (dev < mfm_drives) {
  11320. +        sync_dev(dev);
  11321. +        mfm_access[dev]--;
  11322. +    }
  11323. +}
  11324. +
  11325. +static int mfm_reread_partitions (int dev)
  11326. +{
  11327. +    int target = DEVICE_NR(MINOR(dev)),start = target << mfm_gendisk.minor_shift,partition;
  11328. +
  11329. +    cli();
  11330. +
  11331. +    mfm_valid[target] = (mfm_access[target] != 1);
  11332. +
  11333. +    sti();
  11334. +
  11335. +    if (mfm_valid[target])
  11336. +        return -EBUSY;
  11337. +
  11338. +    for (partition = mfm_gendisk.max_p - 1; partition >= 0; partition--) {
  11339. +        sync_dev(MAJOR_NR << 8 | start | partition);
  11340. +        invalidate_inodes(MAJOR_NR << 8 | start | partition);
  11341. +        invalidate_buffers(MAJOR_NR << 8 | start | partition);
  11342. +        mfm_gendisk.part[start + partition].start_sect = 0;
  11343. +        mfm_gendisk.part[start + partition].nr_sects = 0;
  11344. +    };
  11345. +
  11346. +    mfm_gendisk.part[start].nr_sects = mfm_info[target].heads *
  11347. +        mfm_info[target].cylinders * mfm_info[target].sectors;
  11348. +    resetup_one_dev(&mfm_gendisk,target);
  11349. +
  11350. +    mfm_valid[target] = 1;
  11351. +    wake_up(&mfm_wait_open);
  11352. +
  11353. +    return 0;
  11354. +}
  11355. +
  11356. +static void print_status (void)
  11357. +{
  11358. +    char *error;
  11359. +    static char *errors[] =
  11360. +    { "no error",
  11361. +      "command aborted",
  11362. +      "invalid command",
  11363. +      "parameter error",
  11364. +      "not initialised",
  11365. +      "rejected TEST",
  11366. +      "no useld",
  11367. +      "write fault",
  11368. +      "not ready",
  11369. +      "no scp",
  11370. +      "in seek",
  11371. +      "invalid NCA",
  11372. +      "invalid step rate",
  11373. +      "seek error",
  11374. +      "over run",
  11375. +      "invalid PHA",
  11376. +      "data field EEC error",
  11377. +      "data field CRC error",
  11378. +      "error corrected",
  11379. +      "data field fatal error",
  11380. +      "no data am",
  11381. +      "not hit",
  11382. +      "ID field CRC error",
  11383. +      "time over",
  11384. +      "no ID am",
  11385. +      "not writable"
  11386. +    };
  11387. +    if(result[1] < 0x65)
  11388. +        error = errors[result[1] >> 2];
  11389. +    else
  11390. +        error = "unknown";
  11391. +    printk("(");
  11392. +    if(mfm_status & STAT_BSY)
  11393. +        printk("BSY ");
  11394. +    if(mfm_status & STAT_CPR)
  11395. +        printk("CPR ");
  11396. +    if(mfm_status & STAT_CED)
  11397. +        printk("CED ");
  11398. +    if(mfm_status & STAT_SED)
  11399. +        printk("SED ");
  11400. +    if(mfm_status & STAT_DER)
  11401. +        printk("DER ");
  11402. +    if(mfm_status & STAT_ABN)
  11403. +        printk("ABN ");
  11404. +    if(mfm_status & STAT_POL)
  11405. +        printk("POL ");
  11406. +    printk(") SSB = %X (%s)\n", result[1], error);
  11407. +
  11408. +}
  11409. +
  11410. +/* ------------------------------------------------------------------------------------- */
  11411. +
  11412. +static void issue_command (int command, unsigned char *cmdb, int len)
  11413. +{
  11414. +    int status;
  11415. +#ifdef DEBUG
  11416. +    int i;
  11417. +    printk("issue_command: %02X: ",command);
  11418. +    for(i=0; i<len; i++)
  11419. +      printk("%02X ", cmdb[i]);
  11420. +    printk("\n");
  11421. +#endif
  11422. +
  11423. +    do {
  11424. +        status = inw(MFM_STATUS);
  11425. +    } while(status & (STAT_BSY|STAT_POL));
  11426. +    if(status & STAT_CPR)
  11427. +    {
  11428. +        outw(CMD_RCAL, MFM_COMMAND);
  11429. +        while(inw(MFM_STATUS) & STAT_BSY);
  11430. +    }
  11431. +
  11432. +    while(len > 0)
  11433. +    {
  11434. +        outw(cmdb[1] | (cmdb[0] << 8), MFM_DATAOUT);
  11435. +        len -= 2;
  11436. +        cmdb += 2;
  11437. +    }
  11438. +    outw(command, MFM_COMMAND);
  11439. +}
  11440. +
  11441. +static void wait_for_completion (void)
  11442. +{
  11443. +    while((mfm_status = inw(MFM_STATUS)) & STAT_BSY);
  11444. +}
  11445. +
  11446. +/* ------------------------------------------------------------------------------------- */
  11447. +
  11448. +static void mfm_rw_intr (void)
  11449. +{
  11450. +    printk("mfm_rw_intr...\n");
  11451. +    if (cont)
  11452. +    {
  11453. +        cont->done(1);
  11454. +    }
  11455. +    mfm_request();
  11456. +}
  11457. +
  11458. +static void mfm_setup_rw (void)
  11459. +{
  11460. +    printk("setting up for rw...\n");
  11461. +#if 1
  11462. +    SET_INTR(mfm_rw_intr);
  11463. +    issue_command(raw_cmd.cmdcode, raw_cmd.cmddata, raw_cmd.cmdlen);
  11464. +#else
  11465. +    if(cont)
  11466. +    {
  11467. +        cont->done(0);
  11468. +        cont->redo();
  11469. +    }
  11470. +#endif
  11471. +}
  11472. +
  11473. +static void mfm_recal_intr (void)
  11474. +{
  11475. +    printk("recal intr - status = ");
  11476. +    print_status();
  11477. +    if(mfm_status & (STAT_DER|STAT_ABN)) {
  11478. +        printk("recal failed\n");
  11479. +        MFM_DRV_PARAM.cylinder = NEED_2_RECAL;
  11480. +        if(cont)
  11481. +        {
  11482. +            cont->error();
  11483. +            cont->redo();
  11484. +        }
  11485. +        return;
  11486. +    }
  11487. +    if(mfm_status & STAT_SED) {
  11488. +        issue_command(CMD_POD, NULL, 0);
  11489. +        MFM_DRV_PARAM.cylinder = 0;
  11490. +        mfm_seek();
  11491. +        return;
  11492. +    }
  11493. +    if(mfm_status & STAT_CED) {
  11494. +        SET_INTR(mfm_recal_intr);
  11495. +        issue_command(CMD_POL, NULL, 0);
  11496. +        return;
  11497. +    }
  11498. +    printk("recal: unknown status\n");
  11499. +}
  11500. +
  11501. +static void mfm_seek_intr (void)
  11502. +{
  11503. +    printk("seek intr - status = ");
  11504. +    print_status();
  11505. +    if(mfm_status & (STAT_DER|STAT_ABN)) {
  11506. +        printk("seek failed\n");
  11507. +        MFM_DRV_PARAM.cylinder = NEED_2_RECAL;
  11508. +        if(cont)
  11509. +        {
  11510. +            cont->error();
  11511. +            cont->redo();
  11512. +        }
  11513. +        return;
  11514. +    }
  11515. +    if(mfm_status & STAT_SED) {
  11516. +        issue_command(CMD_POD, NULL, 0);
  11517. +        MFM_DRV_PARAM.cylinder = raw_cmd.cylinder;
  11518. +        mfm_seek();
  11519. +        return;
  11520. +    }
  11521. +    if(mfm_status & STAT_CED) {
  11522. +        SET_INTR(mfm_seek_intr);
  11523. +        issue_command(CMD_POL, NULL, 0);
  11524. +        return;
  11525. +    }
  11526. +    printk("seek: unknown status\n");
  11527. +}
  11528. +
  11529. +static void mfm_specify (void)
  11530. +{
  11531. +    unsigned char cmdb[16];
  11532. +    printk("specify...\n");
  11533. +    cmdb[0] = 0x1F;
  11534. +    cmdb[1] = 0xC3;
  11535. +    cmdb[2] = 0x16;
  11536. +    cmdb[3] = 0x02;
  11537. +    cmdb[4] = 0xFC | ((MFM_DRV_PARAM.nocylinders - 1) >> 8);
  11538. +    cmdb[5] = MFM_DRV_PARAM.nocylinders - 1;
  11539. +    cmdb[6] = MFM_DRV_PARAM.noheads - 1;
  11540. +    cmdb[7] = MFM_DRV_PARAM.nosectors - 1;
  11541. +    cmdb[8] = 0xA9;
  11542. +    cmdb[9] = 0x0A;
  11543. +    cmdb[10]= 0x0D;
  11544. +    cmdb[11]= 0x0C;
  11545. +    cmdb[12]= (MFM_DRV_PARAM.precompcylinder - 1) >> 8;
  11546. +    cmdb[13]= MFM_DRV_PARAM.precompcylinder - 1;
  11547. +    cmdb[14]= (MFM_DRV_PARAM.lowcurrentcylinder - 1) >> 8;
  11548. +    cmdb[15]= MFM_DRV_PARAM.lowcurrentcylinder - 1;
  11549. +
  11550. +    issue_command(CMD_SPC, cmdb, 16);
  11551. +    wait_for_completion();
  11552. +}
  11553. +
  11554. +static void mfm_seek (void)
  11555. +{
  11556. +    unsigned char cmdb[4];
  11557. +    printk("seeking...\n");
  11558. +    if(MFM_DRV_PARAM.cylinder < 0) {
  11559. +        cmdb[0] = raw_cmd.dev + 1;
  11560. +        cmdb[1] = raw_cmd.head;
  11561. +
  11562. +        SET_INTR(mfm_recal_intr);
  11563. +        issue_command(CMD_RCLB, cmdb, 2);
  11564. +        return;
  11565. +    }
  11566. +    mfm_specify();
  11567. +    if(MFM_DRV_PARAM.cylinder != raw_cmd.cylinder)
  11568. +    {
  11569. +        cmdb[0] = raw_cmd.dev + 1;
  11570. +        cmdb[1] = raw_cmd.head;
  11571. +        cmdb[2] = raw_cmd.cylinder >> 8;
  11572. +        cmdb[3] = raw_cmd.cylinder;
  11573. +
  11574. +        SET_INTR(mfm_seek_intr);
  11575. +        issue_command(CMD_SEK, cmdb, 4);
  11576. +    }
  11577. +    else
  11578. +        mfm_setup_rw();
  11579. +}
  11580. +
  11581. +static void mfm_initialise (void)
  11582. +{
  11583. +    printk("init...\n");
  11584. +    if(raw_cmd.flags & NEED_SEEK)
  11585. +        mfm_seek();
  11586. +    else
  11587. +        mfm_setup_rw();
  11588. +}
  11589. +
  11590. +/* ------------------------------------------------------------------------------------- */
  11591. +
  11592. +static void request_done(int uptodate)
  11593. +{
  11594. +    if(!CURRENT) {
  11595. +        printk("mfm: request list destroyed\n");
  11596. +        return;
  11597. +    }
  11598. +    if(uptodate) {
  11599. +        end_request (1);
  11600. +    }
  11601. +    else {
  11602. +        end_request (0);
  11603. +    }
  11604. +}
  11605. +
  11606. +static void error_handler (void)
  11607. +{
  11608. +    int i;
  11609. +    printk("error detected... status = ");
  11610. +    print_status();
  11611. +    (*errors) ++;
  11612. +    if(*errors > MFM_DRV_PARAM.errors.abort)
  11613. +        cont->done(0);
  11614. +    if(*errors > MFM_DRV_PARAM.errors.recal)
  11615. +        MFM_DRV_PARAM.cylinder = NEED_2_RECAL;
  11616. +}
  11617. +
  11618. +static void rw_interrupt(void)
  11619. +{
  11620. +}
  11621. +
  11622. +static struct cont rw_cont ={
  11623. +    rw_interrupt,
  11624. +    error_handler,
  11625. +    mfm_request,
  11626. +    request_done
  11627. +};
  11628. +
  11629. +static void mfm_request (void)
  11630. +{
  11631. +    unsigned int dev, block, nsect, track;
  11632. +
  11633. +    if(CURRENT && CURRENT->dev < 0)
  11634. +        return;
  11635. +
  11636. +    while(1){
  11637. +        sti();
  11638. +
  11639. +        INIT_REQUEST;
  11640. +        dev = MINOR(CURRENT->dev);
  11641. +        block = CURRENT->sector;
  11642. +        nsect = CURRENT->nr_sectors;
  11643. +
  11644. +        if(dev >= (mfm_drives << 6) ||
  11645. +            block >= mfm[dev].nr_sects || ((block+nsect) > mfm[dev].nr_sects)) {
  11646. +#ifdef DEBUG
  11647. +            if(dev >= (mfm_drives << 6))
  11648. +                printk("mfm: bad minor number: device=0x%04x\n", CURRENT->dev);
  11649. +            else
  11650. +                printk("mfm%c: bad access: block=%d, count=%d\n", (dev>>6)+'a',
  11651. +                    block, nsect);
  11652. +#endif
  11653. +            end_request(0);
  11654. +            continue;
  11655. +        }
  11656. +        block += mfm[dev].start_sect;
  11657. +
  11658. +        if(CURRENT->cmd != READ && CURRENT->cmd != WRITE)
  11659. +        {
  11660. +            printk("unknown mfm-command %d\n", CURRENT->cmd);
  11661. +            end_request(0);
  11662. +            continue;
  11663. +        }
  11664. +
  11665. +        dev >>= 6;
  11666. +
  11667. +        track = block / mfm_info[dev].sectors;
  11668. +        raw_cmd.flags        = NEED_SEEK;
  11669. +        raw_cmd.dev        = dev;
  11670. +        raw_cmd.sector        = block % mfm_info[dev].sectors;
  11671. +        raw_cmd.head        = track % mfm_info[dev].heads;
  11672. +        raw_cmd.cylinder    = track / mfm_info[dev].heads;
  11673. +        raw_cmd.cmdtype     = CURRENT->cmd;
  11674. +        raw_cmd.cmdcode     = CURRENT->cmd == WRITE ? CMD_WD : CMD_RD;
  11675. +        raw_cmd.cmddata[0]    = dev;
  11676. +        raw_cmd.cmddata[1]    = raw_cmd.head;
  11677. +        raw_cmd.cmddata[2]    = raw_cmd.cylinder >> 8;
  11678. +        raw_cmd.cmddata[3]    = raw_cmd.cylinder;
  11679. +        raw_cmd.cmddata[4]    = raw_cmd.head;
  11680. +        raw_cmd.cmddata[5]    = raw_cmd.sector;
  11681. +        raw_cmd.cmddata[6]    = nsect >> 8;
  11682. +        raw_cmd.cmddata[7]    = nsect;
  11683. +        raw_cmd.cmdlen        = 8;
  11684. +
  11685. +#ifdef DEBUG
  11686. +        printk("mfm%c: %sing: CHS=%d/%d/%d, sectors=%d, buffer=0x%08lx (%p)\n",
  11687. +            raw_cmd.dev+'a', (CURRENT->cmd == READ)?"read":"writ",
  11688. +            raw_cmd.cylinder,
  11689. +            raw_cmd.head,
  11690. +            raw_cmd.sector, nsect, (unsigned long)CURRENT->buffer, CURRENT);
  11691. +#endif
  11692. +        cont = &rw_cont;
  11693. +        errors = &(CURRENT->errors);
  11694. +        mfm_tq.routine = (void (*)(void *))mfm_initialise;
  11695. +        queue_task(&mfm_tq, &tq_timer);
  11696. +        break;
  11697. +    }
  11698. +}
  11699. +
  11700. +static void do_mfm_request (void)
  11701. +{
  11702. +    mfm_request();
  11703. +}
  11704. +
  11705. +static void mfm_unexpected_interrupt (void)
  11706. +{
  11707. +    printk("mfm: unexpected interrupt - status = ");
  11708. +    print_status();
  11709. +}
  11710. +
  11711. +static void mfm_interrupt_handler (int unused, struct pt_regs *regs)
  11712. +{
  11713. +    int i;
  11714. +    void (*handler)(void) = DEVICE_INTR;
  11715. +
  11716. +    CLEAR_INTR;
  11717. +    mfm_status = inw(MFM_STATUS);
  11718. +
  11719. +    if((mfm_status & (STAT_CPR|STAT_BSY)) == STAT_CPR)
  11720. +    {
  11721. +        int len = 0;
  11722. +        while(len <16)
  11723. +        {
  11724. +            int in;
  11725. +            in = inw(MFM_DATAIN);
  11726. +            result[len++] = in>>8;
  11727. +            result[len++] = in;
  11728. +        }
  11729. +    }
  11730. +
  11731. +    outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  11732. +
  11733. +    if(!handler) {
  11734. +        mfm_unexpected_interrupt();
  11735. +        return;
  11736. +    }
  11737. +    mfm_tq.routine = (void (*)(void *))handler;
  11738. +    queue_task_irq(&mfm_tq, &tq_timer);
  11739. +}
  11740. +
  11741. +#ifdef MODULE
  11742. +
  11743. +char kernel_version[] = UTS_RELEASE;
  11744. +
  11745. +int init_module (void)
  11746. +{
  11747. +    mfm_init(0, 0);
  11748. +    mfm_geninit();
  11749. +    return 0;
  11750. +}
  11751. +
  11752. +void cleanup_module (void)
  11753. +{
  11754. +    if (ecs)
  11755. +        ecard_release(ecs);
  11756. +}
  11757. +    
  11758. +#endif
  11759. diff -r -u -N linux.orig/arch/arm/drivers/block/ramdisk.c linux.arm/arch/arm/drivers/block/ramdisk.c
  11760. --- linux.orig/arch/arm/drivers/block/ramdisk.c    Thu Jan  1 01:00:00 1970
  11761. +++ linux.arm/arch/arm/drivers/block/ramdisk.c    Fri Oct 27 23:14:45 1995
  11762. @@ -0,0 +1,234 @@
  11763. +/*
  11764. + *  linux/kernel/blk_drv/ramdisk.c
  11765. + *
  11766. + *  Written by Theodore Ts'o, 12/2/91
  11767. + *
  11768. + * Modifications by Fred N. van Kempen to allow for bootable root
  11769. + * disks (which are used in LINUX/Pro).  Also some cleanups.  03/03/93
  11770. + */
  11771. +
  11772. +
  11773. +#include <linux/sched.h>
  11774. +#include <linux/minix_fs.h>
  11775. +#include <linux/ext2_fs.h>
  11776. +#include <linux/fs.h>
  11777. +#include <linux/kernel.h>
  11778. +#include <linux/string.h>
  11779. +#include <linux/mm.h>
  11780. +
  11781. +#include <asm/system.h>
  11782. +#include <asm/segment.h>
  11783. +
  11784. +#define MAJOR_NR  MEM_MAJOR
  11785. +#include "blk.h"
  11786. +
  11787. +#define RAMDISK_MINOR    1
  11788. +
  11789. +extern void wait_for_keypress(void);
  11790. +
  11791. +char    *rd_start;
  11792. +int    rd_length = 0;
  11793. +static int rd_blocksizes[2] = {0, 0};
  11794. +
  11795. +static void do_rd_request(void)
  11796. +{
  11797. +    int    len;
  11798. +    char    *addr;
  11799. +
  11800. +repeat:
  11801. +    INIT_REQUEST;
  11802. +    addr = rd_start + (CURRENT->sector << 9);
  11803. +    len = CURRENT->current_nr_sectors << 9;
  11804. +
  11805. +    if ((MINOR(CURRENT->dev) != RAMDISK_MINOR) ||
  11806. +        (addr+len > rd_start+rd_length)) {
  11807. +        end_request(0);
  11808. +        goto repeat;
  11809. +    }
  11810. +    if (CURRENT-> cmd == WRITE) {
  11811. +        (void ) memcpy(addr,
  11812. +                  CURRENT->buffer,
  11813. +                  len);
  11814. +    } else if (CURRENT->cmd == READ) {
  11815. +        (void) memcpy(CURRENT->buffer, 
  11816. +                  addr,
  11817. +                  len);
  11818. +    } else
  11819. +        panic("RAMDISK: unknown RAM disk command !\n");
  11820. +    end_request(1);
  11821. +    goto repeat;
  11822. +}
  11823. +
  11824. +static struct file_operations rd_fops = {
  11825. +    NULL,            /* lseek - default */
  11826. +    block_read,        /* read - general block-dev read */
  11827. +    block_write,        /* write - general block-dev write */
  11828. +    NULL,            /* readdir - bad */
  11829. +    NULL,            /* select */
  11830. +    NULL,            /* ioctl */
  11831. +    NULL,            /* mmap */
  11832. +    NULL,            /* no special open code */
  11833. +    NULL,            /* no special release code */
  11834. +    block_fsync        /* fsync */
  11835. +};
  11836. +
  11837. +/*
  11838. + * Returns amount of memory which needs to be reserved.
  11839. + */
  11840. +long rd_init(long mem_start, int length)
  11841. +{
  11842. +    int    i;
  11843. +    char    *cp;
  11844. +
  11845. +    if (register_blkdev(MEM_MAJOR,"rd",&rd_fops)) {
  11846. +        printk("RAMDISK: Unable to get major %d.\n", MEM_MAJOR);
  11847. +        return 0;
  11848. +    }
  11849. +    blk_dev[MEM_MAJOR].request_fn = DEVICE_REQUEST;
  11850. +    rd_start = (char *) mem_start;
  11851. +    rd_length = length;
  11852. +    cp = rd_start;
  11853. +    for (i=0; i < length; i++)
  11854. +        *cp++ = '\0';
  11855. +
  11856. +    for(i=0;i<2;i++) rd_blocksizes[i] = 1024;
  11857. +    blksize_size[MAJOR_NR] = rd_blocksizes;
  11858. +
  11859. +    return(length);
  11860. +}
  11861. +
  11862. +static void do_load(void)
  11863. +{
  11864. +    struct buffer_head *bh;
  11865. +    struct super_block {
  11866. +      union
  11867. +      {
  11868. +        char minix [sizeof (struct minix_super_block)];
  11869. +        char ext2 [sizeof (struct ext2_super_block)];
  11870. +      } record;
  11871. +    } sb;
  11872. +    struct minix_super_block *minixsb =
  11873. +        (struct minix_super_block *)&sb;
  11874. +    struct ext2_super_block *ext2sb =
  11875. +        (struct ext2_super_block *)&sb;
  11876. +    int        block, tries;
  11877. +    int        i = 1;
  11878. +    int        nblocks;
  11879. +    char        *cp;
  11880. +    
  11881. +    /*
  11882. +     * Check for a super block on the diskette.
  11883. +     * The old-style boot/root diskettes had their RAM image
  11884. +     * starting at block 512 of the boot diskette.  LINUX/Pro
  11885. +     * uses the entire diskette as a file system, so in that
  11886. +     * case, we have to look at block 0.  Be intelligent about
  11887. +     * this, and check both... - FvK
  11888. +     */
  11889. +    for (tries = 0; tries < 1000; tries += 512) {
  11890. +        block = tries;
  11891. +        bh = breada(ROOT_DEV,block+1,BLOCK_SIZE, 0,  PAGE_SIZE);
  11892. +        if (!bh) {
  11893. +            printk("RAMDISK: I/O error while looking for super block!\n");
  11894. +            return;
  11895. +        }
  11896. +
  11897. +        /* This is silly- why do we require it to be a MINIX FS? */
  11898. +        *((struct super_block *) &sb) =
  11899. +            *((struct super_block *) bh->b_data);
  11900. +        brelse(bh);
  11901. +
  11902. +
  11903. +        /* Try Minix */
  11904. +        nblocks = -1;
  11905. +        if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
  11906. +            minixsb->s_magic == MINIX_SUPER_MAGIC2) {
  11907. +            printk("RAMDISK: Minix filesystem found at block %d\n",
  11908. +                block);
  11909. +            nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
  11910. +        }
  11911. +
  11912. +        /* Try ext2 */
  11913. +        if (nblocks == -1 && (ext2sb->s_magic ==
  11914. +            EXT2_PRE_02B_MAGIC ||
  11915. +            ext2sb->s_magic == EXT2_SUPER_MAGIC))
  11916. +            {
  11917. +            printk("RAMDISK: Ext2 filesystem found at block %d\n",
  11918. +                block);
  11919. +            nblocks = ext2sb->s_blocks_count;
  11920. +        }
  11921. +
  11922. +        if (nblocks == -1)
  11923. +        {
  11924. +            printk("RAMDISK: trying old-style RAM image.\n");
  11925. +            continue;
  11926. +        }
  11927. +
  11928. +        if (nblocks > (rd_length >> BLOCK_SIZE_BITS)) {
  11929. +            printk("RAMDISK: image too big! (%d/%d blocks)\n",
  11930. +                    nblocks, rd_length >> BLOCK_SIZE_BITS);
  11931. +            return;
  11932. +        }
  11933. +        printk("RAMDISK: Loading %d blocks into RAM disk", nblocks);
  11934. +
  11935. +        /* We found an image file system.  Load it into core! */
  11936. +        cp = rd_start;
  11937. +        while (nblocks) {
  11938. +            if (nblocks > 2) 
  11939. +                    bh = breada(ROOT_DEV, block, BLOCK_SIZE, 0,  PAGE_SIZE);
  11940. +            else
  11941. +                bh = bread(ROOT_DEV, block, BLOCK_SIZE);
  11942. +            if (!bh) {
  11943. +                printk("RAMDISK: I/O error on block %d, aborting!\n", 
  11944. +                block);
  11945. +                return;
  11946. +            }
  11947. +            (void) memcpy(cp, bh->b_data, BLOCK_SIZE);
  11948. +            brelse(bh);
  11949. +            if (!(nblocks-- & 15)) printk(".");
  11950. +            cp += BLOCK_SIZE;
  11951. +            block++;
  11952. +            i++;
  11953. +        }
  11954. +        printk("\ndone\n");
  11955. +
  11956. +        /* We loaded the file system image.  Prepare for mounting it. */
  11957. +        ROOT_DEV = ((MEM_MAJOR << 8) | RAMDISK_MINOR);
  11958. +        return;
  11959. +    }
  11960. +}
  11961. +
  11962. +/*
  11963. + * If the root device is the RAM disk, try to load it.
  11964. + * In order to do this, the root device is originally set to the
  11965. + * floppy, and we later change it to be RAM disk.
  11966. + */
  11967. +void rd_load(void)
  11968. +{
  11969. +    struct inode inode;
  11970. +    struct file filp;
  11971. +
  11972. +    /* If no RAM disk specified, give up early. */
  11973. +    if (!rd_length)
  11974. +        return;
  11975. +    printk("RAMDISK: %d bytes, starting at 0x%x\n",
  11976. +            rd_length, (int) rd_start);
  11977. +
  11978. +    /* If we are doing a diskette boot, we might have to pre-load it. */
  11979. +    if (MAJOR(ROOT_DEV) != FLOPPY_MAJOR)
  11980. +        return;
  11981. +
  11982. +    /* for Slackware install disks */
  11983. +    printk(KERN_NOTICE "VFS: Insert ramdisk floppy and press ENTER\n");
  11984. +    wait_for_keypress();
  11985. +
  11986. +    memset(&filp, 0, sizeof(filp));
  11987. +    memset(&inode, 0, sizeof(inode));
  11988. +    inode.i_rdev = ROOT_DEV;
  11989. +    filp.f_mode = 1; /* read only */
  11990. +    filp.f_inode = &inode;
  11991. +    if(blkdev_open(&inode, &filp) == 0 ){
  11992. +        do_load();
  11993. +        if(filp.f_op && filp.f_op->release)
  11994. +            filp.f_op->release(&inode,&filp);
  11995. +    }
  11996. +}
  11997. diff -r -u -N linux.orig/arch/arm/drivers/char/Makefile linux.arm/arch/arm/drivers/char/Makefile
  11998. --- linux.orig/arch/arm/drivers/char/Makefile    Thu Jan  1 01:00:00 1970
  11999. +++ linux.arm/arch/arm/drivers/char/Makefile    Fri Oct 27 23:14:21 1995
  12000. @@ -0,0 +1,81 @@
  12001. +#
  12002. +# Makefile for the kernel character device drivers.
  12003. +#
  12004. +# Note! Dependencies are done automagically by 'make dep', which also
  12005. +# removes any old dependencies. DON'T put your own dependencies here
  12006. +# unless it's something special (ie not a .c file).
  12007. +#
  12008. +# Note 2! The CFLAGS definitions are now inherited from the
  12009. +# parent makes..
  12010. +#
  12011. +
  12012. +.c.s:
  12013. +    $(CC) $(CFLAGS) -S $<
  12014. +.s.o:
  12015. +    $(AS) -c -o $*.o $<
  12016. +.c.o:
  12017. +    $(CC) $(CFLAGS) -c $<
  12018. +
  12019. +OBJS  = tty_io.o n_tty.o console.o keyboard.o serial.o \
  12020. +    tty_ioctl.o pty.o vt.o mem.o \
  12021. +    defkeymap.o consolemap.o arcmouse.o ptr.o iic.o \
  12022. +    vc_screen.o
  12023. +# vesa_blank.o selection.o
  12024. +
  12025. +SRCS  = tty_io.c n_tty.c console.c keyboard.c serial.c \
  12026. +    tty_ioctl.c pty.c vt.c mem.c \
  12027. +    defkeymap.c consolemap.c arcmouse.c ptr.c iic.c \
  12028. +    vc_screen.c
  12029. +#vc_screen.c \
  12030. +#    defkeymap.c vesa_blank.c selection.c
  12031. +
  12032. +
  12033. +ifdef CONFIG_PRINTER
  12034. +OBJS := $(OBJS) lp.o
  12035. +SRCS := $(SRCS) lp.c
  12036. +else
  12037. +MODULES := $(MODULES) lp.o
  12038. +endif
  12039. +
  12040. +ifdef CONFIG_ARMMOUSE
  12041. +OBJS := $(OBJS) arcmouse.o
  12042. +SRCS := $(SRCS) arcmouse.c
  12043. +M = 1
  12044. +endif
  12045. +
  12046. +ifdef M
  12047. +OBJS := $(OBJS) mouse.o
  12048. +SRCS := $(SRCS) mouse.c
  12049. +endif
  12050. +
  12051. +all: char.a
  12052. +
  12053. +char.a: $(OBJS)
  12054. +    $(AR) rcs char.a $(OBJS)
  12055. +    sync    
  12056. +
  12057. +ifdef MODULES
  12058. +
  12059. +modules: $(MODULES)
  12060. +    (cd ../../modules;for i in $(MODULES); do ln -sf ../drivers/char/$$i .; done)
  12061. +
  12062. +else
  12063. +
  12064. +modules:
  12065. +
  12066. +endif
  12067. +
  12068. +dep:
  12069. +    $(CPP) -M $(SRCS) > .depend
  12070. +ifdef MODULES
  12071. +    $(CPP) -M -DMODULE $(MODULES:.o=.c) >> .depend
  12072. +endif
  12073. +
  12074. +dummy:
  12075. +
  12076. +#
  12077. +# include a dependency file if one exists
  12078. +#
  12079. +ifeq (.depend,$(wildcard .depend))
  12080. +include .depend
  12081. +endif
  12082. diff -r -u -N linux.orig/arch/arm/drivers/char/arcmouse.c linux.arm/arch/arm/drivers/char/arcmouse.c
  12083. --- linux.orig/arch/arm/drivers/char/arcmouse.c    Thu Jan  1 01:00:00 1970
  12084. +++ linux.arm/arch/arm/drivers/char/arcmouse.c    Fri Oct 27 23:14:22 1995
  12085. @@ -0,0 +1,140 @@
  12086. +#include <linux/config.h>
  12087. +#include <linux/kernel.h>
  12088. +#include <linux/sched.h>
  12089. +#include <linux/errno.h>
  12090. +
  12091. +#include <asm/system.h>
  12092. +#include <asm/segment.h>
  12093. +
  12094. +#pragma no_check_stack
  12095. +
  12096. +char   mouse_buttons;
  12097. +int    mouse_dxpos;
  12098. +int    mouse_dypos;
  12099. +int    mouse_present;
  12100. +char   mouse_ready;
  12101. +char   mouse_active;
  12102. +struct wait_queue *mouse_wait;
  12103. +
  12104. +void arch_mouse_close(struct inode *inode,struct file *file)
  12105. +{
  12106. +  mouse_active=0;
  12107. +  mouse_ready =0;
  12108. +  return;
  12109. +}
  12110. +
  12111. +int arch_mouse_open(struct inode *inode,struct file *file)
  12112. +{
  12113. +  unsigned long flags;
  12114. +
  12115. +  if(!mouse_present)
  12116. +    return -EINVAL;
  12117. +
  12118. +  if(mouse_active)
  12119. +    return -EBUSY;
  12120. +
  12121. +  save_flags(flags);
  12122. +  cli();
  12123. +
  12124. +  mouse_active =1;
  12125. +  mouse_ready  =0;
  12126. +  mouse_dxpos  =0;
  12127. +  mouse_dypos  =0;
  12128. +  mouse_buttons=0;
  12129. +
  12130. +  restore_flags(flags);
  12131. +
  12132. +  return 0;
  12133. +}
  12134. +
  12135. +int arch_mouse_read(struct inode *inode,struct file *file,char *buffer,int count)
  12136. +{
  12137. +  unsigned long flags;
  12138. +  int dxpos,dypos,i,buttons;
  12139. +
  12140. +  if(count<3)
  12141. +    return -EINVAL;
  12142. +
  12143. +  if(!mouse_ready)
  12144. +    return -EAGAIN;
  12145. +
  12146. +  save_flags(flags);
  12147. +  cli();
  12148. +
  12149. +  dxpos=mouse_dxpos;
  12150. +  dypos=mouse_dypos;
  12151. +  buttons=mouse_buttons^7;
  12152. +
  12153. +  if(dxpos<-127)
  12154. +    dxpos=-127;
  12155. +  if(dxpos>127)
  12156. +    dxpos=127;
  12157. +  if(dypos<-127)
  12158. +    dypos=-127;
  12159. +  if(dypos>127)
  12160. +    dypos=127;
  12161. +
  12162. +  mouse_dxpos-=dxpos;
  12163. +  mouse_dypos-=dypos;
  12164. +  mouse_ready=0;
  12165. +
  12166. +  restore_flags(flags);
  12167. +
  12168. +  put_fs_byte((char)buttons|0x80,buffer);
  12169. +  put_fs_byte((char)dxpos,buffer+1);
  12170. +  put_fs_byte((char)dypos,buffer+2);
  12171. +  for(i=3;i<count;i++)
  12172. +    put_fs_byte(0x00,buffer+i);
  12173. +
  12174. +  return i;
  12175. +}
  12176. +
  12177. +int arch_mouse_write(struct inode *inode,struct file *file,char *buffer,int count)
  12178. +{
  12179. +  return -EINVAL;
  12180. +}
  12181. +
  12182. +int arch_mouse_select(struct inode *inode,struct file *file,int sel_type,select_table *wait)
  12183. +{
  12184. +  if(sel_type!=SEL_IN)
  12185. +    return 0;
  12186. +
  12187. +  if(mouse_ready)
  12188. +    return 1;
  12189. +
  12190. +  select_wait(&mouse_wait,wait);
  12191. +
  12192. +  return 0;
  12193. +}
  12194. +
  12195. +struct file_operations arch_mouse_fops=
  12196. +{
  12197. +  NULL,            /* mouse_seek */
  12198. +  arch_mouse_read,
  12199. +  arch_mouse_write,
  12200. +  NULL,            /* mouse_readdir */
  12201. +  arch_mouse_select,
  12202. +  NULL,            /* mouse_ioctl */
  12203. +  NULL,            /* mouse_mmap */
  12204. +  arch_mouse_open,
  12205. +  arch_mouse_close
  12206. +};
  12207. +
  12208. +unsigned long arch_mouse_init(unsigned long kmem_start)
  12209. +{
  12210. +  unsigned long flags;
  12211. +
  12212. +  save_flags(flags);
  12213. +  cli();
  12214. +
  12215. +  mouse_buttons=0;
  12216. +  mouse_dxpos  =0;
  12217. +  mouse_dypos  =0;
  12218. +  mouse_present=1;
  12219. +  mouse_ready  =0;
  12220. +  mouse_active =0;
  12221. +  mouse_wait   =NULL;
  12222. +
  12223. +  restore_flags(flags);
  12224. +  return kmem_start;
  12225. +}
  12226. diff -r -u -N linux.orig/arch/arm/drivers/char/console.c linux.arm/arch/arm/drivers/char/console.c
  12227. --- linux.orig/arch/arm/drivers/char/console.c    Thu Jan  1 01:00:00 1970
  12228. +++ linux.arm/arch/arm/drivers/char/console.c    Fri Oct 27 23:14:30 1995
  12229. @@ -0,0 +1,2663 @@
  12230. +/*
  12231. + * linux/arch/arm/drivers/char/console.c
  12232. + */
  12233. +
  12234. +/*
  12235. + *  arcscr.c
  12236. + *
  12237. + * This module exports the console io functions:
  12238. + *
  12239. + *    'int vc_allocate(unsigned int console)'
  12240. + *    'int vc_cons_allocated(unsigned int console)'
  12241. + *    'int vc_resize(unsigned long lines,unsigned long cols)'
  12242. + *    'void vc_disallocate(unsigned int currcons)'
  12243. + *
  12244. + *    'long con_init(long)'
  12245. + * S    'int con_open(struct tty_struct *tty,struct file *filp)'
  12246. + * S    'void con_write(struct tty_struct *tty)'
  12247. + * S    'void console_print(const char *b)'
  12248. + *    'void update_screen(int new_console)'
  12249. + *
  12250. + *    'void blank_screen(void)'
  12251. + *    'void unblank_screen(void)'
  12252. + *    'void poke_blanked_console(void)'
  12253. + *    'void scrollback(int lines)'            *
  12254. + *    'void scrollfront(int lines)'            *
  12255. + *    'int do_screendump(int arg)'
  12256. + *
  12257. + *    'int con_get_font(char *)'
  12258. + *    'int con_set_font(char *)'
  12259. + *    'int con_get_trans(char *)'
  12260. + *    'int con_set_trans(char *)'
  12261. + *
  12262. + *    'int set_selection(const int arg)'        *
  12263. + *    'int paste_selection(struct tty_struct *tty)'    *
  12264. + *    'int sel_loadlut(const int arg)'        *
  12265. + *    'int mouse_reporting(void)'            *
  12266. + *
  12267. + */
  12268. +
  12269. +#define BLANK 0x0020
  12270. +
  12271. +/* A bitmap for codes <32. A bit of 1 indicates that the code
  12272. + * corresponding to that bit number invokes a special action
  12273. + * (such as cursor movement) and should not be displayed as a
  12274. + * glyph unless the disp_ctrl mode is explicitly enabled.
  12275. + */
  12276. +#define CTRL_ACTION 0xd00ff80
  12277. + 
  12278. +#include <linux/config.h>
  12279. +#include <linux/sched.h>
  12280. +#include <linux/timer.h>
  12281. +#include <linux/interrupt.h>
  12282. +#include <linux/tty.h>
  12283. +#include <linux/tty_flip.h>
  12284. +#include <linux/kernel.h>
  12285. +#include <linux/errno.h>
  12286. +#include <linux/kd.h>
  12287. +#include <linux/major.h>
  12288. +#include <linux/mm.h>
  12289. +#include <linux/malloc.h>
  12290. +
  12291. +#include <asm/segment.h>
  12292. +#include <asm/irq-no.h>
  12293. +
  12294. +#include "kbd_kern.h"
  12295. +#include "vt_kern.h"
  12296. +#include "consolemap.h"
  12297. +
  12298. +/* ARM Extensions */
  12299. +extern void memc_write (int reg, int val);
  12300. +extern void vidc_write (int reg, int val);
  12301. +extern void ll_char_write(unsigned long ps, int ch, unsigned char forec,
  12302. +             unsigned char backc, unsigned char flgs);
  12303. +extern void memfastset (void *ptr, unsigned long word, int length);
  12304. +extern void prints (const char *, ...);
  12305. +extern void map_screen_mem (unsigned long vid_base, int remap);
  12306. +static void ll_erase(int currcons,unsigned char sx,unsigned char sy,
  12307. +            unsigned char cx,unsigned char cy);
  12308. +static void vsync_irq(int irq, struct pt_regs *regs);
  12309. +static void put_cursor(char on_off,unsigned long cpp);
  12310. +unsigned char bytes_per_char_h;
  12311. +unsigned char bytes_per_char_v;
  12312. +unsigned long video_addr_mask;
  12313. +/* MUST get rid of these */
  12314. +#define BOLD        0x01
  12315. +#define ITALIC        0x02
  12316. +#define UNDERLINE    0x04
  12317. +#define FLASH        0x08
  12318. +#define INVERSE        0x10
  12319. +#define FLAGS ((underline?UNDERLINE:0)|(reverse?INVERSE:0)|(blink?FLASH:0)|intensity)
  12320. +
  12321. +#include <linux/ctype.h>
  12322. +
  12323. +/* Routines for selection control. */
  12324. +int set_selection(const int arg, struct tty_struct *tty);
  12325. +int paste_selection(struct tty_struct *tty);
  12326. +static void clear_selection(void);
  12327. +static void highlight_pointer(const int currcons,const int where);
  12328. +
  12329. +#define SEL_BUFFER_SIZE 4096
  12330. +int sel_cons = 0;
  12331. +static int sel_start = -1;
  12332. +static int sel_end;
  12333. +static char sel_buffer[SEL_BUFFER_SIZE] = { '\0' };
  12334. +
  12335. +
  12336. +
  12337. +#ifndef MIN
  12338. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  12339. +#endif
  12340. +
  12341. +struct tty_driver console_driver;
  12342. +static int console_refcount;
  12343. +static struct tty_struct *console_table[MAX_NR_CONSOLES];
  12344. +static struct termios *console_termios[MAX_NR_CONSOLES];
  12345. +static struct termios *console_termios_locked[MAX_NR_CONSOLES];
  12346. +
  12347. +#define NPAR 16
  12348. +
  12349. +static void con_setsize(unsigned long rows, unsigned long cols);
  12350. +static void vc_init(unsigned int console, unsigned long rows, unsigned long cols,
  12351. +            int do_clear);
  12352. +static void get_scrmem(int currcons);
  12353. +static void set_scrmem(int currcons, long offset);
  12354. +static void set_origin(int currcons);
  12355. +static void blank_screen(void);
  12356. +static void unblank_screen(void);
  12357. +void poke_blanked_console(void);
  12358. +static void gotoxy(int currcons, int new_x, int new_y);
  12359. +static void save_cur(int currcons);
  12360. +static inline void set_cursor(int currcons);
  12361. +static void reset_terminal(int currcons, int do_clear);
  12362. +extern void reset_vc(unsigned int new_console);
  12363. +extern void vt_init(void);
  12364. +extern void register_console(void (*proc)(const char *));
  12365. +extern void compute_shiftstate(void);
  12366. +extern int conv_uni_to_pc(unsigned long ucs);
  12367. +
  12368. +/* Description of the hardware situation */
  12369. +static unsigned long    video_mem_base;        /* Base of video memory        */
  12370. +static unsigned long    video_mem_term;        /* End of video memory        */
  12371. +       unsigned long    video_num_columns;    /* Number of text columns    */
  12372. +static unsigned long    video_num_lines;    /* Number of text lines        */
  12373. +static unsigned long    video_size_row;
  12374. +static unsigned long    video_screen_size;
  12375. +static unsigned long    video_buf_size;
  12376. +static int can_do_color = 1;
  12377. +static int printable = 0;            /* Is console ready for printing? */
  12378. +
  12379. +static unsigned char *vc_scrbuf[MAX_NR_CONSOLES];
  12380. +
  12381. +static int console_blanked = 0;
  12382. +static int blankinterval = 10*60*HZ;
  12383. +
  12384. +struct vc_data {
  12385. +    unsigned long    vc_screenbuf_size;
  12386. +    unsigned short    vc_video_erase_char;    /* Background erase character */
  12387. +    unsigned char    vc_attr;        /* Current attributes */
  12388. +    unsigned char    vc_def_forecol;
  12389. +    unsigned char    vc_def_backcol;
  12390. +    unsigned char    vc_forecol;
  12391. +    unsigned char    vc_backcol;
  12392. +    unsigned char    vc_s_forecol;
  12393. +    unsigned char    vc_s_backcol;
  12394. +    unsigned char    vc_cursoron;        /* Cursor on/off */
  12395. +    unsigned char    vc_ulcolor;        /* Colour for underline mode */
  12396. +    unsigned char    vc_halfcolor;        /* Colour for half intensity mode */
  12397. +    unsigned long    vc_origin;        /* Used for EGA/VGA fast scroll    */
  12398. +    unsigned long    vc_scr_end;        /* Used for EGA/VGA fast scroll    */
  12399. +    unsigned long    vc_pos;
  12400. +    unsigned long    vc_x,vc_y;
  12401. +    unsigned long    vc_top,vc_bottom;
  12402. +    unsigned long    vc_cstate;
  12403. +    unsigned long    vc_npar,vc_par[NPAR];
  12404. +    unsigned long    vc_video_mem_start;    /* Start of video RAM        */
  12405. +    unsigned long    vc_video_mem_end;    /* End of video RAM (sort of)    */
  12406. +    unsigned long    vc_saved_x;
  12407. +    unsigned long    vc_saved_y;
  12408. +    /* mode flags */
  12409. +    unsigned long    vc_charset    : 1;    /* Character set G0 / G1 */
  12410. +    unsigned long    vc_s_charset    : 1;    /* Saved character set */
  12411. +    unsigned long    vc_disp_ctrl    : 1;    /* Display chars < 32? */
  12412. +    unsigned long    vc_toggle_meta    : 1;    /* Toggle high bit? */
  12413. +    unsigned long    vc_decscnm    : 1;    /* Screen Mode */
  12414. +    unsigned long    vc_decom    : 1;    /* Origin Mode */
  12415. +    unsigned long    vc_decawm    : 1;    /* Autowrap Mode */
  12416. +    unsigned long    vc_deccm    : 1;    /* Cursor Visible */
  12417. +    unsigned long    vc_decim    : 1;    /* Insert Mode */
  12418. +    unsigned long    vc_deccolm    : 1;    /* 80/132 Column Mode */
  12419. +    /* attribute flags */
  12420. +    unsigned long    vc_intensity    : 2;    /* 0=half-bright, 1=normal, 2=bold */
  12421. +    unsigned long    vc_underline    : 1;
  12422. +    unsigned long    vc_blink    : 1;
  12423. +    unsigned long    vc_reverse    : 1;
  12424. +    unsigned long    vc_s_intensity    : 2;    /* saved rendition */
  12425. +    unsigned long    vc_s_underline    : 1;
  12426. +    unsigned long    vc_s_blink    : 1;
  12427. +    unsigned long    vc_s_reverse    : 1;
  12428. +    /* misc */
  12429. +    unsigned long    vc_ques        : 1;
  12430. +    unsigned long    vc_need_wrap    : 1;
  12431. +    unsigned long    vc_has_scrolled : 1;    /* Info for unblank_screen */
  12432. +    unsigned long    vc_kmalloced    : 1;    /* kfree_s() needed */
  12433. +    unsigned long    vc_report_mouse : 2;
  12434. +    unsigned char    vc_utf        : 1;    /* Unicode UTF-8 encoding */
  12435. +    unsigned char    vc_utf_count;
  12436. +    unsigned long    vc_utf_char;
  12437. +    unsigned long    vc_tab_stop[5];        /* Tab stops. 160 columns. */
  12438. +    unsigned char * vc_translate;
  12439. +    unsigned char     vc_G0_charset;
  12440. +    unsigned char     vc_G1_charset;
  12441. +    unsigned char     vc_saved_G0;
  12442. +    unsigned char     vc_saved_G1;
  12443. +    unsigned long * vc_paletteentries;
  12444. +    /* additional information is in vt_kern.h */
  12445. +};
  12446. +
  12447. +static struct vc {
  12448. +    struct vc_data *d;
  12449. +
  12450. +    /* might add  scrmem, vt_struct, kbd  at some time,
  12451. +       to have everything in one place - the disadvantage
  12452. +       would be that vc_cons etc can no longer be static */
  12453. +} vc_cons [MAX_NR_CONSOLES];
  12454. +
  12455. +#define screenbuf_size    (vc_cons[currcons].d->vc_screenbuf_size)
  12456. +#define origin        (vc_cons[currcons].d->vc_origin)
  12457. +#define scr_end        (vc_cons[currcons].d->vc_scr_end)
  12458. +#define pos        (vc_cons[currcons].d->vc_pos)
  12459. +#define top        (vc_cons[currcons].d->vc_top)
  12460. +#define bottom        (vc_cons[currcons].d->vc_bottom)
  12461. +#define x        (vc_cons[currcons].d->vc_x)
  12462. +#define y        (vc_cons[currcons].d->vc_y)
  12463. +#define vc_state    (vc_cons[currcons].d->vc_cstate)
  12464. +#define npar        (vc_cons[currcons].d->vc_npar)
  12465. +#define par        (vc_cons[currcons].d->vc_par)
  12466. +#define ques        (vc_cons[currcons].d->vc_ques)
  12467. +#define attr        (vc_cons[currcons].d->vc_attr)
  12468. +#define saved_x        (vc_cons[currcons].d->vc_saved_x)
  12469. +#define saved_y        (vc_cons[currcons].d->vc_saved_y)
  12470. +#define translate    (vc_cons[currcons].d->vc_translate)
  12471. +#define G0_charset    (vc_cons[currcons].d->vc_G0_charset)
  12472. +#define G1_charset    (vc_cons[currcons].d->vc_G1_charset)
  12473. +#define saved_G0    (vc_cons[currcons].d->vc_saved_G0)
  12474. +#define saved_G1    (vc_cons[currcons].d->vc_saved_G1)
  12475. +#define utf        (vc_cons[currcons].d->vc_utf)
  12476. +#define utf_count    (vc_cons[currcons].d->vc_utf_count)
  12477. +#define utf_char    (vc_cons[currcons].d->vc_utf_char)
  12478. +#define video_mem_start    (vc_cons[currcons].d->vc_video_mem_start)
  12479. +#define video_mem_end    (vc_cons[currcons].d->vc_video_mem_end)
  12480. +#define video_erase_char (vc_cons[currcons].d->vc_video_erase_char)
  12481. +#define disp_ctrl    (vc_cons[currcons].d->vc_disp_ctrl)
  12482. +#define toggle_meta    (vc_cons[currcons].d->vc_toggle_meta)
  12483. +#define decscnm        (vc_cons[currcons].d->vc_decscnm)
  12484. +#define decom        (vc_cons[currcons].d->vc_decom)
  12485. +#define decawm        (vc_cons[currcons].d->vc_decawm)
  12486. +#define deccm        (vc_cons[currcons].d->vc_deccm)
  12487. +#define decim        (vc_cons[currcons].d->vc_decim)
  12488. +#define deccolm         (vc_cons[currcons].d->vc_deccolm)
  12489. +#define need_wrap    (vc_cons[currcons].d->vc_need_wrap)
  12490. +#define has_scrolled    (vc_cons[currcons].d->vc_has_scrolled)
  12491. +#define kmalloced    (vc_cons[currcons].d->vc_kmalloced)
  12492. +#define report_mouse    (vc_cons[currcons].d->vc_report_mouse)
  12493. +#define forecol        (vc_cons[currcons].d->vc_forecol)
  12494. +#define backcol        (vc_cons[currcons].d->vc_backcol)
  12495. +#define s_forecol    (vc_cons[currcons].d->vc_s_forecol)
  12496. +#define s_backcol    (vc_cons[currcons].d->vc_s_backcol)
  12497. +#define def_forecol    (vc_cons[currcons].d->vc_def_forecol)
  12498. +#define def_backcol    (vc_cons[currcons].d->vc_def_backcol)
  12499. +#define cursoron    (vc_cons[currcons].d->vc_cursoron)
  12500. +#define charset        (vc_cons[currcons].d->vc_charset)
  12501. +#define s_charset    (vc_cons[currcons].d->vc_s_charset)
  12502. +#define    intensity    (vc_cons[currcons].d->vc_intensity)
  12503. +#define    underline    (vc_cons[currcons].d->vc_underline)
  12504. +#define    blink        (vc_cons[currcons].d->vc_blink)
  12505. +#define    reverse        (vc_cons[currcons].d->vc_reverse)
  12506. +#define    s_intensity    (vc_cons[currcons].d->vc_s_intensity)
  12507. +#define    s_underline    (vc_cons[currcons].d->vc_s_underline)
  12508. +#define    s_blink        (vc_cons[currcons].d->vc_s_blink)
  12509. +#define    s_reverse    (vc_cons[currcons].d->vc_s_reverse)
  12510. +#define tab_stop    (vc_cons[currcons].d->vc_tab_stop)
  12511. +#define paletteentries    (vc_cons[currcons].d->vc_paletteentries)
  12512. +
  12513. +#define vcmode        (vt_cons[currcons]->vc_mode)
  12514. +#define structsize    (sizeof(struct vc_data) + sizeof(struct vt_struct))
  12515. +
  12516. +/* ARC Extention */
  12517. +char cmap_80[][8]=
  12518. +{
  12519. + {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, /*   */
  12520. + {0x18,0x18,0x18,0x18,0x18,0x00,0x18,0x00}, /* ! */
  12521. + {0x6C,0x6C,0x6C,0x00,0x00,0x00,0x00,0x00}, /* " */
  12522. + {0x36,0x36,0x7F,0x36,0x7F,0x36,0x36,0x00}, /* # */
  12523. + {0x0C,0x3F,0x68,0x3E,0x0B,0x7E,0x18,0x00}, /* $ */
  12524. + {0x60,0x66,0x0C,0x18,0x30,0x66,0x06,0x00}, /* % */
  12525. + {0x38,0x6C,0x6C,0x38,0x6D,0x66,0x3B,0x00}, /* & */
  12526. + {0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00}, /* ' */
  12527. + {0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x00}, /* ( */
  12528. + {0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0x00}, /* ) */
  12529. + {0x00,0x18,0x7E,0x3C,0x7E,0x18,0x00,0x00}, /* * */
  12530. + {0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00}, /* + */
  12531. + {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x30}, /* , */
  12532. + {0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00}, /* - */
  12533. + {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00}, /* . */
  12534. + {0x00,0x06,0x0C,0x18,0x30,0x60,0x00,0x00}, /* / */
  12535. + {0x3C,0x66,0x6E,0x7E,0x76,0x66,0x3C,0x00}, /* 0 */
  12536. + {0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00}, /* 1 */
  12537. + {0x3C,0x66,0x06,0x0C,0x18,0x30,0x7E,0x00}, /* 2 */
  12538. + {0x3C,0x66,0x06,0x1C,0x06,0x66,0x3C,0x00}, /* 3 */
  12539. + {0x0C,0x1C,0x3C,0x6C,0x7E,0x0C,0x0C,0x00}, /* 4 */
  12540. + {0x7E,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00}, /* 5 */
  12541. + {0x1C,0x30,0x60,0x7C,0x66,0x66,0x3C,0x00}, /* 6 */
  12542. + {0x7E,0x06,0x0C,0x18,0x30,0x30,0x30,0x00}, /* 7 */
  12543. + {0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00}, /* 8 */
  12544. + {0x3C,0x66,0x66,0x3E,0x06,0x0C,0x38,0x00}, /* 9 */
  12545. + {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00}, /* : */
  12546. + {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x30}, /* ; */
  12547. + {0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00}, /* < */
  12548. + {0x00,0x00,0x7E,0x00,0x7E,0x00,0x00,0x00}, /* = */
  12549. + {0x30,0x18,0x0C,0x06,0x0C,0x18,0x30,0x00}, /* > */
  12550. + {0x3C,0x66,0x0C,0x18,0x18,0x00,0x18,0x00}, /* ? */
  12551. + {0x3C,0x66,0x6E,0x6A,0x6E,0x60,0x3C,0x00}, /* @ */
  12552. + {0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00}, /* A */
  12553. + {0x7C,0x66,0x66,0x7C,0x66,0x66,0x7C,0x00}, /* B */
  12554. + {0x3C,0x66,0x60,0x60,0x60,0x66,0x3C,0x00}, /* C */
  12555. + {0x78,0x6C,0x66,0x66,0x66,0x6C,0x78,0x00}, /* D */
  12556. + {0x7E,0x60,0x60,0x7C,0x60,0x60,0x7E,0x00}, /* E */
  12557. + {0x7E,0x60,0x60,0x7C,0x60,0x60,0x60,0x00}, /* F */
  12558. + {0x3C,0x66,0x60,0x6E,0x66,0x66,0x3C,0x00}, /* G */
  12559. + {0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00}, /* H */
  12560. + {0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00}, /* I */
  12561. + {0x3E,0x0C,0x0C,0x0C,0x0C,0x6C,0x38,0x00}, /* J */
  12562. + {0x66,0x6C,0x78,0x70,0x78,0x6C,0x66,0x00}, /* K */
  12563. + {0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00}, /* L */
  12564. + {0x63,0x77,0x7F,0x6B,0x6B,0x63,0x63,0x00}, /* M */
  12565. + {0x66,0x66,0x76,0x7E,0x6E,0x66,0x66,0x00}, /* N */
  12566. + {0x3C,0x66,0x66,0x66,0x66,0x66,0x3C,0x00}, /* O */
  12567. + {0x7C,0x66,0x66,0x7C,0x60,0x60,0x60,0x00}, /* P */
  12568. + {0x3C,0x66,0x66,0x66,0x6A,0x6C,0x36,0x00}, /* Q */
  12569. + {0x7C,0x66,0x66,0x7C,0x6C,0x66,0x66,0x00}, /* R */
  12570. + {0x3C,0x66,0x60,0x3C,0x06,0x66,0x3C,0x00}, /* S */
  12571. + {0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00}, /* T */
  12572. + {0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00}, /* U */
  12573. + {0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00}, /* V */
  12574. + {0x63,0x63,0x6B,0x6B,0x7F,0x77,0x63,0x00}, /* W */
  12575. + {0x66,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00}, /* X */
  12576. + {0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00}, /* Y */
  12577. + {0x7E,0x06,0x0C,0x18,0x30,0x60,0x7E,0x00}, /* Z */
  12578. + {0x7C,0x60,0x60,0x60,0x60,0x60,0x7C,0x00}, /* [ */
  12579. + {0x00,0x60,0x30,0x18,0x0C,0x06,0x00,0x00}, /* \ */
  12580. + {0x3E,0x06,0x06,0x06,0x06,0x06,0x3E,0x00}, /* ] */
  12581. + {0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00}, /* ^ */
  12582. + {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF}, /* _ */
  12583. + {0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00}, /* ` */
  12584. + {0x00,0x00,0x3C,0x06,0x3E,0x66,0x3E,0x00}, /* a */
  12585. + {0x60,0x60,0x7C,0x66,0x66,0x66,0x7C,0x00}, /* b */
  12586. + {0x00,0x00,0x3C,0x66,0x60,0x66,0x3C,0x00}, /* c */
  12587. + {0x06,0x06,0x3E,0x66,0x66,0x66,0x3E,0x00}, /* d */
  12588. + {0x00,0x00,0x3C,0x66,0x7E,0x60,0x3C,0x00}, /* e */
  12589. + {0x1C,0x30,0x30,0x7C,0x30,0x30,0x30,0x00}, /* f */
  12590. + {0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x3C}, /* g */
  12591. + {0x60,0x60,0x7C,0x66,0x66,0x66,0x66,0x00}, /* h */
  12592. + {0x18,0x00,0x38,0x18,0x18,0x18,0x3C,0x00}, /* i */
  12593. + {0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x70}, /* j */
  12594. + {0x60,0x60,0x66,0x6C,0x78,0x6C,0x66,0x00}, /* k */
  12595. + {0x38,0x18,0x18,0x18,0x18,0x18,0x3C,0x00}, /* l */
  12596. + {0x00,0x00,0x36,0x7F,0x6B,0x6B,0x63,0x00}, /* m */
  12597. + {0x00,0x00,0x7C,0x66,0x66,0x66,0x66,0x00}, /* n */
  12598. + {0x00,0x00,0x3C,0x66,0x66,0x66,0x3C,0x00}, /* o */
  12599. + {0x00,0x00,0x7C,0x66,0x66,0x7C,0x60,0x60}, /* p */
  12600. + {0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x07}, /* q */
  12601. + {0x00,0x00,0x6C,0x76,0x60,0x60,0x60,0x00}, /* r */
  12602. + {0x00,0x00,0x3E,0x60,0x3C,0x06,0x7C,0x00}, /* s */
  12603. + {0x30,0x30,0x7C,0x30,0x30,0x30,0x1C,0x00}, /* t */
  12604. + {0x00,0x00,0x66,0x66,0x66,0x66,0x3E,0x00}, /* u */
  12605. + {0x00,0x00,0x66,0x66,0x66,0x3C,0x18,0x00}, /* v */
  12606. + {0x00,0x00,0x63,0x6B,0x6B,0x7F,0x36,0x00}, /* w */
  12607. + {0x00,0x00,0x66,0x3C,0x18,0x3C,0x66,0x00}, /* x */
  12608. + {0x00,0x00,0x66,0x66,0x66,0x3E,0x06,0x3C}, /* y */
  12609. + {0x00,0x00,0x7E,0x0C,0x18,0x30,0x7E,0x00}, /* z */
  12610. + {0x0C,0x18,0x18,0x70,0x18,0x18,0x0C,0x00}, /* { */
  12611. + {0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00}, /* | */
  12612. + {0x30,0x18,0x18,0x0E,0x18,0x18,0x30,0x00}, /* } */
  12613. + {0x31,0x6B,0x46,0x00,0x00,0x00,0x00,0x00}, /* ~ */
  12614. + {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}  /*  */
  12615. +};
  12616. +
  12617. +static unsigned long palette_4[]=
  12618. +{
  12619. +    0x1000,       /* Black */
  12620. +    0x100D,       /* Red */
  12621. +    0x10D0,       /* Green */
  12622. +    0x10DD,       /* Yellow */
  12623. +    0x1D00,       /* Blue */
  12624. +    0x1D0D,       /* Magenta */
  12625. +    0x1DD0,       /* Cyan */
  12626. +    0x1DDD,       /* White */
  12627. +    0x1000,
  12628. +    0x100F,
  12629. +    0x10F0,
  12630. +    0x10FF,
  12631. +    0x1F00,
  12632. +    0x1F0F,
  12633. +    0x1FF0,
  12634. +    0x1FFF,
  12635. +    0x1000
  12636. +};
  12637. +
  12638. +static unsigned long palette_8[]=
  12639. +{
  12640. +    0x1000,
  12641. +    0x1111,
  12642. +    0x1222,
  12643. +    0x1333,
  12644. +    0x1400,
  12645. +    0x1511,
  12646. +    0x1622,
  12647. +    0x1733,
  12648. +    0x1004,
  12649. +    0x1115,
  12650. +    0x1226,
  12651. +    0x1337,
  12652. +    0x1404,
  12653. +    0x1515,
  12654. +    0x1626,
  12655. +    0x1737,
  12656. +    0x1000
  12657. +};
  12658. +
  12659. +static unsigned long *default_palette_entries = palette_4;
  12660. +
  12661. +/* -------------------------------------------------------------------------------
  12662. + * Low level char write
  12663. + * ------------------------------------------------------------------------------- */
  12664. +
  12665. +static inline void charwrite(int currcons,unsigned long ps,int ch)
  12666. +{
  12667. +  unsigned long *buffer = (unsigned long *)vc_scrbuf[currcons];
  12668. +  unsigned int index;
  12669. +  unsigned char flgs;
  12670. +
  12671. +  flgs=FLAGS;
  12672. +
  12673. +  if(currcons == fg_console)
  12674. +    ll_char_write(ps, ch, forecol, backcol, flgs);
  12675. +
  12676. +  index = (x + y * video_num_columns);
  12677. +
  12678. +  buffer[index] = (flgs<<24)|(backcol<<16)|(forecol<<8)|ch;
  12679. +}
  12680. +
  12681. +static char cursor_on=0;
  12682. +unsigned long cp;
  12683. +
  12684. +static inline void remove_cursors(int currcons)
  12685. +{
  12686. +  unsigned long flags;
  12687. +
  12688. +  save_flags(flags);
  12689. +  cli();
  12690. +  if(--cursoron==0 && currcons == fg_console)
  12691. +    put_cursor(0, cp);
  12692. +  restore_flags(flags);
  12693. +}
  12694. +
  12695. +static inline void restore_cursors(int currcons)
  12696. +{
  12697. +  unsigned long flags;
  12698. +
  12699. +  save_flags(flags);
  12700. +  cli();
  12701. +  if(++cursoron==1 && cursor_on && currcons == fg_console)
  12702. +    put_cursor(1,cp);
  12703. +  restore_flags(flags);
  12704. +}
  12705. +
  12706. +/* -----------------------------------------------------------------------------------------
  12707. + * VC stuff
  12708. + * ----------------------------------------------------------------------------------------- */
  12709. +
  12710. +int vc_cons_allocated(unsigned int i)
  12711. +{
  12712. +      return (i < MAX_NR_CONSOLES && vc_cons[i].d);
  12713. +}
  12714. +
  12715. +int vc_allocate(unsigned int i)
  12716. +{
  12717. +    if (i >= MAX_NR_CONSOLES)
  12718. +      return -ENODEV;
  12719. +    if (!vc_cons[i].d) {
  12720. +        long p, q;
  12721. +
  12722. +        /* prevent users from taking too much memory */
  12723. +        if (i >= MAX_NR_USER_CONSOLES && !suser())
  12724. +          return -EPERM;
  12725. +
  12726. +        /* due to the granularity of kmalloc, we waste some memory here */
  12727. +        /* the alloc is done in two steps, to optimize the common situation
  12728. +           of a 25x80 console (structsize=216, video_screen_size=4000) */
  12729. +        q = (long) kmalloc(video_buf_size, GFP_KERNEL);
  12730. +        if (!q)
  12731. +          return -ENOMEM;
  12732. +        p = (long) kmalloc(structsize, GFP_KERNEL);
  12733. +        if (!p) {
  12734. +        kfree_s((char *) q, video_buf_size);
  12735. +        return -ENOMEM;
  12736. +        }
  12737. +
  12738. +        memset((void *)q, 0, video_buf_size);
  12739. +
  12740. +        vc_cons[i].d = (struct vc_data *) p;
  12741. +        p += sizeof(struct vc_data);
  12742. +        vt_cons[i] = (struct vt_struct *) p;
  12743. +        vc_scrbuf[i] = (unsigned char *) q;
  12744. +        vc_cons[i].d->vc_kmalloced = 1;
  12745. +        vc_cons[i].d->vc_screenbuf_size = video_buf_size;
  12746. +        vc_init (i, video_num_lines, video_num_columns, 1);
  12747. +    }
  12748. +    return 0;
  12749. +}
  12750. +
  12751. +int vc_resize(unsigned long lines, unsigned long cols)
  12752. +{/* TODO */
  12753. +    return -ENOMEM;
  12754. +}
  12755. +
  12756. +void vc_disallocate(unsigned int currcons)
  12757. +{
  12758. +    if(vc_cons_allocated(currcons))
  12759. +    {
  12760. +      if(kmalloced)
  12761. +        kfree_s(vc_scrbuf[currcons], screenbuf_size);
  12762. +      if(currcons >= MIN_NR_CONSOLES)
  12763. +        kfree_s(vc_cons[currcons].d, structsize);
  12764. +      vc_cons[currcons].d = 0;
  12765. +    }
  12766. +}
  12767. +
  12768. +#define set_kbd(x) set_vc_kbd_mode(kbd_table+currcons,x)
  12769. +#define clr_kbd(x) clr_vc_kbd_mode(kbd_table+currcons,x)
  12770. +#define is_kbd(x) vc_kbd_mode(kbd_table+currcons,x)
  12771. +
  12772. +#define decarm        VC_REPEAT
  12773. +#define decckm        VC_CKMODE
  12774. +#define kbdapplic    VC_APPLIC
  12775. +#define lnm        VC_CRLF
  12776. +
  12777. +/*
  12778. + * this is what the terminal answers to a ESC-Z or csi0c query.
  12779. + */
  12780. +#define VT100ID "\033[?1;2c"
  12781. +#define VT102ID "\033[?6c"
  12782. +
  12783. +static unsigned char color_4[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 };
  12784. +static unsigned char color_8[] = {0x00, 0x1B, 0x63, 0x7B, 0x87, 0x9F, 0xE7, 0xFF,
  12785. +                                  0x00, 0x1B, 0x63, 0x7B, 0x87, 0x9F, 0xE7, 0xFF};
  12786. +static unsigned char *color_table = color_4;
  12787. +
  12788. +/*
  12789. + * gotoxy() must verify all boundaries, because the arguments
  12790. + * might also be negative. If a given position is out of
  12791. + * bounds, the cursor is placed at the nearest margin.
  12792. + */
  12793. +static void gotoxy(int currcons,int new_x,int new_y)
  12794. +{
  12795. +  int max_y;
  12796. +
  12797. +  if(new_x<0)
  12798. +    x = 0;
  12799. +  else
  12800. +  if(new_x>=video_num_columns)
  12801. +    x = video_num_columns-1;
  12802. +  else
  12803. +    x = new_x;
  12804. +
  12805. +  if(decom)
  12806. +  {
  12807. +    new_y += top;
  12808. +    max_y = bottom;
  12809. +  }
  12810. +  else
  12811. +    max_y=video_num_lines;
  12812. +
  12813. +  if(new_y < 0)
  12814. +    y = 0;
  12815. +  else
  12816. +  if(new_y >= max_y)
  12817. +    y = max_y-1;
  12818. +  else
  12819. +    y = new_y;
  12820. +
  12821. +  pos = origin + (y*video_num_columns*bytes_per_char_v+x)*bytes_per_char_h;
  12822. +  need_wrap=0;
  12823. +}
  12824. +
  12825. +static unsigned long __real_origin;
  12826. +static unsigned long __origin;        /* Offset of currently displayed screen */
  12827. +
  12828. +static void __set_origin(unsigned long offset)
  12829. +{
  12830. +  unsigned long flags;
  12831. +  clear_selection();
  12832. +  save_flags(flags); cli();
  12833. +  __origin = offset;
  12834. +
  12835. +  memc_write(0,offset>>2);
  12836. +  memc_write(1,0);
  12837. +  memc_write(2,video_addr_mask>>2);
  12838. +  restore_flags(flags);
  12839. +}
  12840. +
  12841. +/*
  12842. +void scrollback(int lines)
  12843. +{
  12844. +}
  12845. +
  12846. +void scrollfront(int lines)
  12847. +{
  12848. +}
  12849. + */
  12850. +
  12851. +static void set_origin(int currcons)
  12852. +{
  12853. +    if(currcons != fg_console || vcmode == KD_GRAPHICS)
  12854. +        return;
  12855. +    __real_origin = origin - video_mem_start;
  12856. +    if(__real_origin >= video_addr_mask)
  12857. +        __real_origin -= video_addr_mask;
  12858. +    __set_origin(__real_origin);
  12859. +}
  12860. +
  12861. +static void hide_cursor(void)
  12862. +{
  12863. +    put_cursor(0,-1);
  12864. +}
  12865. +
  12866. +static void set_cursor(int currcons)
  12867. +{
  12868. +    unsigned long flags;
  12869. +
  12870. +    if(currcons != fg_console || vcmode == KD_GRAPHICS)
  12871. +        return;
  12872. +
  12873. +    if(__real_origin != __origin)
  12874. +        __set_origin(__real_origin);
  12875. +    save_flags(flags);
  12876. +    cli();
  12877. +
  12878. +    if(deccm)
  12879. +        cp = pos + video_num_columns * bytes_per_char_h * (bytes_per_char_v - 1);
  12880. +    else
  12881. +        hide_cursor();
  12882. +    restore_flags(flags);
  12883. +}
  12884. +
  12885. +/* --------------------------------------------------------------------------------
  12886. + * Screen scrolling
  12887. + * -------------------------------------------------------------------------------- */
  12888. +
  12889. +static void scrup(int currcons,unsigned int t, unsigned int b,unsigned char l)
  12890. +{
  12891. +    unsigned char flgs;
  12892. +
  12893. +    if(b > video_num_columns || t >= b)
  12894. +        return;
  12895. +
  12896. +    if(currcons == fg_console)
  12897. +    {
  12898. +        if(t || b != video_num_lines)
  12899. +        {
  12900. +            if(l<t-b)
  12901. +                memmove((void*)(origin+t*video_size_row),
  12902. +                        (void*)(origin+(t+l)*video_size_row),
  12903. +                        (b-t-l)*video_size_row);
  12904. +            else
  12905. +            if(l>b-t)
  12906. +                l=b-t;
  12907. +
  12908. +            memfastset((void*)(origin+(b-l)*video_size_row),
  12909. +                    0x11111111*backcol,l*video_size_row);
  12910. +        }
  12911. +        else
  12912. +        {
  12913. +            memfastset((void*)(origin+l*video_size_row*video_num_lines),
  12914. +                0x11111111L*backcol,l*video_size_row);
  12915. +            pos-=origin;
  12916. +            origin+=l*video_size_row;
  12917. +            if(origin>=video_mem_term)
  12918. +                origin=origin-video_mem_term+video_mem_base;
  12919. +            pos+=origin;
  12920. +            set_origin(currcons);
  12921. +        }
  12922. +    }
  12923. +    else
  12924. +    {
  12925. +        if(!t && b == video_num_lines)
  12926. +        {
  12927. +            pos-=origin;
  12928. +            origin+=l*video_size_row;
  12929. +            if(origin>=video_mem_term)
  12930. +                origin=origin-video_mem_term+video_mem_base;
  12931. +            pos+=origin;
  12932. +        }
  12933. +        }
  12934. +    if(l < t-b)
  12935. +        memmove((void*)(vc_scrbuf[currcons]+t*video_num_columns*4),
  12936. +            (void*)(vc_scrbuf[currcons]+(t+l)*video_num_columns*4),
  12937. +            (b-t-l)*video_num_columns*4);
  12938. +    else
  12939. +    if(l > b-t)
  12940. +        l=b-t;
  12941. +
  12942. +    flgs=FLAGS;
  12943. +
  12944. +    memfastset((void*)(vc_scrbuf[currcons]+(b-l)*video_num_columns*4),
  12945. +        (flgs << 24)|(backcol << 16)|(forecol << 8)|32,
  12946. +        l*video_num_columns*4);
  12947. +}
  12948. +
  12949. +static void scrdown(int currcons,unsigned int t,unsigned int b,unsigned char l)
  12950. +{
  12951. +    unsigned char flgs;
  12952. +
  12953. +    if(b>video_num_columns || t >= b)
  12954. +        return;
  12955. +
  12956. +    if(currcons == fg_console)
  12957. +    {
  12958. +        if(t || b != video_num_lines)
  12959. +        {
  12960. +            if(l<t-b)
  12961. +                memmove((void*)(origin+(t+l)*video_size_row),
  12962. +                        (void*)(origin+t*video_size_row),
  12963. +                        (b-t-l)*video_size_row);
  12964. +            else
  12965. +            if(l>b-t)
  12966. +                l=b-t;
  12967. +
  12968. +            memfastset((void*)(origin+t*video_size_row),
  12969. +                    0x11111111*backcol,l*video_size_row);
  12970. +        }
  12971. +        else
  12972. +        {
  12973. +            pos-=origin;
  12974. +            origin-=l*video_size_row;
  12975. +            if(origin<video_mem_base)
  12976. +                origin=origin-video_mem_base+video_mem_term;
  12977. +            pos+=origin;
  12978. +            memfastset((void*)origin,0x11111111L*backcol,l*video_size_row);
  12979. +            set_origin(currcons);
  12980. +        }
  12981. +    }
  12982. +    else
  12983. +    {
  12984. +        if(!t && b == video_num_lines)
  12985. +        {
  12986. +            pos-=origin;
  12987. +            origin-=l*video_size_row;
  12988. +            if(origin<video_mem_base)
  12989. +                origin=origin-video_mem_base+video_mem_term;
  12990. +            pos+=origin;
  12991. +        }
  12992. +    }
  12993. +    if(l < t-b)
  12994. +        memmove((void*)(vc_scrbuf[currcons]+(t+l)*video_num_columns*4),
  12995. +            (void*)(vc_scrbuf[currcons]+t*video_num_columns*4),
  12996. +            (b-t-l)*video_num_columns*4);
  12997. +    else
  12998. +    if(l > b-t)
  12999. +        l = b-t;
  13000. +
  13001. +    flgs=FLAGS;
  13002. +    memfastset((void*)(vc_scrbuf[currcons]+t*video_num_columns*4),
  13003. +        (flgs << 24)|(backcol << 16)|(forecol << 8)|32,
  13004. +        l*video_num_columns*4);
  13005. +}
  13006. +
  13007. +static void lf(int currcons)
  13008. +{
  13009. +    if (y + 1 < bottom) {
  13010. +        y++;
  13011. +        pos += video_size_row;
  13012. +        return;
  13013. +    }
  13014. +    scrup(currcons,top,bottom,1);
  13015. +    need_wrap=0;
  13016. +}
  13017. +
  13018. +static void ri(int currcons)
  13019. +{
  13020. +    if (y > top) {
  13021. +        y--;
  13022. +        pos -= video_size_row;
  13023. +        return;
  13024. +    }
  13025. +    scrdown(currcons,top,bottom,1);
  13026. +    need_wrap=0;
  13027. +}
  13028. +
  13029. +static inline void cr(int currcons)
  13030. +{
  13031. +    pos -= x*bytes_per_char_h;
  13032. +    need_wrap = x = 0;
  13033. +}
  13034. +
  13035. +static inline void bs(int currcons)
  13036. +{
  13037. +    if (x) {
  13038. +        if (!need_wrap) {
  13039. +            pos -= bytes_per_char_h;
  13040. +            x--;
  13041. +        }
  13042. +        need_wrap = 0;
  13043. +    }
  13044. +}
  13045. +
  13046. +static inline void del(int currcons)
  13047. +{
  13048. +  /* ignored */
  13049. +}
  13050. +
  13051. +static void csi_J(int currcons, int vpar)
  13052. +{
  13053. +    unsigned char countx,county;
  13054. +    unsigned char startx,starty;
  13055. +
  13056. +    switch(vpar) {
  13057. +        case 0: /* erase from cursor to bottom of screen */
  13058. +            startx=x;
  13059. +            starty=y;
  13060. +            countx=video_num_columns-x;
  13061. +            county=video_num_lines-y-1;
  13062. +            break;
  13063. +        case 1: /* erase from top of screen to cursor */
  13064. +            startx=0;
  13065. +            starty=0;
  13066. +            countx=x;
  13067. +            county=y;
  13068. +            break;
  13069. +        case 2: /* erase entire screen */
  13070. +            startx=0;
  13071. +            starty=0;
  13072. +            countx=video_num_columns;
  13073. +            county=video_num_lines-1;
  13074. +            origin=video_mem_base;
  13075. +            set_origin(currcons);
  13076. +            gotoxy(currcons,x,y);
  13077. +            break;
  13078. +        default:
  13079. +            return;
  13080. +    }
  13081. +    ll_erase(currcons,startx,starty,countx,county);
  13082. +    need_wrap = 0;
  13083. +}
  13084. +
  13085. +static void csi_K(int currcons, int vpar)
  13086. +{
  13087. +    unsigned char countx;
  13088. +    unsigned char startx;
  13089. +
  13090. +    switch(vpar) {
  13091. +        case 0: /* erase from cursor to end of line */
  13092. +            startx = x;
  13093. +            countx = video_num_columns - x;
  13094. +            break;
  13095. +        case 1: /* erase from beginning of line to cursor */
  13096. +            startx = 0;
  13097. +            countx = x;
  13098. +            break;
  13099. +        case 2: /* erase entire line */
  13100. +            startx=0;
  13101. +            countx=video_num_columns;
  13102. +            break;
  13103. +        default:
  13104. +            return;
  13105. +    }
  13106. +    ll_erase(currcons,startx,y,countx,0);
  13107. +    need_wrap = 0;
  13108. +}
  13109. +
  13110. +static void csi_X(int currcons, int vpar) /* erase the following vpar positions */
  13111. +{                      /* not vt100? */
  13112. +    unsigned char countx,county;
  13113. +    unsigned char startx,starty;
  13114. +
  13115. +    if (!vpar)
  13116. +        vpar++;
  13117. +
  13118. +    startx = x;
  13119. +    starty = y;
  13120. +    countx = 0;
  13121. +    county = 0;
  13122. +#if 0 /* TODO */
  13123. +    ll_erase(currcons,startx,starty,countx,county);
  13124. +#endif
  13125. +    need_wrap = 0;
  13126. +}
  13127. +
  13128. +
  13129. +/*
  13130. +static void update_addr(int currcons)
  13131. +{
  13132. +
  13133. +}
  13134. + */
  13135. +static void default_attr(int currcons)
  13136. +{
  13137. +    underline = 0;
  13138. +    reverse = 0;
  13139. +    blink = 0;
  13140. +    intensity = 0;
  13141. +
  13142. +    forecol = def_forecol;
  13143. +    backcol = def_backcol;
  13144. +}
  13145. +
  13146. +static void csi_m(int currcons)
  13147. +{
  13148. +  int i;
  13149. +
  13150. +  for(i=0;i<=npar;i++)
  13151. +  {
  13152. +    switch(par[i])
  13153. +    {
  13154. +      case 0:    default_attr(currcons); break;
  13155. +      case 1:    intensity|=BOLD;    break;    /* Bold */
  13156. +      case 2:    intensity&=~BOLD;    break;    /* Feint */
  13157. +      case 3:    intensity|=ITALIC;    break;    /* Italic */
  13158. +      case 4:    underline = 1;        break;    /* Underline */
  13159. +      case 5:
  13160. +      case 6:    blink = 1;        break;    /* Flash */
  13161. +      case 7:    reverse = 1;        break;    /* Inverse chars */
  13162. +
  13163. +            case 10: /* ANSI X3.64-1979 (SCO-ish?)
  13164. +                  * Select primary font, don't display
  13165. +                  * control chars if defined, don't set
  13166. +                  * bit 8 on output.
  13167. +                  */
  13168. +                translate = set_translate(charset == 0
  13169. +                        ? G0_charset
  13170. +                        : G1_charset);
  13171. +                disp_ctrl = 0;
  13172. +                toggle_meta = 0;
  13173. +                break;
  13174. +            case 11: /* ANSI X3.64-1979 (SCO-ish?)
  13175. +                  * Select first alternate font, let's
  13176. +                  * chars < 32 be displayed as ROM chars.
  13177. +                  */
  13178. +                translate = set_translate(NULL_MAP);
  13179. +                disp_ctrl = 1;
  13180. +                toggle_meta = 0;
  13181. +                break;
  13182. +            case 12: /* ANSI X3.64-1979 (SCO-ish?)
  13183. +                  * Select second alternate font, toggle
  13184. +                  * high bit before displaying as ROM char.
  13185. +                  */
  13186. +                translate = set_translate(NULL_MAP);
  13187. +                disp_ctrl = 1;
  13188. +                toggle_meta = 1;
  13189. +                break;
  13190. +
  13191. +      case 21:
  13192. +      case 22:  intensity = 0;    break;
  13193. +      case 24:  underline = 0;    break;
  13194. +      case 25:  blink = 0;    break;
  13195. +      case 27:    reverse = 0;    break;
  13196. +      case 30:
  13197. +      case 31:
  13198. +      case 32:
  13199. +      case 33:
  13200. +      case 34:
  13201. +      case 35:
  13202. +      case 36:
  13203. +      case 37:  forecol=color_table[par[i]-30];        break;    /* Foreground colour */
  13204. +      case 38:  forecol=def_forecol; underline = 1;    break;
  13205. +      case 39:  forecol=def_forecol; underline = 0;    break;    /* Default foreground colour */
  13206. +      case 40:
  13207. +      case 41:
  13208. +      case 42:
  13209. +      case 43:
  13210. +      case 44:
  13211. +      case 45:
  13212. +      case 46:
  13213. +      case 47:  backcol=color_table[par[i]-40];    break;    /* Background colour */
  13214. +      case 49:  backcol=def_backcol;        break;    /* Default background colour */
  13215. +    }
  13216. +  }
  13217. +}
  13218. +
  13219. +static void respond_string(char *p,struct tty_struct *tty)
  13220. +{
  13221. +    while(*p)
  13222. +        tty_insert_flip_char(tty, *p++, 0);
  13223. +    tty_schedule_flip(tty);
  13224. +}
  13225. +
  13226. +static void cursor_report(int currcons,struct tty_struct *tty)
  13227. +{
  13228. +    char buf[40];
  13229. +
  13230. +    sprintf(buf, "\033[%ld;%ldR",y + (decom ? top+1 : 1),
  13231. +                     x + 1);
  13232. +    respond_string(buf, tty);
  13233. +}
  13234. +
  13235. +static void status_report(struct tty_struct *tty)
  13236. +{
  13237. +    respond_string("\033[0n",tty);
  13238. +}
  13239. +
  13240. +static void respond_ID(struct tty_struct *tty)
  13241. +{
  13242. +    respond_string(VT102ID,tty);
  13243. +}
  13244. +
  13245. +static void mouse_report(int currcons, struct tty_struct *tty, int butt, int mrx, int mry)
  13246. +{
  13247. +    char buf[8];
  13248. +
  13249. +    sprintf(buf,"\033[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
  13250. +        (char)('!'+mry));
  13251. +    respond_string(buf,tty);
  13252. +}
  13253. +
  13254. +/* invoked by ioctl(TIOCLINUX) */
  13255. +int mouse_reporting(void)
  13256. +{
  13257. +    int currcons = fg_console;
  13258. +
  13259. +    return report_mouse;
  13260. +}
  13261. +
  13262. +static void invert_screen(void)
  13263. +{
  13264. +  /* Todo */
  13265. +}
  13266. +
  13267. +unsigned long *screen_pos(int currcons, int screen_offset)
  13268. +{
  13269. +    return (unsigned long *)(vc_scrbuf[currcons] + screen_offset * 4);
  13270. +}
  13271. +
  13272. +void getconsxy(int currcons, char *p)
  13273. +{
  13274. +    p[0] = x;
  13275. +    p[1] = y;
  13276. +}
  13277. +
  13278. +void putconsxy(int currcons, char *p)
  13279. +{
  13280. +    gotoxy(currcons, p[0], p[1]);
  13281. +    set_cursor(currcons);
  13282. +}
  13283. +
  13284. +static void set_mode(int currcons, int on_off)
  13285. +{
  13286. +    int i;
  13287. +
  13288. +    for(i=0;i<=npar;i++)
  13289. +        if(ques) switch(par[i]) {    /* DEC private modes set/reset */
  13290. +            case 1:            /* Cursor keys send ^[Ox/^[[x */
  13291. +                if (on_off)
  13292. +                    set_kbd(decckm);
  13293. +                else
  13294. +                    clr_kbd(decckm);
  13295. +                break;
  13296. +            case 3:         /* 80/132 mode switch unimplemented */
  13297. +                deccolm = on_off;
  13298. +#if 0
  13299. +                csi_J(currcons,2);
  13300. +                gotoxy(currcons,0,0);
  13301. +#endif
  13302. +                break;
  13303. +            case 5:            /* Inverted screen on/off */
  13304. +                if (decscnm != on_off) {
  13305. +                    decscnm = on_off;
  13306. +                    invert_screen();
  13307. +/*                     update_attr(); */
  13308. +                }
  13309. +                break;
  13310. +            case 6:            /* Origin relative/absolute */
  13311. +                decom = on_off;
  13312. +                gotoxy(currcons,0,0);
  13313. +                break;
  13314. +            case 7:            /* Autowrap on/off */
  13315. +                decawm = on_off;
  13316. +                break;
  13317. +            case 8:            /* Autorepeat on/off */
  13318. +                if (on_off)
  13319. +                    set_kbd(decarm);
  13320. +                else
  13321. +                    clr_kbd(decarm);
  13322. +                break;
  13323. +            case 9:
  13324. +                report_mouse = on_off ? 1 : 0;
  13325. +                break;
  13326. +            case 25:        /* Cursor on/off */
  13327. +                deccm = on_off;
  13328. +                set_cursor(currcons);
  13329. +                break;
  13330. +            case 1000:
  13331. +                report_mouse = on_off ? 2 : 0;
  13332. +                break;
  13333. +        } else switch(par[i]) {        /* ANSI modes set/reset */
  13334. +            case 3:            /* Monitor (display ctrls) */
  13335. +                disp_ctrl = on_off;
  13336. +                break;
  13337. +            case 4:            /* Insert mode on/off */
  13338. +                decim = on_off;
  13339. +                break;
  13340. +            case 20:        /* Lf, Enter = CrLf/Lf */
  13341. +                if (on_off)
  13342. +                    set_kbd(lnm);
  13343. +                else
  13344. +                    clr_kbd(lnm);
  13345. +                break;
  13346. +        }
  13347. +}
  13348. +
  13349. +static void setterm_command(int currcons)
  13350. +{
  13351. +    switch(par[0]) {
  13352. +        case 1: /* Set colour for underline mode (implemented as an underline) */
  13353. +            break;
  13354. +        case 2: /* set colour for half intensity mode (implemented as half) */
  13355. +            break;
  13356. +        case 8:
  13357. +            def_forecol = forecol;
  13358. +            def_backcol = backcol;
  13359. +            break;
  13360. +        case 9:
  13361. +            blankinterval=((par[1]<60)?par[1]:60)*60*HZ;
  13362. +            break;
  13363. +    }
  13364. +}
  13365. +
  13366. +static void insert_char(int currcons)
  13367. +{
  13368. +    register unsigned char *c,*cc;
  13369. +    register unsigned char row;
  13370. +    register int col;
  13371. +
  13372. +    c = (unsigned char*)pos;
  13373. +    cc = (unsigned char*)pos + bytes_per_char_h;
  13374. +
  13375. +    for (row = 0; row < bytes_per_char_v; row++) {
  13376. +        for(col = (video_num_columns - x - 1) * bytes_per_char_h - 1; col >= 0; col--)
  13377. +            cc[col] = c[col];
  13378. +        *c = 0x11*backcol;
  13379. +        c += video_num_columns * bytes_per_char_h;
  13380. +        cc += video_num_columns * bytes_per_char_h;
  13381. +    }
  13382. +}
  13383. +
  13384. +static void insert_line(int currcons,int n)
  13385. +{
  13386. +    scrdown(currcons,y,bottom,n);
  13387. +    need_wrap = 0;
  13388. +}
  13389. +
  13390. +static void delete_char(int currcons)
  13391. +{
  13392. +    register unsigned char *c, *cc;
  13393. +    register unsigned char row;
  13394. +    register unsigned int  col;
  13395. +
  13396. +    c = (unsigned char*)pos;
  13397. +    cc = (unsigned char*)pos + bytes_per_char_h;
  13398. +
  13399. +    for (row=0; row < bytes_per_char_v; row++) {
  13400. +        for (col=0; col < bytes_per_char_h * (video_num_columns - x - 1); col++) {
  13401. +            c[col] = cc[col];
  13402. +            cc[col] = 0x11*backcol;
  13403. +        }
  13404. +        c += video_num_columns * bytes_per_char_h;
  13405. +        cc += video_num_columns * bytes_per_char_h;
  13406. +    }
  13407. +}
  13408. +
  13409. +static void delete_line(int currcons,int n)
  13410. +{
  13411. +    scrup(currcons,y,bottom,n);
  13412. +    need_wrap = 0;
  13413. +}
  13414. +
  13415. +static void csi_at(int currcons,int nr)
  13416. +{
  13417. +    if (nr > video_num_columns - x)
  13418. +        nr = video_num_columns-x;
  13419. +    else if (!nr)
  13420. +        nr = 1;
  13421. +    while(nr--)
  13422. +        insert_char(currcons);
  13423. +}
  13424. +
  13425. +static void csi_L(int currcons,int nr)
  13426. +{
  13427. +    if (nr > video_num_lines - y)
  13428. +        nr = video_num_lines - y;
  13429. +    else if (!nr)
  13430. +        nr = 1;
  13431. +    insert_line(currcons,nr);
  13432. +}
  13433. +
  13434. +static void csi_P(int currcons,int nr)
  13435. +{
  13436. +    if (nr > video_num_columns)
  13437. +        nr = video_num_columns;
  13438. +    else if (!nr)
  13439. +        nr = 1;
  13440. +    while(nr--)
  13441. +        delete_char(currcons);
  13442. +}
  13443. +
  13444. +static void csi_M(int currcons,int nr)
  13445. +{
  13446. +    if (nr > video_num_lines)
  13447. +        nr = video_num_lines;
  13448. +    else if (!nr)
  13449. +        nr = 1;
  13450. +    delete_line(currcons,nr);
  13451. +}
  13452. +
  13453. +static void save_cur(int currcons)
  13454. +{
  13455. +    saved_x        = x;
  13456. +    saved_y        = y;
  13457. +    saved_G0    = G0_charset;
  13458. +    saved_G1    = G1_charset;
  13459. +    s_intensity    = intensity;
  13460. +    s_blink        = blink;
  13461. +    s_underline    = underline;
  13462. +    s_reverse    = reverse;
  13463. +    s_forecol    = forecol;
  13464. +    s_backcol    = backcol;
  13465. +}
  13466. +
  13467. +static void restore_cur(int currcons)
  13468. +{
  13469. +    gotoxy(currcons,saved_x,saved_y);
  13470. +    G0_charset    = saved_G0;
  13471. +    G1_charset    = saved_G1;
  13472. +    intensity    = s_intensity;
  13473. +    blink        = s_blink;
  13474. +    underline    = s_underline;
  13475. +    reverse        = s_reverse;
  13476. +    forecol        = s_forecol;
  13477. +    backcol        = s_backcol;
  13478. +    need_wrap    = 0;
  13479. +}
  13480. +
  13481. +enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
  13482. +    EShash, ESsetG0, ESsetG1, ESpercent, ESignore };
  13483. +
  13484. +static void reset_terminal(int currcons,int do_clear)
  13485. +{
  13486. +    top        = 0;
  13487. +    bottom        = video_num_lines;
  13488. +    vc_state    = ESnormal;
  13489. +    ques        = 0;
  13490. +    translate    = set_translate(NORM_MAP);
  13491. +    G0_charset    = NORM_MAP;
  13492. +    G1_charset    = GRAF_MAP;
  13493. +    charset        = 0;
  13494. +    need_wrap    = 0;
  13495. +    report_mouse    = 0;
  13496. +    utf        = 0; /* ? *** */
  13497. +    utf_count    = 0;
  13498. +
  13499. +    paletteentries    = 0;
  13500. +    disp_ctrl    = 0;
  13501. +    toggle_meta    = 0;
  13502. +
  13503. +    def_forecol    = color_table[7];
  13504. +    def_backcol    = color_table[0];
  13505. +    forecol    = color_table[7];
  13506. +    backcol    = color_table[0];
  13507. +
  13508. +    decscnm        = 0;
  13509. +    decom        = 0;
  13510. +    decawm        = 1;
  13511. +    deccm        = 1;
  13512. +    decim        = 0;
  13513. +
  13514. +    set_kbd(decarm);
  13515. +    clr_kbd(decckm);
  13516. +    clr_kbd(kbdapplic);
  13517. +    clr_kbd(lnm);
  13518. +    kbd_table[currcons].lockstate = 0;
  13519. +    kbd_table[currcons].ledmode = LED_SHOW_FLAGS;
  13520. +    kbd_table[currcons].ledflagstate = kbd_table[currcons].default_ledflagstate;
  13521. +    set_leds();
  13522. +
  13523. +    default_attr(currcons);
  13524. +
  13525. +    tab_stop[0]    = 0x01010100;
  13526. +    tab_stop[1]    =
  13527. +    tab_stop[2]    =
  13528. +    tab_stop[3]    =
  13529. +    tab_stop[4]    = 0x01010101;
  13530. +
  13531. +    gotoxy(currcons,0,0);
  13532. +    save_cur(currcons);
  13533. +    if (do_clear)
  13534. +        csi_J(currcons,2);
  13535. +}
  13536. +
  13537. +/*
  13538. + * Turn the Scroll-Lock LED on when the tty is stopped
  13539. + */
  13540. +static void con_stop(struct tty_struct *tty)
  13541. +{
  13542. +    int console_num;
  13543. +    if (!tty)
  13544. +        return;
  13545. +    console_num = MINOR(tty->device) - (tty->driver.minor_start);
  13546. +    if (!vc_cons_allocated(console_num))
  13547. +        return;
  13548. +    set_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
  13549. +    set_leds();
  13550. +}
  13551. +
  13552. +/*
  13553. + * Turn the Scroll-Lock LED off when the console is started
  13554. + */
  13555. +static void con_start(struct tty_struct *tty)
  13556. +{
  13557. +    int console_num;
  13558. +    if(!tty)
  13559. +        return;
  13560. +    console_num = MINOR(tty->device) - (tty->driver.minor_start);
  13561. +    if (!vc_cons_allocated(console_num))
  13562. +        return;
  13563. +    clr_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
  13564. +    set_leds();
  13565. +}
  13566. +
  13567. +static int con_write(struct tty_struct * tty, int from_user,
  13568. +             unsigned char *buf, int count)
  13569. +{
  13570. +    int c, tc, ok, n = 0, r = 0;
  13571. +    unsigned int currcons;
  13572. +    struct vt_struct *vt = (struct vt_struct *)tty->driver_data;
  13573. +    unsigned char buffer[32], *p = buffer;
  13574. +
  13575. +    currcons = vt->vc_num;
  13576. +    if (!vc_cons_allocated(currcons)) {
  13577. +        /* could this happen? */
  13578. +        static int error = 0;
  13579. +        if(!error) {
  13580. +        error = 1;
  13581. +        printk("con_write: tty %d not allocated\n", currcons+1);
  13582. +        }
  13583. +        return 0;
  13584. +    }
  13585. +
  13586. +    remove_cursors(currcons);
  13587. +    if(currcons == sel_cons)
  13588. +        clear_selection();
  13589. +
  13590. +    disable_bh(KEYBOARD_BH);
  13591. +    while(!tty->stopped && count) {
  13592. +        if(from_user && r == 0)
  13593. +        {
  13594. +            r = count;
  13595. +            if(r > 32) r = 32;
  13596. +            memcpy_fromfs(buffer, buf, r);
  13597. +            p = buffer;
  13598. +            }
  13599. +        c = from_user ? *p++ : *buf;
  13600. +        buf++; n++; count--;
  13601. +        if(from_user) r--;
  13602. +
  13603. +        if (utf) {
  13604. +            /* Combine UTF-8 into Unicode */
  13605. +            /* Incomplete characters silently ignored */
  13606. +            if(c > 0x7f) {
  13607. +            if (utf_count > 0 && (c & 0xc0) == 0x80) {
  13608. +                utf_char = (utf_char << 6) | (c & 0x3f);
  13609. +                utf_count--;
  13610. +                if (utf_count == 0)
  13611. +                    c = utf_char;
  13612. +                else continue;
  13613. +            } else {
  13614. +                if ((c & 0xe0) == 0xc0) {
  13615. +                    utf_count = 1;
  13616. +                    utf_char = (c & 0x1f);
  13617. +                } else if ((c & 0xf0) == 0xe0) {
  13618. +                    utf_count = 2;
  13619. +                    utf_char = (c & 0x0f);
  13620. +                } else
  13621. +                    utf_count = 0;
  13622. +                continue;
  13623. +            }
  13624. +            } else
  13625. +              utf_count = 0;
  13626. +
  13627. +            tc = conv_uni_to_pc(c);
  13628. +            if (tc == -1 || tc == -2)
  13629. +              continue;
  13630. +            if (tc == -3 || tc == -4) { /* hashtable not valid */
  13631. +                            /* or symbol not found */
  13632. +                tc = (c <= 0xff) ? translate[c] : 040;
  13633. +                ok = 0;
  13634. +            } else
  13635. +                ok = 1;
  13636. +        } else {    /* no utf */
  13637. +            tc = translate[toggle_meta ? (c|0x80) : c];
  13638. +            ok = 0;
  13639. +        }
  13640. +
  13641. +        /* If the origional code was < 32 we only allow a
  13642. +         * glyph to be displayed if the code is not normally
  13643. +         * used (such as for cursor movement) or if the
  13644. +         * disp_ctrl mode has been explicitly enabled.
  13645. +         * Note: ESC is *never* allowed to be displayed as
  13646. +         * that would disable all escape sequences!
  13647. +         */
  13648. +        if (!ok && tc && (c >= 32 || (disp_ctrl && c !=0x1b)
  13649. +        || !((CTRL_ACTION >> c) & 1)))
  13650. +            ok = 1;
  13651. +
  13652. +        if (vc_state == ESnormal && ok) {
  13653. +            if (need_wrap) {
  13654. +                cr(currcons);
  13655. +                lf(currcons);
  13656. +                  }
  13657. +            if(decim)
  13658. +                insert_char(currcons);
  13659. +            charwrite(currcons, pos, translate[c]);
  13660. +            if (x == video_num_columns - 1)
  13661. +                need_wrap = decawm;
  13662. +            else {
  13663. +                x++;
  13664. +                pos+=bytes_per_char_h;
  13665. +            }
  13666. +            continue;
  13667. +        }
  13668. +
  13669. +        /*
  13670. +         *  Control characters can be used in the _middle_
  13671. +         *  of an escape sequence.
  13672. +         */
  13673. +        switch(c) {
  13674. +            case 7:
  13675. +                kd_mksound(0x637, HZ/8);
  13676. +                continue;
  13677. +            case 8:
  13678. +                bs(currcons);
  13679. +                continue;
  13680. +            case 9:
  13681. +                pos -= x * bytes_per_char_h;
  13682. +                while (x < video_num_columns - 1) {
  13683. +                    x++;
  13684. +                    if (tab_stop[x >> 5] & (1 << (x & 31)))
  13685. +                        break;
  13686. +                }
  13687. +                pos += x * bytes_per_char_h;
  13688. +                continue;
  13689. +            case 10: case 11: case 12:
  13690. +                lf(currcons);
  13691. +                if(!is_kbd(lnm))
  13692. +                    continue;
  13693. +            case 13:
  13694. +                cr(currcons);
  13695. +                continue;
  13696. +            case 14:
  13697. +                charset = 1;
  13698. +                translate = set_translate(G1_charset);
  13699. +                disp_ctrl = 1;
  13700. +                continue;
  13701. +            case 15:
  13702. +                charset = 0;
  13703. +                translate = set_translate(G0_charset);
  13704. +                disp_ctrl = 0;
  13705. +                continue;
  13706. +            case 24: case 26:
  13707. +                vc_state = ESnormal;
  13708. +                continue;
  13709. +            case 27:
  13710. +                vc_state = ESesc;
  13711. +                continue;
  13712. +            case 127:
  13713. +                del(currcons);
  13714. +                continue;
  13715. +            case 128+27:
  13716. +                vc_state = ESsquare;
  13717. +                continue;
  13718. +            }
  13719. +        switch(vc_state) {
  13720. +            case ESesc:
  13721. +                vc_state = ESnormal;
  13722. +                switch (c) {
  13723. +                    case '[':
  13724. +                        vc_state = ESsquare;
  13725. +                        continue;
  13726. +                    case '%':
  13727. +                        vc_state = ESpercent;
  13728. +                        continue;
  13729. +                    case 'E':
  13730. +                        cr(currcons);
  13731. +                        lf(currcons);
  13732. +                        continue;
  13733. +                    case 'M':
  13734. +                        ri(currcons);
  13735. +                        continue;
  13736. +                    case 'D':
  13737. +                        lf(currcons);
  13738. +                        continue;
  13739. +                    case 'H':
  13740. +                        tab_stop[x >> 5] |= (1 << (x & 31));
  13741. +                        continue;
  13742. +                    case 'Z':
  13743. +                        respond_ID(tty);
  13744. +                        continue;
  13745. +                    case '7':
  13746. +                        save_cur(currcons);
  13747. +                        continue;
  13748. +                    case '8':
  13749. +                        restore_cur(currcons);
  13750. +                        continue;
  13751. +                    case '(':
  13752. +                        vc_state = ESsetG0;
  13753. +                        continue;
  13754. +                    case ')':
  13755. +                        vc_state = ESsetG1;
  13756. +                        continue;
  13757. +                    case '#':
  13758. +                        vc_state = EShash;
  13759. +                        continue;
  13760. +                    case 'c':
  13761. +                        reset_terminal(currcons,1);
  13762. +                        continue;
  13763. +                    case '>': /* Numeric keypad */
  13764. +                        clr_kbd(kbdapplic);
  13765. +                        continue;
  13766. +                    case '=': /* Appl. keypad */
  13767. +                        set_kbd(kbdapplic);
  13768. +                        continue;
  13769. +                }
  13770. +                continue;
  13771. +            case ESsquare:
  13772. +                for(npar = 0; npar < NPAR ; npar++)
  13773. +                    par[npar] = 0;
  13774. +                npar = 0;
  13775. +                vc_state = ESgetpars;
  13776. +                if (c == '[') { /* Function key */
  13777. +                    vc_state=ESfunckey;
  13778. +                    continue;
  13779. +                }
  13780. +                ques = (c == '?');
  13781. +                if (ques)
  13782. +                    continue;
  13783. +            case ESgetpars:
  13784. +                if(c==';' && npar<NPAR-1) {
  13785. +                    npar++;
  13786. +                    continue;
  13787. +                } else if (c>='0' && c<='9') {
  13788. +                    par[npar] = par[npar] * 10 + c - '0';
  13789. +                    continue;
  13790. +                } else vc_state=ESgotpars;
  13791. +            case ESgotpars:
  13792. +                vc_state=ESnormal;
  13793. +                switch (c) {
  13794. +                    case 'h':
  13795. +                        set_mode(currcons,1);
  13796. +                        continue;
  13797. +                    case 'l':
  13798. +                        set_mode(currcons,0);
  13799. +                        continue;
  13800. +                    case 'n':
  13801. +                        if (!ques) {
  13802. +                            if (par[0] == 5)
  13803. +                                status_report(tty);
  13804. +                            else if (par[0] == 6)
  13805. +                                cursor_report(currcons,tty);
  13806. +                        }
  13807. +                        continue;
  13808. +                }
  13809. +                if (ques) {
  13810. +                    ques = 0;
  13811. +                    continue;
  13812. +                }
  13813. +                switch(c) {
  13814. +                    case 'G': case '`':
  13815. +                        if (par[0]) par[0]--;
  13816. +                        gotoxy(currcons,par[0],y);
  13817. +                        continue;
  13818. +                    case 'A':
  13819. +                        if (!par[0]) par[0]++;
  13820. +                        gotoxy(currcons,x,y-par[0]);
  13821. +                        continue;
  13822. +                    case 'B': case 'e':
  13823. +                        if (!par[0]) par[0]++;
  13824. +                        gotoxy(currcons,x,y+par[0]);
  13825. +                        continue;
  13826. +                    case 'C': case 'a':
  13827. +                        if (!par[0]) par[0]++;
  13828. +                        gotoxy(currcons,x+par[0],y);
  13829. +                        continue;
  13830. +                    case 'D':
  13831. +                        if (!par[0]) par[0]++;
  13832. +                        gotoxy(currcons,x-par[0],y);
  13833. +                        continue;
  13834. +                    case 'E':
  13835. +                        if (!par[0]) par[0]++;
  13836. +                        gotoxy(currcons,0,y+par[0]);
  13837. +                        continue;
  13838. +                    case 'F':
  13839. +                        if (!par[0]) par[0]++;
  13840. +                        gotoxy(currcons,0,y-par[0]);
  13841. +                        continue;
  13842. +                    case 'd':
  13843. +                        if (par[0]) par[0]--;
  13844. +                        gotoxy(currcons,x,par[0]);
  13845. +                        continue;
  13846. +                    case 'H': case 'f':
  13847. +                        if (par[0]) par[0]--;
  13848. +                        if (par[1]) par[1]--;
  13849. +                        gotoxy(currcons,par[1],par[0]);
  13850. +                        continue;
  13851. +                    case 'J':
  13852. +                        csi_J(currcons,par[0]);
  13853. +                        continue;
  13854. +                    case 'K':
  13855. +                        csi_K(currcons,par[0]);
  13856. +                        continue;
  13857. +                    case 'L':
  13858. +                        csi_L(currcons,par[0]);
  13859. +                        continue;
  13860. +                    case 'M':
  13861. +                        csi_M(currcons,par[0]);
  13862. +                        continue;
  13863. +                    case 'P':
  13864. +                        csi_P(currcons,par[0]);
  13865. +                        continue;
  13866. +                    case 'c':
  13867. +                        if (!par[0])
  13868. +                            respond_ID(tty);
  13869. +                        continue;
  13870. +                    case 'g':
  13871. +                        if (!par[0])
  13872. +                            tab_stop[x >> 5] &= ~(1 << (x & 31));
  13873. +                        else if (par[0] == 3) {
  13874. +                            tab_stop[0] =
  13875. +                            tab_stop[1] =
  13876. +                            tab_stop[2] =
  13877. +                            tab_stop[3] =
  13878. +                            tab_stop[4] = 0;
  13879. +                        }
  13880. +                        continue;
  13881. +                    case 'm':
  13882. +                        csi_m(currcons);
  13883. +                        continue;
  13884. +                    case 'q': /* DECLL - but only 3 leds */
  13885. +                        /* map 0,1,2,3 to 0,1,2,4 */
  13886. +                        if (par[0] < 4)
  13887. +                          setledstate(kbd_table + currcons,
  13888. +                                    (par[0] < 3 ? par[0] : 4));
  13889. +                        continue;
  13890. +                    case 'r':
  13891. +                        if (!par[0])
  13892. +                            par[0]++;
  13893. +                        if (!par[1])
  13894. +                            par[1] = video_num_lines;
  13895. +                        if (par[0] < par[1] &&
  13896. +                            par[1] <= video_num_lines) {
  13897. +                            top=par[0]-1;
  13898. +                            bottom=par[1];
  13899. +                            gotoxy(currcons,0,0);
  13900. +                        }
  13901. +                        continue;
  13902. +                    case 's':
  13903. +                        save_cur(currcons);
  13904. +                        continue;
  13905. +                    case 'u':
  13906. +                        restore_cur(currcons);
  13907. +                        continue;
  13908. +                    case 'X':
  13909. +                        csi_X(currcons, par[0]);
  13910. +                        continue;
  13911. +                    case '@':
  13912. +                        csi_at(currcons,par[0]);
  13913. +                        continue;
  13914. +                    case ']': /* setterm functions */
  13915. +                        setterm_command(currcons);
  13916. +                        continue;
  13917. +                }
  13918. +                continue;
  13919. +            case ESpercent:
  13920. +                vc_state = ESnormal;
  13921. +                switch (c) {
  13922. +                    case '@': /* defined in ISO 2022 */
  13923. +                        utf = 0;
  13924. +                        continue;
  13925. +                    case 'G': /* prelim official escape code */
  13926. +                    case '8': /* retained for compatibility */
  13927. +                        utf = 1;
  13928. +                        continue;
  13929. +                }
  13930. +                continue;
  13931. +            case ESfunckey:
  13932. +                vc_state = ESnormal;
  13933. +                continue;
  13934. +            case EShash:
  13935. +                vc_state = ESnormal;
  13936. +                if (c == '8') {
  13937. +                    /* DEC screen alignment test. kludge :-) */
  13938. +                }
  13939. +                continue;
  13940. +            case ESsetG0:
  13941. +                if (c == '0')
  13942. +                    G0_charset = GRAF_MAP;
  13943. +                else if (c == 'B')
  13944. +                    G0_charset = NORM_MAP;
  13945. +                else if (c == 'U')
  13946. +                    G0_charset = NULL_MAP;
  13947. +                else if (c == 'K')
  13948. +                    G0_charset = USER_MAP;
  13949. +                if (charset == 0)
  13950. +                    translate = set_translate(G0_charset);
  13951. +                vc_state = ESnormal;
  13952. +                continue;
  13953. +            case ESsetG1:
  13954. +                if (c == '0')
  13955. +                    G1_charset = GRAF_MAP;
  13956. +                else if (c == 'B')
  13957. +                    G1_charset = NORM_MAP;
  13958. +                else if (c == 'U')
  13959. +                    G1_charset = NULL_MAP;
  13960. +                else if (c == 'K')
  13961. +                    G1_charset = USER_MAP;
  13962. +                if (charset == 1)
  13963. +                    translate = set_translate(G1_charset);
  13964. +                vc_state = ESnormal;
  13965. +                continue;
  13966. +            default:
  13967. +                vc_state = ESnormal;
  13968. +        }
  13969. +    }
  13970. +    if (vcmode != KD_GRAPHICS)
  13971. +        set_cursor(currcons);
  13972. +    enable_bh(KEYBOARD_BH);
  13973. +    restore_cursors(currcons);
  13974. +    return n;
  13975. +}
  13976. +
  13977. +static int con_write_room(struct tty_struct *tty)
  13978. +{
  13979. +    if (tty->stopped)
  13980. +        return 0;
  13981. +    return 4096;        /* No limit, really; we're not buffering */
  13982. +}
  13983. +
  13984. +static int con_chars_in_buffer(struct tty_struct *tty)
  13985. +{
  13986. +    return 0;        /* we're not buffering */
  13987. +}
  13988. +
  13989. +void poke_blanked_console(void)
  13990. +{
  13991. +    timer_active&=~(1<<BLANK_TIMER);
  13992. +    if (vt_cons[fg_console]->vc_mode == KD_GRAPHICS)
  13993. +        return;
  13994. +    if (console_blanked) {
  13995. +        timer_table[BLANK_TIMER].expires = 0;
  13996. +        timer_active |= 1<<BLANK_TIMER;
  13997. +    } else if(blankinterval) {
  13998. +        timer_table[BLANK_TIMER].expires = jiffies + blankinterval;
  13999. +        timer_active |= 1<<BLANK_TIMER;
  14000. +    }
  14001. +}
  14002. +
  14003. +static void console_print(const char *b)
  14004. +{
  14005. +    int currcons = fg_console;
  14006. +    unsigned char c;
  14007. +    static int printing = 0;
  14008. +
  14009. +  if(vt_cons[fg_console]->vc_mode == KD_GRAPHICS)
  14010. +  {
  14011. +    prints(b);
  14012. +    return;
  14013. +  }
  14014. +
  14015. +    if (!printable || printing)
  14016. +        return;  /* console not yet initialized */
  14017. +    printing = 1;
  14018. +
  14019. +    if(!vc_cons_allocated(currcons)) {
  14020. +        /* impossible */
  14021. +          printk("console_print: tty %d not allocated ??\n",currcons+1);
  14022. +          return;
  14023. +    }
  14024. +
  14025. +    remove_cursors(currcons);
  14026. +
  14027. +    while ((c = *b++) != 0) {
  14028. +        if (c == 10 || c == 13 || need_wrap) {
  14029. +            if (c != 13)
  14030. +                lf(currcons);
  14031. +            cr(currcons);
  14032. +            if(c==10 || c==13)
  14033. +                continue;
  14034. +        }
  14035. +        charwrite(currcons,pos,c);
  14036. +        if (x == video_num_columns - 1) {
  14037. +            need_wrap=1;
  14038. +            continue;
  14039. +        }
  14040. +        x++;
  14041. +        pos += bytes_per_char_h;
  14042. +    }
  14043. +    set_cursor(currcons);
  14044. +
  14045. +    restore_cursors(currcons);
  14046. +
  14047. +    poke_blanked_console();
  14048. +    printing = 0;
  14049. +}
  14050. +
  14051. +/*
  14052. + * con_throttle and con_unthrottle are only used for
  14053. + * paste_selection(), which has to stuff in a large number of
  14054. + * characters...
  14055. + */
  14056. +static void con_throttle(struct tty_struct *tty)
  14057. +{
  14058. +}
  14059. +
  14060. +static void con_unthrottle(struct tty_struct *tty)
  14061. +{
  14062. +      struct vt_struct *vt = (struct vt_struct *)tty->driver_data;
  14063. +
  14064. +      wake_up_interruptible(&vt->paste_wait);
  14065. +}
  14066. +
  14067. +static void vc_init(unsigned int currcons, unsigned long rows, unsigned long cols, int do_clear)
  14068. +{
  14069. +    long base = (long) vc_scrbuf[currcons];
  14070. +
  14071. +    video_num_columns = cols;
  14072. +    video_num_lines   = rows;
  14073. +    video_size_row    = video_num_columns*bytes_per_char_h*bytes_per_char_v;
  14074. +    video_screen_size = video_num_lines * video_size_row;
  14075. +    video_buf_size    = video_num_lines * video_num_columns * 4;
  14076. +    video_mem_start   = video_mem_base;
  14077. +    video_mem_end      = video_mem_term;
  14078. +
  14079. +    pos = origin      = video_mem_start;
  14080. +    scr_end          = video_mem_start + video_num_lines * video_size_row;
  14081. +    video_mem_end     = base + video_screen_size;
  14082. +    reset_vc(currcons);
  14083. +    def_forecol      = color_table[7];
  14084. +    def_backcol      = color_table[0];
  14085. +    vt_cons[currcons]->paste_wait = 0;
  14086. +    cursoron      = 0;
  14087. +
  14088. +    reset_terminal(currcons,do_clear);
  14089. +}
  14090. +
  14091. +static void con_setsize(unsigned long rows,unsigned long cols)
  14092. +{
  14093. +    video_num_lines   = rows;
  14094. +    video_num_columns = cols;
  14095. +    video_size_row    = video_num_columns*bytes_per_char_h*bytes_per_char_v;
  14096. +    video_screen_size = video_num_lines * video_size_row;
  14097. +    video_buf_size    = video_num_lines * video_num_columns * 4;
  14098. +}
  14099. +
  14100. +static int con_ioctl(struct tty_struct *tty, struct file * file,
  14101. +         unsigned int cmd, unsigned long arg)
  14102. +{
  14103. +    return vt_ioctl(tty, file, cmd, arg);
  14104. +}
  14105. +
  14106. +/*
  14107. + *  long con_init(long);
  14108. + *
  14109. + * This routine initialises console interrupts, and does nothing
  14110. + * else. If you want the screen to clear, call tty_write with
  14111. + * the apropriate escape-sequence.
  14112. + *
  14113. + */
  14114. +long con_init(long kmem_start)
  14115. +{
  14116. +    int currcons = 0, i;
  14117. +
  14118. +    memset(&console_driver, 0, sizeof(struct tty_driver));
  14119. +    console_driver.magic = TTY_DRIVER_MAGIC;
  14120. +    console_driver.name = "tty";
  14121. +    console_driver.name_base = 1;
  14122. +    console_driver.major = TTY_MAJOR;
  14123. +    console_driver.minor_start = 1;
  14124. +    console_driver.num = MAX_NR_CONSOLES;
  14125. +    console_driver.type = TTY_DRIVER_TYPE_CONSOLE;
  14126. +    console_driver.init_termios = tty_std_termios;
  14127. +    console_driver.flags = TTY_DRIVER_REAL_RAW;
  14128. +    console_driver.refcount = &console_refcount;
  14129. +    console_driver.table = console_table;
  14130. +    console_driver.termios = console_termios;
  14131. +    console_driver.termios_locked = console_termios_locked;
  14132. +
  14133. +    console_driver.open = con_open;
  14134. +    console_driver.write = con_write;
  14135. +    console_driver.write_room = con_write_room;
  14136. +    console_driver.chars_in_buffer = con_chars_in_buffer;
  14137. +    console_driver.ioctl = con_ioctl;
  14138. +    console_driver.stop = con_stop;
  14139. +    console_driver.start = con_start;
  14140. +    console_driver.throttle = con_throttle;
  14141. +    console_driver.unthrottle = con_unthrottle;
  14142. +
  14143. +    if(tty_register_driver(&console_driver))
  14144. +          panic("Couldn't register console driver\n");
  14145. +
  14146. +    con_setsize(ORIG_VIDEO_LINES,ORIG_VIDEO_COLS);
  14147. +
  14148. +    timer_table[BLANK_TIMER].fn=blank_screen;
  14149. +    timer_table[BLANK_TIMER].expires=0;
  14150. +    if(blankinterval) {
  14151. +          timer_table[BLANK_TIMER].expires=jiffies+blankinterval;
  14152. +        timer_active|=1<<BLANK_TIMER;
  14153. +    }
  14154. +
  14155. +    for(i=0; i<17; i++)
  14156. +        vidc_write(i<<2, default_palette_entries[i]);
  14157. +
  14158. +    /* Use ORIG_VIDEO_MODE */
  14159. +    video_addr_mask= (video_num_lines * video_num_columns * bytes_per_char_h *
  14160. +                 bytes_per_char_v - 1) | (PAGE_SIZE-1);
  14161. +    video_mem_term = 0x02000000;
  14162. +    video_mem_base = video_mem_term - video_addr_mask - 1;
  14163. +
  14164. +    map_screen_mem (video_mem_base, 1);
  14165. +
  14166. +    can_do_color=1;
  14167. +    if(bytes_per_char_h == 8)
  14168. +    {
  14169. +        default_palette_entries = palette_8;
  14170. +        color_table = color_8;
  14171. +    }
  14172. +
  14173. +    for(currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) {
  14174. +        vc_cons[currcons].d = (struct vc_data *) kmem_start;
  14175. +        kmem_start += sizeof(struct vc_data);
  14176. +        vt_cons[currcons] = (struct vt_struct *) kmem_start;
  14177. +        kmem_start += sizeof(struct vt_struct);
  14178. +        vc_scrbuf[currcons] = (unsigned char *) kmem_start;
  14179. +        memfastset(vc_scrbuf[currcons],    0x00000720, video_buf_size);
  14180. +        kmem_start += video_buf_size;
  14181. +        kmalloced = 0;
  14182. +        screenbuf_size = video_buf_size;
  14183. +        vc_init(currcons, video_num_lines, video_num_columns,currcons);
  14184. +    }
  14185. +
  14186. +    currcons = fg_console = 0;
  14187. +
  14188. +    video_mem_start = video_mem_base;
  14189. +    video_mem_end    = video_mem_term;
  14190. +    pos=origin=cp    = video_mem_start;
  14191. +    scr_end        = video_mem_start + video_num_lines * video_size_row;
  14192. +    cursoron    = 1;
  14193. +
  14194. +    gotoxy (currcons,ORIG_X,ORIG_Y);
  14195. +    csi_J (currcons, 0);
  14196. +    printable=1;
  14197. +    printk ("Console: %s %s %ldx%ldx%d, %d virtual console%s (max %d)\n","colour", "A5000",
  14198. +          video_num_columns,
  14199. +          video_num_lines,
  14200. +          bytes_per_char_h == 8 ? 256:16,
  14201. +          MIN_NR_CONSOLES,
  14202. +          (MIN_NR_CONSOLES == 1) ? "":"s",
  14203. +          MAX_NR_CONSOLES);
  14204. +    register_console (console_print);
  14205. +    if(request_irq (IRQ_VSYNCPULSE, vsync_irq, 0, "console"))
  14206. +        panic ("Unable to get VSYNC irq for console\n");
  14207. +    return kmem_start;
  14208. +}
  14209. +
  14210. +static void get_scrmem(int currcons)
  14211. +{
  14212. +}
  14213. +
  14214. +void update_scrmem(int currcons, int start, int length)
  14215. +{
  14216. +    unsigned long p, pp, sx, sy, ex, ey;
  14217. +    unsigned long *buffer;
  14218. +
  14219. +    sy = start / video_num_columns;
  14220. +    sx = start % video_num_columns;
  14221. +    length += start;
  14222. +    ey = length / video_num_columns;
  14223. +    ex = length % video_num_columns;
  14224. +
  14225. +    if (ey > video_num_lines)
  14226. +        ey = video_num_lines;
  14227. +
  14228. +    p = origin + sy * video_size_row;
  14229. +    buffer = ((unsigned long *)vc_scrbuf[currcons]) + start;
  14230. +
  14231. +    if (ey > sy)
  14232. +    {
  14233. +        for (; sy < ey; sy++)
  14234. +        {
  14235. +            pp = p + sx * bytes_per_char_h;
  14236. +            for (; sx < video_num_columns; sx++)
  14237. +            {
  14238. +                ll_char_write (pp, buffer[0] & 0xff, (buffer[0] >> 8) & 0xff,
  14239. +                    (buffer[0] >> 16) & 0xff, (buffer[0] >> 24) & 0xff);
  14240. +                pp += bytes_per_char_h;
  14241. +                buffer ++;
  14242. +            }
  14243. +            p += video_size_row;
  14244. +            sx = 0;
  14245. +        }
  14246. +    }
  14247. +    if (ey == sy && ex)
  14248. +    {
  14249. +        for (; sx < ex; sx++)
  14250. +        {
  14251. +            ll_char_write (p, buffer[0] & 0xff, (buffer[0] >> 8) & 0xff,
  14252. +                (buffer[0] >> 16) & 0xff, (buffer[0] >> 24) & 0xff);
  14253. +            p += bytes_per_char_h;
  14254. +            buffer ++;
  14255. +        }
  14256. +    }
  14257. +}
  14258. +
  14259. +void set_scrmem(int currcons,long offset)
  14260. +{
  14261. +    unsigned long p,pp,mx,my;
  14262. +    unsigned long *buffer;
  14263. +    int i;
  14264. +
  14265. +    p = origin;
  14266. +    buffer = (unsigned long *)vc_scrbuf[currcons];
  14267. +
  14268. +    for(my = 0; my < video_num_lines ; my++)
  14269. +    {
  14270. +        pp = p;
  14271. +        for(mx = 0; mx < video_num_columns; mx++)
  14272. +        {
  14273. +            ll_char_write(pp,buffer[0] & 0xff,(buffer[0] >> 8) & 0xff,
  14274. +                     (buffer[0] >> 16) & 0xff,(buffer[0] >> 24) & 0xff);
  14275. +            pp+=bytes_per_char_h;
  14276. +            buffer+=1;
  14277. +        }
  14278. +        p+=video_size_row;
  14279. +    }
  14280. +    pp = origin + ((video_screen_size + 0x7FFF) & PAGE_MASK);
  14281. +    while(p<pp)
  14282. +    {
  14283. +        *(unsigned long *)p=0;
  14284. +        p+=4;
  14285. +    }
  14286. +    if(!paletteentries || vcmode != KD_GRAPHICS)
  14287. +        for(i=0; i<17; i++)
  14288. +            vidc_write(i<<2, default_palette_entries[i]);
  14289. +    else
  14290. +        for(i=0; i<17; i++)
  14291. +            vidc_write(i<<2, paletteentries[i] & 0x1fff);
  14292. +}
  14293. +
  14294. +/* ------------------------------------------------------------------------------------- *
  14295. + * Screen blanking routines
  14296. + * ------------------------------------------------------------------------------------- */
  14297. +
  14298. +void do_blank_screen(int nopowersave)
  14299. +{
  14300. +    int i;
  14301. +
  14302. +    if (console_blanked)
  14303. +        return;
  14304. +
  14305. +    timer_active &= ~(1<<BLANK_TIMER);
  14306. +    timer_table[BLANK_TIMER].fn = unblank_screen;
  14307. +
  14308. +    /* DISABLE VIDEO */
  14309. +    for (i = 0; i < 17; i++)
  14310. +        vidc_write(i<<2, 0);
  14311. +
  14312. +    console_blanked = fg_console + 1;
  14313. +}
  14314. +
  14315. +void do_unblank_screen(void)
  14316. +{
  14317. +    int i;
  14318. +    int currcons;
  14319. +
  14320. +    if (!console_blanked)
  14321. +        return;
  14322. +    if (!vc_cons_allocated(fg_console)) {
  14323. +        /* impossible */
  14324. +        printk("unblank_screen: tty %d not allocated ??\n", fg_console+1);
  14325. +        return;
  14326. +    }
  14327. +    timer_table[BLANK_TIMER].fn = blank_screen;
  14328. +    if (blankinterval)
  14329. +    {
  14330. +        timer_table[BLANK_TIMER].expires = jiffies + blankinterval;
  14331. +        timer_active |= 1<<BLANK_TIMER;
  14332. +    }
  14333. +
  14334. +    currcons = fg_console;
  14335. +    console_blanked = 0;
  14336. +
  14337. +    if(!paletteentries || vcmode != KD_GRAPHICS)
  14338. +        for(i=0; i<17; i++)
  14339. +            vidc_write(i<<2, default_palette_entries[i]);
  14340. +    else
  14341. +        for(i=0; i<17; i++)
  14342. +            vidc_write(i<<2, paletteentries[i] & 0x1fff);
  14343. +}
  14344. +
  14345. +/*
  14346. + * If a blank_screen is due to a timer, then a power save is allowed.
  14347. + * If it is related to console_switching, then avoid power save.
  14348. + */
  14349. +static void blank_screen(void)
  14350. +{
  14351. +    do_blank_screen(0);
  14352. +}
  14353. +
  14354. +static void unblank_screen(void)
  14355. +{
  14356. +    do_unblank_screen();
  14357. +}
  14358. +
  14359. +void update_screen(int new_console)
  14360. +{
  14361. +    static int lock = 0;
  14362. +
  14363. +    if(new_console == fg_console || lock)
  14364. +        return;
  14365. +    if(!vc_cons_allocated(new_console)) {
  14366. +        /* strange ... */
  14367. +        printk("update_screen: tty %d not allocated ??\n",new_console);
  14368. +        return;
  14369. +    }
  14370. +    lock = 1;
  14371. +    
  14372. +    highlight_pointer(fg_console,-1);
  14373. +    
  14374. +    remove_cursors(fg_console);
  14375. +    
  14376. +    if(!console_blanked)
  14377. +        get_scrmem(fg_console);
  14378. +    else
  14379. +        console_blanked = -1;        /* no longer of the form console+1 */
  14380. +    fg_console = new_console;    /* this is the only (nonzero) assignment to fg_console */
  14381. +                    /* consequently, fg_console will always be allocated */
  14382. +    set_scrmem(fg_console, 0);
  14383. +    set_origin(fg_console);
  14384. +    set_cursor(fg_console);
  14385. +    restore_cursors(fg_console);
  14386. +    set_leds();
  14387. +    compute_shiftstate();
  14388. +    lock = 0;
  14389. +}
  14390. +
  14391. +/*
  14392. + * Allocate the console screen memory
  14393. + */
  14394. +int con_open(struct tty_struct *tty,struct file *filp)
  14395. +{
  14396. +    unsigned int idx;
  14397. +    int i;
  14398. +    
  14399. +    idx = MINOR(tty->device) - tty->driver.minor_start;
  14400. +
  14401. +    i = vc_allocate(idx);
  14402. +    if(i)
  14403. +        return i;
  14404. +
  14405. +    vt_cons[idx]->vc_num = idx;
  14406. +    tty->driver_data = vt_cons[idx];
  14407. +
  14408. +    if(!tty->winsize.ws_row && !tty->winsize.ws_col) {
  14409. +        tty->winsize.ws_row = video_num_lines;
  14410. +        tty->winsize.ws_col = video_num_columns;
  14411. +    }
  14412. +    return 0;
  14413. +}
  14414. +
  14415. +/*
  14416. + * PIO_FONT support
  14417. + */
  14418. +int con_set_font (char *arg)
  14419. +{
  14420. +    return -EINVAL;
  14421. +}
  14422. +
  14423. +int con_get_font (char *arg)
  14424. +{
  14425. +    return -EINVAL;
  14426. +}
  14427. +
  14428. +/* == arm specific console code ============================================================== */
  14429. +
  14430. +int palette_getentries(int currcons, int offset, int size, unsigned long *entries)
  14431. +{
  14432. +  int i;
  14433. +
  14434. +  if(offset>18 || offset<0 || size<1)
  14435. +    return -EINVAL;
  14436. +
  14437. +  if(size>19)
  14438. +    size=19;
  14439. +
  14440. +  verify_area(VERIFY_WRITE,entries,size);
  14441. +
  14442. +  if(!paletteentries)
  14443. +    for(i=offset; i<offset+size; i++)
  14444. +      *entries++=default_palette_entries[i];
  14445. +  else
  14446. +    for(i=offset; i<offset+size; i++)
  14447. +      *entries++=(paletteentries[i] & 0x1FFF);
  14448. +
  14449. +  return size;
  14450. +}
  14451. +
  14452. +int palette_setentries(int currcons, int offset, int size, unsigned long *entries)
  14453. +{
  14454. +  int i;
  14455. +
  14456. +  if(offset>18 || offset<0 || size<1)
  14457. +    return -EINVAL;
  14458. +
  14459. +  if(size>19)
  14460. +    size=19;
  14461. +
  14462. +  verify_area(VERIFY_READ, entries, size);
  14463. +
  14464. +  if(!paletteentries)
  14465. +  {
  14466. +    paletteentries = (unsigned long *)kmalloc(sizeof(unsigned long)*19,GFP_KERNEL);
  14467. +    if(!paletteentries)
  14468. +      return -ENOMEM;
  14469. +
  14470. +    for(i=0; i<19; i++)
  14471. +      paletteentries[i]=default_palette_entries[i];
  14472. +  }
  14473. +
  14474. +  for(i=offset; i<offset+size; i++)
  14475. +    paletteentries[i]=(*entries++);
  14476. +
  14477. +  if(vcmode == KD_GRAPHICS && currcons == fg_console)
  14478. +    for(i=0; i<17; i++)
  14479. +      vidc_write(i<<2, paletteentries[i] & 0x1fff);
  14480. +
  14481. +  return size;
  14482. +}
  14483. +
  14484. +void palette_update(int currcons)
  14485. +{
  14486. +  int i;
  14487. +  if(vcmode == KD_GRAPHICS && paletteentries)
  14488. +    for(i=0; i<17; i++)
  14489. +      vidc_write(i<<2, paletteentries[i] & 0x1fff);
  14490. +  else
  14491. +    for(i=0; i<17; i++)
  14492. +      vidc_write(i<<2, default_palette_entries[i]);
  14493. +}
  14494. +
  14495. +int console_getparams(int con, unsigned long *data)
  14496. +{
  14497. +    data[0] = 0;                    /* version      */
  14498. +    data[1] = video_num_columns * 8;        /* horiz pixels */
  14499. +    data[2] = video_num_lines * 8;            /* vert. pixels */
  14500. +    data[3] = bytes_per_char_h == 4 ? 4 : 8;    /* bits per pix */
  14501. +    data[4] = 4;                    /* depth        */
  14502. +    return 0;
  14503. +}
  14504. +
  14505. +static void put_cursor(char on_off,unsigned long newcp)
  14506. +{
  14507. +  static char con=0;
  14508. +  unsigned long cp_p=cp;
  14509. +  int c = bytes_per_char_h == 8 ? color_table[15] : 0x11 * color_table[15];
  14510. +  int i;
  14511. +
  14512. +  if(vt_cons[fg_console]->vc_mode == KD_GRAPHICS)
  14513. +    return;
  14514. +
  14515. +  cp=newcp;
  14516. +
  14517. +  if(con!=on_off)
  14518. +  {
  14519. +    if(cp_p!=-1)
  14520. +      for(i=0;i<bytes_per_char_h;i++)
  14521. +        ((unsigned char*)cp_p)[i]^=c;
  14522. +    con=on_off;
  14523. +  }
  14524. +}
  14525. +
  14526. +static void vsync_irq(int irq, struct pt_regs *regs)
  14527. +{
  14528. +  static char cursor_flash=0;
  14529. +  int currcons = fg_console;
  14530. +
  14531. +  if(++cursor_flash==16)
  14532. +  {
  14533. +    cursor_flash=0;
  14534. +    cursor_on=cursor_on?0:1;
  14535. +    if(cursoron>0)
  14536. +      put_cursor(cursor_on,cp);
  14537. +  }
  14538. +}
  14539. +
  14540. +int do_screendump(int arg)
  14541. +{
  14542. +  char *buf=(char *)arg;
  14543. +  int l;
  14544. +  if(!suser())
  14545. +    return -EPERM;
  14546. +  l=verify_area(VERIFY_WRITE,buf,2);
  14547. +  if(l)
  14548. +    return l;
  14549. +  return -ENOSYS;
  14550. +}
  14551. +
  14552. +/* This routine reverses the highlight on s-e position */
  14553. +
  14554. +static void highlight(const int currcons, int s, int e)
  14555. +{
  14556. +    int i;
  14557. +    unsigned char *buffer = (unsigned char *)vc_scrbuf[currcons];
  14558. +
  14559. +    for(i = s; i <= e; i++)
  14560. +        buffer[4*i+3] ^= INVERSE;
  14561. +
  14562. +
  14563. +    if(currcons == fg_console)
  14564. +    {
  14565. +        unsigned long p,pp;
  14566. +        int hx,hy,hex,hey,mx,my;
  14567. +
  14568. +        buffer += (s*4);
  14569. +
  14570. +        hx = s % video_num_columns;
  14571. +        hy = s / video_num_columns;
  14572. +        hex = e % video_num_columns;
  14573. +        hey = e / video_num_columns;
  14574. +
  14575. +        p = origin + (hy * video_size_row);
  14576. +        for(my = hy; my <= hey ; my++)
  14577. +        {
  14578. +            pp = p + (hx * bytes_per_char_h);
  14579. +            for(mx = hx; mx < ((my == hey)?hex+1:video_num_columns); mx++)
  14580. +            {
  14581. +                ll_char_write(pp,buffer[0],buffer[1],buffer[2],buffer[3]);
  14582. +                pp+=bytes_per_char_h;
  14583. +                buffer+=4;
  14584. +                hx = 0;
  14585. +            }
  14586. +            p+=video_size_row;
  14587. +        }
  14588. +    }
  14589. +}
  14590. +
  14591. +static void highlight_pointer(const int currcons,const int where)
  14592. +{
  14593. +}
  14594. +
  14595. +static unsigned long inwordLut[4]={
  14596. +  0x00000000, /* control char      */
  14597. +  0x03FF0000, /* digits            */
  14598. +  0x87FFFFFE, /* uppercase and '_' */
  14599. +  0x07FFFFFE  /* lowercase         */
  14600. +};
  14601. +
  14602. +static inline int inword(const char c)
  14603. +{
  14604. +  return ( inwordLut[(c>>5)&3] >> (c&0x1F) ) & 1;
  14605. +}
  14606. +
  14607. +int sel_loadlut(const int arg)
  14608. +{
  14609. +    memcpy_fromfs(inwordLut, (unsigned long *)(arg+4), 16);
  14610. +    return 0;
  14611. +}
  14612. +
  14613. +static inline int atedge(const int p)
  14614. +{
  14615. +    return (!(p % video_num_columns) || !((p + 1) % video_num_columns));
  14616. +}
  14617. +
  14618. +/* constrain v such that l <= v <= u */
  14619. +static inline short limit(const int v, const int l, const int u)
  14620. +{
  14621. +    return (v < l) ? l : ((v > u) ? u : v);
  14622. +}
  14623. +
  14624. +int set_selection(const int arg, struct tty_struct *tty)
  14625. +{
  14626. +    unsigned short *args, xs, ys, xe, ye;
  14627. +    int sel_mode, new_sel_start, new_sel_end;
  14628. +    int ps, pe, i;
  14629. +    int currcons = fg_console;
  14630. +    char spc, *obp, *bp, *spos;
  14631. +
  14632. +    char *off = (char *)vc_scrbuf[currcons];
  14633. +
  14634. +    unblank_screen();
  14635. +    args = (unsigned short *)(arg + 1);
  14636. +    xs = limit(get_fs_word(args++) - 1, 0, video_num_columns - 1);
  14637. +    ys = limit(get_fs_word(args++) - 1, 0, video_num_lines - 1);
  14638. +    xe = limit(get_fs_word(args++) - 1, 0, video_num_columns - 1);
  14639. +    ye = limit(get_fs_word(args++) - 1, 0, video_num_lines - 1);
  14640. +    sel_mode = get_fs_word(args);
  14641. +
  14642. +    ps = ys * video_num_columns + xs;
  14643. +    pe = ye * video_num_columns + xe;
  14644. +
  14645. +    if (report_mouse && (sel_mode & 16))
  14646. +    {
  14647. +        mouse_report(currcons, tty, sel_mode & 15, xs, ys);
  14648. +        return 0;
  14649. +    }
  14650. +
  14651. +    if ( ps > pe )
  14652. +    {
  14653. +        ps ^= pe;
  14654. +        pe ^= ps;
  14655. +        ps ^= pe;
  14656. +    }
  14657. +
  14658. +    switch (sel_mode)
  14659. +    {
  14660. +        case 0: /* character-by-character selection */
  14661. +            new_sel_start = ps;
  14662. +            new_sel_end = pe;
  14663. +            break;
  14664. +        case 1:    /* word-by-word selection */
  14665. +            spc = isspace(*off + (ps << 2));
  14666. +            for (new_sel_start = ps; ; ps -= 1)
  14667. +            {
  14668. +                if ((spc && !isspace(*(off + (ps << 2)))) ||
  14669. +                    (!spc && !inword(*(off + (ps << 2)))))
  14670. +                    break;
  14671. +                new_sel_start = ps;
  14672. +                if (!(ps % video_num_columns))
  14673. +                    break;
  14674. +            }
  14675. +            spc = isspace(*(off + (pe << 2)));
  14676. +            for (new_sel_end = pe; ; pe += 1)
  14677. +            {
  14678. +                if ((spc && !isspace(*(off + (pe << 2)))) ||
  14679. +                    (!spc && !inword(*(off + (pe << 2)))))
  14680. +                    break;
  14681. +                new_sel_end = pe;
  14682. +                if (!((pe + 1) % video_num_columns))
  14683. +                    break;
  14684. +            }
  14685. +            break;
  14686. +        case 2: /* line-by-line selection */
  14687. +            new_sel_start = ps - ps % video_num_columns;
  14688. +            new_sel_end   = pe + video_num_columns - pe % video_num_columns - 1;
  14689. +            break;
  14690. +        case 3:    /* pointer highlight */
  14691. +            if (sel_cons != currcons)
  14692. +            {
  14693. +                highlight_pointer(sel_cons, -1);
  14694. +                clear_selection();
  14695. +                sel_cons = currcons;
  14696. +            }
  14697. +            highlight_pointer(sel_cons, pe);
  14698. +            return 0;
  14699. +        default:
  14700. +            return -EINVAL;
  14701. +    }
  14702. +    if(new_sel_end > new_sel_start && !atedge(new_sel_end) &&
  14703. +            isspace(*(off + (new_sel_end << 2))))
  14704. +    {
  14705. +        for (pe = new_sel_end + 1; ; pe += 1)
  14706. +        {
  14707. +            if (!isspace(*(off + (pe << 2))) || atedge(pe))
  14708. +                break;
  14709. +        }
  14710. +        if (isspace(*(off + (pe << 2))))
  14711. +            new_sel_end = pe;
  14712. +    }
  14713. +    if (sel_cons != currcons)
  14714. +    {
  14715. +        clear_selection();
  14716. +        sel_cons = currcons;
  14717. +    }
  14718. +    if(sel_start == -1)
  14719. +        highlight(sel_cons, new_sel_start, new_sel_end);
  14720. +    else if (new_sel_start == sel_start)
  14721. +    {
  14722. +        if (new_sel_end == sel_end)    /* no action required */
  14723. +            return 0;
  14724. +        else if (new_sel_end > sel_end)    /* extend to right/down */
  14725. +            highlight(sel_cons, sel_end + 1, new_sel_end);
  14726. +        else                /* contract from right/up */
  14727. +            highlight(sel_cons, new_sel_end + 1, sel_end);
  14728. +    }
  14729. +    else if (new_sel_end == sel_end)
  14730. +    {
  14731. +        if (new_sel_start < sel_start)    /* extend to left */
  14732. +            highlight(sel_cons, new_sel_start, sel_start - 1);
  14733. +        else
  14734. +            highlight(sel_cons, sel_start, new_sel_start - 1);
  14735. +    }
  14736. +    else
  14737. +    {
  14738. +        clear_selection();
  14739. +        highlight(sel_cons, new_sel_start, new_sel_end);
  14740. +    }
  14741. +    sel_start = new_sel_start;
  14742. +    sel_end = new_sel_end;
  14743. +
  14744. +    obp = bp = sel_buffer;
  14745. +
  14746. +    for (i = sel_start; i <= sel_end; i+=1)
  14747. +    {
  14748. +        spos = (char *)off + (i << 2);
  14749. +        *bp++ = *spos;
  14750. +        if (!isspace(*spos))
  14751. +            obp = bp;
  14752. +        if (! ((i+1) % video_num_columns))
  14753. +        {
  14754. +             /* strip trailing spaces from line and add newline,
  14755. +                unless non-space at end of line. */
  14756. +             if (obp != bp)
  14757. +             {
  14758. +                 bp = obp;
  14759. +                 *bp++ = '\r';
  14760. +             }
  14761. +             obp = bp;
  14762. +        }
  14763. +        /* check for space, leaving room for next character, possible
  14764. +           newline, and null at end. */
  14765. +        if (bp - sel_buffer > SEL_BUFFER_SIZE - 3)
  14766. +            break;
  14767. +    }
  14768. +    *bp = '\0';
  14769. +    return 0;
  14770. +}
  14771. +
  14772. +int paste_selection(struct tty_struct *tty)
  14773. +{
  14774. +    struct wait_queue wait;
  14775. +    char *bp = sel_buffer;
  14776. +    int c,l;
  14777. +    struct vt_struct *vt = (struct vt_struct *) tty->driver_data;
  14778. +
  14779. +    if(!sel_buffer[0])
  14780. +        return 0;
  14781. +    unblank_screen();
  14782. +    c = strlen(sel_buffer);
  14783. +    current->state = TASK_INTERRUPTIBLE;
  14784. +    add_wait_queue(&vt->paste_wait, &wait);
  14785. +    while (c) {
  14786. +        if (test_bit(TTY_THROTTLED, &tty->flags)) {
  14787. +            schedule();
  14788. +            continue;
  14789. +        }
  14790. +        l = MIN(c, tty->ldisc.receive_room(tty));
  14791. +        tty->ldisc.receive_buf(tty,(unsigned char *) bp, 0, l);
  14792. +        c -= l;
  14793. +        bp += l;
  14794. +    }
  14795. +    current->state = TASK_RUNNING;
  14796. +    return 0;
  14797. +}
  14798. +
  14799. +static void clear_selection()
  14800. +{
  14801. +    highlight_pointer(sel_cons, -1); /* hide the pointer */
  14802. +    if (sel_start != -1)
  14803. +    {
  14804. +        highlight(sel_cons, sel_start, sel_end);
  14805. +        sel_start = -1;
  14806. +    }
  14807. +}
  14808. +
  14809. +/* -------------------------------------------------------------------------------
  14810. + * erasing
  14811. + * ------------------------------------------------------------------------------- */
  14812. +
  14813. +static void ll_erasebuf(int currcons,unsigned char sx,unsigned char sy,
  14814. +            unsigned char cx,unsigned char cy)
  14815. +{
  14816. +    unsigned char *buffer = vc_scrbuf[currcons];
  14817. +    if(sx!=0) /* Erase to end of line */
  14818. +    {
  14819. +        register unsigned char c;
  14820. +        if(cy!=0)
  14821. +            c=video_num_columns-sx;
  14822. +        else
  14823. +            c=video_num_columns-sx<cx?video_num_columns-sx:cx;
  14824. +        memfastset((void*)(buffer+4*(sx+sy*video_num_columns)),
  14825. +            (backcol<<16) | (forecol<<8) | 32, 4*c);
  14826. +        cx-=c;
  14827. +        sy++;
  14828. +        if(cy>0)
  14829. +            cy--;
  14830. +        sx=0;
  14831. +    }
  14832. +    if(cy!=0)
  14833. +    {
  14834. +        memfastset((void*)(buffer+sy*video_num_columns*4),
  14835. +            (backcol<<16) | (forecol<<8) | 32,cy*video_num_columns*4);
  14836. +    }
  14837. +    if(cx!=0)
  14838. +    {
  14839. +        memfastset((void*)(buffer+(sy+cy)*video_num_columns*4),
  14840. +            (backcol<<16) | (forecol<<8) | 32,cx*4);
  14841. +    }
  14842. +}
  14843. +
  14844. +static void ll_erase(int currcons,unsigned char sx,unsigned char sy,
  14845. +                      unsigned char cx,unsigned char cy)
  14846. +{
  14847. +    register unsigned char *p,cc;
  14848. +    register unsigned int i1,i2;
  14849. +
  14850. +    ll_erasebuf(currcons,sx,sy,cx,cy);
  14851. +
  14852. +    if(currcons==fg_console)
  14853. +    {
  14854. +        cc=0x11*backcol;
  14855. +
  14856. +        if(sx!=0) /* Erase to end of line */
  14857. +        {
  14858. +            register unsigned char c;
  14859. +            if(cy!=0)
  14860. +                c=video_num_columns-sx;
  14861. +            else
  14862. +                c=video_num_columns-sx<cx?video_num_columns-sx:cx;
  14863. +            p=(unsigned char*)(origin+sy*video_num_columns*
  14864. +                        bytes_per_char_h*bytes_per_char_v+
  14865. +                                sx*bytes_per_char_h);
  14866. +            for(i1=0;i1<c*bytes_per_char_h;i1++)
  14867. +                for(i2=0;i2<bytes_per_char_v;i2++)
  14868. +                    p[i1+i2*video_num_columns*bytes_per_char_h]=cc;
  14869. +            cx-=c;
  14870. +            if(cy>0)
  14871. +                cy--;
  14872. +            sy++;
  14873. +            sx=0;
  14874. +        }
  14875. +        if(cy!=0)
  14876. +        {
  14877. +            memfastset((void*)(origin+sy*video_num_columns*
  14878. +                        bytes_per_char_h*bytes_per_char_v),
  14879. +                0x11111111L*backcol,
  14880. +                cy*bytes_per_char_h*bytes_per_char_v*video_num_columns);
  14881. +        }
  14882. +        if(cx!=0)
  14883. +        {
  14884. +            p=(unsigned char*)(origin+(sy+cy)*video_num_columns*
  14885. +                        bytes_per_char_h*bytes_per_char_v);
  14886. +            for(i1=0;i1<cx*bytes_per_char_h;i1++)
  14887. +                for(i2=0;i2<bytes_per_char_v;i2++)
  14888. +                    p[i1+i2*video_num_columns*bytes_per_char_h]=cc;
  14889. +        }
  14890. +    }
  14891. +}
  14892. +
  14893. diff -r -u -N linux.orig/arch/arm/drivers/char/consolemap.c linux.arm/arch/arm/drivers/char/consolemap.c
  14894. --- linux.orig/arch/arm/drivers/char/consolemap.c    Thu Jan  1 01:00:00 1970
  14895. +++ linux.arm/arch/arm/drivers/char/consolemap.c    Fri Oct 27 23:14:30 1995
  14896. @@ -0,0 +1,286 @@
  14897. +/*
  14898. + * consolemap.c
  14899. + *
  14900. + * Mapping from internal code (such as Latin-1 or Unicode or IBM PC code)
  14901. + * to font positions.
  14902. + *
  14903. + * aeb, 950210
  14904. + */
  14905. +
  14906. +#include <linux/kd.h>
  14907. +#include <linux/errno.h>
  14908. +#include <linux/mm.h>
  14909. +#include <linux/malloc.h>
  14910. +#include <asm/segment.h>
  14911. +#include "consolemap.h"
  14912. +
  14913. +static unsigned char * translations[] = {
  14914. +/* 8-bit Latin-1 mapped to the PC character set: '\0' means non-printable */
  14915. +(unsigned char *)
  14916. +    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  14917. +    "\0\0\0\0\0\0\0\0\0\0\376\0\0\0\0\0"
  14918. +    " !\"#$%&'()*+,-./0123456789:;<=>?"
  14919. +    "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
  14920. +    "`abcdefghijklmnopqrstuvwxyz{|}~\0"
  14921. +    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  14922. +    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  14923. +    "\377\255\233\234\376\235\174\025\376\376\246\256\252\055\376\376"
  14924. +    "\370\361\375\376\376\346\024\371\376\376\247\257\254\253\376\250"
  14925. +    "\376\376\376\376\216\217\222\200\376\220\376\376\376\376\376\376"
  14926. +    "\376\245\376\376\376\376\231\376\350\376\376\376\232\376\376\341"
  14927. +    "\205\240\203\376\204\206\221\207\212\202\210\211\215\241\214\213"
  14928. +    "\376\244\225\242\223\376\224\366\355\227\243\226\201\376\376\230",
  14929. +/* vt100 graphics */
  14930. +(unsigned char *)
  14931. +    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  14932. +    "\0\0\0\0\0\0\0\0\0\0\376\0\0\0\0\0"
  14933. +    " !\"#$%&'()*+,-./0123456789:;<=>?"
  14934. +    "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ "
  14935. +    "\004\261\007\007\007\007\370\361\007\007\331\277\332\300\305\304"
  14936. +    "\304\304\137\137\303\264\301\302\263\363\362\343\330\234\007\0"
  14937. +    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  14938. +    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  14939. +    "\377\255\233\234\376\235\174\025\376\376\246\256\252\055\376\376"
  14940. +    "\370\361\375\376\376\346\024\371\376\376\247\257\254\253\376\250"
  14941. +    "\376\376\376\376\216\217\222\200\376\220\376\376\376\376\376\376"
  14942. +    "\376\245\376\376\376\376\231\376\376\376\376\376\232\376\376\341"
  14943. +    "\205\240\203\376\204\206\221\207\212\202\210\211\215\241\214\213"
  14944. +    "\376\244\225\242\223\376\224\366\376\227\243\226\201\376\376\230",
  14945. +/* IBM graphics: minimal translations (BS, CR, LF, LL, SO, SI and ESC) */
  14946. +(unsigned char *)
  14947. +    "\000\001\002\003\004\005\006\007\000\011\000\013\000\000\000\000"
  14948. +    "\020\021\022\023\024\025\026\027\030\031\032\000\034\035\036\037"
  14949. +    "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
  14950. +    "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
  14951. +    "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
  14952. +    "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
  14953. +    "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
  14954. +    "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
  14955. +    "\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
  14956. +    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237"
  14957. +    "\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
  14958. +    "\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277"
  14959. +    "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
  14960. +    "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"
  14961. +    "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"
  14962. +    "\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377",
  14963. + /* USER: customizable mappings, initialized as the previous one (IBM) */
  14964. +(unsigned char *)
  14965. +    "\000\001\002\003\004\005\006\007\010\011\000\013\000\000\016\017"
  14966. +    "\020\021\022\023\024\025\026\027\030\031\032\000\034\035\036\037"
  14967. +    "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
  14968. +    "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
  14969. +    "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
  14970. +    "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
  14971. +    "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
  14972. +    "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
  14973. +    "\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
  14974. +    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237"
  14975. +    "\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
  14976. +    "\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277"
  14977. +    "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
  14978. +    "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"
  14979. +    "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"
  14980. +    "\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377"
  14981. +};
  14982. +
  14983. +/* the above mappings are not invertible - this is just a best effort */
  14984. +static unsigned char * inv_translate = NULL;
  14985. +static unsigned char inv_norm_transl[E_TABSZ];
  14986. +static unsigned char * inverse_translations[4] = { NULL, NULL, NULL, NULL };
  14987. +
  14988. +static void set_inverse_transl(int i)
  14989. +{
  14990. +    int j;
  14991. +    unsigned char *p = translations[i];
  14992. +    unsigned char *q = inverse_translations[i];
  14993. +
  14994. +    if (!q) {
  14995. +        /* slightly messy to avoid calling kmalloc too early */
  14996. +        q = inverse_translations[i] = ((i == NORM_MAP)
  14997. +            ? inv_norm_transl
  14998. +            : (unsigned char *) kmalloc(E_TABSZ, GFP_KERNEL));
  14999. +        if (!q)
  15000. +            return;
  15001. +    }
  15002. +    for (j=0; j<E_TABSZ; j++)
  15003. +        q[j] = 0;
  15004. +    for (j=0; j<E_TABSZ; j++)
  15005. +        if (q[p[j]] < 32)    /* prefer '-' above SHY etc. */
  15006. +            q[p[j]] = j;
  15007. +}
  15008. +
  15009. +unsigned char *set_translate(int m)
  15010. +{
  15011. +    if (!inverse_translations[m])
  15012. +        set_inverse_transl(m);
  15013. +    inv_translate = inverse_translations[m];
  15014. +    return translations[m];
  15015. +}
  15016. +
  15017. +/*
  15018. + * Inverse translation is impossible for several reasons:
  15019. + * 1. The translation maps are not 1-1
  15020. + * 2. The text may have been written while a different translation map
  15021. + *    was active
  15022. + * Still, it is now possible to a certain extent to cut and paste non-ASCII.
  15023. + */
  15024. +unsigned char inverse_translate(unsigned char c) {
  15025. +    return ((inv_translate && inv_translate[c]) ? inv_translate[c] : c);
  15026. +}
  15027. +
  15028. +/*
  15029. + * Load customizable translation table
  15030. + * arg points to a 256 byte translation table.
  15031. + */
  15032. +int con_set_trans(char * arg)
  15033. +{
  15034. +    int i;
  15035. +    unsigned char *p = translations[USER_MAP];
  15036. +
  15037. +    i = verify_area(VERIFY_READ, (void *)arg, E_TABSZ);
  15038. +    if (i)
  15039. +        return i;
  15040. +
  15041. +    for (i=0; i<E_TABSZ ; i++)
  15042. +        p[i] = get_fs_byte(arg+i);
  15043. +    p[012] = p[014] = p[015] = p[033] = 0;
  15044. +    set_inverse_transl(USER_MAP);
  15045. +    return 0;
  15046. +}
  15047. +
  15048. +int con_get_trans(char * arg)
  15049. +{
  15050. +    int i;
  15051. +    unsigned char *p = translations[USER_MAP];
  15052. +
  15053. +    i = verify_area(VERIFY_WRITE, (void *)arg, E_TABSZ);
  15054. +    if (i)
  15055. +        return i;
  15056. +
  15057. +    for (i=0; i<E_TABSZ ; i++) put_fs_byte(p[i],arg+i);
  15058. +    return 0;
  15059. +}
  15060. +
  15061. +/*
  15062. + * Unicode -> current font conversion 
  15063. + *
  15064. + * A font has at most 512 chars, usually 256.
  15065. + * But one font position may represent several Unicode chars
  15066. + * (and moreover, hashtables work best when they are not too full),
  15067. + * so pick HASHSIZE somewhat larger than 512.
  15068. + * Since there are likely to be long consecutive stretches
  15069. + * (like U+0000 to U+00FF), HASHSTEP should not be too small.
  15070. + * Searches longer than MAXHASHLEVEL steps are refused, unless
  15071. + * requested explicitly.
  15072. + *
  15073. + * Note: no conversion tables are compiled in, so the user
  15074. + * must supply an explicit mapping herself. See kbd-0.90 (or an
  15075. + * earlier kernel version) for the default Unicode-to-PC mapping.
  15076. + * Usually, the mapping will be loaded simultaneously with the font.
  15077. + */
  15078. +
  15079. +#define HASHSIZE   641
  15080. +#define HASHSTEP   189        /* yields hashlevel = 3 initially */
  15081. +#define MAXHASHLEVEL 6
  15082. +static struct unipair hashtable[HASHSIZE];
  15083. +
  15084. +int hashtable_contents_valid = 0;     /* cleared by setfont */
  15085. +
  15086. +static unsigned int hashsize;
  15087. +static unsigned int hashstep;
  15088. +static unsigned int hashlevel;
  15089. +static unsigned int maxhashlevel;
  15090. +
  15091. +void
  15092. +con_clear_unimap(struct unimapinit *ui) {
  15093. +    int i;
  15094. +
  15095. +    /* read advisory values for hash algorithm */
  15096. +    hashsize = ui->advised_hashsize;
  15097. +    if (hashsize < 256 || hashsize > HASHSIZE)
  15098. +      hashsize = HASHSIZE;
  15099. +    hashstep = (ui->advised_hashstep % hashsize);
  15100. +    if (hashstep < 64)
  15101. +      hashstep = HASHSTEP;
  15102. +    maxhashlevel = ui->advised_hashlevel;
  15103. +    if (!maxhashlevel)
  15104. +      maxhashlevel = MAXHASHLEVEL;
  15105. +    if (maxhashlevel > hashsize)
  15106. +      maxhashlevel = hashsize;
  15107. +
  15108. +    /* initialize */
  15109. +    hashlevel = 0;
  15110. +    for (i=0; i<hashsize; i++)
  15111. +      hashtable[i].unicode = 0xffff;
  15112. +    hashtable_contents_valid = 1;
  15113. +}
  15114. +
  15115. +int
  15116. +con_set_unimap(ushort ct, struct unipair *list){
  15117. +    int i, lct;
  15118. +    ushort u, hu;
  15119. +    struct unimapinit hashdefaults = { 0, 0, 0 };
  15120. +
  15121. +    if (!hashtable_contents_valid)
  15122. +      con_clear_unimap(&hashdefaults);
  15123. +    while(ct) {
  15124. +        u = get_fs_word(&list->unicode);
  15125. +        i = u % hashsize;
  15126. +        lct = 1;
  15127. +        while ((hu = hashtable[i].unicode) != 0xffff && hu != u) {
  15128. +        if (lct++ >=  maxhashlevel)
  15129. +          return -ENOMEM;
  15130. +        i += hashstep;
  15131. +        if (i >= hashsize)
  15132. +          i -= hashsize;
  15133. +        }
  15134. +        if (lct > hashlevel)
  15135. +          hashlevel = lct;
  15136. +        hashtable[i].unicode = u;
  15137. +        hashtable[i].fontpos = get_fs_word(&list->fontpos);
  15138. +        list++;
  15139. +        ct--;
  15140. +    }
  15141. +    return 0;
  15142. +}
  15143. +
  15144. +int
  15145. +con_get_unimap(ushort ct, ushort *uct, struct unipair *list){
  15146. +    int i, ect;
  15147. +
  15148. +    ect = 0;
  15149. +    if (hashtable_contents_valid)
  15150. +      for (i = 0; i<hashsize; i++)
  15151. +        if (hashtable[i].unicode != 0xffff) {
  15152. +        if (ect++ < ct) {
  15153. +            put_fs_word(hashtable[i].unicode, &list->unicode);
  15154. +            put_fs_word(hashtable[i].fontpos, &list->fontpos);
  15155. +            list++;
  15156. +        }
  15157. +        }
  15158. +    put_fs_word(ect, uct);
  15159. +    return ((ect <= ct) ? 0 : -ENOMEM);
  15160. +}
  15161. +
  15162. +int
  15163. +conv_uni_to_pc(unsigned long ucs) {
  15164. +      int i, h;
  15165. +
  15166. +      if (!hashtable_contents_valid || ucs < 0x20)
  15167. +    return -3;
  15168. +      if (ucs == 0xffff || ucs == 0xfffe)
  15169. +    return -1;
  15170. +      if (ucs == 0xfeff || (ucs >= 0x200a && ucs <= 0x200f))
  15171. +    return -2;
  15172. +      
  15173. +      h = ucs % hashsize;
  15174. +      for (i = 0; i < hashlevel; i++) {
  15175. +      if (hashtable[h].unicode == ucs)
  15176. +        return hashtable[h].fontpos;
  15177. +      if ((h += hashstep) >= hashsize)
  15178. +        h -= hashsize;
  15179. +      }
  15180. +
  15181. +      return -4;        /* not found */
  15182. +}
  15183. diff -r -u -N linux.orig/arch/arm/drivers/char/consolemap.h linux.arm/arch/arm/drivers/char/consolemap.h
  15184. --- linux.orig/arch/arm/drivers/char/consolemap.h    Thu Jan  1 01:00:00 1970
  15185. +++ linux.arm/arch/arm/drivers/char/consolemap.h    Fri Oct 27 23:14:39 1995
  15186. @@ -0,0 +1,13 @@
  15187. +/*
  15188. + * consolemap.h
  15189. + *
  15190. + * Interface between console.c, selection.c  and consolemap.c
  15191. + */
  15192. +#define NORM_MAP 0
  15193. +#define GRAF_MAP 1
  15194. +#define NULL_MAP 2
  15195. +#define USER_MAP 3
  15196. +
  15197. +extern int hashtable_contents_valid;
  15198. +extern unsigned char inverse_translate(unsigned char c);
  15199. +extern unsigned char *set_translate(int m);
  15200. diff -r -u -N linux.orig/arch/arm/drivers/char/defkeymap.c linux.arm/arch/arm/drivers/char/defkeymap.c
  15201. --- linux.orig/arch/arm/drivers/char/defkeymap.c    Thu Jan  1 01:00:00 1970
  15202. +++ linux.arm/arch/arm/drivers/char/defkeymap.c    Fri Oct 27 23:14:20 1995
  15203. @@ -0,0 +1,331 @@
  15204. +#include <linux/types.h>
  15205. +#include <linux/keyboard.h>
  15206. +#include <linux/kd.h>
  15207. +
  15208. +/* Normal (maps 1:1 with no processing) */
  15209. +#define KTn    0xF0
  15210. +/* Function keys */
  15211. +#define KTf    0xF1
  15212. +/* Special (Performs special house-keeping funcs) */
  15213. +#define KTs    0xF2
  15214. +#define KIGNORE        K(KTs, 0)    /* Ignore */
  15215. +#define KENTER        K(KTs, 1)    /* Enter */
  15216. +#define KREGS        K(KTs, 2)    /* Regs */
  15217. +#define KMEM        K(KTs, 3)    /* Mem */
  15218. +#define KSTAT        K(KTs, 4)    /* State */
  15219. +#define KINTR        K(KTs, 5)    /* Intr */
  15220. +#define Ksl    6    /* Last console */
  15221. +#define KCAPSLK        K(KTs, 7)    /* Caps lock */
  15222. +#define KNUMLK        K(KTs, 8)    /* Num-lock */
  15223. +#define KSCRLLK        K(KTs, 9)    /* Scroll-lock */
  15224. +#define KSCRLFOR    K(KTs,10)    /* Scroll forward */
  15225. +#define KSCRLBAK    K(KTs,11)    /* Scroll back */
  15226. +#define KREBOOT        K(KTs,12)    /* Reboot */
  15227. +#define KCAPSON        K(KTs,13)    /* Caps on */
  15228. +#define KCOMPOSE    K(KTs,14)    /* Compose */
  15229. +#define KSAK        K(KTs,15)    /* SAK */
  15230. +#define CONS_DEC    K(KTs,16)    /* Dec console */
  15231. +#define CONS_INC    K(KTs,17)    /* Incr console */
  15232. +#define KFLOPPY        K(KTs,18)    /* Floppy */
  15233. +/* Key pad (0-9 = digits, 10=+, 11=-, 12=*, 13=/, 14=enter, 16=., 17=# */
  15234. +#define KTp    0xF3
  15235. +#define KPAD_0        K(KTp, 0 )
  15236. +#define KPAD_1      K(KTp, 1 )
  15237. +#define KPAD_2        K(KTp, 2 )
  15238. +#define KPAD_3        K(KTp, 3 )
  15239. +#define KPAD_4        K(KTp, 4 )
  15240. +#define KPAD_5        K(KTp, 5 )
  15241. +#define KPAD_6        K(KTp, 6 )
  15242. +#define KPAD_7        K(KTp, 7 )
  15243. +#define KPAD_8        K(KTp, 8 )
  15244. +#define KPAD_9        K(KTp, 9 )
  15245. +#define KPAD_PL        K(KTp,10 )
  15246. +#define KPAD_MI        K(KTp,11 )
  15247. +#define KPAD_ML        K(KTp,12 )
  15248. +#define KPAD_DV        K(KTp,13 )
  15249. +#define KPAD_EN        K(KTp,14 )
  15250. +#define KPAD_DT        K(KTp,16 )
  15251. +#define KPAD_HS        K(KTp,18 )
  15252. +/* Console switching */
  15253. +#define KCn    0xF5
  15254. +/* Cursor */
  15255. +#define KTc    0xF6
  15256. +#define Kcd    0    /* Cursor down */
  15257. +#define Kcl    1    /* Cursor left */
  15258. +#define Kcr    2    /* Cursor right */
  15259. +#define Kcu    3    /* Cursor up */
  15260. +/* Shift/alt modifiers etc */
  15261. +#define KMd    0xF7
  15262. +#define KSHIFT        K(KMd, 0 )
  15263. +#define KALTGR        K(KMd, 1 )
  15264. +#define KCTRL        K(KMd, 2 )
  15265. +#define KALT        K(KMd, 3 )
  15266. +/* Meta */
  15267. +#define KMt    0xF8
  15268. +#define KAs    0xF9
  15269. +#define KPADA_0        K(KAs, 0 )
  15270. +#define KPADA_1        K(KAs, 1 )
  15271. +#define KPADA_2        K(KAs, 2 )
  15272. +#define KPADA_3        K(KAs, 3 )
  15273. +#define KPADA_4        K(KAs, 4 )
  15274. +#define KPADA_5        K(KAs, 5 )
  15275. +#define KPADA_6        K(KAs, 6 )
  15276. +#define KPADA_7        K(KAs, 7 )
  15277. +#define KPADA_8        K(KAs, 8 )
  15278. +#define KPADA_9        K(KAs, 9 )
  15279. +#define KPADB_0        K(KAs,10 )
  15280. +#define KPADB_1        K(KAs,11 )
  15281. +#define KPADB_2        K(KAs,12 )
  15282. +#define KPADB_3        K(KAs,13 )
  15283. +#define KPADB_4        K(KAs,14 )
  15284. +#define KPADB_5        K(KAs,15 )
  15285. +#define KPADB_6        K(KAs,16 )
  15286. +#define KPADB_7        K(KAs,17 )
  15287. +#define KPADB_8        K(KAs,18 )
  15288. +#define KPADB_9        K(KAs,19 )
  15289. +/* Locking keys */
  15290. +#define KLk    0xFA
  15291. +/* Letters */
  15292. +#define KTl    0xFB
  15293. +
  15294. +u_short plain_map[]=
  15295. +{
  15296. +  K(KTn, 27),K(KTf,  0),K(KTf,  1),K(KTf,  2 ),K(KTf,  3),K(KTf,  4),K(KTf,  5 ),K(KTf,  6),
  15297. +  K(KTf,  7),K(KTf,  8),K(KTf,  9),K(KTf, 10 ),K(KTf, 11),KIGNORE   ,KSCRLLK    ,KINTR     ,
  15298. +  K(KTn,'`'),K(KTn,'1'),K(KTn,'2'),K(KTn,'3' ),K(KTn,'4'),K(KTn,'5'),K(KTn,'6' ),K(KTn,'7'),
  15299. +  K(KTn,'8'),K(KTn,'9'),K(KTn,'0'),K(KTn,'-' ),K(KTn,'='),K(KTn,'£'),K(KTn,127 ),K(KTf,21 ),
  15300. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,K(KTn,  9 ),K(KTl,'q'),
  15301. +  K(KTl,'w'),K(KTl,'e'),K(KTl,'r'),K(KTl,'t' ),K(KTl,'y'),K(KTl,'u'),K(KTl,'i' ),K(KTl,'o'),
  15302. +  K(KTl,'p'),K(KTn,'['),K(KTn,']'),K(KTn,'\\'),K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
  15303. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTl,'a'),K(KTl,'s'),K(KTl,'d' ),K(KTl,'f'),
  15304. +  K(KTl,'g'),K(KTl,'h'),K(KTl,'j'),K(KTl,'k' ),K(KTl,'l'),K(KTn,';'),K(KTn,'\''),KENTER    ,
  15305. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTl,'z' ),K(KTl,'x'),
  15306. +  K(KTl,'c'),K(KTl,'v'),K(KTl,'b'),K(KTl,'n' ),K(KTl,'m'),K(KTn,','),K(KTn,'.' ),K(KTn,'/'),
  15307. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn,' '),
  15308. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   
  15309. +};
  15310. +
  15311. +u_short shift_map[]=
  15312. +{
  15313. +  K(KTn, 27),K(KTf, 10),K(KTf, 11),K(KTf, 12 ),K(KTf, 13),K(KTf, 14),K(KTf, 15 ),K(KTf, 16),
  15314. +  K(KTf, 17),K(KTf, 18),K(KTf, 19),K(KTf, 20 ),K(KTf, 21),KIGNORE   ,KMEM       ,KINTR     ,
  15315. +  K(KTn,'~'),K(KTn,'!'),K(KTn,'@'),K(KTn,'#' ),K(KTn,'$'),K(KTn,'%'),K(KTn,'^' ),K(KTn,'&'),
  15316. +  K(KTn,'*'),K(KTn,'('),K(KTn,')'),K(KTn,'_' ),K(KTn,'+'),K(KTn,'¤'),K(KTn,127 ),K(KTf,21 ),
  15317. +  K(KTf,20 ),KSCRLBAK  ,KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,K(KTn,  9 ),K(KTl,'Q'),
  15318. +  K(KTl,'W'),K(KTl,'E'),K(KTl,'R'),K(KTl,'T' ),K(KTl,'Y'),K(KTl,'U'),K(KTl,'I' ),K(KTl,'O'),
  15319. +  K(KTl,'P'),K(KTn,'{'),K(KTn,'}'),K(KTn,'|' ),K(KTf,22 ),K(KTf,23 ),KSCRLFOR   ,KPAD_7    ,
  15320. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTl,'A'),K(KTl,'S'),K(KTl,'D' ),K(KTl,'F'),
  15321. +  K(KTl,'G'),K(KTl,'H'),K(KTl,'J'),K(KTl,'K' ),K(KTl,'L'),K(KTn,':'),K(KTn,'"' ),KENTER    ,
  15322. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTl,'Z' ),K(KTl,'X'),
  15323. +  K(KTl,'C'),K(KTl,'V'),K(KTl,'B'),K(KTl,'N' ),K(KTl,'M'),K(KTn,'<'),K(KTn,'>' ),K(KTn,'?'),
  15324. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn,' '),
  15325. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   
  15326. +};
  15327. +
  15328. +u_short altgr_map[]=
  15329. +{
  15330. +  KIGNORE   ,K(KCn,12 ),K(KCn,13 ),K(KCn,14  ),K(KCn,15 ),K(KCn,16 ),K(KCn,17  ),K(KCn, 18),
  15331. +  K(KCn, 19),K(KCn,20 ),K(KCn,21 ),K(KCn,22  ),K(KCn,23 ),KIGNORE   ,KREGS      ,KINTR     ,
  15332. +  KIGNORE   ,KIGNORE   ,K(KTn,'@'),KIGNORE    ,K(KTn,'$'),KIGNORE   ,KIGNORE    ,K(KTn,'{'),
  15333. +  K(KTn,'['),K(KTn,']'),K(KTn,'}'),K(KTn,'\\'),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
  15334. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KTl,'q'),
  15335. +  K(KTl,'w'),K(KTl,'e'),K(KTl,'r'),K(KTl,'t' ),K(KTl,'y'),K(KTl,'u'),K(KTl,'i' ),K(KTl,'o'),
  15336. +  K(KTl,'p'),KIGNORE   ,K(KTn,'~'),KIGNORE    ,K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPADB_7   ,
  15337. +  KPADB_8   ,KPADB_9   ,KPAD_MI   ,KCTRL      ,K(KAs,20 ),K(KTl,'s'),K(KAs,23  ),K(KAs,25 ),
  15338. +  K(KTl,'g'),K(KTl,'h'),K(KTl,'j'),K(KTl,'k' ),K(KTl,'l'),KIGNORE   ,KIGNORE    ,KENTER    ,
  15339. +  KPADB_4   ,KPADB_5   ,KPADB_6   ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTl,'z' ),K(KTl,'x'),
  15340. +  K(KAs,22 ),K(KTl,'v'),K(KTl,21 ),K(KTl,'n' ),K(KTl,'m'),KIGNORE   ,KIGNORE    ,KIGNORE   ,
  15341. +  KSHIFT    ,K(KTc,Kcu),KPADB_1   ,KPADB_2    ,KPADB_3   ,KCAPSLK   ,KALT       ,KIGNORE   ,
  15342. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPADB_0   ,KPAD_DT    ,KPAD_EN
  15343. +};
  15344. +
  15345. +u_short ctrl_map[]=
  15346. +{
  15347. +  KIGNORE   ,K(KTf,  0),K(KTf,  1),K(KTf,  2 ),K(KTf,  3),K(KTf,  4),K(KTf, 5  ),K(KTf,  6),
  15348. +  K(KTf,  7),K(KTf,  8),K(KTf,  9),K(KTf, 10 ),K(KTf, 11),KIGNORE   ,KSTAT      ,KINTR     ,
  15349. +  KIGNORE   ,K(KTn, 1 ),K(KTn, 2 ),K(KTn, 3  ),K(KTn, 4 ),K(KTn, 5 ),K(KTn, 6  ),K(KTn, 7 ),
  15350. +  K(KTn, 8 ),K(KTn, 9 ),K(KTn, 0 ),K(KTn,31  ),KIGNORE   ,KIGNORE   ,K(KTn, 8  ),K(KTf,21 ),
  15351. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KTn,17 ),
  15352. +  K(KTn,23 ),K(KTn, 5 ),K(KTn,18 ),K(KTn,20  ),K(KTn,25 ),K(KTn,21 ),K(KTn, 9  ),K(KTn,15 ),
  15353. +  K(KTn,16 ),K(KTn,27 ),K(KTn,29 ),K(KTn,28  ),K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
  15354. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTn, 1 ),K(KTn,19 ),K(KTn, 4  ),K(KTn, 6 ),
  15355. +  K(KTn, 7 ),K(KTn, 8 ),K(KTn,10 ),K(KTn,11  ),K(KTn,12 ),KIGNORE   ,K(KTn, 7  ),KENTER    ,
  15356. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTn,26  ),K(KTn,24 ),
  15357. +  K(KTn, 3 ),K(KTn,22 ),K(KTn, 2 ),K(KTn,14  ),K(KTn,13 ),KIGNORE   ,KCOMPOSE   ,K(KTn,127),
  15358. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn, 0 ),
  15359. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   
  15360. +};
  15361. +
  15362. +u_short shift_ctrl_map[]=
  15363. +{
  15364. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
  15365. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KFLOPPY    ,KINTR     ,
  15366. +  KIGNORE   ,KIGNORE   ,K(KTn, 0 ),KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
  15367. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,K(KTn,31  ),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
  15368. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KTn,17 ),
  15369. +  K(KTn,23 ),K(KTn, 5 ),K(KTn,18 ),K(KTn,20  ),K(KTn,25 ),K(KTn,21 ),K(KTn, 9  ),K(KTn,15 ),
  15370. +  K(KTn,16 ),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
  15371. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTn, 1 ),K(KTn,19 ),K(KTn, 4  ),K(KTn, 6 ),
  15372. +  K(KTn, 7 ),K(KTn, 8 ),K(KTn,10 ),K(KTn,11  ),K(KTn,12 ),KIGNORE   ,K(KTn, 7  ),KENTER    ,
  15373. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTn,26  ),K(KTn,24 ),
  15374. +  K(KTn, 3 ),K(KTn,22 ),K(KTn, 2 ),K(KTn,14  ),K(KTn,13 ),KIGNORE   ,KIGNORE    ,KIGNORE   ,
  15375. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn, 0 ),
  15376. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   
  15377. +};
  15378. +
  15379. +u_short alt_map[]=
  15380. +{
  15381. +  K(KMt,27 ),K(KCn, 0 ),K(KCn, 1 ),K(KCn, 2  ),K(KCn, 3 ),K(KCn, 4 ),K(KCn, 5  ),K(KCn, 6 ),
  15382. +  K(KCn, 7 ),K(KCn, 8 ),K(KCn, 9 ),K(KCn,10  ),K(KCn,11 ),KIGNORE   ,KSCRLLK    ,KINTR     ,
  15383. +  K(KMt,'`'),K(KMt,'1'),K(KMt,'2'),K(KMt,'3' ),K(KMt,'4'),K(KMt,'5'),K(KMt,'6' ),K(KMt,'7'),
  15384. +  K(KMt,'8'),K(KMt,'9'),K(KMt,'0'),K(KMt,'-' ),K(KMt,'='),K(KMt,'£'),K(KMt,127 ),K(KTf,21 ),
  15385. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,K(KMt, 9  ),K(KMt,'q'),
  15386. +  K(KMt,'w'),K(KMt,'e'),K(KMt,'r'),K(KMt,'t' ),K(KMt,'y'),K(KMt,'u'),K(KMt,'i' ),K(KMt,'o'),
  15387. +  K(KMt,'p'),K(KMt,'['),K(KMt,']'),K(KMt,'\\'),K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPADA_7   ,
  15388. +  KPADA_8   ,KPADA_9   ,KPAD_MI   ,KCTRL      ,K(KMt,'a'),K(KMt,'s'),K(KMt,'d' ),K(KMt,'f'),
  15389. +  K(KMt,'g'),K(KMt,'h'),K(KMt,'j'),K(KMt,'k' ),K(KMt,'l'),K(KMt,';'),K(KMt,'\''),K(KMt,13 ),
  15390. +  KPADA_4   ,KPADA_5   ,KPADA_6   ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KMt,'z' ),K(KMt,'x'),
  15391. +  K(KMt,'c'),K(KMt,'v'),K(KMt,'b'),K(KMt,'n' ),K(KMt,'m'),K(KMt,','),K(KMt,'.' ),KIGNORE   ,
  15392. +  KSHIFT    ,K(KTc,Kcu),KPADA_1   ,KPADA_2    ,KPADA_3   ,KCAPSLK   ,KALT       ,K(KMt,' '),
  15393. +  KALTGR    ,KCTRL     ,CONS_DEC  ,K(KTc,Kcd ),CONS_INC  ,KPADA_0   ,KPAD_DT    ,KPAD_EN
  15394. +};
  15395. +
  15396. +u_short ctrl_alt_map[]=
  15397. +{
  15398. +  KIGNORE   ,K(KCn, 0 ),K(KCn, 1 ),K(KCn, 2  ),K(KCn, 3 ),K(KCn, 4 ),K(KCn, 5  ),K(KCn, 6 ),
  15399. +  K(KCn, 7 ),K(KCn, 8 ),K(KCn, 9 ),K(KCn,10  ),K(KCn,11 ),KIGNORE   ,KIGNORE    ,KINTR     ,
  15400. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
  15401. +  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
  15402. +  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KMt,17 ),
  15403. +  K(KMt,23 ),K(KMt, 5 ),K(KMt,18 ),K(KMt,20  ),K(KMt,25 ),K(KMt,21 ),K(KMt, 9  ),K(KMt,15 ),
  15404. +  K(KMt,16 ),KIGNORE   ,KIGNORE   ,KIGNORE    ,KREBOOT   ,K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
  15405. +  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KMt, 1 ),K(KMt,19 ),K(KMt, 4  ),K(KMt, 6 ),
  15406. +  K(KMt, 7 ),K(KMt, 8 ),K(KMt,10 ),K(KMt,11  ),K(KMt,12 ),KIGNORE   ,KIGNORE    ,KENTER    ,
  15407. +  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KMt,26  ),K(KMt,24 ),
  15408. +  K(KMt, 3 ),K(KMt,22 ),K(KMt, 2 ),K(KMt,14  ),K(KMt,13 ),KIGNORE   ,KIGNORE    ,KIGNORE   ,
  15409. +  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,KIGNORE   ,
  15410. +  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KREBOOT    ,KPAD_EN
  15411. +};
  15412. +
  15413. +ushort *key_maps[MAX_NR_KEYMAPS] = {
  15414. +    plain_map, shift_map, altgr_map, 0,
  15415. +    ctrl_map, shift_ctrl_map, 0, 0,
  15416. +    alt_map, 0, 0, 0,
  15417. +    ctrl_alt_map,    0
  15418. +};
  15419. +
  15420. +unsigned int keymap_count = 7;
  15421. +
  15422. +/*
  15423. + * Philosophy: most people do not define more strings, but they who do
  15424. + * often want quite a lot of string space. So, we statically allocate
  15425. + * the default and allocate dynamically in chunks of 512 bytes.
  15426. + */
  15427. +
  15428. +char func_buf[] = {
  15429. +    '\033', '[', '[', 'A', 0,
  15430. +    '\033', '[', '[', 'B', 0,
  15431. +    '\033', '[', '[', 'C', 0,
  15432. +    '\033', '[', '[', 'D', 0,
  15433. +    '\033', '[', '[', 'E', 0,
  15434. +    '\033', '[', '1', '7', '~', 0,
  15435. +    '\033', '[', '1', '8', '~', 0,
  15436. +    '\033', '[', '1', '9', '~', 0,
  15437. +    '\033', '[', '2', '0', '~', 0,
  15438. +    '\033', '[', '2', '1', '~', 0,
  15439. +    '\033', '[', '2', '3', '~', 0,
  15440. +    '\033', '[', '2', '4', '~', 0,
  15441. +    '\033', '[', '2', '5', '~', 0,
  15442. +    '\033', '[', '2', '6', '~', 0,
  15443. +    '\033', '[', '2', '8', '~', 0,
  15444. +    '\033', '[', '2', '9', '~', 0,
  15445. +    '\033', '[', '3', '1', '~', 0,
  15446. +    '\033', '[', '3', '2', '~', 0,
  15447. +    '\033', '[', '3', '3', '~', 0,
  15448. +    '\033', '[', '3', '4', '~', 0,
  15449. +    '\033', '[', '1', '~', 0,
  15450. +    '\033', '[', '2', '~', 0,
  15451. +    '\033', '[', '3', '~', 0,
  15452. +    '\033', '[', '4', '~', 0,
  15453. +    '\033', '[', '5', '~', 0,
  15454. +    '\033', '[', '6', '~', 0,
  15455. +    '\033', '[', 'M', 0,
  15456. +    '\033', '[', 'P', 0,
  15457. +};
  15458. +
  15459. +char *funcbufptr = func_buf;
  15460. +int funcbufsize = sizeof(func_buf);
  15461. +int funcbufleft = 0;          /* space left */
  15462. +
  15463. +char *func_table[MAX_NR_FUNC] = {
  15464. +    func_buf + 0,
  15465. +    func_buf + 5,
  15466. +    func_buf + 10,
  15467. +    func_buf + 15,
  15468. +    func_buf + 20,
  15469. +    func_buf + 25,
  15470. +    func_buf + 31,
  15471. +    func_buf + 37,
  15472. +    func_buf + 43,
  15473. +    func_buf + 49,
  15474. +    func_buf + 55,
  15475. +    func_buf + 61,
  15476. +    func_buf + 67,
  15477. +    func_buf + 73,
  15478. +    func_buf + 79,
  15479. +    func_buf + 85,
  15480. +    func_buf + 91,
  15481. +    func_buf + 97,
  15482. +    func_buf + 103,
  15483. +    func_buf + 109,
  15484. +    func_buf + 115,
  15485. +    func_buf + 120,
  15486. +    func_buf + 125,
  15487. +    func_buf + 130,
  15488. +    func_buf + 135,
  15489. +    func_buf + 140,
  15490. +    func_buf + 145,
  15491. +    0,
  15492. +    0,
  15493. +    func_buf + 149,
  15494. +    0,
  15495. +};
  15496. +
  15497. +struct kbdiacr accent_table[MAX_DIACR] = {
  15498. +    {'`', 'A', '\300'},    {'`', 'a', '\340'},
  15499. +    {'\'', 'A', '\301'},    {'\'', 'a', '\341'},
  15500. +    {'^', 'A', '\302'},    {'^', 'a', '\342'},
  15501. +    {'~', 'A', '\303'},    {'~', 'a', '\343'},
  15502. +    {'"', 'A', '\304'},    {'"', 'a', '\344'},
  15503. +    {'O', 'A', '\305'},    {'o', 'a', '\345'},
  15504. +    {'0', 'A', '\305'},    {'0', 'a', '\345'},
  15505. +    {'A', 'A', '\305'},    {'a', 'a', '\345'},
  15506. +    {'A', 'E', '\306'},    {'a', 'e', '\346'},
  15507. +    {',', 'C', '\307'},    {',', 'c', '\347'},
  15508. +    {'`', 'E', '\310'},    {'`', 'e', '\350'},
  15509. +    {'\'', 'E', '\311'},    {'\'', 'e', '\351'},
  15510. +    {'^', 'E', '\312'},    {'^', 'e', '\352'},
  15511. +    {'"', 'E', '\313'},    {'"', 'e', '\353'},
  15512. +    {'`', 'I', '\314'},    {'`', 'i', '\354'},
  15513. +    {'\'', 'I', '\315'},    {'\'', 'i', '\355'},
  15514. +    {'^', 'I', '\316'},    {'^', 'i', '\356'},
  15515. +    {'"', 'I', '\317'},    {'"', 'i', '\357'},
  15516. +    {'-', 'D', '\320'},    {'-', 'd', '\360'},
  15517. +    {'~', 'N', '\321'},    {'~', 'n', '\361'},
  15518. +    {'`', 'O', '\322'},    {'`', 'o', '\362'},
  15519. +    {'\'', 'O', '\323'},    {'\'', 'o', '\363'},
  15520. +    {'^', 'O', '\324'},    {'^', 'o', '\364'},
  15521. +    {'~', 'O', '\325'},    {'~', 'o', '\365'},
  15522. +    {'"', 'O', '\326'},    {'"', 'o', '\366'},
  15523. +    {'/', 'O', '\330'},    {'/', 'o', '\370'},
  15524. +    {'`', 'U', '\331'},    {'`', 'u', '\371'},
  15525. +    {'\'', 'U', '\332'},    {'\'', 'u', '\372'},
  15526. +    {'^', 'U', '\333'},    {'^', 'u', '\373'},
  15527. +    {'"', 'U', '\334'},    {'"', 'u', '\374'},
  15528. +    {'\'', 'Y', '\335'},    {'\'', 'y', '\375'},
  15529. +    {'T', 'H', '\336'},    {'t', 'h', '\376'},
  15530. +    {'s', 's', '\337'},    {'"', 'y', '\377'},
  15531. +    {'s', 'z', '\337'},    {'i', 'j', '\377'},
  15532. +};
  15533. +
  15534. +unsigned int accent_table_size = 68;
  15535. diff -r -u -N linux.orig/arch/arm/drivers/char/diacr.h linux.arm/arch/arm/drivers/char/diacr.h
  15536. --- linux.orig/arch/arm/drivers/char/diacr.h    Thu Jan  1 01:00:00 1970
  15537. +++ linux.arm/arch/arm/drivers/char/diacr.h    Fri Oct 27 23:14:20 1995
  15538. @@ -0,0 +1,8 @@
  15539. +#ifndef _DIACR_H
  15540. +#define _DIACR_H
  15541. +#include <linux/kd.h>
  15542. +
  15543. +extern struct kbdiacr accent_table[];
  15544. +extern unsigned int accent_table_size;
  15545. +
  15546. +#endif /* _DIACR_H */
  15547. diff -r -u -N linux.orig/arch/arm/drivers/char/iic.c linux.arm/arch/arm/drivers/char/iic.c
  15548. --- linux.orig/arch/arm/drivers/char/iic.c    Thu Jan  1 01:00:00 1970
  15549. +++ linux.arm/arch/arm/drivers/char/iic.c    Fri Oct 27 23:14:20 1995
  15550. @@ -0,0 +1,102 @@
  15551. +#pragma no_check_stack
  15552. +#include <asm/system.h>
  15553. +
  15554. +#define DELAY udelay(10)
  15555. +
  15556. +/* extern volatile char *const ioc; */
  15557. +#define ioc ((volatile char *)0x03200000)
  15558. +
  15559. +static void iic_start(void)
  15560. +{
  15561. +  char out;
  15562. +
  15563. +  out=(ioc[0] & 0xFC) | 0xC0;
  15564. +
  15565. +  ioc[0]=out|3;  DELAY;
  15566. +  ioc[0]=out|2;  DELAY;
  15567. +}
  15568. +
  15569. +static void iic_stop(void)
  15570. +{
  15571. +  char out;
  15572. +
  15573. +  out=(ioc[0] & 0xFC) | 0xC0;
  15574. +
  15575. +  DELAY;  ioc[0]=out|2;
  15576. +  DELAY;  ioc[0]=out|3;
  15577. +}
  15578. +
  15579. +static int iic_sendbyte(char b)
  15580. +{
  15581. +  char out,in;
  15582. +  int i;
  15583. +
  15584. +  out=(ioc[0] & 0xFC) | 0xC0;
  15585. +
  15586. +  ioc[0]=out;
  15587. +  for(i=7;i>=0;i--)
  15588. +  {
  15589. +    ioc[0]=out|((b&(1<<i))?1:0);    DELAY;
  15590. +    ioc[0]=out|((b&(1<<i))?1:0)|2;  DELAY;
  15591. +    ioc[0]=out|((b&(1<<i))?1:0);
  15592. +  }
  15593. +  ioc[0]=out|1;  DELAY;
  15594. +  ioc[0]=out|3;  DELAY;
  15595. +  in=ioc[0]&1;
  15596. +  ioc[0]=out|1;  DELAY;
  15597. +  ioc[0]=out;    DELAY;
  15598. +  if(in)
  15599. +  {
  15600. +    printk("No acknowledge from RTC\n");
  15601. +    return 1;
  15602. +  }
  15603. +  else
  15604. +    return 0;
  15605. +}
  15606. +
  15607. +static char iic_recvbyte(void)
  15608. +{
  15609. +  char out,in;
  15610. +  int i;
  15611. +
  15612. +  out=(ioc[0] & 0xFC) | 0xC0;
  15613. +
  15614. +  ioc[0]=out;
  15615. +  for(i=7;i>=0;i--)
  15616. +  {
  15617. +    ioc[0]=out|1;  DELAY;
  15618. +    ioc[0]=out|3;  DELAY;
  15619. +    in=(in<<1)|(ioc[0]&1);
  15620. +    ioc[0]=out|1;  DELAY;
  15621. +  }
  15622. +  ioc[0]=out;      DELAY;
  15623. +  ioc[0]=out|2;    DELAY;
  15624. +  return in;
  15625. +}
  15626. +
  15627. +void iic_control(int addr,int loc,char *buf,int len)
  15628. +{
  15629. +  iic_start();
  15630. +  if(iic_sendbyte(addr & 0xFE))
  15631. +    goto error;
  15632. +  if(iic_sendbyte(loc))
  15633. +    goto error;
  15634. +  if(addr & 1)
  15635. +  {
  15636. +    int i;
  15637. +    for(i=0;i<len;i++)
  15638. +      if(iic_sendbyte(buf[i]))
  15639. +        goto error;
  15640. +  }
  15641. +  else
  15642. +  {
  15643. +    int i;
  15644. +    iic_stop();
  15645. +    iic_start();
  15646. +    iic_sendbyte(addr|1);
  15647. +    for(i=0;i<len;i++)
  15648. +      buf[i]=iic_recvbyte();
  15649. +  }
  15650. +  error:
  15651. +  iic_stop();
  15652. +}
  15653. diff -r -u -N linux.orig/arch/arm/drivers/char/kbd_kern.h linux.arm/arch/arm/drivers/char/kbd_kern.h
  15654. --- linux.orig/arch/arm/drivers/char/kbd_kern.h    Thu Jan  1 01:00:00 1970
  15655. +++ linux.arm/arch/arm/drivers/char/kbd_kern.h    Fri Oct 27 23:14:23 1995
  15656. @@ -0,0 +1,127 @@
  15657. +#ifndef _KBD_KERN_H
  15658. +#define _KBD_KERN_H
  15659. +
  15660. +#include <linux/interrupt.h>
  15661. +#define set_leds() mark_bh(KEYBOARD_BH)
  15662. +
  15663. +#include <linux/keyboard.h>
  15664. +
  15665. +extern char *func_table[MAX_NR_FUNC];
  15666. +extern char func_buf[];
  15667. +extern char *funcbufptr;
  15668. +extern int funcbufsize, funcbufleft;
  15669. +
  15670. +/*
  15671. + * kbd->xxx contains the VC-local things (flag settings etc..)
  15672. + *
  15673. + * Note: externally visible are LED_SCR, LED_NUM, LED_CAP defined in kd.h
  15674. + *       The code in KDGETLED / KDSETLED depends on the internal and
  15675. + *       external order being the same.
  15676. + *
  15677. + * Note: lockstate is used as index in the array key_map.
  15678. + */
  15679. +struct kbd_struct {
  15680. +
  15681. +    unsigned char lockstate;
  15682. +/* 8 modifiers - the names do not have any meaning at all;
  15683. +   they can be associated to arbitrarily chosen keys */
  15684. +#define VC_SHIFTLOCK    KG_SHIFT    /* shift lock mode */
  15685. +#define VC_ALTGRLOCK    KG_ALTGR    /* altgr lock mode */
  15686. +#define VC_CTRLLOCK    KG_CTRL     /* control lock mode */
  15687. +#define VC_ALTLOCK    KG_ALT      /* alt lock mode */
  15688. +#define VC_SHIFTLLOCK    KG_SHIFTL    /* shiftl lock mode */
  15689. +#define VC_SHIFTRLOCK    KG_SHIFTR    /* shiftr lock mode */
  15690. +#define VC_CTRLLLOCK    KG_CTRLL     /* ctrll lock mode */
  15691. +#define VC_CTRLRLOCK    KG_CTRLR     /* ctrlr lock mode */
  15692. +
  15693. +    unsigned char ledmode:2;     /* one 2-bit value */
  15694. +#define LED_SHOW_FLAGS 0        /* traditional state */
  15695. +#define LED_SHOW_IOCTL 1        /* only change leds upon ioctl */
  15696. +#define LED_SHOW_MEM 2          /* `heartbeat': peek into memory */
  15697. +
  15698. +    unsigned char ledflagstate:3;    /* flags, not lights */
  15699. +    unsigned char default_ledflagstate:3;
  15700. +#define VC_SCROLLOCK    0    /* scroll-lock mode */
  15701. +#define VC_NUMLOCK    1    /* numeric lock mode */
  15702. +#define VC_CAPSLOCK    2    /* capslock mode */
  15703. +
  15704. +    unsigned char kbdmode:2;    /* one 2-bit value */
  15705. +#define VC_XLATE    0    /* translate keycodes using keymap */
  15706. +#define VC_MEDIUMRAW    1    /* medium raw (keycode) mode */
  15707. +#define VC_RAW        2    /* raw (scancode) mode */
  15708. +#define VC_UNICODE    3    /* Unicode mode */
  15709. +
  15710. +    unsigned char modeflags:5;
  15711. +#define VC_APPLIC    0    /* application key mode */
  15712. +#define VC_CKMODE    1    /* cursor key mode */
  15713. +#define VC_REPEAT    2    /* keyboard repeat */
  15714. +#define VC_CRLF        3    /* 0 - enter sends CR, 1 - enter sends CRLF */
  15715. +#define VC_META        4    /* 0 - meta, 1 - meta=prefix with ESC */
  15716. +};
  15717. +
  15718. +extern struct kbd_struct kbd_table[];
  15719. +
  15720. +extern unsigned long kbd_init(unsigned long);
  15721. +
  15722. +extern unsigned char getledstate(void);
  15723. +extern void setledstate(struct kbd_struct *kbd, unsigned int led);
  15724. +#ifndef __ARM__
  15725. +extern inline int vc_kbd_mode(struct kbd_struct * kbd, int flag)
  15726. +{
  15727. +    return ((kbd->modeflags >> flag) & 1);
  15728. +}
  15729. +
  15730. +extern inline int vc_kbd_led(struct kbd_struct * kbd, int flag)
  15731. +{
  15732. +    return ((kbd->ledflagstate >> flag) & 1);
  15733. +}
  15734. +
  15735. +extern inline void set_vc_kbd_mode(struct kbd_struct * kbd, int flag)
  15736. +{
  15737. +    kbd->modeflags |= 1 << flag;
  15738. +}
  15739. +
  15740. +extern inline void set_vc_kbd_led(struct kbd_struct * kbd, int flag)
  15741. +{
  15742. +    kbd->ledflagstate |= 1 << flag;
  15743. +}
  15744. +
  15745. +extern inline void clr_vc_kbd_mode(struct kbd_struct * kbd, int flag)
  15746. +{
  15747. +    kbd->modeflags &= ~(1 << flag);
  15748. +}
  15749. +
  15750. +extern inline void clr_vc_kbd_led(struct kbd_struct * kbd, int flag)
  15751. +{
  15752. +    kbd->ledflagstate &= ~(1 << flag);
  15753. +}
  15754. +
  15755. +extern inline void chg_vc_kbd_lock(struct kbd_struct * kbd, int flag)
  15756. +{
  15757. +    kbd->lockstate ^= 1 << flag;
  15758. +}
  15759. +
  15760. +extern inline void chg_vc_kbd_mode(struct kbd_struct * kbd, int flag)
  15761. +{
  15762. +    kbd->modeflags ^= 1 << flag;
  15763. +}
  15764. +
  15765. +extern inline void chg_vc_kbd_led(struct kbd_struct * kbd, int flag)
  15766. +{
  15767. +    kbd->ledflagstate ^= 1 << flag;
  15768. +}
  15769. +#else
  15770. +#define vc_kbd_mode(kbd,flag)        (((kbd)->modeflags >> flag) & 1)
  15771. +#define vc_kbd_led(kbd,flag)        (((kbd)->ledflagstate >> flag) & 1)
  15772. +#define set_vc_kbd_mode(kbd,flag)    ((kbd)->modeflags |= 1 << flag)
  15773. +#define set_vc_kbd_led(kbd,flag)    ((kbd)->ledflagstate |= 1 << flag)
  15774. +#define clr_vc_kbd_mode(kbd,flag)    ((kbd)->modeflags &= ~(1 << flag))
  15775. +#define clr_vc_kbd_led(kbd,flag)    ((kbd)->ledflagstate &= ~(1 << flag))
  15776. +#define chg_vc_kbd_lock(kbd,flag)    ((kbd)->lockstate ^= 1 << flag)
  15777. +#define chg_vc_kbd_mode(kbd,flag)    ((kbd)->modeflags ^= 1 << flag)
  15778. +#define chg_vc_kbd_led(kbd,flag)    ((kbd)->ledflagstate ^= 1 << flag)
  15779. +#endif
  15780. +
  15781. +#define U(x) ((x) ^ 0xf000)
  15782. +
  15783. +#endif
  15784. diff -r -u -N linux.orig/arch/arm/drivers/char/keyboard.c linux.arm/arch/arm/drivers/char/keyboard.c
  15785. --- linux.orig/arch/arm/drivers/char/keyboard.c    Thu Jan  1 01:00:00 1970
  15786. +++ linux.arm/arch/arm/drivers/char/keyboard.c    Fri Oct 27 23:14:24 1995
  15787. @@ -0,0 +1,1062 @@
  15788. +#define IRQ_KEYBOARDRX 15
  15789. +#define IRQ_KEYBOARDTX 14
  15790. +
  15791. +#define VERSION 002
  15792. +
  15793. +#include <linux/config.h>
  15794. +#include <linux/sched.h>
  15795. +#include <linux/interrupt.h>
  15796. +#include <linux/tty.h>
  15797. +#include <linux/tty_flip.h>
  15798. +#include <linux/ctype.h>
  15799. +#include <linux/mm.h>
  15800. +#include <linux/timer.h>
  15801. +#include <linux/ptrace.h>
  15802. +
  15803. +#include <asm/irq.h>
  15804. +
  15805. +#include "kbd_kern.h"
  15806. +#include "diacr.h"
  15807. +#include "vt_kern.h"
  15808. +
  15809. +#define SIZE(x) (sizeof(x)/sizeof((x)[0]))
  15810. +
  15811. +/* Mouse stuff */
  15812. +
  15813. +extern struct wait_queue *mouse_wait;
  15814. +extern char        mouse_buttons;
  15815. +extern int        mouse_dxpos;
  15816. +extern int        mouse_dypos;
  15817. +extern char        mouse_ready;
  15818. +
  15819. +#define KBD_IRQ_RPT    1
  15820. +#define KBD_IRQ_KEY    2
  15821. +
  15822. +#ifndef KBD_DEFMODE
  15823. +#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
  15824. +#endif
  15825. +
  15826. +#ifndef KBD_DEFLEDS
  15827. +#define KBD_DEFLEDS 0 /* VC_NUMLOCK */
  15828. +#endif
  15829. +
  15830. +#ifndef KBD_DEFLOCK
  15831. +#define KBD_DEFLOCK 0
  15832. +#endif
  15833. +
  15834. +#define KBD_SHIFT     0x11
  15835. +#define KBD_CTRL      0x22
  15836. +#define KBD_ALT       0x44
  15837. +
  15838. +#define KBD_LSHIFT    0x01
  15839. +#define KBD_LCTRL    0x02
  15840. +#define KBD_LALT    0x04
  15841. +#define KBD_RSHIFT    0x10
  15842. +#define KBD_RCTRL    0x20
  15843. +#define KBD_RALT    0x40
  15844. +
  15845. +#define HRST 0xFF
  15846. +#define RAK1 0xFE
  15847. +#define RAK2 0xFD
  15848. +#define SMAK 0x33
  15849. +
  15850. +extern void poke_blanked_console (void);
  15851. +extern void ctrl_alt_del (void);
  15852. +extern void change_console (unsigned int console);
  15853. +static void process_key(int keycode, char up_flag, int repeattimeout);
  15854. +static unsigned char getleds(void);
  15855. +
  15856. +static unsigned char k_down[NR_SHIFT] = {0, };
  15857. +
  15858. +static int want_console    = -1;
  15859. +static int last_console    = 0;         /* last used VC */
  15860. +static int dead_key_next   = 0;
  15861. +
  15862. +int shift_state     = 0;
  15863. +static int npadch          = -1;        /* -1 or number assembled on pad */
  15864. +static unsigned char diacr = 0;
  15865. +static char rep            = 0;            /* Flag telling character repeat */
  15866. +struct kbd_struct kbd_table[MAX_NR_CONSOLES];
  15867. +static struct tty_struct **ttytab;
  15868. +static struct kbd_struct * kbd = kbd_table;
  15869. +static struct tty_struct * tty;
  15870. +
  15871. +static int kbd_rollover[3] = {-1,-1,-1};
  15872. +
  15873. +extern unsigned char    *ioc;
  15874. +static unsigned char    kbd_sendvala[4];
  15875. +static unsigned char    kbd_sendptri;
  15876. +static unsigned char    kbd_sendptro;
  15877. +static unsigned char    ledstate = 0xff;
  15878. +static unsigned char    kbd_repeatkey=-1;
  15879. +
  15880. +typedef void (*k_hand)(unsigned char value, char up_flag);
  15881. +typedef void (k_handfn)(unsigned char value, char up_flag);
  15882. +
  15883. +static k_handfn
  15884. +    do_self, do_fn, do_spec, do_pad, do_dead, do_cons, do_cur, do_shift,
  15885. +    do_meta, do_ascii, do_lock, do_lowercase, do_ignore;
  15886. +
  15887. +static k_hand key_handler[16] = {
  15888. +    do_self, do_fn, do_spec, do_pad, do_dead, do_cons, do_cur, do_shift,
  15889. +    do_meta, do_ascii, do_lock, do_lowercase,
  15890. +    do_ignore, do_ignore, do_ignore, do_ignore
  15891. +};
  15892. +
  15893. +typedef void (*void_fnp)(void);
  15894. +typedef void (void_fn)(void);
  15895. +
  15896. +static void_fn enter, show_ptregs, send_intr, lastcons, caps_toggle,
  15897. +    num, hold, scroll_forw, scroll_back, boot_it, caps_on, compose,
  15898. +    SAK, decr_console, incr_console, show_stack/*, show_floppy*/;
  15899. +
  15900. +static void_fnp spec_fn_table[] = {
  15901. +    NULL,        enter,        show_ptregs,    show_mem,
  15902. +    show_state,    send_intr,    lastcons,    caps_toggle,
  15903. +    num,        hold,        scroll_forw,    scroll_back,
  15904. +    boot_it,    caps_on,    compose,    SAK,
  15905. +    decr_console,    incr_console,    show_stack/*,    show_floppy*/
  15906. +};
  15907. +
  15908. +/* maximum values each key_handler can handle */
  15909. +const int max_vals[] = {
  15910. +    255, SIZE(func_table) - 1, SIZE(spec_fn_table) - 1, NR_PAD - 1,
  15911. +    NR_DEAD - 1, 255, 3, NR_SHIFT - 1,
  15912. +    255, NR_ASCII - 1, NR_LOCK - 1, 255
  15913. +};
  15914. +
  15915. +const int NR_TYPES = SIZE(max_vals);
  15916. +
  15917. +static void put_queue(int);
  15918. +static unsigned char handle_diacr(unsigned char);
  15919. +
  15920. +/* pt_regs - set by keyboard_interrupt(), used by show_ptregs() */
  15921. +static struct pt_regs * pt_regs;
  15922. +
  15923. +void to_utf8(ushort c) {
  15924. +    if (c < 0x80)
  15925. +    put_queue(c);            /*  0*******  */
  15926. +    else if (c < 0x800) {
  15927. +    put_queue(0xc0 | (c >> 6));     /*  110***** 10******  */
  15928. +    put_queue(0x80 | (c & 0x3f));
  15929. +    } else {
  15930. +    put_queue(0xe0 | (c >> 12));     /*  1110**** 10****** 10******  */
  15931. +    put_queue(0x80 | ((c >> 6) & 0x3f));
  15932. +    put_queue(0x80 | (c & 0x3f));
  15933. +    }
  15934. +     /* uft-8 is defined for words of up to 36 bits,
  15935. +       but we need only 16 bits here */
  15936. +}
  15937. +
  15938. +int setkeycode(unsigned int scancode, unsigned int keycode)
  15939. +{
  15940. +#if 0
  15941. +    if (scancode < SC_LIM || scancode > 255 || keycode > 127)
  15942. +        return -EINVAL;
  15943. +    if (scancode < 128)
  15944. +        high_keys[scancode - SC_LIM] = keycode;
  15945. +    else
  15946. +        e0_keys[scancode - 128] = keycode;
  15947. +    return 0;
  15948. +#else
  15949. +    return -EINVAL;
  15950. +#endif
  15951. +}
  15952. +
  15953. +int getkeycode(unsigned int scancode)
  15954. +{
  15955. +#if 0
  15956. +    return
  15957. +        (scancode < SC_LIM || scancode > 255) ? -EINVAL :
  15958. +        (scancode < 128) ? high_keys[scancode - SC_LIM] :
  15959. +        e0_keys[scancode - 128];
  15960. +#else
  15961. +    return -EINVAL;
  15962. +#endif
  15963. +}
  15964. +
  15965. +
  15966. +/* ----------------------------------------------------------------------------------------- */
  15967. +
  15968. +static void key_callback(unsigned long nr)
  15969. +{
  15970. +  rep = 1;
  15971. +  mark_bh(KEYBOARD_BH);
  15972. +}
  15973. +
  15974. +static struct timer_list key_timer=
  15975. +{
  15976. +  NULL,NULL,0,0,key_callback
  15977. +};
  15978. +
  15979. +static void kbd_key(int keycode, char up_flag)
  15980. +{
  15981. +  char process=0;
  15982. +  if(keycode >= 0x70 && keycode <= 0x72)
  15983. +  {
  15984. +    switch(keycode)
  15985. +    {
  15986. +      case 0x70:/* Left mouse button */
  15987. +        if(up_flag)
  15988. +          mouse_buttons&=~4;
  15989. +        else
  15990. +          mouse_buttons|=4;
  15991. +        break;
  15992. +
  15993. +      case 0x71:/* Middle mouse button */
  15994. +        if(up_flag)
  15995. +          mouse_buttons&=~2;
  15996. +        else
  15997. +          mouse_buttons|=2;
  15998. +        break;
  15999. +
  16000. +      case 0x72:/* Right mouse button */
  16001. +        if(up_flag)
  16002. +          mouse_buttons&=~1;
  16003. +        else
  16004. +          mouse_buttons|=1;
  16005. +        break;
  16006. +    }
  16007. +    mouse_ready=1;
  16008. +    wake_up_interruptible(&mouse_wait);
  16009. +    mark_bh(KEYBOARD_BH);
  16010. +    return;
  16011. +  }
  16012. +
  16013. +  tty = ttytab[fg_console];
  16014. +  kbd = kbd_table + fg_console;
  16015. +
  16016. +  if(!up_flag)
  16017. +  {
  16018. +    if(kbd_rollover[0] != -1)
  16019. +    {
  16020. +      if(kbd_rollover[1] != -1)
  16021. +      {
  16022. +        if(kbd_rollover[2] != -1)
  16023. +          return;
  16024. +        kbd_rollover[2] = kbd_rollover[1];
  16025. +      }
  16026. +      kbd_rollover[1] = kbd_rollover[0];
  16027. +    }
  16028. +    kbd_rollover[0] = keycode;
  16029. +    process=1;
  16030. +  }
  16031. +  else
  16032. +  {
  16033. +    if(kbd_rollover[0] == keycode)
  16034. +      kbd_rollover[0] = -1;
  16035. +    if(kbd_rollover[1] == keycode)
  16036. +      kbd_rollover[1] = -1;
  16037. +    if(kbd_rollover[2] == keycode)
  16038. +      kbd_rollover[2] = -1;
  16039. +    process=1;
  16040. +  }
  16041. +
  16042. +  del_timer(&key_timer);
  16043. +  rep = 0;
  16044. +
  16045. +  if(kbd->kbdmode == VC_RAW)
  16046. +    put_queue(keycode|(up_flag?0x80:0));
  16047. +  else
  16048. +  {
  16049. +    if(process)
  16050. +      process_key(keycode, up_flag, HZ*300/1000);
  16051. +    mark_bh(KEYBOARD_BH);
  16052. +  }
  16053. +}
  16054. +
  16055. +static void kbd_sendval(unsigned char val)
  16056. +{
  16057. +  kbd_sendvala[kbd_sendptri]=val;
  16058. +  kbd_sendptri=(kbd_sendptri+1)&3;
  16059. +  disable_irq(15);
  16060. +  enable_irq(14);
  16061. +}
  16062. +
  16063. +static void kbd_reset(void)
  16064. +{
  16065. +  int i;
  16066. +  for(i = 0; i<NR_SHIFT; i++)
  16067. +    k_down[i] = 0;
  16068. +  shift_state = 0;
  16069. +}
  16070. +
  16071. +/*
  16072. + * Keyboard states:
  16073. + *  0 initial reset condition, sent HRST, wait for HRST
  16074. + *  1 Sent RAK1, wait for RAK1
  16075. + *  2 Sent RAK2, wait for RAK2
  16076. + *  3 Sent SMAK, wait for *
  16077. + *  4 Wait for second keyboard nibble for key pressed
  16078. + *  5 Wait for second keyboard nibble for key released
  16079. + *  6 Wait for second part of mouse data
  16080. + */
  16081. +
  16082. +static void kbd_rx(int irq, struct pt_regs *regs)
  16083. +{
  16084. +  int keyval;
  16085. +  static char kbd_mousedx=0;
  16086. +  static unsigned char kbd_state=0;
  16087. +  static unsigned char kbd_keyhigh=0;
  16088. +
  16089. +  keyval=ioc[4];
  16090. +
  16091. +  switch(kbd_state)
  16092. +  {
  16093. +    case 0:/* initial reset condition */
  16094. +      if(keyval == HRST)
  16095. +      {
  16096. +        kbd_reset();
  16097. +        kbd_sendval(RAK1);
  16098. +        kbd_state = 1;
  16099. +      }
  16100. +      else
  16101. +      {
  16102. +        kbd_sendval(HRST);
  16103. +        kbd_state = 0;
  16104. +      }
  16105. +      break;
  16106. +
  16107. +    case 1:/* Sent RAK1 */
  16108. +      if(keyval == RAK1)
  16109. +      {
  16110. +        kbd_sendval(RAK2);
  16111. +        kbd_state = 2;
  16112. +      }
  16113. +      else
  16114. +      {
  16115. +        kbd_sendval(HRST);
  16116. +        kbd_state = 0;
  16117. +      }
  16118. +      break;
  16119. +
  16120. +    case 2:/* Sent RAK2 */
  16121. +      if(keyval == RAK2)
  16122. +      {
  16123. +        kbd_sendval(SMAK);
  16124. +        kbd_state = 3;
  16125. +        ledstate  = 0xff;
  16126. +        mark_bh(KEYBOARD_BH);
  16127. +      }
  16128. +      else
  16129. +      {
  16130. +        kbd_sendval(HRST);
  16131. +        kbd_state = 0;
  16132. +      }
  16133. +      break;
  16134. +
  16135. +    case 3:/* Send SMAK, ready for any reply */
  16136. +      if(keyval == HRST)
  16137. +      {
  16138. +        kbd_sendval(HRST);
  16139. +        kbd_state = 0;
  16140. +      }
  16141. +      else
  16142. +      if(keyval&0x80)
  16143. +      {
  16144. +        switch(keyval&0xF0)
  16145. +        {
  16146. +          case 0xC0:
  16147. +            kbd_keyhigh=keyval;
  16148. +            kbd_state = 4;
  16149. +            kbd_sendval(0x3F);
  16150. +            break;
  16151. +
  16152. +          case 0xD0:
  16153. +            kbd_keyhigh=keyval;
  16154. +            kbd_state = 5;
  16155. +            kbd_sendval(0x3F);
  16156. +            break;
  16157. +
  16158. +          default:
  16159. +            kbd_state = 0;
  16160. +            kbd_sendval(HRST);
  16161. +        }
  16162. +      }
  16163. +      else
  16164. +      {
  16165. +        kbd_mousedx=keyval&0x40?keyval|0x80:keyval;
  16166. +        kbd_state = 6;
  16167. +        kbd_sendval(0x3F);
  16168. +      }
  16169. +      break;
  16170. +
  16171. +    case 4:
  16172. +      if((keyval & 0xF0)!=0xC0)
  16173. +      {
  16174. +        kbd_state = 0;
  16175. +        kbd_sendval(HRST);
  16176. +      }
  16177. +      else
  16178. +      {
  16179. +        kbd_state = 3;
  16180. +        kbd_sendval(SMAK);
  16181. +        if(((kbd_keyhigh^keyval)&0xF0)==0)
  16182. +          kbd_key((keyval&0x0F)|((kbd_keyhigh<<4)&0xF0),0);
  16183. +      }
  16184. +      break;
  16185. +
  16186. +    case 5:
  16187. +      if((keyval & 0xF0)!=0xD0)
  16188. +      {
  16189. +        kbd_state = 0;
  16190. +        kbd_sendval(HRST);
  16191. +      }
  16192. +      else
  16193. +      {
  16194. +        kbd_state = 3;
  16195. +        kbd_sendval(SMAK);
  16196. +        if(((kbd_keyhigh^keyval)&0xF0)==0)
  16197. +          kbd_key((keyval&0x0F)|((kbd_keyhigh<<4)&0xF0),1);
  16198. +      }
  16199. +      break;
  16200. +
  16201. +    case 6:
  16202. +      if(keyval & 0x80)
  16203. +      {
  16204. +        kbd_state = 0;
  16205. +        kbd_sendval(HRST);
  16206. +      }
  16207. +      else
  16208. +      {
  16209. +        kbd_state = 3;
  16210. +        kbd_sendval(SMAK);
  16211. +        mouse_dypos+=(int)((char)(keyval&0x40?keyval|0x80:keyval));
  16212. +        mouse_dxpos+=(int)kbd_mousedx;
  16213. +        mouse_ready=1;
  16214. +        wake_up_interruptible(&mouse_wait);
  16215. +        mark_bh(KEYBOARD_BH);
  16216. +      }
  16217. +      break;
  16218. +  }
  16219. +}
  16220. +
  16221. +static void kbd_tx(int irq, struct pt_regs *regs)
  16222. +{
  16223. +  if(kbd_sendptri!=kbd_sendptro)
  16224. +  {
  16225. +    ioc[0x04]=kbd_sendvala[kbd_sendptro];
  16226. +    kbd_sendptro=(kbd_sendptro+1)&3;
  16227. +  }
  16228. +  if(kbd_sendptri==kbd_sendptro)
  16229. +  {
  16230. +    disable_irq(14);
  16231. +    enable_irq(15);
  16232. +  }
  16233. +}
  16234. +
  16235. +static void process_key(int keycode, char up_flag, int repeattimeout)
  16236. +{
  16237. +  del_timer(&key_timer);
  16238. +
  16239. +  if(!up_flag)
  16240. +  {
  16241. +    kbd_repeatkey = keycode;
  16242. +    if(vc_kbd_mode(kbd, VC_REPEAT))
  16243. +    {
  16244. +      key_timer.expires = repeattimeout;
  16245. +      add_timer(&key_timer);
  16246. +    }
  16247. +  }
  16248. +  else
  16249. +    del_timer(&key_timer);
  16250. +
  16251. +  if(!rep || (vc_kbd_mode(kbd,VC_REPEAT) && tty &&
  16252. +               (L_ECHO(tty) || (tty->driver.chars_in_buffer(tty) == 0))))
  16253. +  {
  16254. +    u_short keysym;
  16255. +    u_char  type;
  16256. +    int     shift_final = shift_state ^ kbd->lockstate;
  16257. +    u_short *key_map = key_maps[shift_final];
  16258. +
  16259. +    if(key_map != NULL)
  16260. +    {
  16261. +      keysym = key_map[keycode];
  16262. +      type   = KTYP(keysym);
  16263. +
  16264. +      if((type & 15) == KT_SHIFT)
  16265. +        kbd_rollover[0] = -1;
  16266. +
  16267. +      if(type >= 0xf0)
  16268. +      {
  16269. +        type -= 0xf0;
  16270. +        if(type == KT_LETTER)
  16271. +        {
  16272. +          type = KT_LATIN;
  16273. +          if(vc_kbd_led(kbd, VC_CAPSLOCK))
  16274. +          {
  16275. +            key_map = key_maps[shift_final ^ (1<<KG_SHIFT)];
  16276. +            if (key_map)
  16277. +              keysym = key_map[keycode];
  16278. +          }
  16279. +        }
  16280. +        (*key_handler[type])(keysym & 0xff, up_flag);
  16281. +      }
  16282. +      else
  16283. +      {
  16284. +        if(!up_flag)
  16285. +          to_utf8(keysym);
  16286. +      }
  16287. +    }
  16288. +    else
  16289. +    {
  16290. +      keysym = U(plain_map[keycode]);
  16291. +      type   = KTYP(keysym);
  16292. +      if(type == KT_SHIFT)
  16293. +        (*key_handler[type])(keysym & 0xff, up_flag);
  16294. +    }
  16295. +  }
  16296. +}
  16297. +
  16298. +static void kbd_bh(void *unused)
  16299. +{
  16300. +  unsigned char leds;
  16301. +
  16302. +  tty = ttytab[fg_console];
  16303. +  kbd = kbd_table + fg_console;
  16304. +
  16305. +  if(rep)
  16306. +    process_key(kbd_repeatkey, 0, HZ*30/1000);
  16307. +  rep = 0;
  16308. +
  16309. +  if(want_console >= 0)
  16310. +  {
  16311. +    if(want_console != fg_console)
  16312. +    {
  16313. +      last_console = fg_console;
  16314. +      change_console(want_console);
  16315. +    }
  16316. +    want_console = -1;
  16317. +  }
  16318. +
  16319. +  leds = getleds();
  16320. +  if(leds != ledstate)
  16321. +  {
  16322. +    unsigned long flags;
  16323. +    ledstate = leds;
  16324. +#define LED_LKCAPS        1
  16325. +#define LED_LKNUM        2
  16326. +#define LED_LKSCRL        4
  16327. +    leds = ((leds & (1<<VC_SCROLLOCK))?LED_LKSCRL:0) | ((leds & (1<<VC_NUMLOCK))?LED_LKNUM:0) |
  16328. +            ((leds & (1<<VC_CAPSLOCK))?LED_LKCAPS:0);
  16329. +    save_flags(flags); cli(); intr_count -= 1;
  16330. +    kbd_sendval(leds);
  16331. +    intr_count += 1; restore_flags(flags);
  16332. +  }
  16333. +  poke_blanked_console();
  16334. +}
  16335. +
  16336. +/* ----------------------------------------------------------------------------------------- */
  16337. +
  16338. +static void put_queue(int ch)
  16339. +{
  16340. +     wake_up(&keypress_wait);
  16341. +    if (tty) {
  16342. +        tty_insert_flip_char(tty, ch, 0);
  16343. +        tty_schedule_flip(tty);
  16344. +    }
  16345. +}
  16346. +
  16347. +static void puts_queue(char *cp)
  16348. +{
  16349. +    wake_up(&keypress_wait);
  16350. +    if (!tty)
  16351. +        return;
  16352. +
  16353. +    while(*cp)
  16354. +        tty_insert_flip_char(tty, *cp++, 0);
  16355. +    tty_schedule_flip(tty);
  16356. +}
  16357. +
  16358. +static void applkey(int key, char mode)
  16359. +{
  16360. +  static char buf[] = { 0x1b, 'O', 0x00, 0x00};
  16361. +
  16362. +  buf[1] = (mode ? 'O' : '[');
  16363. +  buf[2] = key;
  16364. +  puts_queue(buf);
  16365. +}
  16366. +
  16367. +static void enter(void)
  16368. +{
  16369. +  put_queue(13);
  16370. +  if(vc_kbd_mode(kbd, VC_CRLF))
  16371. +    put_queue(10);
  16372. +}
  16373. +
  16374. +static void caps_toggle(void)
  16375. +{
  16376. +  if(rep)
  16377. +    return;
  16378. +  chg_vc_kbd_led(kbd, VC_CAPSLOCK);
  16379. +}
  16380. +
  16381. +static void caps_on(void)
  16382. +{
  16383. +  if(rep)
  16384. +    return;
  16385. +
  16386. +  set_vc_kbd_led(kbd, VC_CAPSLOCK);
  16387. +}
  16388. +int debug_flag=0;
  16389. +static void show_ptregs(void)
  16390. +{ debug_flag ^= 1;
  16391. +  if(!pt_regs)
  16392. +    return;
  16393. +  printk("\n");
  16394. +}
  16395. +
  16396. +static void show_stack(void)
  16397. +{
  16398. +    unsigned long *p;
  16399. +    unsigned long *q = (unsigned long *)((int)current->kernel_stack_page + 4096);
  16400. +    int i;
  16401. +    __asm__("mov %0, sp\n\t": "=r" (p));
  16402. +
  16403. +    for(i=0; p < q; p++, i++)
  16404. +    {
  16405. +        if(i && !(i & 7))
  16406. +            printk("\n");
  16407. +        printk("%08lX ", *p);
  16408. +    }
  16409. +}
  16410. +
  16411. +static void hold(void)
  16412. +{
  16413. +  if(rep || !tty)
  16414. +    return;
  16415. +
  16416. +  if(tty->stopped)
  16417. +    start_tty(tty);
  16418. +  else
  16419. +    stop_tty(tty);
  16420. +}
  16421. +
  16422. +static void num(void)
  16423. +{
  16424. +  if(vc_kbd_mode(kbd,VC_APPLIC))
  16425. +  {
  16426. +    applkey('P', 1);
  16427. +    return;
  16428. +  }
  16429. +  if(!rep)
  16430. +    chg_vc_kbd_led(kbd, VC_NUMLOCK);
  16431. +}
  16432. +
  16433. +static void lastcons(void)
  16434. +{
  16435. +  want_console = last_console;
  16436. +}
  16437. +
  16438. +static void decr_console(void)
  16439. +{
  16440. +  int i;
  16441. +
  16442. +  for(i=fg_console - 1; i != fg_console; i--)
  16443. +  {
  16444. +    if(i == -1)
  16445. +      i = MAX_NR_CONSOLES - 1;
  16446. +    if(vc_cons_allocated(i))
  16447. +      break;
  16448. +  }
  16449. +  want_console = i;
  16450. +}
  16451. +
  16452. +static void incr_console(void)
  16453. +{
  16454. +  int i;
  16455. +
  16456. +  for(i=fg_console + 1; i != fg_console; i++)
  16457. +  {
  16458. +    if(i == MAX_NR_CONSOLES)
  16459. +      i = 0;
  16460. +    if(vc_cons_allocated(i))
  16461. +      break;
  16462. +  }
  16463. +  want_console = i;
  16464. +}
  16465. +
  16466. +static void send_intr(void)
  16467. +{
  16468. +  if(!tty || (tty->termios && I_IGNBRK(tty)))
  16469. +    return;
  16470. +  tty_insert_flip_char(tty, 0, TTY_BREAK);
  16471. +}
  16472. +
  16473. +static void scroll_forw(void)
  16474. +{
  16475. +}
  16476. +
  16477. +static void scroll_back(void)
  16478. +{
  16479. +}
  16480. +
  16481. +static void boot_it(void)
  16482. +{
  16483. +  ctrl_alt_del();
  16484. +}
  16485. +
  16486. +static void compose(void)
  16487. +{
  16488. +  dead_key_next = 1;
  16489. +}
  16490. +
  16491. +int spawnpid, spawnsig;
  16492. +
  16493. +static void spawn_console(void)
  16494. +{
  16495. +    if (spawnpid)
  16496. +      if (kill_proc(spawnpid, spawnsig, 1))
  16497. +        spawnpid = 0;
  16498. +}
  16499. +
  16500. +static void SAK(void)
  16501. +{
  16502. +  do_SAK(tty);
  16503. +}
  16504. +
  16505. +static void do_ignore(unsigned char value, char up_flag)
  16506. +{
  16507. +}
  16508. +
  16509. +static void do_spec(unsigned char value,char up_flag)
  16510. +{
  16511. +  if(up_flag)
  16512. +    return;
  16513. +  if(value >= SIZE(spec_fn_table))
  16514. +    return;
  16515. +  if(!spec_fn_table[value])
  16516. +    return;
  16517. +  spec_fn_table[value]();
  16518. +}
  16519. +
  16520. +static void do_lowercase(unsigned char value, char up_flag)
  16521. +{
  16522. +  printk("keyboard.c: do_lowercase was called - impossible\n");
  16523. +}
  16524. +
  16525. +static void do_self(unsigned char value, char up_flag)
  16526. +{
  16527. +  if(up_flag)
  16528. +    return;
  16529. +
  16530. +  if(diacr)
  16531. +    value = handle_diacr(value);
  16532. +
  16533. +  if(dead_key_next)
  16534. +  {
  16535. +    dead_key_next = 0;
  16536. +    diacr = value;
  16537. +    return;
  16538. +  }
  16539. +if (debug_flag) printk("inserting into put_queue\n");
  16540. +  put_queue(value);
  16541. +}
  16542. +
  16543. +#define A_GRAVE '`'
  16544. +#define A_ACUTE '\''
  16545. +#define A_CFLEX '^'
  16546. +#define A_TILDE '~'
  16547. +#define A_DIAER '"'
  16548. +static unsigned char ret_diacr[] = {A_GRAVE, A_ACUTE, A_CFLEX, A_TILDE, A_DIAER };
  16549. +
  16550. +static void do_dead(unsigned char value, char up_flag)
  16551. +{
  16552. +  if(up_flag)
  16553. +    return;
  16554. +
  16555. +  value = ret_diacr[value];
  16556. +  if(diacr == value)
  16557. +  {
  16558. +    diacr = 0;
  16559. +    put_queue(value);
  16560. +    return;
  16561. +  }
  16562. +  diacr = value;
  16563. +}
  16564. +
  16565. +static unsigned char handle_diacr(unsigned char ch)
  16566. +{
  16567. +  int d = diacr;
  16568. +  int i;
  16569. +
  16570. +  diacr = 0;
  16571. +  if(ch == ' ')
  16572. +    return d;
  16573. +
  16574. +  for(i = 0; i<accent_table_size; i++)
  16575. +  {
  16576. +    if(accent_table[i].diacr == d && accent_table[i].base == ch)
  16577. +      return accent_table[i].result;
  16578. +  }
  16579. +  put_queue(d);
  16580. +  return ch;
  16581. +}
  16582. +
  16583. +static void do_cons(unsigned char value, char up_flag)
  16584. +{
  16585. +  if(up_flag)
  16586. +    return;
  16587. +  want_console = value;
  16588. +}
  16589. +
  16590. +static void do_fn(unsigned char value, char up_flag)
  16591. +{
  16592. +  if(up_flag)
  16593. +    return;
  16594. +
  16595. +  if(value<sizeof(func_table) && func_table[value]!=NULL)
  16596. +    puts_queue(func_table[value]);
  16597. +  else
  16598. +    printk("do_fn called with value=%d\n",value);
  16599. +}
  16600. +
  16601. +static void do_pad(unsigned char value, char up_flag)
  16602. +{
  16603. +  static char *pad_chars = "0123456789+-*/\015,.?#";
  16604. +  static char *app_map = "pqrstuvwxylSRQMnn?#";
  16605. +
  16606. +  if(up_flag)
  16607. +    return;
  16608. +
  16609. +  if(vc_kbd_mode(kbd, VC_APPLIC) && !k_down[KG_SHIFT])
  16610. +  {
  16611. +    applkey(app_map[value], 1);
  16612. +    return;
  16613. +  }
  16614. +
  16615. +  if(!vc_kbd_led(kbd,VC_NUMLOCK))
  16616. +    switch(value)
  16617. +    {
  16618. +      case 15:
  16619. +      case 16: do_fn (22, 0); return;
  16620. +      case 7:  do_fn (20, 0); return;
  16621. +      case 8:  do_cur( 3, 0); return;
  16622. +      case 9:  do_fn (24, 0); return;
  16623. +      case 4:  do_cur( 1, 0); return;
  16624. +      case 6:  do_cur( 2, 0); return;
  16625. +      case 1:  do_fn (23, 0); return;
  16626. +      case 2:  do_cur( 0, 0); return;
  16627. +      case 3:  do_fn (25, 0); return;
  16628. +      case 5:  applkey('G',vc_kbd_mode(kbd, VC_APPLIC)); return;
  16629. +    }
  16630. +
  16631. +  put_queue(pad_chars[value]);
  16632. +  if(value == 14 && vc_kbd_mode(kbd, VC_CRLF))
  16633. +    put_queue(10);
  16634. +}
  16635. +
  16636. +static void do_cur(unsigned char value, char up_flag)
  16637. +{
  16638. +  static char *cur_chars = "BDCA";
  16639. +
  16640. +  if(up_flag)
  16641. +    return;
  16642. +
  16643. +  applkey(cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
  16644. +}
  16645. +
  16646. +void compute_shiftstate(void)
  16647. +{
  16648. +}
  16649. +
  16650. +static void do_shift(unsigned char value, char up_flag)
  16651. +{
  16652. +  int old_state = shift_state;
  16653. +
  16654. +  if (rep)
  16655. +    return;
  16656. +
  16657. +  /* Mimic typewriter: a CapsShift key acts like Shift but undoes CapsLock */
  16658. +  if (value == KVAL(K_CAPSSHIFT))
  16659. +  {
  16660. +    value = KVAL(K_SHIFT);
  16661. +    if(!up_flag)
  16662. +      clr_vc_kbd_led(kbd, VC_CAPSLOCK);
  16663. +  }
  16664. +
  16665. +  if(up_flag)
  16666. +  {
  16667. +    /* handle the case that two shift or control
  16668. +           keys are depressed simultaneously */
  16669. +    if(k_down[value])
  16670. +      k_down[value]--;
  16671. +  }
  16672. +  else
  16673. +    k_down[value]++;
  16674. +
  16675. +  if(k_down[value])
  16676. +    shift_state |= (1 << value);
  16677. +  else
  16678. +    shift_state &= ~ (1 << value);
  16679. +
  16680. +  /* kludge */
  16681. +  if(up_flag && shift_state != old_state && npadch != -1)
  16682. +  {
  16683. +    if(kbd->kbdmode == VC_UNICODE)
  16684. +      to_utf8(npadch & 0xffff);
  16685. +    else
  16686. +      put_queue(npadch & 0xff);
  16687. +    npadch = -1;
  16688. +  }
  16689. +}
  16690. +
  16691. +static void do_meta(unsigned char value, char up_flag)
  16692. +{
  16693. +  if(up_flag)
  16694. +    return;
  16695. +
  16696. +  if(vc_kbd_mode(kbd, VC_META))
  16697. +  {
  16698. +    put_queue('\033');
  16699. +    put_queue(value);
  16700. +  }
  16701. +  else
  16702. +    put_queue(value | 0x80);
  16703. +}
  16704. +
  16705. +static void do_ascii(unsigned char value, char up_flag)
  16706. +{
  16707. +  int base;
  16708. +
  16709. +  if(up_flag)
  16710. +    return;
  16711. +
  16712. +  if(value < 10)
  16713. +    base = 10;
  16714. +  else
  16715. +  {
  16716. +    value -= 10;
  16717. +    base = 16;
  16718. +  }
  16719. +
  16720. +  if(npadch == -1)
  16721. +    npadch = value;
  16722. +  else
  16723. +    npadch = npadch * base + value;
  16724. +}
  16725. +
  16726. +static void do_lock(unsigned char value, char up_flag)
  16727. +{
  16728. +  if(up_flag || rep)
  16729. +    return;
  16730. +  chg_vc_kbd_lock(kbd, value);
  16731. +}
  16732. +
  16733. +/* --------------------------------------------------------------------------------------- *
  16734. + * Led driver                                           *
  16735. + * --------------------------------------------------------------------------------------- */
  16736. +
  16737. +static unsigned char ledioctl;
  16738. +
  16739. +unsigned char getledstate(void)
  16740. +{
  16741. +  return ledstate;
  16742. +}
  16743. +
  16744. +void setledstate(struct kbd_struct *kbd, unsigned int led)
  16745. +{
  16746. +  if(!(led & ~7))
  16747. +  {
  16748. +    ledioctl = led;
  16749. +    kbd->ledmode = LED_SHOW_IOCTL;
  16750. +  }
  16751. +  else
  16752. +    kbd->ledmode = LED_SHOW_FLAGS;
  16753. +  set_leds();
  16754. +}
  16755. +
  16756. +static struct ledptr
  16757. +{
  16758. +  unsigned int *addr;
  16759. +  unsigned int mask;
  16760. +  unsigned char valid:1;
  16761. +} ledptrs[3];
  16762. +
  16763. +void register_leds(int console,unsigned int led,unsigned int *addr,unsigned int mask)
  16764. +{
  16765. +  struct kbd_struct *kbd = kbd_table + console;
  16766. +
  16767. +  if(led < 3)
  16768. +  {
  16769. +    ledptrs[led].addr = addr;
  16770. +    ledptrs[led].mask = mask;
  16771. +    ledptrs[led].valid= 1;
  16772. +    kbd->ledmode = LED_SHOW_MEM;
  16773. +  }
  16774. +  else
  16775. +    kbd->ledmode = LED_SHOW_FLAGS;
  16776. +}
  16777. +
  16778. +static unsigned char getleds(void)
  16779. +{
  16780. +  struct kbd_struct *kbd = kbd_table + fg_console;
  16781. +  unsigned char leds;
  16782. +
  16783. +  if(kbd->ledmode == LED_SHOW_IOCTL)
  16784. +    return ledioctl;
  16785. +  leds = kbd->ledflagstate;
  16786. +  if(kbd->ledmode == LED_SHOW_MEM)
  16787. +  {
  16788. +    if(ledptrs[0].valid)
  16789. +    {
  16790. +      if(*ledptrs[0].addr & ledptrs[0].mask)
  16791. +        leds|=1;
  16792. +      else
  16793. +        leds&=~1;
  16794. +    }
  16795. +    if(ledptrs[1].valid)
  16796. +    {
  16797. +      if(*ledptrs[1].addr & ledptrs[1].mask)
  16798. +        leds|=2;
  16799. +      else
  16800. +        leds&=~2;
  16801. +    }
  16802. +    if(ledptrs[2].valid)
  16803. +    {
  16804. +      if(*ledptrs[2].addr & ledptrs[2].mask)
  16805. +        leds|=4;
  16806. +      else
  16807. +        leds&=~4;
  16808. +    }
  16809. +  }
  16810. +  return leds;
  16811. +}
  16812. +
  16813. +/* --------------------------------------------------------------------------------------- *
  16814. + *                                   Keyboard initialisation                               *
  16815. + *    kbd_rx must be allocated first, then kbd_tx                                          *
  16816. + * --------------------------------------------------------------------------------------- */
  16817. +
  16818. +unsigned long kbd_init(unsigned long kmem_start)
  16819. +{
  16820. +    int i;
  16821. +    struct kbd_struct kbd0;
  16822. +    extern struct tty_driver console_driver;
  16823. +    unsigned long flags;
  16824. +
  16825. +    kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
  16826. +    kbd0.ledmode      = LED_SHOW_FLAGS;
  16827. +    kbd0.lockstate    = KBD_DEFLOCK;
  16828. +    kbd0.modeflags    = KBD_DEFMODE;
  16829. +    kbd0.kbdmode      = VC_XLATE;
  16830. +
  16831. +    for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
  16832. +        kbd_table[i] = kbd0;
  16833. +
  16834. +    ttytab = console_driver.table;
  16835. +
  16836. +    bh_base[KEYBOARD_BH].routine=kbd_bh;
  16837. +    save_flags(flags);
  16838. +    cli();
  16839. +    if(request_irq(IRQ_KEYBOARDRX, kbd_rx, 0, "keyboard")!=0)
  16840. +        panic("Could not allocate keyboard receive IRQ!");
  16841. +    if(request_irq(IRQ_KEYBOARDTX, kbd_tx, 0, "Keyboard")!=0)
  16842. +        panic("Could not allocate keyboard transmit IRQ!");
  16843. +    disable_irq(IRQ_KEYBOARDTX);
  16844. +    restore_flags(flags);
  16845. +    kbd_sendval(HRST);
  16846. +    printk("%s keyboard driver installed (%s) v%d.%02d.\n", "A5000", "English", VERSION/100, VERSION%100);
  16847. +    return kmem_start;
  16848. +}
  16849. +
  16850. diff -r -u -N linux.orig/arch/arm/drivers/char/lp.c linux.arm/arch/arm/drivers/char/lp.c
  16851. --- linux.orig/arch/arm/drivers/char/lp.c    Thu Jan  1 01:00:00 1970
  16852. +++ linux.arm/arch/arm/drivers/char/lp.c    Fri Oct 27 23:14:24 1995
  16853. @@ -0,0 +1,618 @@
  16854. +/*
  16855. + * Copyright (C) 1992 by Jim Weigand and Linus Torvalds
  16856. + * Copyright (C) 1992,1993 by Michael K. Johnson
  16857. + * - Thanks much to Gunter Windau for pointing out to me where the error
  16858. + *   checking ought to be.
  16859. + * Copyright (C) 1993 by Nigel Gamble (added interrupt code)
  16860. + * Copyright (C) 1994 by Alan Cox (Modularised it)
  16861. + * LPCAREFUL, LPABORT, LPGETSTATUS added by Chris Metcalf, metcalf@lcs.mit.edu
  16862. + */
  16863. +
  16864. +#ifdef MODULE
  16865. +#include <linux/module.h>
  16866. +#include <linux/version.h>
  16867. +#else
  16868. +#define MOD_INC_USE_COUNT
  16869. +#define MOD_DEC_USE_COUNT
  16870. +#endif
  16871. +
  16872. +#include <linux/errno.h>
  16873. +#include <linux/kernel.h>
  16874. +#include <linux/major.h>
  16875. +#include <linux/sched.h>
  16876. +#include <linux/lp.h>
  16877. +#include <linux/malloc.h>
  16878. +#include <linux/ioport.h>
  16879. +#include <linux/fcntl.h>
  16880. +
  16881. +#include <asm/io.h>
  16882. +#include <asm/segment.h>
  16883. +#include <asm/system.h>
  16884. +
  16885. +/* the BIOS manuals say there can be up to 4 lpt devices
  16886. + * but I have not seen a board where the 4th address is listed
  16887. + * if you have different hardware change the table below 
  16888. + * please let me know if you have different equipment
  16889. + * if you have more than 3 printers, remember to increase LP_NO
  16890. + */
  16891. +struct lp_struct lp_table[] = {
  16892. +    { 0x3bc, 0, 0, LP_INIT_CHAR, LP_INIT_TIME, LP_INIT_WAIT, NULL, NULL, },
  16893. +    { 0x378, 0, 0, LP_INIT_CHAR, LP_INIT_TIME, LP_INIT_WAIT, NULL, NULL, },
  16894. +    { 0x278, 0, 0, LP_INIT_CHAR, LP_INIT_TIME, LP_INIT_WAIT, NULL, NULL, },
  16895. +}; 
  16896. +#define LP_NO 3
  16897. +
  16898. +/* Test if printer is ready (and optionally has no error conditions) */
  16899. +#define LP_READY(minor, status) \
  16900. +  ((LP_F(minor) & LP_CAREFUL) ? _LP_CAREFUL_READY(status) : (status & LP_PBUSY))
  16901. +#define LP_CAREFUL_READY(minor, status) \
  16902. +  ((LP_F(minor) & LP_CAREFUL) ? _LP_CAREFUL_READY(status) : 1)
  16903. +#define _LP_CAREFUL_READY(status) \
  16904. +   (status & (LP_PBUSY|LP_POUTPA|LP_PSELECD|LP_PERRORP)) == \
  16905. +      (LP_PBUSY|LP_PSELECD|LP_PERRORP) 
  16906. +
  16907. +/* Allow old versions of tunelp to continue to work */
  16908. +#define OLD_LPCHAR   0x0001
  16909. +#define OLD_LPTIME   0x0002
  16910. +#define OLD_LPABORT  0x0004
  16911. +#define OLD_LPSETIRQ 0x0005
  16912. +#define OLD_LPGETIRQ 0x0006
  16913. +#define OLD_LPWAIT   0x0008
  16914. +#define OLD_IOCTL_MAX 8
  16915. +
  16916. +/* 
  16917. + * All my debugging code assumes that you debug with only one printer at
  16918. + * a time. RWWH
  16919. + */
  16920. +
  16921. +#undef LP_DEBUG
  16922. +
  16923. +static int lp_reset(int minor)
  16924. +{
  16925. +    int testvalue;
  16926. +    unsigned char command;
  16927. +
  16928. +    command = LP_PSELECP | LP_PINITP;
  16929. +
  16930. +    /* reset value */
  16931. +    outb_p(0, LP_C(minor));
  16932. +    for (testvalue = 0 ; testvalue < LP_DELAY ; testvalue++)
  16933. +        ;
  16934. +    outb_p(command, LP_C(minor));
  16935. +    return LP_S(minor);
  16936. +}
  16937. +
  16938. +#ifdef LP_DEBUG
  16939. +static int lp_max_count = 1;
  16940. +#endif
  16941. +
  16942. +static int lp_char_polled(char lpchar, int minor)
  16943. +{
  16944. +    int status = 0, wait = 0;
  16945. +    unsigned long count  = 0; 
  16946. +
  16947. +    do {
  16948. +        status = LP_S(minor);
  16949. +        count ++;
  16950. +        if(need_resched)
  16951. +            schedule();
  16952. +    } while(!LP_READY(minor,status) && count < LP_CHAR(minor));
  16953. +
  16954. +    if (count == LP_CHAR(minor)) {
  16955. +        return 0;
  16956. +        /* we timed out, and the character was /not/ printed */
  16957. +    }
  16958. +#ifdef LP_DEBUG
  16959. +    if (count > lp_max_count) {
  16960. +        printk("lp success after %d counts.\n",count);
  16961. +        lp_max_count=count;
  16962. +    }
  16963. +#endif
  16964. +    outb_p(lpchar, LP_B(minor));
  16965. +    /* must wait before taking strobe high, and after taking strobe
  16966. +       low, according spec.  Some printers need it, others don't. */
  16967. +    while(wait != LP_WAIT(minor)) wait++;
  16968. +        /* control port takes strobe high */
  16969. +    outb_p(( LP_PSELECP | LP_PINITP | LP_PSTROBE ), ( LP_C( minor )));
  16970. +    while(wait) wait--;
  16971. +        /* take strobe low */
  16972. +    outb_p(( LP_PSELECP | LP_PINITP ), ( LP_C( minor )));
  16973. +
  16974. +    return 1;
  16975. +}
  16976. +
  16977. +static int lp_char_interrupt(char lpchar, int minor)
  16978. +{
  16979. +    int wait = 0;
  16980. +    unsigned char status;
  16981. +
  16982. +
  16983. +    if (!((status = LP_S(minor)) & LP_PACK) || (status & LP_PBUSY)
  16984. +    || !((status = LP_S(minor)) & LP_PACK) || (status & LP_PBUSY)
  16985. +    || !((status = LP_S(minor)) & LP_PACK) || (status & LP_PBUSY)) {
  16986. +
  16987. +        if (!LP_CAREFUL_READY(minor, status))
  16988. +            return 0;
  16989. +        outb_p(lpchar, LP_B(minor));
  16990. +        /* must wait before taking strobe high, and after taking strobe
  16991. +           low, according spec.  Some printers need it, others don't. */
  16992. +        while(wait != LP_WAIT(minor)) wait++;
  16993. +        /* control port takes strobe high */
  16994. +        outb_p(( LP_PSELECP | LP_PINITP | LP_PSTROBE ), ( LP_C( minor )));
  16995. +        while(wait) wait--;
  16996. +        /* take strobe low */
  16997. +        outb_p(( LP_PSELECP | LP_PINITP ), ( LP_C( minor )));
  16998. +        return 1;
  16999. +    }
  17000. +
  17001. +    return 0;
  17002. +}
  17003. +
  17004. +#ifdef LP_DEBUG
  17005. +    unsigned int lp_total_chars = 0;
  17006. +    unsigned int lp_last_call = 0;
  17007. +#endif
  17008. +
  17009. +static void lp_interrupt(int irq, struct pt_regs *regs)
  17010. +{
  17011. +    struct lp_struct *lp = &lp_table[0];
  17012. +    struct lp_struct *lp_end = &lp_table[LP_NO];
  17013. +
  17014. +    while (irq != lp->irq) {
  17015. +        if (++lp >= lp_end)
  17016. +            return;
  17017. +    }
  17018. +
  17019. +    wake_up(&lp->lp_wait_q);
  17020. +}
  17021. +
  17022. +static int lp_write_interrupt(struct inode * inode, struct file * file, char * buf, int count)
  17023. +{
  17024. +    unsigned int minor = MINOR(inode->i_rdev);
  17025. +    unsigned long copy_size;
  17026. +    unsigned long total_bytes_written = 0;
  17027. +    unsigned long bytes_written;
  17028. +    struct lp_struct *lp = &lp_table[minor];
  17029. +    unsigned char status;
  17030. +
  17031. +    do {
  17032. +        bytes_written = 0;
  17033. +        copy_size = (count <= LP_BUFFER_SIZE ? count : LP_BUFFER_SIZE);
  17034. +        memcpy_fromfs(lp->lp_buffer, buf, copy_size);
  17035. +
  17036. +        while (copy_size) {
  17037. +            if (lp_char_interrupt(lp->lp_buffer[bytes_written], minor)) {
  17038. +                --copy_size;
  17039. +                ++bytes_written;
  17040. +            } else {
  17041. +                int rc = total_bytes_written + bytes_written;
  17042. +                status = LP_S(minor);
  17043. +                if ((status & LP_POUTPA)) {
  17044. +                    printk(KERN_INFO "lp%d out of paper\n", minor);
  17045. +                    if (LP_F(minor) & LP_ABORT)
  17046. +                        return rc?rc:-ENOSPC;
  17047. +                } else if (!(status & LP_PSELECD)) {
  17048. +                    printk(KERN_INFO "lp%d off-line\n", minor);
  17049. +                    if (LP_F(minor) & LP_ABORT)
  17050. +                        return rc?rc:-EIO;
  17051. +                } else if (!(status & LP_PERRORP)) {
  17052. +                    printk(KERN_ERR "lp%d printer error\n", minor);
  17053. +                    if (LP_F(minor) & LP_ABORT)
  17054. +                        return rc?rc:-EIO;
  17055. +                }
  17056. +                cli();
  17057. +                outb_p((LP_PSELECP|LP_PINITP|LP_PINTEN), (LP_C(minor)));
  17058. +                status = LP_S(minor);
  17059. +                if ((!(status & LP_PACK) || (status & LP_PBUSY))
  17060. +                  && LP_CAREFUL_READY(minor, status)) {
  17061. +                    outb_p((LP_PSELECP|LP_PINITP), (LP_C(minor)));
  17062. +                    sti();
  17063. +                    continue;
  17064. +                }
  17065. +                current->timeout = jiffies + LP_TIMEOUT_INTERRUPT;
  17066. +                interruptible_sleep_on(&lp->lp_wait_q);
  17067. +                outb_p((LP_PSELECP|LP_PINITP), (LP_C(minor)));
  17068. +                sti();
  17069. +                if (current->signal & ~current->blocked) {
  17070. +                    if (total_bytes_written + bytes_written)
  17071. +                        return total_bytes_written + bytes_written;
  17072. +                    else
  17073. +                        return -EINTR;
  17074. +                }
  17075. +            }
  17076. +        }
  17077. +
  17078. +        total_bytes_written += bytes_written;
  17079. +        buf += bytes_written;
  17080. +        count -= bytes_written;
  17081. +
  17082. +    } while (count > 0);
  17083. +
  17084. +    return total_bytes_written;
  17085. +}
  17086. +
  17087. +static int lp_write_polled(struct inode * inode, struct file * file,
  17088. +               char * buf, int count)
  17089. +{
  17090. +    int  retval;
  17091. +    unsigned int minor = MINOR(inode->i_rdev);
  17092. +    char c, *temp = buf;
  17093. +
  17094. +#ifdef LP_DEBUG
  17095. +    if (jiffies-lp_last_call > LP_TIME(minor)) {
  17096. +        lp_total_chars = 0;
  17097. +        lp_max_count = 1;
  17098. +    }
  17099. +    lp_last_call = jiffies;
  17100. +#endif
  17101. +
  17102. +    temp = buf;
  17103. +    while (count > 0) {
  17104. +        c = get_fs_byte(temp);
  17105. +        retval = lp_char_polled(c, minor);
  17106. +        /* only update counting vars if character was printed */
  17107. +        if (retval) { count--; temp++;
  17108. +#ifdef LP_DEBUG
  17109. +            lp_total_chars++;
  17110. +#endif
  17111. +        }
  17112. +        if (!retval) { /* if printer timed out */
  17113. +            int status = LP_S(minor);
  17114. +
  17115. +            if (status & LP_POUTPA) {
  17116. +                printk(KERN_INFO "lp%d out of paper\n", minor);
  17117. +                if(LP_F(minor) & LP_ABORT)
  17118. +                    return temp-buf?temp-buf:-ENOSPC;
  17119. +                current->state = TASK_INTERRUPTIBLE;
  17120. +                current->timeout = jiffies + LP_TIMEOUT_POLLED;
  17121. +                schedule();
  17122. +            } else
  17123. +            if (!(status & LP_PSELECD)) {
  17124. +                printk(KERN_INFO "lp%d off-line\n", minor);
  17125. +                if(LP_F(minor) & LP_ABORT)
  17126. +                    return temp-buf?temp-buf:-EIO;
  17127. +                current->state = TASK_INTERRUPTIBLE;
  17128. +                current->timeout = jiffies + LP_TIMEOUT_POLLED;
  17129. +                schedule();
  17130. +            } else
  17131. +                    /* not offline or out of paper. on fire? */
  17132. +            if (!(status & LP_PERRORP)) {
  17133. +                printk(KERN_ERR "lp%d reported invalid error status (on fire, eh?)\n", minor);
  17134. +                if(LP_F(minor) & LP_ABORT)
  17135. +                    return temp-buf?temp-buf:-EIO;
  17136. +                current->state = TASK_INTERRUPTIBLE;
  17137. +                current->timeout = jiffies + LP_TIMEOUT_POLLED;
  17138. +                schedule();
  17139. +            }
  17140. +
  17141. +            /* check for signals before going to sleep */
  17142. +            if (current->signal & ~current->blocked) {
  17143. +                if (temp != buf)
  17144. +                    return temp-buf;
  17145. +                else
  17146. +                    return -EINTR;
  17147. +            }
  17148. +#ifdef LP_DEBUG
  17149. +            printk("lp sleeping at %d characters for %d jiffies\n",
  17150. +                lp_total_chars, LP_TIME(minor));
  17151. +            lp_total_chars=0;
  17152. +#endif
  17153. +            current->state = TASK_INTERRUPTIBLE;
  17154. +            current->timeout = jiffies + LP_TIME(minor);
  17155. +            schedule();
  17156. +        }
  17157. +    }
  17158. +    return temp-buf;
  17159. +}
  17160. +
  17161. +static int lp_write(struct inode * inode, struct file * file, char * buf, int count)
  17162. +{
  17163. +    if (LP_IRQ(MINOR(inode->i_rdev)))
  17164. +        return lp_write_interrupt(inode, file, buf, count);
  17165. +    else
  17166. +        return lp_write_polled(inode, file, buf, count);
  17167. +}
  17168. +
  17169. +static int lp_lseek(struct inode * inode, struct file * file,
  17170. +            off_t offset, int origin)
  17171. +{
  17172. +    return -ESPIPE;
  17173. +}
  17174. +
  17175. +static int lp_open(struct inode * inode, struct file * file)
  17176. +{
  17177. +    unsigned int minor = MINOR(inode->i_rdev);
  17178. +    int ret;
  17179. +    unsigned int irq;
  17180. +
  17181. +    if (minor >= LP_NO)
  17182. +        return -ENODEV;
  17183. +    if ((LP_F(minor) & LP_EXIST) == 0)
  17184. +        return -ENODEV;
  17185. +    if (LP_F(minor) & LP_BUSY)
  17186. +        return -EBUSY;
  17187. +
  17188. +    MOD_INC_USE_COUNT;
  17189. +
  17190. +    /* If ABORTOPEN is set and the printer is offline or out of paper,
  17191. +       we may still want to open it to perform ioctl()s.  Therefore we
  17192. +       have commandeered O_NONBLOCK, even though it is being used in
  17193. +       a non-standard manner.  This is strictly a Linux hack, and
  17194. +       should most likely only ever be used by the tunelp application. */
  17195. +        if ((LP_F(minor) & LP_ABORTOPEN) && !(file->f_flags & O_NONBLOCK)) {
  17196. +        int status = LP_S(minor);
  17197. +        if (status & LP_POUTPA) {
  17198. +            printk(KERN_INFO "lp%d out of paper\n", minor);
  17199. +            MOD_DEC_USE_COUNT;
  17200. +            return -ENOSPC;
  17201. +        } else if (!(status & LP_PSELECD)) {
  17202. +            printk(KERN_INFO "lp%d off-line\n", minor);
  17203. +            MOD_DEC_USE_COUNT;
  17204. +            return -EIO;
  17205. +        } else if (!(status & LP_PERRORP)) {
  17206. +            printk(KERN_ERR "lp%d printer error\n", minor);
  17207. +            MOD_DEC_USE_COUNT;
  17208. +            return -EIO;
  17209. +        }
  17210. +    }
  17211. +
  17212. +    if ((irq = LP_IRQ(minor))) {
  17213. +        lp_table[minor].lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
  17214. +        if (!lp_table[minor].lp_buffer) {
  17215. +            MOD_DEC_USE_COUNT;
  17216. +            return -ENOMEM;
  17217. +        }
  17218. +
  17219. +        ret = request_irq(irq, lp_interrupt, SA_INTERRUPT, "printer");
  17220. +        if (ret) {
  17221. +            kfree_s(lp_table[minor].lp_buffer, LP_BUFFER_SIZE);
  17222. +            lp_table[minor].lp_buffer = NULL;
  17223. +            printk("lp%d unable to use interrupt %d, error %d\n", minor, irq, ret);
  17224. +            MOD_DEC_USE_COUNT;
  17225. +            return ret;
  17226. +        }
  17227. +    }
  17228. +
  17229. +    LP_F(minor) |= LP_BUSY;
  17230. +    return 0;
  17231. +}
  17232. +
  17233. +static void lp_release(struct inode * inode, struct file * file)
  17234. +{
  17235. +    unsigned int minor = MINOR(inode->i_rdev);
  17236. +    unsigned int irq;
  17237. +
  17238. +    if ((irq = LP_IRQ(minor))) {
  17239. +        free_irq(irq);
  17240. +        kfree_s(lp_table[minor].lp_buffer, LP_BUFFER_SIZE);
  17241. +        lp_table[minor].lp_buffer = NULL;
  17242. +    }
  17243. +
  17244. +    LP_F(minor) &= ~LP_BUSY;
  17245. +    MOD_DEC_USE_COUNT;
  17246. +}
  17247. +
  17248. +
  17249. +static int lp_ioctl(struct inode *inode, struct file *file,
  17250. +            unsigned int cmd, unsigned long arg)
  17251. +{
  17252. +    unsigned int minor = MINOR(inode->i_rdev);
  17253. +    int retval = 0;
  17254. +
  17255. +#ifdef LP_DEBUG
  17256. +    printk("lp%d ioctl, cmd: 0x%x, arg: 0x%x\n", minor, cmd, arg);
  17257. +#endif
  17258. +    if (minor >= LP_NO)
  17259. +        return -ENODEV;
  17260. +    if ((LP_F(minor) & LP_EXIST) == 0)
  17261. +        return -ENODEV;
  17262. +    if (cmd <= OLD_IOCTL_MAX)
  17263. +        printk(KERN_NOTICE "lp%d: warning: obsolete ioctl %#x (perhaps you need a new tunelp)\n",
  17264. +            minor, cmd);
  17265. +    switch ( cmd ) {
  17266. +        case OLD_LPTIME:
  17267. +        case LPTIME:
  17268. +            LP_TIME(minor) = arg;
  17269. +            break;
  17270. +        case OLD_LPCHAR:
  17271. +        case LPCHAR:
  17272. +            LP_CHAR(minor) = arg;
  17273. +            break;
  17274. +        case OLD_LPABORT:
  17275. +        case LPABORT:
  17276. +            if (arg)
  17277. +                LP_F(minor) |= LP_ABORT;
  17278. +            else
  17279. +                LP_F(minor) &= ~LP_ABORT;
  17280. +            break;
  17281. +        case LPABORTOPEN:
  17282. +            if (arg)
  17283. +                LP_F(minor) |= LP_ABORTOPEN;
  17284. +            else
  17285. +                LP_F(minor) &= ~LP_ABORTOPEN;
  17286. +            break;
  17287. +        case LPCAREFUL:
  17288. +            if (arg)
  17289. +                LP_F(minor) |= LP_CAREFUL;
  17290. +            else
  17291. +                LP_F(minor) &= ~LP_CAREFUL;
  17292. +            break;
  17293. +        case OLD_LPWAIT:
  17294. +        case LPWAIT:
  17295. +            LP_WAIT(minor) = arg;
  17296. +            break;
  17297. +        case OLD_LPSETIRQ:
  17298. +        case LPSETIRQ: {
  17299. +            int oldirq;
  17300. +            int newirq = arg;
  17301. +            struct lp_struct *lp = &lp_table[minor];
  17302. +
  17303. +            if (!suser())
  17304. +                return -EPERM;
  17305. +
  17306. +            oldirq = LP_IRQ(minor);
  17307. +
  17308. +            /* Allocate buffer now if we are going to need it */
  17309. +            if (!oldirq && newirq) {
  17310. +                lp->lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
  17311. +                if (!lp->lp_buffer)
  17312. +                    return -ENOMEM;
  17313. +            }
  17314. +
  17315. +            if (oldirq) {
  17316. +                free_irq(oldirq);
  17317. +            }
  17318. +            if (newirq) {
  17319. +                /* Install new irq */
  17320. +                if ((retval = request_irq(newirq, lp_interrupt, SA_INTERRUPT, "printer"))) {
  17321. +                    if (oldirq) {
  17322. +                        /* restore old irq */
  17323. +                        request_irq(oldirq, lp_interrupt, SA_INTERRUPT, "printer");
  17324. +                    } else {
  17325. +                        /* We don't need the buffer */
  17326. +                        kfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
  17327. +                        lp->lp_buffer = NULL;
  17328. +                    }
  17329. +                    return retval;
  17330. +                }
  17331. +            }
  17332. +            if (oldirq && !newirq) {
  17333. +                /* We don't need the buffer */
  17334. +                kfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
  17335. +                lp->lp_buffer = NULL;
  17336. +            }
  17337. +            LP_IRQ(minor) = newirq;
  17338. +            lp_reset(minor);
  17339. +            break;
  17340. +        }
  17341. +        case OLD_LPGETIRQ:
  17342. +            retval = LP_IRQ(minor);
  17343. +            break;
  17344. +        case LPGETIRQ:
  17345. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  17346. +                sizeof(int));
  17347. +                if (retval)
  17348. +                    return retval;
  17349. +            memcpy_tofs((int *) arg, &LP_IRQ(minor), sizeof(int));
  17350. +            break;
  17351. +        case LPGETSTATUS:
  17352. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  17353. +                sizeof(int));
  17354. +                if (retval)
  17355. +                    return retval;
  17356. +            else {
  17357. +                int status = LP_S(minor);
  17358. +                memcpy_tofs((int *) arg, &status, sizeof(int));
  17359. +            }
  17360. +            break;
  17361. +        case LPRESET:
  17362. +            lp_reset(minor);
  17363. +            break;
  17364. +        default:
  17365. +            retval = -EINVAL;
  17366. +    }
  17367. +    return retval;
  17368. +}
  17369. +
  17370. +
  17371. +static struct file_operations lp_fops = {
  17372. +    lp_lseek,
  17373. +    NULL,        /* lp_read */
  17374. +    lp_write,
  17375. +    NULL,        /* lp_readdir */
  17376. +    NULL,        /* lp_select */
  17377. +    lp_ioctl,
  17378. +    NULL,        /* lp_mmap */
  17379. +    lp_open,
  17380. +    lp_release
  17381. +};
  17382. +
  17383. +#ifndef MODULE
  17384. +
  17385. +long lp_init(long kmem_start)
  17386. +{
  17387. +    int offset = 0;
  17388. +    unsigned int testvalue = 0;
  17389. +    int count = 0;
  17390. +
  17391. +    if (register_chrdev(LP_MAJOR,"lp",&lp_fops)) {
  17392. +        printk("unable to get major %d for line printer\n", LP_MAJOR);
  17393. +        return kmem_start;
  17394. +    }
  17395. +    /* take on all known port values */
  17396. +    for (offset = 0; offset < LP_NO; offset++) {
  17397. +        if (check_region(LP_B(offset), 3))
  17398. +            continue;
  17399. +        /* write to port & read back to check */
  17400. +        outb_p( LP_DUMMY, LP_B(offset));
  17401. +        for (testvalue = 0 ; testvalue < LP_DELAY ; testvalue++)
  17402. +            ;
  17403. +        testvalue = inb_p(LP_B(offset));
  17404. +        if (testvalue == LP_DUMMY) {
  17405. +            LP_F(offset) |= LP_EXIST;
  17406. +            lp_reset(offset);
  17407. +            printk("lp%d at 0x%04x, ", offset,LP_B(offset));
  17408. +            request_region(LP_B(offset), 3, "lp");
  17409. +            if (LP_IRQ(offset))
  17410. +                printk("using IRQ%d\n", LP_IRQ(offset));
  17411. +            else
  17412. +                printk("using polling driver\n");
  17413. +            count++;
  17414. +        }
  17415. +    }
  17416. +    if (count == 0)
  17417. +        printk("lp_init: no lp devices found\n");
  17418. +    return kmem_start;
  17419. +}
  17420. +
  17421. +#else
  17422. +
  17423. +char kernel_version[]= UTS_RELEASE;
  17424. +
  17425. +int init_module(void)
  17426. +{
  17427. +    int offset = 0;
  17428. +    unsigned int testvalue = 0;
  17429. +    int count = 0;
  17430. +
  17431. +    if (register_chrdev(LP_MAJOR,"lp",&lp_fops)) {
  17432. +        printk("unable to get major %d for line printer\n", LP_MAJOR);
  17433. +        return -EIO;
  17434. +    }
  17435. +    /* take on all known port values */
  17436. +    for (offset = 0; offset < LP_NO; offset++) {
  17437. +        /* write to port & read back to check */
  17438. +        outb_p( LP_DUMMY, LP_B(offset));
  17439. +        for (testvalue = 0 ; testvalue < LP_DELAY ; testvalue++)
  17440. +            ;
  17441. +        testvalue = inb_p(LP_B(offset));
  17442. +        if (testvalue == LP_DUMMY) {
  17443. +            LP_F(offset) |= LP_EXIST;
  17444. +            lp_reset(offset);
  17445. +            printk("lp%d at 0x%04x, ", offset,LP_B(offset));
  17446. +            request_region(LP_B(offset),3,"lp");
  17447. +            if (LP_IRQ(offset))
  17448. +                printk("using IRQ%d\n", LP_IRQ(offset));
  17449. +            else
  17450. +                printk("using polling driver\n");
  17451. +            count++;
  17452. +        }
  17453. +    }
  17454. +    if (count == 0)
  17455. +        printk("lp_init: no lp devices found\n");
  17456. +    return 0;
  17457. +}
  17458. +
  17459. +void cleanup_module(void)
  17460. +{
  17461. +        int offset;
  17462. +    if(MOD_IN_USE)
  17463. +               printk("lp: busy - remove delayed\n");
  17464. +        else
  17465. +               unregister_chrdev(LP_MAJOR,"lp");
  17466. +           for (offset = 0; offset < LP_NO; offset++) 
  17467. +            if(LP_F(offset) && LP_EXIST) 
  17468. +                 release_region(LP_B(offset),3);
  17469. +}
  17470. +
  17471. +#endif
  17472. diff -r -u -N linux.orig/arch/arm/drivers/char/lp.c.orig linux.arm/arch/arm/drivers/char/lp.c.orig
  17473. --- linux.orig/arch/arm/drivers/char/lp.c.orig    Thu Jan  1 01:00:00 1970
  17474. +++ linux.arm/arch/arm/drivers/char/lp.c.orig    Fri Oct 27 23:14:38 1995
  17475. @@ -0,0 +1,526 @@
  17476. +/*
  17477. + * Copyright (C) 1992 by Jim Weigand and Linus Torvalds
  17478. + * Copyright (C) 1992,1993 by Michael K. Johnson
  17479. + * - Thanks much to Gunter Windau for pointing out to me where the error
  17480. + *   checking ought to be.
  17481. + * Copyright (C) 1993 by Nigel Gamble (added interrupt code)
  17482. + * Copyright (C) 1994 by Alan Cox (Modularised it)
  17483. + */
  17484. +
  17485. +#include <linux/config.h>
  17486. +#include <linux/errno.h>
  17487. +#include <linux/kernel.h>
  17488. +#include <linux/major.h>
  17489. +#include <linux/sched.h>
  17490. +#include <linux/lp.h>
  17491. +#include <linux/malloc.h>
  17492. +
  17493. +#include <asm/io.h>
  17494. +#include <asm/segment.h>
  17495. +#include <asm/system.h>
  17496. +
  17497. +/* the BIOS manuals say there can be up to 4 lpt devices
  17498. + * but I have not seen a board where the 4th address is listed
  17499. + * if you have different hardware change the table below
  17500. + * please let me know if you have different equipment
  17501. + * if you have more than 3 printers, remember to increase LP_NO
  17502. + */
  17503. +struct lp_struct lp_table[] = {
  17504. +    { 0x3bc, 0, 0, LP_INIT_CHAR, LP_INIT_TIME, LP_INIT_WAIT, NULL, NULL, },
  17505. +    { 0x378, 0, 0, LP_INIT_CHAR, LP_INIT_TIME, LP_INIT_WAIT, NULL, NULL, },
  17506. +    { 0x278, 0, 0, LP_INIT_CHAR, LP_INIT_TIME, LP_INIT_WAIT, NULL, NULL, },
  17507. +};
  17508. +#define LP_NO 3
  17509. +
  17510. +#ifdef MODULE
  17511. +#include <linux/module.h>
  17512. +#include "../../tools/version.h"
  17513. +#endif
  17514. +
  17515. +/*
  17516. + * All my debugging code assumes that you debug with only one printer at
  17517. + * a time. RWWH
  17518. + */
  17519. +
  17520. +#undef LP_DEBUG
  17521. +
  17522. +static int lp_reset(int minor)
  17523. +{
  17524. +    int testvalue;
  17525. +    unsigned char command;
  17526. +
  17527. +    command = LP_PSELECP | LP_PINITP;
  17528. +
  17529. +    /* reset value */
  17530. +    outb_p(0, LP_C(minor));
  17531. +    for (testvalue = 0 ; testvalue < LP_DELAY ; testvalue++)
  17532. +        ;
  17533. +    outb_p(command, LP_C(minor));
  17534. +    return LP_S(minor);
  17535. +}
  17536. +
  17537. +#ifdef LP_DEBUG
  17538. +static int lp_max_count = 1;
  17539. +#endif
  17540. +
  17541. +static int lp_char_polled(char lpchar, int minor)
  17542. +{
  17543. +    int status = 0, wait = 0;
  17544. +    unsigned long count  = 0;
  17545. +
  17546. +    do {
  17547. +        status = LP_S(minor);
  17548. +        count ++;
  17549. +        if(need_resched)
  17550. +            schedule();
  17551. +    } while(!(status & LP_PBUSY) && count < LP_CHAR(minor));
  17552. +
  17553. +    if (count == LP_CHAR(minor)) {
  17554. +        return 0;
  17555. +        /* we timed out, and the character was /not/ printed */
  17556. +    }
  17557. +#ifdef LP_DEBUG
  17558. +    if (count > lp_max_count) {
  17559. +        printk("lp success after %d counts.\n",count);
  17560. +        lp_max_count=count;
  17561. +    }
  17562. +#endif
  17563. +    outb_p(lpchar, LP_B(minor));
  17564. +    /* must wait before taking strobe high, and after taking strobe
  17565. +       low, according spec.  Some printers need it, others don't. */
  17566. +    while(wait != LP_WAIT(minor)) wait++;
  17567. +        /* control port takes strobe high */
  17568. +    outb_p(( LP_PSELECP | LP_PINITP | LP_PSTROBE ), ( LP_C( minor )));
  17569. +    while(wait) wait--;
  17570. +        /* take strobe low */
  17571. +    outb_p(( LP_PSELECP | LP_PINITP ), ( LP_C( minor )));
  17572. +
  17573. +    return 1;
  17574. +}
  17575. +
  17576. +static int lp_char_interrupt(char lpchar, int minor)
  17577. +{
  17578. +    int wait = 0;
  17579. +    unsigned char status;
  17580. +
  17581. +
  17582. +    if (!((status = LP_S(minor)) & LP_PACK) || (status & LP_PBUSY)
  17583. +    || !((status = LP_S(minor)) & LP_PACK) || (status & LP_PBUSY)
  17584. +    || !((status = LP_S(minor)) & LP_PACK) || (status & LP_PBUSY)) {
  17585. +
  17586. +        outb_p(lpchar, LP_B(minor));
  17587. +        /* must wait before taking strobe high, and after taking strobe
  17588. +           low, according spec.  Some printers need it, others don't. */
  17589. +        while(wait != LP_WAIT(minor)) wait++;
  17590. +        /* control port takes strobe high */
  17591. +        outb_p(( LP_PSELECP | LP_PINITP | LP_PSTROBE ), ( LP_C( minor )));
  17592. +        while(wait) wait--;
  17593. +        /* take strobe low */
  17594. +        outb_p(( LP_PSELECP | LP_PINITP ), ( LP_C( minor )));
  17595. +        return 1;
  17596. +    }
  17597. +
  17598. +    return 0;
  17599. +}
  17600. +
  17601. +#ifdef LP_DEBUG
  17602. +    unsigned int lp_total_chars = 0;
  17603. +    unsigned int lp_last_call = 0;
  17604. +#endif
  17605. +
  17606. +static void lp_interrupt(int irq)
  17607. +{
  17608. +    struct lp_struct *lp = &lp_table[0];
  17609. +    struct lp_struct *lp_end = &lp_table[LP_NO];
  17610. +
  17611. +    while (irq != lp->irq) {
  17612. +        if (++lp >= lp_end)
  17613. +            return;
  17614. +    }
  17615. +
  17616. +    wake_up(&lp->lp_wait_q);
  17617. +}
  17618. +
  17619. +static int lp_write_interrupt(struct inode * inode, struct file * file, char * buf, int count)
  17620. +{
  17621. +    unsigned int minor = MINOR(inode->i_rdev);
  17622. +    unsigned long copy_size;
  17623. +    unsigned long total_bytes_written = 0;
  17624. +    unsigned long bytes_written;
  17625. +    struct lp_struct *lp = &lp_table[minor];
  17626. +    unsigned char status;
  17627. +
  17628. +    do {
  17629. +        bytes_written = 0;
  17630. +        copy_size = (count <= LP_BUFFER_SIZE ? count : LP_BUFFER_SIZE);
  17631. +        memcpy_fromfs(lp->lp_buffer, buf, copy_size);
  17632. +
  17633. +        while (copy_size) {
  17634. +            if (lp_char_interrupt(lp->lp_buffer[bytes_written], minor)) {
  17635. +                --copy_size;
  17636. +                ++bytes_written;
  17637. +            } else {
  17638. +                if (!((status = LP_S(minor)) & LP_PERRORP)) {
  17639. +                    int rc = total_bytes_written + bytes_written;
  17640. +
  17641. +                    if ((status & LP_POUTPA)) {
  17642. +                        printk("lp%d out of paper\n", minor);
  17643. +                        if (!rc)
  17644. +                            rc = -ENOSPC;
  17645. +                    } else if (!(status & LP_PSELECD)) {
  17646. +                        printk("lp%d off-line\n", minor);
  17647. +                        if (!rc)
  17648. +                            rc = -EIO;
  17649. +                    } else {
  17650. +                        printk("lp%d printer error\n", minor);
  17651. +                        if (!rc)
  17652. +                            rc = -EIO;
  17653. +                    }
  17654. +                    if(LP_F(minor) & LP_ABORT)
  17655. +                        return rc;
  17656. +                }
  17657. +                cli();
  17658. +                outb_p((LP_PSELECP|LP_PINITP|LP_PINTEN), (LP_C(minor)));
  17659. +                status = LP_S(minor);
  17660. +                if (!(status & LP_PACK) || (status & LP_PBUSY)) {
  17661. +                    outb_p((LP_PSELECP|LP_PINITP), (LP_C(minor)));
  17662. +                    sti();
  17663. +                    continue;
  17664. +                }
  17665. +                current->timeout = jiffies + LP_TIMEOUT_INTERRUPT;
  17666. +                interruptible_sleep_on(&lp->lp_wait_q);
  17667. +                outb_p((LP_PSELECP|LP_PINITP), (LP_C(minor)));
  17668. +                sti();
  17669. +                if (current->signal & ~current->blocked) {
  17670. +                    if (total_bytes_written + bytes_written)
  17671. +                        return total_bytes_written + bytes_written;
  17672. +                    else
  17673. +                        return -EINTR;
  17674. +                }
  17675. +            }
  17676. +        }
  17677. +
  17678. +        total_bytes_written += bytes_written;
  17679. +        buf += bytes_written;
  17680. +        count -= bytes_written;
  17681. +
  17682. +    } while (count > 0);
  17683. +
  17684. +    return total_bytes_written;
  17685. +}
  17686. +
  17687. +static int lp_write_polled(struct inode * inode, struct file * file,
  17688. +               char * buf, int count)
  17689. +{
  17690. +    int  retval;
  17691. +    unsigned int minor = MINOR(inode->i_rdev);
  17692. +    char c, *temp = buf;
  17693. +
  17694. +#ifdef LP_DEBUG
  17695. +    if (jiffies-lp_last_call > LP_TIME(minor)) {
  17696. +        lp_total_chars = 0;
  17697. +        lp_max_count = 1;
  17698. +    }
  17699. +    lp_last_call = jiffies;
  17700. +#endif
  17701. +
  17702. +    temp = buf;
  17703. +    while (count > 0) {
  17704. +        c = get_fs_byte(temp);
  17705. +        retval = lp_char_polled(c, minor);
  17706. +        /* only update counting vars if character was printed */
  17707. +        if (retval) { count--; temp++;
  17708. +#ifdef LP_DEBUG
  17709. +            lp_total_chars++;
  17710. +#endif
  17711. +        }
  17712. +        if (!retval) { /* if printer timed out */
  17713. +            int status = LP_S(minor);
  17714. +
  17715. +            if (status & LP_POUTPA) {
  17716. +                printk("lp%d out of paper\n", minor);
  17717. +                if(LP_F(minor) & LP_ABORT)
  17718. +                    return temp-buf?temp-buf:-ENOSPC;
  17719. +                current->state = TASK_INTERRUPTIBLE;
  17720. +                current->timeout = jiffies + LP_TIMEOUT_POLLED;
  17721. +                schedule();
  17722. +            } else
  17723. +            if (!(status & LP_PSELECD)) {
  17724. +                printk("lp%d off-line\n", minor);
  17725. +                if(LP_F(minor) & LP_ABORT)
  17726. +                    return temp-buf?temp-buf:-EIO;
  17727. +                current->state = TASK_INTERRUPTIBLE;
  17728. +                current->timeout = jiffies + LP_TIMEOUT_POLLED;
  17729. +                schedule();
  17730. +            } else
  17731. +                    /* not offline or out of paper. on fire? */
  17732. +            if (!(status & LP_PERRORP)) {
  17733. +                printk("lp%d reported invalid error status (on fire, eh?)\n", minor);
  17734. +                if(LP_F(minor) & LP_ABORT)
  17735. +                    return temp-buf?temp-buf:-EFAULT;
  17736. +                current->state = TASK_INTERRUPTIBLE;
  17737. +                current->timeout = jiffies + LP_TIMEOUT_POLLED;
  17738. +                schedule();
  17739. +            }
  17740. +
  17741. +            /* check for signals before going to sleep */
  17742. +            if (current->signal & ~current->blocked) {
  17743. +                if (temp != buf)
  17744. +                    return temp-buf;
  17745. +                else
  17746. +                    return -EINTR;
  17747. +            }
  17748. +#ifdef LP_DEBUG
  17749. +            printk("lp sleeping at %d characters for %d jiffies\n",
  17750. +                lp_total_chars, LP_TIME(minor));
  17751. +            lp_total_chars=0;
  17752. +#endif
  17753. +            current->state = TASK_INTERRUPTIBLE;
  17754. +            current->timeout = jiffies + LP_TIME(minor);
  17755. +            schedule();
  17756. +        }
  17757. +    }
  17758. +    return temp-buf;
  17759. +}
  17760. +
  17761. +static int lp_write(struct inode * inode, struct file * file, char * buf, int count)
  17762. +{
  17763. +    if (LP_IRQ(MINOR(inode->i_rdev)))
  17764. +        return lp_write_interrupt(inode, file, buf, count);
  17765. +    else
  17766. +        return lp_write_polled(inode, file, buf, count);
  17767. +}
  17768. +
  17769. +static int lp_lseek(struct inode * inode, struct file * file,
  17770. +            off_t offset, int origin)
  17771. +{
  17772. +    return -ESPIPE;
  17773. +}
  17774. +
  17775. +static int lp_open(struct inode * inode, struct file * file)
  17776. +{
  17777. +    unsigned int minor = MINOR(inode->i_rdev);
  17778. +    int ret;
  17779. +    unsigned int irq;
  17780. +
  17781. +    if (minor >= LP_NO)
  17782. +        return -ENODEV;
  17783. +    if ((LP_F(minor) & LP_EXIST) == 0)
  17784. +        return -ENODEV;
  17785. +    if (LP_F(minor) & LP_BUSY)
  17786. +        return -EBUSY;
  17787. +
  17788. +    if ((irq = LP_IRQ(minor))) {
  17789. +        lp_table[minor].lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
  17790. +        if (!lp_table[minor].lp_buffer)
  17791. +            return -ENOMEM;
  17792. +
  17793. +        ret = request_irq(irq, lp_interrupt, SA_INTERRUPT, "printer");
  17794. +        if (ret) {
  17795. +            kfree_s(lp_table[minor].lp_buffer, LP_BUFFER_SIZE);
  17796. +            lp_table[minor].lp_buffer = NULL;
  17797. +            printk("lp%d unable to use interrupt %d, error %d\n", minor, irq, ret);
  17798. +            return ret;
  17799. +        }
  17800. +    }
  17801. +
  17802. +    LP_F(minor) |= LP_BUSY;
  17803. +#ifdef MODULE
  17804. +    MOD_INC_USE_COUNT;
  17805. +#endif
  17806. +    return 0;
  17807. +}
  17808. +
  17809. +static void lp_release(struct inode * inode, struct file * file)
  17810. +{
  17811. +    unsigned int minor = MINOR(inode->i_rdev);
  17812. +    unsigned int irq;
  17813. +
  17814. +    if ((irq = LP_IRQ(minor))) {
  17815. +        free_irq(irq);
  17816. +        kfree_s(lp_table[minor].lp_buffer, LP_BUFFER_SIZE);
  17817. +        lp_table[minor].lp_buffer = NULL;
  17818. +    }
  17819. +
  17820. +    LP_F(minor) &= ~LP_BUSY;
  17821. +#ifdef MODULE
  17822. +    MOD_DEC_USE_COUNT;
  17823. +#endif
  17824. +}
  17825. +
  17826. +
  17827. +static int lp_ioctl(struct inode *inode, struct file *file,
  17828. +            unsigned int cmd, unsigned long arg)
  17829. +{
  17830. +    unsigned int minor = MINOR(inode->i_rdev);
  17831. +    int retval = 0;
  17832. +
  17833. +#ifdef LP_DEBUG
  17834. +    printk("lp%d ioctl, cmd: 0x%x, arg: 0x%x\n", minor, cmd, arg);
  17835. +#endif
  17836. +    if (minor >= LP_NO)
  17837. +        return -ENODEV;
  17838. +    if ((LP_F(minor) & LP_EXIST) == 0)
  17839. +        return -ENODEV;
  17840. +    switch ( cmd ) {
  17841. +        case LPTIME:
  17842. +            LP_TIME(minor) = arg;
  17843. +            break;
  17844. +        case LPCHAR:
  17845. +            LP_CHAR(minor) = arg;
  17846. +            break;
  17847. +        case LPABORT:
  17848. +            if (arg)
  17849. +                LP_F(minor) |= LP_ABORT;
  17850. +            else
  17851. +                LP_F(minor) &= ~LP_ABORT;
  17852. +            break;
  17853. +        case LPWAIT:
  17854. +            LP_WAIT(minor) = arg;
  17855. +            break;
  17856. +        case LPSETIRQ: {
  17857. +            int oldirq;
  17858. +            int newirq = arg;
  17859. +            struct lp_struct *lp = &lp_table[minor];
  17860. +
  17861. +            if (!suser())
  17862. +                return -EPERM;
  17863. +
  17864. +            oldirq = LP_IRQ(minor);
  17865. +
  17866. +            /* Allocate buffer now if we are going to need it */
  17867. +            if (!oldirq && newirq) {
  17868. +                lp->lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
  17869. +                if (!lp->lp_buffer)
  17870. +                    return -ENOMEM;
  17871. +            }
  17872. +
  17873. +            if (oldirq) {
  17874. +                free_irq(oldirq);
  17875. +            }
  17876. +            if (newirq) {
  17877. +                /* Install new irq */
  17878. +                if ((retval = request_irq(newirq, lp_interrupt, SA_INTERRUPT, "printer"))) {
  17879. +                    if (oldirq) {
  17880. +                        /* restore old irq */
  17881. +                        request_irq(oldirq, lp_interrupt, SA_INTERRUPT, "printer");
  17882. +                    } else {
  17883. +                        /* We don't need the buffer */
  17884. +                        kfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
  17885. +                        lp->lp_buffer = NULL;
  17886. +                    }
  17887. +                    return retval;
  17888. +                }
  17889. +            }
  17890. +            if (oldirq && !newirq) {
  17891. +                /* We don't need the buffer */
  17892. +                kfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
  17893. +                lp->lp_buffer = NULL;
  17894. +            }
  17895. +            LP_IRQ(minor) = newirq;
  17896. +            lp_reset(minor);
  17897. +            break;
  17898. +        }
  17899. +        case LPGETIRQ:
  17900. +            retval = LP_IRQ(minor);
  17901. +            break;
  17902. +        default:
  17903. +            retval = -EINVAL;
  17904. +    }
  17905. +    return retval;
  17906. +}
  17907. +
  17908. +
  17909. +static struct file_operations lp_fops = {
  17910. +    lp_lseek,
  17911. +    NULL,        /* lp_read */
  17912. +    lp_write,
  17913. +    NULL,        /* lp_readdir */
  17914. +    NULL,        /* lp_select */
  17915. +    lp_ioctl,
  17916. +    NULL,        /* lp_mmap */
  17917. +    lp_open,
  17918. +    lp_release
  17919. +};
  17920. +
  17921. +#ifndef MODULE
  17922. +
  17923. +long lp_init(long kmem_start)
  17924. +{
  17925. +    int offset = 0;
  17926. +    unsigned int testvalue = 0;
  17927. +    int count = 0;
  17928. +
  17929. +    if (register_chrdev(LP_MAJOR,"lp",&lp_fops)) {
  17930. +        printk("unable to get major %d for line printer\n", LP_MAJOR);
  17931. +        return kmem_start;
  17932. +    }
  17933. +    /* take on all known port values */
  17934. +    for (offset = 0; offset < LP_NO; offset++) {
  17935. +        /* write to port & read back to check */
  17936. +        outb_p( LP_DUMMY, LP_B(offset));
  17937. +        for (testvalue = 0 ; testvalue < LP_DELAY ; testvalue++)
  17938. +            ;
  17939. +        testvalue = inb_p(LP_B(offset));
  17940. +        if (testvalue == LP_DUMMY) {
  17941. +            LP_F(offset) |= LP_EXIST;
  17942. +            lp_reset(offset);
  17943. +            printk("lp_init: lp%d exists, ", offset);
  17944. +            if (LP_IRQ(offset))
  17945. +                printk("using IRQ%d\n", LP_IRQ(offset));
  17946. +            else
  17947. +                printk("using polling driver\n");
  17948. +            count++;
  17949. +        }
  17950. +    }
  17951. +    if (count == 0)
  17952. +        printk("lp_init: no lp devices found\n");
  17953. +    return kmem_start;
  17954. +}
  17955. +
  17956. +#else
  17957. +
  17958. +char kernel_version[]= UTS_RELEASE;
  17959. +
  17960. +int init_module(void)
  17961. +{
  17962. +    int offset = 0;
  17963. +    unsigned int testvalue = 0;
  17964. +    int count = 0;
  17965. +
  17966. +    if (register_chrdev(LP_MAJOR,"lp",&lp_fops)) {
  17967. +        printk("unable to get major %d for line printer\n", LP_MAJOR);
  17968. +        return -EIO;
  17969. +    }
  17970. +    /* take on all known port values */
  17971. +    for (offset = 0; offset < LP_NO; offset++) {
  17972. +        /* write to port & read back to check */
  17973. +        outb_p( LP_DUMMY, LP_B(offset));
  17974. +        for (testvalue = 0 ; testvalue < LP_DELAY ; testvalue++)
  17975. +            ;
  17976. +        testvalue = inb_p(LP_B(offset));
  17977. +        if (testvalue == LP_DUMMY) {
  17978. +            LP_F(offset) |= LP_EXIST;
  17979. +            lp_reset(offset);
  17980. +            printk("lp_init: lp%d exists, ", offset);
  17981. +            if (LP_IRQ(offset))
  17982. +                printk("using IRQ%d\n", LP_IRQ(offset));
  17983. +            else
  17984. +                printk("using polling driver\n");
  17985. +            count++;
  17986. +        }
  17987. +    }
  17988. +    if (count == 0)
  17989. +        printk("lp_init: no lp devices found\n");
  17990. +    return 0;
  17991. +}
  17992. +
  17993. +void cleanup_module(void)
  17994. +{
  17995. +       if(MOD_IN_USE)
  17996. +               printk("lp: busy - remove delayed\n");
  17997. +       else
  17998. +               unregister_chrdev(LP_MAJOR,"lp");
  17999. +}
  18000. +
  18001. +#endif
  18002. diff -r -u -N linux.orig/arch/arm/drivers/char/mem.c linux.arm/arch/arm/drivers/char/mem.c
  18003. --- linux.orig/arch/arm/drivers/char/mem.c    Thu Jan  1 01:00:00 1970
  18004. +++ linux.arm/arch/arm/drivers/char/mem.c    Fri Oct 27 23:14:24 1995
  18005. @@ -0,0 +1,388 @@
  18006. +/*
  18007. + *  linux/drivers/char/mem.c
  18008. + *
  18009. + *  Copyright (C) 1991, 1992  Linus Torvalds
  18010. + */
  18011. +
  18012. +#include <linux/config.h>
  18013. +#include <linux/types.h>
  18014. +#include <linux/errno.h>
  18015. +#include <linux/sched.h>
  18016. +#include <linux/kernel.h>
  18017. +#include <linux/major.h>
  18018. +#include <linux/tty.h>
  18019. +#include <linux/mouse.h>
  18020. +#include <linux/tpqic02.h>
  18021. +#include <linux/malloc.h>
  18022. +#include <linux/mman.h>
  18023. +
  18024. +#include <asm/segment.h>
  18025. +#include <asm/io.h>
  18026. +
  18027. +#ifdef CONFIG_SOUND
  18028. +extern long soundcard_init(long mem_start);
  18029. +#endif
  18030. +
  18031. +static int read_ram(struct inode * inode, struct file * file,char * buf, int count)
  18032. +{
  18033. +    return -EIO;
  18034. +}
  18035. +
  18036. +static int write_ram(struct inode * inode, struct file * file,char * buf, int count)
  18037. +{
  18038. +    return -EIO;
  18039. +}
  18040. +
  18041. +static int read_mem(struct inode * inode, struct file * file,char * buf, int count)
  18042. +{
  18043. +    unsigned long p = file->f_pos;
  18044. +    int read;
  18045. +
  18046. +    if (count < 0)
  18047. +        return -EINVAL;
  18048. +    if (p >= high_memory)
  18049. +        return 0;
  18050. +    if (count > high_memory - p)
  18051. +        count = high_memory - p;
  18052. +    read = 0;
  18053. +    while (p < PAGE_SIZE && count > 0) {
  18054. +        put_fs_byte(0,buf);
  18055. +        buf++;
  18056. +        p++;
  18057. +        count--;
  18058. +        read++;
  18059. +    }
  18060. +    memcpy_tofs(buf,(void *) p,count);
  18061. +    read += count;
  18062. +    file->f_pos += read;
  18063. +    return read;
  18064. +}
  18065. +
  18066. +static int write_mem(struct inode * inode, struct file * file,char * buf, int count)
  18067. +{
  18068. +    unsigned long p = file->f_pos;
  18069. +    int written;
  18070. +
  18071. +    if (count < 0)
  18072. +        return -EINVAL;
  18073. +    if (p >= high_memory)
  18074. +        return 0;
  18075. +    if (count > high_memory - p)
  18076. +        count = high_memory - p;
  18077. +    written = 0;
  18078. +    while (p < PAGE_SIZE && count > 0) {
  18079. +        /* Hmm. Do something? */
  18080. +        buf++;
  18081. +        p++;
  18082. +        count--;
  18083. +        written++;
  18084. +    }
  18085. +    memcpy_fromfs((void *) p,buf,count);
  18086. +    written += count;
  18087. +    file->f_pos += written;
  18088. +    return count;
  18089. +}
  18090. +
  18091. +static int mmap_mem(struct inode * inode, struct file * file, struct vm_area_struct * vma)
  18092. +{
  18093. +    if (vma->vm_offset & ~PAGE_MASK)
  18094. +        return -ENXIO;
  18095. +#ifndef __arm__
  18096. +    if (x86 > 3 && vma->vm_offset >= high_memory)
  18097. +        vma->vm_page_prot |= PAGE_PCD;
  18098. +#endif
  18099. +    if (remap_page_range(vma->vm_start, vma->vm_offset, vma->vm_end - vma->vm_start, vma->vm_page_prot))
  18100. +        return -EAGAIN;
  18101. +    vma->vm_inode = inode;
  18102. +    inode->i_count++;
  18103. +    return 0;
  18104. +}
  18105. +
  18106. +static int read_kmem(struct inode *inode, struct file *file, char *buf, int count)
  18107. +{
  18108. +    int read1, read2;
  18109. +
  18110. +    read1 = read_mem(inode, file, buf, count);
  18111. +    if (read1 < 0)
  18112. +        return read1;
  18113. +    read2 = vread(buf + read1, (char *) ((unsigned long) file->f_pos), count - read1);
  18114. +    if (read2 < 0)
  18115. +        return read2;
  18116. +    file->f_pos += read2;
  18117. +    return read1 + read2;
  18118. +}
  18119. +
  18120. +static int read_port(struct inode * inode,struct file * file,char * buf, int count)
  18121. +{
  18122. +    unsigned int i = file->f_pos;
  18123. +    char * tmp = buf;
  18124. +
  18125. +    while (count-- > 0 && i < 65536) {
  18126. +        put_fs_byte(inb(i),tmp);
  18127. +        i++;
  18128. +        tmp++;
  18129. +    }
  18130. +    file->f_pos = i;
  18131. +    return tmp-buf;
  18132. +}
  18133. +
  18134. +static int write_port(struct inode * inode,struct file * file,char * buf, int count)
  18135. +{
  18136. +    unsigned int i = file->f_pos;
  18137. +    char * tmp = buf;
  18138. +
  18139. +    while (count-- > 0 && i < 65536) {
  18140. +        outb(get_fs_byte(tmp),i);
  18141. +        i++;
  18142. +        tmp++;
  18143. +    }
  18144. +    file->f_pos = i;
  18145. +    return tmp-buf;
  18146. +}
  18147. +
  18148. +static int read_null(struct inode * node,struct file * file,char * buf,int count)
  18149. +{
  18150. +    return 0;
  18151. +}
  18152. +
  18153. +static int write_null(struct inode * inode,struct file * file,char * buf, int count)
  18154. +{
  18155. +    return count;
  18156. +}
  18157. +
  18158. +static int read_zero(struct inode * node,struct file * file,char * buf,int count)
  18159. +{
  18160. +    int left;
  18161. +
  18162. +    for (left = count; left > 0; left--) {
  18163. +        put_fs_byte(0,buf);
  18164. +        buf++;
  18165. +    }
  18166. +    return count;
  18167. +}
  18168. +
  18169. +static int mmap_zero(struct inode * inode, struct file * file, struct vm_area_struct * vma)
  18170. +{
  18171. +    if (vma->vm_flags & VM_SHARED)
  18172. +        return -EINVAL;
  18173. +    if (zeromap_page_range(vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_page_prot))
  18174. +        return -EAGAIN;
  18175. +    return 0;
  18176. +}
  18177. +
  18178. +static int read_full(struct inode * node,struct file * file,char * buf,int count)
  18179. +{
  18180. +    return count;
  18181. +}
  18182. +
  18183. +static int write_full(struct inode * inode,struct file * file,char * buf, int count)
  18184. +{
  18185. +    return -ENOSPC;
  18186. +}
  18187. +
  18188. +/*
  18189. + * Special lseek() function for /dev/null and /dev/zero.  Most notably, you can fopen()
  18190. + * both devices with "a" now.  This was previously impossible.  SRB.
  18191. + */
  18192. +
  18193. +static int null_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
  18194. +{
  18195. +    return file->f_pos=0;
  18196. +}
  18197. +/*
  18198. + * The memory devices use the full 32 bits of the offset, and so we cannot
  18199. + * check against negative addresses: they are ok. The return value is weird,
  18200. + * though, in that case (0).
  18201. + *
  18202. + * also note that seeking relative to the "end of file" isn't supported:
  18203. + * it has no meaning, so it returns -EINVAL.
  18204. + */
  18205. +static int memory_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
  18206. +{
  18207. +    switch (orig) {
  18208. +        case 0:
  18209. +            file->f_pos = offset;
  18210. +            return file->f_pos;
  18211. +        case 1:
  18212. +            file->f_pos += offset;
  18213. +            return file->f_pos;
  18214. +        default:
  18215. +            return -EINVAL;
  18216. +    }
  18217. +    if (file->f_pos < 0)
  18218. +        return 0;
  18219. +    return file->f_pos;
  18220. +}
  18221. +
  18222. +#define write_kmem    write_mem
  18223. +#define mmap_kmem    mmap_mem
  18224. +#define zero_lseek    null_lseek
  18225. +#define write_zero    write_null
  18226. +
  18227. +static struct file_operations ram_fops = {
  18228. +    memory_lseek,
  18229. +    read_ram,
  18230. +    write_ram,
  18231. +    NULL,        /* ram_readdir */
  18232. +    NULL,        /* ram_select */
  18233. +    NULL,        /* ram_ioctl */
  18234. +    NULL,        /* ram_mmap */
  18235. +    NULL,        /* no special open code */
  18236. +    NULL,        /* no special release code */
  18237. +    NULL        /* fsync */
  18238. +};
  18239. +
  18240. +static struct file_operations mem_fops = {
  18241. +    memory_lseek,
  18242. +    read_mem,
  18243. +    write_mem,
  18244. +    NULL,        /* mem_readdir */
  18245. +    NULL,        /* mem_select */
  18246. +    NULL,        /* mem_ioctl */
  18247. +    mmap_mem,
  18248. +    NULL,        /* no special open code */
  18249. +    NULL,        /* no special release code */
  18250. +    NULL        /* fsync */
  18251. +};
  18252. +
  18253. +static struct file_operations kmem_fops = {
  18254. +    memory_lseek,
  18255. +    read_kmem,
  18256. +    write_kmem,
  18257. +    NULL,        /* kmem_readdir */
  18258. +    NULL,        /* kmem_select */
  18259. +    NULL,        /* kmem_ioctl */
  18260. +    mmap_kmem,
  18261. +    NULL,        /* no special open code */
  18262. +    NULL,        /* no special release code */
  18263. +    NULL        /* fsync */
  18264. +};
  18265. +
  18266. +static struct file_operations null_fops = {
  18267. +    null_lseek,
  18268. +    read_null,
  18269. +    write_null,
  18270. +    NULL,        /* null_readdir */
  18271. +    NULL,        /* null_select */
  18272. +    NULL,        /* null_ioctl */
  18273. +    NULL,        /* null_mmap */
  18274. +    NULL,        /* no special open code */
  18275. +    NULL,        /* no special release code */
  18276. +    NULL        /* fsync */
  18277. +};
  18278. +
  18279. +static struct file_operations port_fops = {
  18280. +    memory_lseek,
  18281. +    read_port,
  18282. +    write_port,
  18283. +    NULL,        /* port_readdir */
  18284. +    NULL,        /* port_select */
  18285. +    NULL,        /* port_ioctl */
  18286. +    NULL,        /* port_mmap */
  18287. +    NULL,        /* no special open code */
  18288. +    NULL,        /* no special release code */
  18289. +    NULL        /* fsync */
  18290. +};
  18291. +
  18292. +static struct file_operations zero_fops = {
  18293. +    zero_lseek,
  18294. +    read_zero,
  18295. +    write_zero,
  18296. +    NULL,        /* zero_readdir */
  18297. +    NULL,        /* zero_select */
  18298. +    NULL,        /* zero_ioctl */
  18299. +    mmap_zero,
  18300. +    NULL,        /* no special open code */
  18301. +    NULL        /* no special release code */
  18302. +};
  18303. +
  18304. +static struct file_operations full_fops = {
  18305. +    memory_lseek,
  18306. +    read_full,
  18307. +    write_full,
  18308. +    NULL,        /* full_readdir */
  18309. +    NULL,        /* full_select */
  18310. +    NULL,        /* full_ioctl */
  18311. +    NULL,        /* full_mmap */
  18312. +    NULL,        /* no special open code */
  18313. +    NULL        /* no special release code */
  18314. +};
  18315. +
  18316. +static int memory_open(struct inode * inode, struct file * filp)
  18317. +{
  18318. +    switch (MINOR(inode->i_rdev)) {
  18319. +        case 0:
  18320. +            filp->f_op = &ram_fops;
  18321. +            break;
  18322. +        case 1:
  18323. +            filp->f_op = &mem_fops;
  18324. +            break;
  18325. +        case 2:
  18326. +            filp->f_op = &kmem_fops;
  18327. +            break;
  18328. +        case 3:
  18329. +            filp->f_op = &null_fops;
  18330. +            break;
  18331. +        case 4:
  18332. +            filp->f_op = &port_fops;
  18333. +            break;
  18334. +        case 5:
  18335. +            filp->f_op = &zero_fops;
  18336. +            break;
  18337. +        case 7:
  18338. +            filp->f_op = &full_fops;
  18339. +            break;
  18340. +        default:
  18341. +            return -ENODEV;
  18342. +    }
  18343. +    if (filp->f_op && filp->f_op->open)
  18344. +        return filp->f_op->open(inode,filp);
  18345. +    return 0;
  18346. +}
  18347. +
  18348. +static struct file_operations memory_fops = {
  18349. +    NULL,        /* lseek */
  18350. +    NULL,        /* read */
  18351. +    NULL,        /* write */
  18352. +    NULL,        /* readdir */
  18353. +    NULL,        /* select */
  18354. +    NULL,        /* ioctl */
  18355. +    NULL,        /* mmap */
  18356. +    memory_open,    /* just a selector for the real open */
  18357. +    NULL,        /* release */
  18358. +    NULL        /* fsync */
  18359. +};
  18360. +
  18361. +#ifdef CONFIG_FTAPE
  18362. +char* ftape_big_buffer;
  18363. +#endif
  18364. +
  18365. +long chr_dev_init(long mem_start, long mem_end)
  18366. +{
  18367. +    if (register_chrdev(MEM_MAJOR,"mem",&memory_fops))
  18368. +        printk("unable to get major %d for memory devs\n", MEM_MAJOR);
  18369. +    mem_start = tty_init(mem_start);
  18370. +#ifdef CONFIG_PRINTER
  18371. +    mem_start = lp_init(mem_start);
  18372. +#endif
  18373. +#ifdef CONFIG_ARMMOUSE
  18374. +    mem_start = mouse_init(mem_start);
  18375. +#endif
  18376. +/*#ifdef CONFIG_SOUND
  18377. +    mem_start = soundcard_init(mem_start);
  18378. +#endif*/
  18379. +#ifdef CONFIG_QIC02_TAPE
  18380. +    mem_start = qic02_tape_init(mem_start);
  18381. +#endif
  18382. +/*
  18383. + *      Rude way to allocate kernel memory buffer for tape device
  18384. + */
  18385. +#ifdef CONFIG_FTAPE
  18386. +        /* allocate NR_FTAPE_BUFFERS 32Kb buffers at aligned address */
  18387. +        ftape_big_buffer= (char*) ((mem_start + 0x7fff) & ~0x7fff);
  18388. +        printk( "ftape: allocated %d buffers aligned at: %p\n",
  18389. +               NR_FTAPE_BUFFERS, ftape_big_buffer);
  18390. +        mem_start = (long) ftape_big_buffer + NR_FTAPE_BUFFERS * 0x8000;
  18391. +#endif
  18392. +    return mem_start;
  18393. +}
  18394. diff -r -u -N linux.orig/arch/arm/drivers/char/mouse.c linux.arm/arch/arm/drivers/char/mouse.c
  18395. --- linux.orig/arch/arm/drivers/char/mouse.c    Thu Jan  1 01:00:00 1970
  18396. +++ linux.arm/arch/arm/drivers/char/mouse.c    Fri Oct 27 23:14:24 1995
  18397. @@ -0,0 +1,68 @@
  18398. +/*
  18399. + * linux/drivers/char/mouse.c
  18400. + *
  18401. + * Generic mouse open routine by Johan Myreen
  18402. + *
  18403. + * Based on code from Linus
  18404. + *
  18405. + * Teemu Rantanen's Microsoft Busmouse support and Derrick Cole's
  18406. + *   changes incorporated into 0.97pl4
  18407. + *   by Peter Cervasio (pete%q106fm.uucp@wupost.wustl.edu) (08SEP92)
  18408. + *   See busmouse.c for particulars.
  18409. + *
  18410. + * Made things a lot mode modular - easy to compile in just one or two
  18411. + * of the mouse drivers, as they are now completely independent. Linus.
  18412. + */
  18413. +
  18414. +#include <linux/fs.h>
  18415. +#include <linux/errno.h>
  18416. +#include <linux/mouse.h>
  18417. +#include <linux/config.h>
  18418. +#include <linux/kernel.h>
  18419. +#include <linux/major.h>
  18420. +
  18421. +/*
  18422. + * note that you can remove any or all of the drivers by undefining
  18423. + * the minor values in <linux/mouse.h>
  18424. + */
  18425. +extern struct file_operations arch_mouse_fops;
  18426. +extern unsigned long arch_mouse_init(unsigned long);
  18427. +
  18428. +static int mouse_open(struct inode * inode, struct file * file)
  18429. +{
  18430. +    int minor = MINOR(inode->i_rdev);
  18431. +
  18432. +    switch (minor) {
  18433. +#ifdef CONFIG_ARMMOUSE
  18434. +        case 4:
  18435. +            file->f_op = &arch_mouse_fops;
  18436. +            break;
  18437. +#endif
  18438. +        default:
  18439. +            return -ENODEV;
  18440. +    }
  18441. +        return file->f_op->open(inode,file);
  18442. +}
  18443. +
  18444. +static struct file_operations mouse_fops = {
  18445. +        NULL,        /* seek */
  18446. +    NULL,        /* read */
  18447. +    NULL,        /* write */
  18448. +    NULL,        /* readdir */
  18449. +    NULL,        /* select */
  18450. +    NULL,        /* ioctl */
  18451. +    NULL,        /* mmap */
  18452. +        mouse_open,
  18453. +        NULL        /* release */
  18454. +};
  18455. +
  18456. +unsigned long mouse_init(unsigned long kmem_start)
  18457. +{
  18458. +#ifdef CONFIG_ARMMOUSE
  18459. +    kmem_start = arch_mouse_init(kmem_start);
  18460. +#endif
  18461. +    if (register_chrdev(MOUSE_MAJOR, "mouse", &mouse_fops))
  18462. +        printk("unable to get major %d for mouse devices\n",
  18463. +               MOUSE_MAJOR);
  18464. +    return kmem_start;
  18465. +}
  18466. diff -r -u -N linux.orig/arch/arm/drivers/char/n_tty.c linux.arm/arch/arm/drivers/char/n_tty.c
  18467. --- linux.orig/arch/arm/drivers/char/n_tty.c    Thu Jan  1 01:00:00 1970
  18468. +++ linux.arm/arch/arm/drivers/char/n_tty.c    Fri Oct 27 23:14:25 1995
  18469. @@ -0,0 +1,1021 @@
  18470. +/*
  18471. + * n_tty.c --- implements the N_TTY line discipline.
  18472. + * 
  18473. + * This code used to be in tty_io.c, but things are getting hairy
  18474. + * enough that it made sense to split things off.  (The N_TTY
  18475. + * processing has changed so much that it's hardly recognizable,
  18476. + * anyway...)
  18477. + *
  18478. + * Note that the open routine for N_TTY is guaranteed never to return
  18479. + * an error.  This is because Linux will fall back to setting a line
  18480. + * to N_TTY if it can not switch to any other line discipline.  
  18481. + *
  18482. + * Written by Theodore Ts'o, Copyright 1994.
  18483. + * 
  18484. + * This file also contains code originally written by Linus Torvalds,
  18485. + * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
  18486. + * 
  18487. + * This file may be redistributed under the terms of the GNU Public
  18488. + * License.
  18489. + */
  18490. +
  18491. +#include <linux/types.h>
  18492. +#include <linux/major.h>
  18493. +#include <linux/errno.h>
  18494. +#include <linux/signal.h>
  18495. +#include <linux/fcntl.h>
  18496. +#include <linux/sched.h>
  18497. +#include <linux/interrupt.h>
  18498. +#include <linux/tty.h>
  18499. +#include <linux/timer.h>
  18500. +#include <linux/ctype.h>
  18501. +#include <linux/kd.h>
  18502. +#include <linux/mm.h>
  18503. +#include <linux/string.h>
  18504. +#include <linux/malloc.h>
  18505. +
  18506. +#include <asm/segment.h>
  18507. +#include <asm/system.h>
  18508. +#include <asm/bitops.h>
  18509. +
  18510. +#define CONSOLE_DEV MKDEV(TTY_MAJOR,0)
  18511. +
  18512. +#ifndef MIN
  18513. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  18514. +#endif
  18515. +
  18516. +/* number of characters left in xmit buffer before select has we have room */
  18517. +#define WAKEUP_CHARS 256
  18518. +
  18519. +/*
  18520. + * This defines the low- and high-watermarks for throttling and
  18521. + * unthrottling the TTY driver.  These watermarks are used for
  18522. + * controlling the space in the read buffer.
  18523. + */
  18524. +#define TTY_THRESHOLD_THROTTLE        (N_TTY_BUF_SIZE - 128)
  18525. +#define TTY_THRESHOLD_UNTHROTTLE     128
  18526. +
  18527. +static inline void put_tty_queue(unsigned char c, struct tty_struct *tty)
  18528. +{
  18529. +    if (tty->read_cnt < N_TTY_BUF_SIZE) {
  18530. +        tty->read_buf[tty->read_head] = c;
  18531. +        tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
  18532. +        tty->read_cnt++;
  18533. +    }
  18534. +}
  18535. +
  18536. +/*
  18537. + * Flush the input buffer
  18538. + */
  18539. +void n_tty_flush_buffer(struct tty_struct * tty)
  18540. +{
  18541. +    tty->read_head = tty->read_tail = tty->read_cnt = 0;
  18542. +    tty->canon_head = tty->canon_data = tty->erasing = 0;
  18543. +    memset(&tty->read_flags, 0, sizeof tty->read_flags);
  18544. +    
  18545. +    if (!tty->link)
  18546. +        return;
  18547. +
  18548. +    if (tty->driver.unthrottle)
  18549. +        (tty->driver.unthrottle)(tty);
  18550. +    if (tty->link->packet) {
  18551. +        tty->ctrl_status |= TIOCPKT_FLUSHREAD;
  18552. +        wake_up_interruptible(&tty->link->read_wait);
  18553. +    }
  18554. +}
  18555. +
  18556. +/*
  18557. + * Return number of characters buffered to be delivered to user
  18558. + */
  18559. +int n_tty_chars_in_buffer(struct tty_struct *tty)
  18560. +{
  18561. +    return tty->read_cnt;
  18562. +}
  18563. +
  18564. +/*
  18565. + * Perform OPOST processing.  Returns -1 when the output device is
  18566. + * full and the character must be retried.
  18567. + */
  18568. +static int opost(unsigned char c, struct tty_struct *tty)
  18569. +{
  18570. +    int    space, spaces;
  18571. +
  18572. +    space = tty->driver.write_room(tty);
  18573. +    if (!space)
  18574. +        return -1;
  18575. +
  18576. +    if (O_OPOST(tty)) {
  18577. +        switch (c) {
  18578. +        case '\n':
  18579. +            if (O_ONLRET(tty))
  18580. +                tty->column = 0;
  18581. +            if (O_ONLCR(tty)) {
  18582. +                if (space < 2)
  18583. +                    return -1;
  18584. +                tty->driver.put_char(tty, '\r');
  18585. +                tty->column = 0;
  18586. +            }
  18587. +            tty->canon_column = tty->column;
  18588. +            break;
  18589. +        case '\r':
  18590. +            if (O_ONOCR(tty) && tty->column == 0)
  18591. +                return 0;
  18592. +            if (O_OCRNL(tty)) {
  18593. +                c = '\n';
  18594. +                if (O_ONLRET(tty))
  18595. +                    tty->canon_column = tty->column = 0;
  18596. +                break;
  18597. +            }
  18598. +            tty->canon_column = tty->column = 0;
  18599. +            break;
  18600. +        case '\t':
  18601. +            spaces = 8 - (tty->column & 7);
  18602. +            if (O_TABDLY(tty) == XTABS) {
  18603. +                if (space < spaces)
  18604. +                    return -1;
  18605. +                tty->column += spaces;
  18606. +                tty->driver.write(tty, 0, "        ", spaces);
  18607. +                return 0;
  18608. +            }
  18609. +            tty->column += spaces;
  18610. +            break;
  18611. +        case '\b':
  18612. +            if (tty->column > 0)
  18613. +                tty->column--;
  18614. +            break;
  18615. +        default:
  18616. +            if (O_OLCUC(tty))
  18617. +                c = toupper(c);
  18618. +            if (!iscntrl(c))
  18619. +                tty->column++;
  18620. +            break;
  18621. +        }
  18622. +    }
  18623. +    tty->driver.put_char(tty, c);
  18624. +    return 0;
  18625. +}
  18626. +
  18627. +static inline void put_char(unsigned char c, struct tty_struct *tty)
  18628. +{
  18629. +    tty->driver.put_char(tty, c);
  18630. +}
  18631. +
  18632. +/* Must be called only when L_ECHO(tty) is true. */
  18633. +
  18634. +static void echo_char(unsigned char c, struct tty_struct *tty)
  18635. +{
  18636. +    if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t') {
  18637. +        put_char('^', tty);
  18638. +        put_char(c ^ 0100, tty);
  18639. +        tty->column += 2;
  18640. +    } else
  18641. +        opost(c, tty);
  18642. +}
  18643. +
  18644. +static inline void finish_erasing(struct tty_struct *tty)
  18645. +{
  18646. +    if (tty->erasing) {
  18647. +        put_char('/', tty);
  18648. +        tty->column += 2;
  18649. +        tty->erasing = 0;
  18650. +    }
  18651. +}
  18652. +
  18653. +static void eraser(unsigned char c, struct tty_struct *tty)
  18654. +{
  18655. +    enum { ERASE, WERASE, KILL } kill_type;
  18656. +    int head, seen_alnums;
  18657. +
  18658. +    if (tty->read_head == tty->canon_head) {
  18659. +        /* opost('\a', tty); */        /* what do you think? */
  18660. +        return;
  18661. +    }
  18662. +    if (c == ERASE_CHAR(tty))
  18663. +        kill_type = ERASE;
  18664. +    else if (c == WERASE_CHAR(tty))
  18665. +        kill_type = WERASE;
  18666. +    else {
  18667. +        if (!L_ECHO(tty)) {
  18668. +            tty->read_cnt -= ((tty->read_head - tty->canon_head) &
  18669. +                      (N_TTY_BUF_SIZE - 1));
  18670. +            tty->read_head = tty->canon_head;
  18671. +            return;
  18672. +        }
  18673. +        if (!L_ECHOK(tty) || !L_ECHOKE(tty)) {
  18674. +            tty->read_cnt -= ((tty->read_head - tty->canon_head) &
  18675. +                      (N_TTY_BUF_SIZE - 1));
  18676. +            tty->read_head = tty->canon_head;
  18677. +            finish_erasing(tty);
  18678. +            echo_char(KILL_CHAR(tty), tty);
  18679. +            /* Add a newline if ECHOK is on and ECHOKE is off. */
  18680. +            if (L_ECHOK(tty))
  18681. +                opost('\n', tty);
  18682. +            return;
  18683. +        }
  18684. +        kill_type = KILL;
  18685. +    }
  18686. +
  18687. +    seen_alnums = 0;
  18688. +    while (tty->read_head != tty->canon_head) {
  18689. +        head = (tty->read_head - 1) & (N_TTY_BUF_SIZE-1);
  18690. +        c = tty->read_buf[head];
  18691. +        if (kill_type == WERASE) {
  18692. +            /* Equivalent to BSD's ALTWERASE. */
  18693. +            if (isalnum(c) || c == '_')
  18694. +                seen_alnums++;
  18695. +            else if (seen_alnums)
  18696. +                break;
  18697. +        }
  18698. +        tty->read_head = head;
  18699. +        tty->read_cnt--;
  18700. +        if (L_ECHO(tty)) {
  18701. +            if (L_ECHOPRT(tty)) {
  18702. +                if (!tty->erasing) {
  18703. +                    put_char('\\', tty);
  18704. +                    tty->column++;
  18705. +                    tty->erasing = 1;
  18706. +                }
  18707. +                echo_char(c, tty);
  18708. +            } else if (!L_ECHOE(tty)) {
  18709. +                echo_char(ERASE_CHAR(tty), tty);
  18710. +            } else if (c == '\t') {
  18711. +                unsigned int col = tty->canon_column;
  18712. +                unsigned long tail = tty->canon_head;
  18713. +
  18714. +                /* Find the column of the last char. */
  18715. +                while (tail != tty->read_head) {
  18716. +                    c = tty->read_buf[tail];
  18717. +                    if (c == '\t')
  18718. +                        col = (col | 7) + 1;
  18719. +                    else if (iscntrl(c)) {
  18720. +                        if (L_ECHOCTL(tty))
  18721. +                            col += 2;
  18722. +                    } else
  18723. +                        col++;
  18724. +                    tail = (tail+1) & (N_TTY_BUF_SIZE-1);
  18725. +                }
  18726. +
  18727. +                /* Now backup to that column. */
  18728. +                while (tty->column > col) {
  18729. +                    /* Can't use opost here. */
  18730. +                    put_char('\b', tty);
  18731. +                    tty->column--;
  18732. +                }
  18733. +            } else {
  18734. +                if (iscntrl(c) && L_ECHOCTL(tty)) {
  18735. +                    put_char('\b', tty);
  18736. +                    put_char(' ', tty);
  18737. +                    put_char('\b', tty);
  18738. +                    tty->column--;
  18739. +                }
  18740. +                if (!iscntrl(c) || L_ECHOCTL(tty)) {
  18741. +                    put_char('\b', tty);
  18742. +                    put_char(' ', tty);
  18743. +                    put_char('\b', tty);
  18744. +                    tty->column--;
  18745. +                }
  18746. +            }
  18747. +        }
  18748. +        if (kill_type == ERASE)
  18749. +            break;
  18750. +    }
  18751. +    if (tty->read_head == tty->canon_head)
  18752. +        finish_erasing(tty);
  18753. +}
  18754. +
  18755. +static void isig(int sig, struct tty_struct *tty)
  18756. +{
  18757. +    if (tty->pgrp > 0)
  18758. +        kill_pg(tty->pgrp, sig, 1);
  18759. +    if (!L_NOFLSH(tty)) {
  18760. +        n_tty_flush_buffer(tty);
  18761. +        if (tty->driver.flush_buffer)
  18762. +            tty->driver.flush_buffer(tty);
  18763. +    }
  18764. +}
  18765. +
  18766. +static inline void n_tty_receive_break(struct tty_struct *tty)
  18767. +{
  18768. +    if (I_IGNBRK(tty))
  18769. +        return;
  18770. +    if (I_BRKINT(tty)) {
  18771. +        isig(SIGINT, tty);
  18772. +        return;
  18773. +    }
  18774. +    if (I_PARMRK(tty)) {
  18775. +        put_tty_queue('\377', tty);
  18776. +        put_tty_queue('\0', tty);
  18777. +    }
  18778. +    put_tty_queue('\0', tty);
  18779. +    wake_up_interruptible(&tty->read_wait);
  18780. +}
  18781. +
  18782. +static inline void n_tty_receive_overrun(struct tty_struct *tty)
  18783. +{
  18784. +    char buf[64];
  18785. +
  18786. +    tty->num_overrun++;
  18787. +    if (tty->overrun_time < (jiffies - HZ)) {
  18788. +        printk("%s: %d input overrun(s)\n", _tty_name(tty, buf),
  18789. +               tty->num_overrun);
  18790. +        tty->overrun_time = jiffies;
  18791. +        tty->num_overrun = 0;
  18792. +    }
  18793. +}
  18794. +
  18795. +static inline void n_tty_receive_parity_error(struct tty_struct *tty,
  18796. +                          unsigned char c)
  18797. +{
  18798. +    if (I_IGNPAR(tty)) {
  18799. +        return;
  18800. +    }
  18801. +    if (I_PARMRK(tty)) {
  18802. +        put_tty_queue('\377', tty);
  18803. +        put_tty_queue('\0', tty);
  18804. +        put_tty_queue(c, tty);
  18805. +    } else
  18806. +        put_tty_queue('\0', tty);
  18807. +    wake_up_interruptible(&tty->read_wait);
  18808. +}
  18809. +extern int debug_flag;
  18810. +static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
  18811. +{if (debug_flag) printk("received from queue: n_tty_receive_char");
  18812. +    if (tty->raw) {
  18813. +        put_tty_queue(c, tty);
  18814. +        return;
  18815. +    }
  18816. +    
  18817. +    if (tty->stopped && I_IXON(tty) && I_IXANY(tty)) {
  18818. +        start_tty(tty);
  18819. +        return;
  18820. +    }
  18821. +    
  18822. +    if (I_ISTRIP(tty))
  18823. +        c &= 0x7f;
  18824. +    if (I_IUCLC(tty) && L_IEXTEN(tty))
  18825. +        c=tolower(c);
  18826. +
  18827. +    if (tty->closing) {
  18828. +        if (I_IXON(tty)) {
  18829. +            if (c == START_CHAR(tty))
  18830. +                start_tty(tty);
  18831. +            else if (c == STOP_CHAR(tty))
  18832. +                stop_tty(tty);
  18833. +        }
  18834. +        return;
  18835. +    }
  18836. +if (debug_flag) printk("trace 1\n");
  18837. +    /*
  18838. +     * If the previous character was LNEXT, or we know that this
  18839. +     * character is not one of the characters that we'll have to
  18840. +     * handle specially, do shortcut processing to speed things
  18841. +     * up.
  18842. +     */
  18843. +    if (!test_bit(c, &tty->process_char_map) || tty->lnext) {
  18844. +        finish_erasing(tty);
  18845. +        tty->lnext = 0;
  18846. +        if (L_ECHO(tty)) {
  18847. +            if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  18848. +                put_char('\a', tty); /* beep if no space */
  18849. +                return;
  18850. +            }
  18851. +            /* Record the column of first canon char. */
  18852. +            if (tty->canon_head == tty->read_head)
  18853. +                tty->canon_column = tty->column;
  18854. +            echo_char(c, tty);
  18855. +        }
  18856. +        if (I_PARMRK(tty) && c == (unsigned char) '\377')
  18857. +            put_tty_queue(c, tty);
  18858. +        put_tty_queue(c, tty);
  18859. +        return;
  18860. +    }
  18861. +if (debug_flag) printk("trace 2\n");
  18862. +    if (c == '\r') {
  18863. +        if (I_IGNCR(tty))
  18864. +            return;
  18865. +        if (I_ICRNL(tty))
  18866. +            c = '\n';
  18867. +    } else if (c == '\n' && I_INLCR(tty))
  18868. +        c = '\r';
  18869. +    if (I_IXON(tty)) {
  18870. +        if (c == START_CHAR(tty)) {
  18871. +            start_tty(tty);
  18872. +            return;
  18873. +        }
  18874. +        if (c == STOP_CHAR(tty)) {
  18875. +            stop_tty(tty);
  18876. +            return;
  18877. +        }
  18878. +    }
  18879. +    if (L_ISIG(tty)) {
  18880. +        if (c == INTR_CHAR(tty)) {
  18881. +            isig(SIGINT, tty);
  18882. +            return;
  18883. +        }
  18884. +        if (c == QUIT_CHAR(tty)) {
  18885. +            isig(SIGQUIT, tty);
  18886. +            return;
  18887. +        }
  18888. +        if (c == SUSP_CHAR(tty)) {
  18889. +            if (!is_orphaned_pgrp(tty->pgrp))
  18890. +                isig(SIGTSTP, tty);
  18891. +            return;
  18892. +        }
  18893. +    }
  18894. +if (debug_flag) printk("trace 3\n");
  18895. +    if (L_ICANON(tty)) {
  18896. +        if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
  18897. +            (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
  18898. +            eraser(c, tty);
  18899. +            return;
  18900. +        }
  18901. +        if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
  18902. +            tty->lnext = 1;
  18903. +            if (L_ECHO(tty)) {
  18904. +                finish_erasing(tty);
  18905. +                if (L_ECHOCTL(tty)) {
  18906. +                    put_char('^', tty);
  18907. +                    put_char('\b', tty);
  18908. +                }
  18909. +            }
  18910. +            return;
  18911. +        }
  18912. +        if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
  18913. +            L_IEXTEN(tty)) {
  18914. +            unsigned long tail = tty->canon_head;
  18915. +
  18916. +            finish_erasing(tty);
  18917. +            echo_char(c, tty);
  18918. +            opost('\n', tty);
  18919. +            while (tail != tty->read_head) {
  18920. +                echo_char(tty->read_buf[tail], tty);
  18921. +                tail = (tail+1) & (N_TTY_BUF_SIZE-1);
  18922. +            }
  18923. +            return;
  18924. +        }
  18925. +        if (c == '\n') {
  18926. +            if (L_ECHO(tty) || L_ECHONL(tty)) {
  18927. +                if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  18928. +                    put_char('\a', tty);
  18929. +                    return;
  18930. +                }
  18931. +                opost('\n', tty);
  18932. +            }
  18933. +            goto handle_newline;
  18934. +        }
  18935. +        if (c == EOF_CHAR(tty)) {
  18936. +                if (tty->canon_head != tty->read_head)
  18937. +                    set_bit(TTY_PUSH, &tty->flags);
  18938. +            c = __DISABLED_CHAR;
  18939. +            goto handle_newline;
  18940. +        }
  18941. +        if ((c == EOL_CHAR(tty)) ||
  18942. +            (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
  18943. +            /*
  18944. +             * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
  18945. +             */
  18946. +            if (L_ECHO(tty)) {
  18947. +                if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  18948. +                    put_char('\a', tty);
  18949. +                    return;
  18950. +                }
  18951. +                /* Record the column of first canon char. */
  18952. +                if (tty->canon_head == tty->read_head)
  18953. +                    tty->canon_column = tty->column;
  18954. +                echo_char(c, tty);
  18955. +            }
  18956. +            /*
  18957. +             * XXX does PARMRK doubling happen for
  18958. +             * EOL_CHAR and EOL2_CHAR?
  18959. +             */
  18960. +            if (I_PARMRK(tty) && c == (unsigned char) '\377')
  18961. +                put_tty_queue(c, tty);
  18962. +
  18963. +        handle_newline:
  18964. +            set_bit(tty->read_head, &tty->read_flags);
  18965. +            put_tty_queue(c, tty);
  18966. +            tty->canon_head = tty->read_head;
  18967. +            tty->canon_data++;
  18968. +            if (tty->fasync)
  18969. +                kill_fasync(tty->fasync, SIGIO);
  18970. +            if (tty->read_wait)
  18971. +                wake_up_interruptible(&tty->read_wait);
  18972. +            return;
  18973. +        }
  18974. +    }
  18975. +    
  18976. +    finish_erasing(tty);
  18977. +    if (L_ECHO(tty)) {
  18978. +        if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  18979. +            put_char('\a', tty); /* beep if no space */
  18980. +            return;
  18981. +        }
  18982. +        if (c == '\n')
  18983. +            opost('\n', tty);
  18984. +        else {
  18985. +            /* Record the column of first canon char. */
  18986. +            if (tty->canon_head == tty->read_head)
  18987. +                tty->canon_column = tty->column;
  18988. +            echo_char(c, tty);
  18989. +        }
  18990. +    }
  18991. +
  18992. +    if (I_PARMRK(tty) && c == (unsigned char) '\377')
  18993. +        put_tty_queue(c, tty);
  18994. +
  18995. +    put_tty_queue(c, tty);
  18996. +}    
  18997. +
  18998. +static void n_tty_receive_buf(struct tty_struct *tty, unsigned char *cp,
  18999. +                  char *fp, int count)
  19000. +{
  19001. +    unsigned char *p;
  19002. +    char *f, flags = 0;
  19003. +    int    i;
  19004. +if (debug_flag) printk("n_tty_receive_buf\n");
  19005. +    if (!tty->read_buf)
  19006. +        return;
  19007. +if (debug_flag) printk("trace a\n");
  19008. +    if (tty->real_raw) {
  19009. +if (debug_flag) printk("trace b\n");
  19010. +        i = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
  19011. +                   N_TTY_BUF_SIZE - tty->read_head));
  19012. +        memcpy(tty->read_buf + tty->read_head, cp, i);
  19013. +        tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
  19014. +        tty->read_cnt += i;
  19015. +        cp += i;
  19016. +        count -= i;
  19017. +
  19018. +        i = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
  19019. +                   N_TTY_BUF_SIZE - tty->read_head));
  19020. +        memcpy(tty->read_buf + tty->read_head, cp, i);
  19021. +        tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
  19022. +        tty->read_cnt += i;
  19023. +    } else {
  19024. +if (debug_flag) printk("trace c\n");
  19025. +        for (i=count, p = cp, f = fp; i; i--, p++) {
  19026. +            if (f)
  19027. +                flags = *f++;
  19028. +            switch (flags) {
  19029. +            case TTY_NORMAL:
  19030. +                n_tty_receive_char(tty, *p);
  19031. +                break;
  19032. +            case TTY_BREAK:
  19033. +                n_tty_receive_break(tty);
  19034. +                break;
  19035. +            case TTY_PARITY:
  19036. +            case TTY_FRAME:
  19037. +                n_tty_receive_parity_error(tty, *p);
  19038. +                break;
  19039. +            case TTY_OVERRUN:
  19040. +                n_tty_receive_overrun(tty);
  19041. +                break;
  19042. +            default:
  19043. +                printk("%s: unknown flag %d\n", tty_name(tty),
  19044. +                       flags);
  19045. +                break;
  19046. +            }
  19047. +        }
  19048. +        if (tty->driver.flush_chars)
  19049. +            tty->driver.flush_chars(tty);
  19050. +    }
  19051. +if (debug_flag) printk("trace d\n");
  19052. +    if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) {
  19053. +if (debug_flag) printk("trace e: %p %p\n", tty->fasync, tty->read_wait);
  19054. +        if (tty->fasync)
  19055. +            kill_fasync(tty->fasync, SIGIO);
  19056. +        if (tty->read_wait)
  19057. +            wake_up_interruptible(&tty->read_wait);
  19058. +    }
  19059. +
  19060. +    if ((tty->read_cnt >= TTY_THRESHOLD_THROTTLE) &&
  19061. +        tty->driver.throttle &&
  19062. +        !set_bit(TTY_THROTTLED, &tty->flags))
  19063. +        tty->driver.throttle(tty);
  19064. +}
  19065. +
  19066. +static int n_tty_receive_room(struct tty_struct *tty)
  19067. +{
  19068. +    int    left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
  19069. +
  19070. +    /*
  19071. +     * If we are doing input canonicalization, and there are no
  19072. +     * pending newlines, let characters through without limit, so
  19073. +     * that erase characters will be handled.  Other excess
  19074. +     * characters will be beeped.
  19075. +     */
  19076. +    if (tty->icanon && !tty->canon_data)
  19077. +        return N_TTY_BUF_SIZE;
  19078. +
  19079. +    if (left > 0)
  19080. +        return left;
  19081. +    return 0;
  19082. +}
  19083. +
  19084. +int is_ignored(int sig)
  19085. +{
  19086. +    return ((current->blocked & (1<<(sig-1))) ||
  19087. +            (current->sigaction[sig-1].sa_handler == SIG_IGN));
  19088. +}
  19089. +
  19090. +static void n_tty_set_termios(struct tty_struct *tty, struct termios * old)
  19091. +{
  19092. +    if (!tty)
  19093. +        return;
  19094. +    
  19095. +    tty->icanon = (L_ICANON(tty) != 0);
  19096. +    if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
  19097. +        I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
  19098. +        I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
  19099. +        I_PARMRK(tty)) {
  19100. +        cli();
  19101. +        memset(tty->process_char_map, 0, 256/32);
  19102. +
  19103. +        if (I_IGNCR(tty) || I_ICRNL(tty))
  19104. +            set_bit('\r', &tty->process_char_map);
  19105. +        if (I_INLCR(tty))
  19106. +            set_bit('\n', &tty->process_char_map);
  19107. +
  19108. +        if (L_ICANON(tty)) {
  19109. +            set_bit(ERASE_CHAR(tty), &tty->process_char_map);
  19110. +            set_bit(KILL_CHAR(tty), &tty->process_char_map);
  19111. +            set_bit(EOF_CHAR(tty), &tty->process_char_map);
  19112. +            set_bit('\n', &tty->process_char_map);
  19113. +            set_bit(EOL_CHAR(tty), &tty->process_char_map);
  19114. +            if (L_IEXTEN(tty)) {
  19115. +                set_bit(WERASE_CHAR(tty),
  19116. +                    &tty->process_char_map);
  19117. +                set_bit(LNEXT_CHAR(tty),
  19118. +                    &tty->process_char_map);
  19119. +                set_bit(EOL2_CHAR(tty),
  19120. +                    &tty->process_char_map);
  19121. +                if (L_ECHO(tty))
  19122. +                    set_bit(REPRINT_CHAR(tty),
  19123. +                        &tty->process_char_map);
  19124. +            }
  19125. +        }
  19126. +        if (I_IXON(tty)) {
  19127. +            set_bit(START_CHAR(tty), &tty->process_char_map);
  19128. +            set_bit(STOP_CHAR(tty), &tty->process_char_map);
  19129. +        }
  19130. +        if (L_ISIG(tty)) {
  19131. +            set_bit(INTR_CHAR(tty), &tty->process_char_map);
  19132. +            set_bit(QUIT_CHAR(tty), &tty->process_char_map);
  19133. +            set_bit(SUSP_CHAR(tty), &tty->process_char_map);
  19134. +        }
  19135. +        clear_bit(__DISABLED_CHAR, &tty->process_char_map);
  19136. +        sti();
  19137. +        tty->raw = 0;
  19138. +        tty->real_raw = 0;
  19139. +    } else {
  19140. +        tty->raw = 1;
  19141. +        if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
  19142. +            (I_IGNPAR(tty) || !I_INPCK(tty)) &&
  19143. +            (tty->driver.flags & TTY_DRIVER_REAL_RAW))
  19144. +            tty->real_raw = 1;
  19145. +        else
  19146. +            tty->real_raw = 0;
  19147. +    }
  19148. +}
  19149. +
  19150. +static void n_tty_close(struct tty_struct *tty)
  19151. +{
  19152. +    n_tty_flush_buffer(tty);
  19153. +    if (tty->read_buf) {
  19154. +        kfree_s((unsigned char *) tty->read_buf, N_TTY_BUF_SIZE);
  19155. +        tty->read_buf = 0;
  19156. +    }
  19157. +}
  19158. +
  19159. +static int n_tty_open(struct tty_struct *tty)
  19160. +{
  19161. +    if (!tty)
  19162. +        return -EINVAL;
  19163. +
  19164. +    if (!tty->read_buf) {
  19165. +        tty->read_buf = (unsigned char *)
  19166. +            kmalloc(N_TTY_BUF_SIZE, intr_count ? GFP_ATOMIC : GFP_KERNEL);
  19167. +        if (!tty->read_buf)
  19168. +            return -ENOMEM;
  19169. +    }
  19170. +    memset(tty->read_buf, 0, N_TTY_BUF_SIZE);
  19171. +    tty->read_head = tty->read_tail = tty->read_cnt = 0;
  19172. +    memset(tty->read_flags, 0, sizeof(tty->read_flags));
  19173. +    n_tty_set_termios(tty, 0);
  19174. +    tty->minimum_to_wake = 1;
  19175. +    tty->closing = 0;
  19176. +    return 0;
  19177. +}
  19178. +
  19179. +static inline int input_available_p(struct tty_struct *tty, int amt)
  19180. +{
  19181. +    if (L_ICANON(tty)) {
  19182. +        if (tty->canon_data)
  19183. +            return 1;
  19184. +    } else if (tty->read_cnt >= (amt ? amt : 1))
  19185. +        return 1;
  19186. +
  19187. +    return 0;
  19188. +}
  19189. +
  19190. +/*
  19191. + * Helper function to speed up read_chan.  It is only called when
  19192. + * ICANON is off; it copies characters straight from the tty queue to
  19193. + * user space directly.  It can be profitably called twice; once to
  19194. + * drain the space from the tail pointer to the (physical) end of the
  19195. + * buffer, and once to drain the space from the (physical) beginning of
  19196. + * the buffer to head pointer.
  19197. + */
  19198. +static inline void copy_from_read_buf(struct tty_struct *tty,
  19199. +                      unsigned char **b,
  19200. +                      unsigned int *nr)
  19201. +
  19202. +{
  19203. +    int    n;
  19204. +
  19205. +    n = MIN(*nr, MIN(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail));
  19206. +    if (!n)
  19207. +        return;
  19208. +    memcpy_tofs(*b, &tty->read_buf[tty->read_tail], n);
  19209. +    tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
  19210. +    tty->read_cnt -= n;
  19211. +    *b += n;
  19212. +    *nr -= n;
  19213. +}
  19214. +
  19215. +static int read_chan(struct tty_struct *tty, struct file *file,
  19216. +             unsigned char *buf, unsigned int nr)
  19217. +{
  19218. +    struct wait_queue wait = { current, NULL };
  19219. +    int c;
  19220. +    unsigned char *b = buf;
  19221. +    int minimum, time;
  19222. +    int retval = 0;
  19223. +    int size;
  19224. +
  19225. +do_it_again:
  19226. +
  19227. +    if (!tty->read_buf) {
  19228. +        printk("n_tty_read_chan: called with read_buf == NULL?!?\n");
  19229. +        return -EIO;
  19230. +    }
  19231. +
  19232. +    /* Job control check -- must be done at start and after
  19233. +       every sleep (POSIX.1 7.1.1.4). */
  19234. +    /* NOTE: not yet done after every sleep pending a thorough
  19235. +       check of the logic of this change. -- jlc */
  19236. +    /* don't stop on /dev/console */
  19237. +    if (file->f_inode->i_rdev != CONSOLE_DEV &&
  19238. +        current->tty == tty) {
  19239. +        if (tty->pgrp <= 0)
  19240. +            printk("read_chan: tty->pgrp <= 0!\n");
  19241. +        else if (current->pgrp != tty->pgrp) {
  19242. +            if (is_ignored(SIGTTIN) ||
  19243. +                is_orphaned_pgrp(current->pgrp))
  19244. +                return -EIO;
  19245. +            kill_pg(current->pgrp, SIGTTIN, 1);
  19246. +            return -ERESTARTSYS;
  19247. +        }
  19248. +    }
  19249. +
  19250. +    if (L_ICANON(tty)) {
  19251. +        minimum = time = 0;
  19252. +        current->timeout = (unsigned long) -1;
  19253. +    } else {
  19254. +        time = (HZ / 10) * TIME_CHAR(tty);
  19255. +        minimum = MIN_CHAR(tty);
  19256. +        if (minimum) {
  19257. +              current->timeout = (unsigned long) -1;
  19258. +            if (time)
  19259. +                tty->minimum_to_wake = 1;
  19260. +            else if (!tty->read_wait ||
  19261. +                 (tty->minimum_to_wake > minimum))
  19262. +                tty->minimum_to_wake = minimum;
  19263. +        } else {
  19264. +            if (time) {
  19265. +                current->timeout = time + jiffies;
  19266. +                time = 0;
  19267. +            } else
  19268. +                current->timeout = 0;
  19269. +            tty->minimum_to_wake = minimum = 1;
  19270. +        }
  19271. +    }
  19272. +
  19273. +    add_wait_queue(&tty->read_wait, &wait);
  19274. +    while (1) {
  19275. +        /* First test for status change. */
  19276. +        if (tty->packet && tty->link->ctrl_status) {
  19277. +            if (b != buf)
  19278. +                break;
  19279. +            put_fs_byte(tty->link->ctrl_status, b++);
  19280. +            tty->link->ctrl_status = 0;
  19281. +            break;
  19282. +        }
  19283. +        /* This statement must be first before checking for input
  19284. +           so that any interrupt will set the state back to
  19285. +           TASK_RUNNING. */
  19286. +        current->state = TASK_INTERRUPTIBLE;
  19287. +        
  19288. +        if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
  19289. +            ((minimum - (b - buf)) >= 1))
  19290. +            tty->minimum_to_wake = (minimum - (b - buf));
  19291. +        
  19292. +        if (!input_available_p(tty, 0)) {
  19293. +            if (tty->flags & (1 << TTY_SLAVE_CLOSED)) {
  19294. +                retval = -EIO;
  19295. +                break;
  19296. +            }
  19297. +            if (tty_hung_up_p(file))
  19298. +                break;
  19299. +            if (!current->timeout)
  19300. +                break;
  19301. +            if (file->f_flags & O_NONBLOCK) {
  19302. +                retval = -EAGAIN;
  19303. +                break;
  19304. +            }
  19305. +            if (current->signal & ~current->blocked) {
  19306. +                retval = -ERESTARTSYS;
  19307. +                break;
  19308. +            }
  19309. +            schedule();
  19310. +            continue;
  19311. +        }
  19312. +        current->state = TASK_RUNNING;
  19313. +
  19314. +        /* Deal with packet mode. */
  19315. +        if (tty->packet && b == buf) {
  19316. +            put_fs_byte(TIOCPKT_DATA, b++);
  19317. +            nr--;
  19318. +        }
  19319. +
  19320. +        if (L_ICANON(tty)) {
  19321. +            while (1) {
  19322. +                int eol;
  19323. +
  19324. +                disable_bh(TQUEUE_BH);
  19325. +                if (!tty->read_cnt) {
  19326. +                    enable_bh(TQUEUE_BH);
  19327. +                    break;
  19328. +                }
  19329. +                eol = clear_bit(tty->read_tail,
  19330. +                        &tty->read_flags);
  19331. +                c = tty->read_buf[tty->read_tail];
  19332. +                tty->read_tail = ((tty->read_tail+1) &
  19333. +                          (N_TTY_BUF_SIZE-1));
  19334. +                tty->read_cnt--;
  19335. +                enable_bh(TQUEUE_BH);
  19336. +                if (!eol) {
  19337. +                    put_fs_byte(c, b++);
  19338. +                    if (--nr)
  19339. +                        continue;
  19340. +                    break;
  19341. +                }
  19342. +                if (--tty->canon_data < 0) {
  19343. +                    tty->canon_data = 0;
  19344. +                }
  19345. +                if (c != __DISABLED_CHAR) {
  19346. +                    put_fs_byte(c, b++);
  19347. +                    nr--;
  19348. +                }
  19349. +                break;
  19350. +            }
  19351. +        } else {
  19352. +            disable_bh(TQUEUE_BH);
  19353. +            copy_from_read_buf(tty, &b, &nr);
  19354. +            copy_from_read_buf(tty, &b, &nr);
  19355. +            enable_bh(TQUEUE_BH);
  19356. +        }
  19357. +
  19358. +        /* If there is enough space in the read buffer now, let the
  19359. +           low-level driver know. */
  19360. +        if (tty->driver.unthrottle &&
  19361. +            (tty->read_cnt <= TTY_THRESHOLD_UNTHROTTLE)
  19362. +            && clear_bit(TTY_THROTTLED, &tty->flags))
  19363. +            tty->driver.unthrottle(tty);
  19364. +
  19365. +        if (b - buf >= minimum || !nr)
  19366. +            break;
  19367. +        if (time)
  19368. +            current->timeout = time + jiffies;
  19369. +    }
  19370. +    remove_wait_queue(&tty->read_wait, &wait);
  19371. +
  19372. +    if (!tty->read_wait)
  19373. +        tty->minimum_to_wake = minimum;
  19374. +
  19375. +    current->state = TASK_RUNNING;
  19376. +    current->timeout = 0;
  19377. +    size = b - buf;
  19378. +    if (size && nr)
  19379. +            clear_bit(TTY_PUSH, &tty->flags);
  19380. +        if (!size && clear_bit(TTY_PUSH, &tty->flags))
  19381. +                goto do_it_again;
  19382. +    if (!size && !retval)
  19383. +            clear_bit(TTY_PUSH, &tty->flags);
  19384. +        return (size ? size : retval);
  19385. +}
  19386. +
  19387. +static int write_chan(struct tty_struct * tty, struct file * file,
  19388. +              unsigned char * buf, unsigned int nr)
  19389. +{
  19390. +    struct wait_queue wait = { current, NULL };
  19391. +    int c;
  19392. +    unsigned char *b = buf;
  19393. +    int retval = 0;
  19394. +
  19395. +    /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
  19396. +    if (L_TOSTOP(tty) && file->f_inode->i_rdev != CONSOLE_DEV) {
  19397. +        retval = tty_check_change(tty);
  19398. +        if (retval)
  19399. +            return retval;
  19400. +    }
  19401. +
  19402. +    add_wait_queue(&tty->write_wait, &wait);
  19403. +    while (1) {
  19404. +        current->state = TASK_INTERRUPTIBLE;
  19405. +        if (current->signal & ~current->blocked) {
  19406. +            retval = -ERESTARTSYS;
  19407. +            break;
  19408. +        }
  19409. +        if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
  19410. +            retval = -EIO;
  19411. +            break;
  19412. +        }
  19413. +        if (O_OPOST(tty)) {
  19414. +            while (nr > 0) {
  19415. +                c = get_fs_byte(b);
  19416. +                if (opost(c, tty) < 0)
  19417. +                    break;
  19418. +                b++; nr--;
  19419. +            }
  19420. +            if (tty->driver.flush_chars)
  19421. +                tty->driver.flush_chars(tty);
  19422. +        } else {
  19423. +            c = tty->driver.write(tty, 1, b, nr);
  19424. +            b += c;
  19425. +            nr -= c;
  19426. +        }
  19427. +        if (!nr)
  19428. +            break;
  19429. +        if (file->f_flags & O_NONBLOCK) {
  19430. +            retval = -EAGAIN;
  19431. +            break;
  19432. +        }
  19433. +        schedule();
  19434. +    }
  19435. +    current->state = TASK_RUNNING;
  19436. +    remove_wait_queue(&tty->write_wait, &wait);
  19437. +    return (b - buf) ? b - buf : retval;
  19438. +}
  19439. +
  19440. +static int normal_select(struct tty_struct * tty, struct inode * inode,
  19441. +             struct file * file, int sel_type, select_table *wait)
  19442. +{
  19443. +    switch (sel_type) {
  19444. +        case SEL_IN:
  19445. +            if (input_available_p(tty, TIME_CHAR(tty) ? 0 :
  19446. +                          MIN_CHAR(tty)))
  19447. +                return 1;
  19448. +            /* fall through */
  19449. +        case SEL_EX:
  19450. +            if (tty->packet && tty->link->ctrl_status)
  19451. +                return 1;
  19452. +            if (tty->flags & (1 << TTY_SLAVE_CLOSED))
  19453. +                return 1;
  19454. +            if (tty_hung_up_p(file))
  19455. +                return 1;
  19456. +            if (!tty->read_wait) {
  19457. +                if (MIN_CHAR(tty) && !TIME_CHAR(tty))
  19458. +                    tty->minimum_to_wake = MIN_CHAR(tty);
  19459. +                else
  19460. +                    tty->minimum_to_wake = 1;
  19461. +            }
  19462. +            select_wait(&tty->read_wait, wait);
  19463. +            return 0;
  19464. +        case SEL_OUT:
  19465. +            if (tty->driver.chars_in_buffer(tty) < WAKEUP_CHARS)
  19466. +                return 1;
  19467. +            select_wait(&tty->write_wait, wait);
  19468. +            return 0;
  19469. +    }
  19470. +    return 0;
  19471. +}
  19472. +
  19473. +struct tty_ldisc tty_ldisc_N_TTY = {
  19474. +    TTY_LDISC_MAGIC,    /* magic */
  19475. +    0,            /* num */
  19476. +    0,            /* flags */
  19477. +    n_tty_open,        /* open */
  19478. +    n_tty_close,        /* close */
  19479. +    n_tty_flush_buffer,    /* flush_buffer */
  19480. +    n_tty_chars_in_buffer,    /* chars_in_buffer */
  19481. +    read_chan,        /* read */
  19482. +    write_chan,        /* write */
  19483. +    n_tty_ioctl,        /* ioctl */
  19484. +    n_tty_set_termios,    /* set_termios */
  19485. +    normal_select,        /* select */
  19486. +    n_tty_receive_buf,    /* receive_buf */
  19487. +    n_tty_receive_room,    /* receive_room */
  19488. +    0            /* write_wakeup */
  19489. +};
  19490. +
  19491. diff -r -u -N linux.orig/arch/arm/drivers/char/n_tty.c.orig linux.arm/arch/arm/drivers/char/n_tty.c.orig
  19492. --- linux.orig/arch/arm/drivers/char/n_tty.c.orig    Thu Jan  1 01:00:00 1970
  19493. +++ linux.arm/arch/arm/drivers/char/n_tty.c.orig    Fri Oct 27 23:14:38 1995
  19494. @@ -0,0 +1,1007 @@
  19495. +/*
  19496. + * n_tty.c --- implements the N_TTY line discipline.
  19497. + *
  19498. + * This code used to be in tty_io.c, but things are getting hairy
  19499. + * enough that it made sense to split things off.  (The N_TTY
  19500. + * processing has changed so much that it's hardly recognizable,
  19501. + * anyway...)
  19502. + *
  19503. + * Note that the open routine for N_TTY is guaranteed never to return
  19504. + * an error.  This is because Linux will fall back to setting a line
  19505. + * to N_TTY if it can not switch to any other line discipline.
  19506. + *
  19507. + * Written by Theodore Ts'o, Copyright 1994.
  19508. + *
  19509. + * This file also contains code originally written by Linus Torvalds,
  19510. + * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
  19511. + *
  19512. + * This file may be redistributed under the terms of the GNU Public
  19513. + * License.
  19514. + */
  19515. +
  19516. +#include <linux/types.h>
  19517. +#include <linux/major.h>
  19518. +#include <linux/errno.h>
  19519. +#include <linux/signal.h>
  19520. +#include <linux/fcntl.h>
  19521. +#include <linux/sched.h>
  19522. +#include <linux/interrupt.h>
  19523. +#include <linux/tty.h>
  19524. +#include <linux/timer.h>
  19525. +#include <linux/ctype.h>
  19526. +#include <linux/kd.h>
  19527. +#include <linux/mm.h>
  19528. +#include <linux/string.h>
  19529. +#include <linux/malloc.h>
  19530. +
  19531. +#include <asm/segment.h>
  19532. +#include <asm/system.h>
  19533. +#include <asm/bitops.h>
  19534. +
  19535. +#define CONSOLE_DEV MKDEV(TTY_MAJOR,0)
  19536. +
  19537. +#ifndef MIN
  19538. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  19539. +#endif
  19540. +
  19541. +/* number of characters left in xmit buffer before select has we have room */
  19542. +#define WAKEUP_CHARS 256
  19543. +
  19544. +/*
  19545. + * This defines the low- and high-watermarks for throttling and
  19546. + * unthrottling the TTY driver.  These watermarks are used for
  19547. + * controlling the space in the read buffer.
  19548. + */
  19549. +#define TTY_THRESHOLD_THROTTLE        (N_TTY_BUF_SIZE - 128)
  19550. +#define TTY_THRESHOLD_UNTHROTTLE     128
  19551. +
  19552. +static inline void put_tty_queue(unsigned char c, struct tty_struct *tty)
  19553. +{
  19554. +    if (tty->read_cnt < N_TTY_BUF_SIZE) {
  19555. +        tty->read_buf[tty->read_head] = c;
  19556. +        tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
  19557. +        tty->read_cnt++;
  19558. +    }
  19559. +}
  19560. +
  19561. +/*
  19562. + * Flush the input buffer
  19563. + */
  19564. +void n_tty_flush_buffer(struct tty_struct * tty)
  19565. +{
  19566. +    tty->read_head = tty->read_tail = tty->read_cnt = 0;
  19567. +    tty->canon_head = tty->canon_data = tty->erasing = 0;
  19568. +    memset(&tty->read_flags, 0, sizeof tty->read_flags);
  19569. +
  19570. +    if (!tty->link)
  19571. +        return;
  19572. +
  19573. +    if (tty->driver.unthrottle)
  19574. +        (tty->driver.unthrottle)(tty);
  19575. +    if (tty->link->packet) {
  19576. +        tty->ctrl_status |= TIOCPKT_FLUSHREAD;
  19577. +        wake_up_interruptible(&tty->link->read_wait);
  19578. +    }
  19579. +}
  19580. +
  19581. +/*
  19582. + * Return number of characters buffered to be delivered to user
  19583. + */
  19584. +int n_tty_chars_in_buffer(struct tty_struct *tty)
  19585. +{
  19586. +    return tty->read_cnt;
  19587. +}
  19588. +
  19589. +/*
  19590. + * Perform OPOST processing.  Returns -1 when the output device is
  19591. + * full and the character must be retried.
  19592. + */
  19593. +static int opost(unsigned char c, struct tty_struct *tty)
  19594. +{
  19595. +    int    space, spaces;
  19596. +
  19597. +    space = tty->driver.write_room(tty);
  19598. +    if (!space)
  19599. +        return -1;
  19600. +
  19601. +    if (O_OPOST(tty)) {
  19602. +        switch (c) {
  19603. +        case '\n':
  19604. +            if (O_ONLRET(tty))
  19605. +                tty->column = 0;
  19606. +            if (O_ONLCR(tty)) {
  19607. +                if (space < 2)
  19608. +                    return -1;
  19609. +                tty->driver.put_char(tty, '\r');
  19610. +                tty->column = 0;
  19611. +            }
  19612. +            tty->canon_column = tty->column;
  19613. +            break;
  19614. +        case '\r':
  19615. +            if (O_ONOCR(tty) && tty->column == 0)
  19616. +                return 0;
  19617. +            if (O_OCRNL(tty)) {
  19618. +                c = '\n';
  19619. +                if (O_ONLRET(tty))
  19620. +                    tty->canon_column = tty->column = 0;
  19621. +                break;
  19622. +            }
  19623. +            tty->canon_column = tty->column = 0;
  19624. +            break;
  19625. +        case '\t':
  19626. +            spaces = 8 - (tty->column & 7);
  19627. +            if (O_TABDLY(tty) == XTABS) {
  19628. +                if (space < spaces)
  19629. +                    return -1;
  19630. +                tty->column += spaces;
  19631. +                tty->driver.write(tty, 0, "        ", spaces);
  19632. +                return 0;
  19633. +            }
  19634. +            tty->column += spaces;
  19635. +            break;
  19636. +        case '\b':
  19637. +            if (tty->column > 0)
  19638. +                tty->column--;
  19639. +            break;
  19640. +        default:
  19641. +            if (O_OLCUC(tty))
  19642. +                c = toupper(c);
  19643. +            if (!iscntrl(c))
  19644. +                tty->column++;
  19645. +            break;
  19646. +        }
  19647. +    }
  19648. +    tty->driver.put_char(tty, c);
  19649. +    return 0;
  19650. +}
  19651. +
  19652. +static inline void put_char(unsigned char c, struct tty_struct *tty)
  19653. +{
  19654. +    tty->driver.put_char(tty, c);
  19655. +}
  19656. +
  19657. +/* Must be called only when L_ECHO(tty) is true. */
  19658. +
  19659. +static void echo_char(unsigned char c, struct tty_struct *tty)
  19660. +{
  19661. +    if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t') {
  19662. +        put_char('^', tty);
  19663. +        put_char(c ^ 0100, tty);
  19664. +        tty->column += 2;
  19665. +    } else
  19666. +        opost(c, tty);
  19667. +}
  19668. +
  19669. +static inline void finish_erasing(struct tty_struct *tty)
  19670. +{
  19671. +    if (tty->erasing) {
  19672. +        put_char('/', tty);
  19673. +        tty->column += 2;
  19674. +        tty->erasing = 0;
  19675. +    }
  19676. +}
  19677. +
  19678. +static void eraser(unsigned char c, struct tty_struct *tty)
  19679. +{
  19680. +    enum { ERASE, WERASE, KILL } kill_type;
  19681. +    int head, seen_alnums;
  19682. +
  19683. +    if (tty->read_head == tty->canon_head) {
  19684. +        /* opost('\a', tty); */        /* what do you think? */
  19685. +        return;
  19686. +    }
  19687. +    if (c == ERASE_CHAR(tty))
  19688. +        kill_type = ERASE;
  19689. +    else if (c == WERASE_CHAR(tty))
  19690. +        kill_type = WERASE;
  19691. +    else {
  19692. +        if (!L_ECHO(tty)) {
  19693. +            tty->read_cnt -= ((tty->read_head - tty->canon_head) &
  19694. +                      (N_TTY_BUF_SIZE - 1));
  19695. +            tty->read_head = tty->canon_head;
  19696. +            return;
  19697. +        }
  19698. +        if (!L_ECHOK(tty) || !L_ECHOKE(tty)) {
  19699. +            tty->read_cnt -= ((tty->read_head - tty->canon_head) &
  19700. +                      (N_TTY_BUF_SIZE - 1));
  19701. +            tty->read_head = tty->canon_head;
  19702. +            finish_erasing(tty);
  19703. +            echo_char(KILL_CHAR(tty), tty);
  19704. +            /* Add a newline if ECHOK is on and ECHOKE is off. */
  19705. +            if (L_ECHOK(tty))
  19706. +                opost('\n', tty);
  19707. +            return;
  19708. +        }
  19709. +        kill_type = KILL;
  19710. +    }
  19711. +
  19712. +    seen_alnums = 0;
  19713. +    while (tty->read_head != tty->canon_head) {
  19714. +        head = (tty->read_head - 1) & (N_TTY_BUF_SIZE-1);
  19715. +        c = tty->read_buf[head];
  19716. +        if (kill_type == WERASE) {
  19717. +            /* Equivalent to BSD's ALTWERASE. */
  19718. +            if (isalnum(c) || c == '_')
  19719. +                seen_alnums++;
  19720. +            else if (seen_alnums)
  19721. +                break;
  19722. +        }
  19723. +        tty->read_head = head;
  19724. +        tty->read_cnt--;
  19725. +        if (L_ECHO(tty)) {
  19726. +            if (L_ECHOPRT(tty)) {
  19727. +                if (!tty->erasing) {
  19728. +                    put_char('\\', tty);
  19729. +                    tty->column++;
  19730. +                    tty->erasing = 1;
  19731. +                }
  19732. +                echo_char(c, tty);
  19733. +            } else if (!L_ECHOE(tty)) {
  19734. +                echo_char(ERASE_CHAR(tty), tty);
  19735. +            } else if (c == '\t') {
  19736. +                unsigned int col = tty->canon_column;
  19737. +                unsigned long tail = tty->canon_head;
  19738. +
  19739. +                /* Find the column of the last char. */
  19740. +                while (tail != tty->read_head) {
  19741. +                    c = tty->read_buf[tail];
  19742. +                    if (c == '\t')
  19743. +                        col = (col | 7) + 1;
  19744. +                    else if (iscntrl(c)) {
  19745. +                        if (L_ECHOCTL(tty))
  19746. +                            col += 2;
  19747. +                    } else
  19748. +                        col++;
  19749. +                    tail = (tail+1) & (N_TTY_BUF_SIZE-1);
  19750. +                }
  19751. +
  19752. +                /* Now backup to that column. */
  19753. +                while (tty->column > col) {
  19754. +                    /* Can't use opost here. */
  19755. +                    put_char('\b', tty);
  19756. +                    tty->column--;
  19757. +                }
  19758. +            } else {
  19759. +                if (iscntrl(c) && L_ECHOCTL(tty)) {
  19760. +                    put_char('\b', tty);
  19761. +                    put_char(' ', tty);
  19762. +                    put_char('\b', tty);
  19763. +                    tty->column--;
  19764. +                }
  19765. +                if (!iscntrl(c) || L_ECHOCTL(tty)) {
  19766. +                    put_char('\b', tty);
  19767. +                    put_char(' ', tty);
  19768. +                    put_char('\b', tty);
  19769. +                    tty->column--;
  19770. +                }
  19771. +            }
  19772. +        }
  19773. +        if (kill_type == ERASE)
  19774. +            break;
  19775. +    }
  19776. +    if (tty->read_head == tty->canon_head)
  19777. +        finish_erasing(tty);
  19778. +}
  19779. +
  19780. +static void isig(int sig, struct tty_struct *tty)
  19781. +{
  19782. +    if (tty->pgrp > 0)
  19783. +        kill_pg(tty->pgrp, sig, 1);
  19784. +    if (!L_NOFLSH(tty)) {
  19785. +        n_tty_flush_buffer(tty);
  19786. +        if (tty->driver.flush_buffer)
  19787. +            tty->driver.flush_buffer(tty);
  19788. +    }
  19789. +}
  19790. +
  19791. +static inline void n_tty_receive_break(struct tty_struct *tty)
  19792. +{
  19793. +    if (I_IGNBRK(tty))
  19794. +        return;
  19795. +    if (I_BRKINT(tty)) {
  19796. +        isig(SIGINT, tty);
  19797. +        return;
  19798. +    }
  19799. +    if (I_PARMRK(tty)) {
  19800. +        put_tty_queue('\377', tty);
  19801. +        put_tty_queue('\0', tty);
  19802. +    }
  19803. +    put_tty_queue('\0', tty);
  19804. +    wake_up_interruptible(&tty->read_wait);
  19805. +}
  19806. +
  19807. +static inline void n_tty_receive_overrun(struct tty_struct *tty)
  19808. +{
  19809. +    char buf[64];
  19810. +
  19811. +    tty->num_overrun++;
  19812. +    if (tty->overrun_time < (jiffies - HZ)) {
  19813. +        printk("%s: %d input overrun(s)\n", _tty_name(tty, buf),
  19814. +               tty->num_overrun);
  19815. +        tty->overrun_time = jiffies;
  19816. +        tty->num_overrun = 0;
  19817. +    }
  19818. +}
  19819. +
  19820. +static inline void n_tty_receive_parity_error(struct tty_struct *tty,
  19821. +                          unsigned char c)
  19822. +{
  19823. +    if (I_IGNPAR(tty)) {
  19824. +        return;
  19825. +    }
  19826. +    if (I_PARMRK(tty)) {
  19827. +        put_tty_queue('\377', tty);
  19828. +        put_tty_queue('\0', tty);
  19829. +        put_tty_queue(c, tty);
  19830. +    } else
  19831. +        put_tty_queue('\0', tty);
  19832. +    wake_up_interruptible(&tty->read_wait);
  19833. +}
  19834. +
  19835. +static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
  19836. +{
  19837. +    if (tty->raw) {
  19838. +        put_tty_queue(c, tty);
  19839. +        return;
  19840. +    }
  19841. +
  19842. +    if (tty->stopped && I_IXON(tty) && I_IXANY(tty) && L_IEXTEN(tty)) {
  19843. +        start_tty(tty);
  19844. +        return;
  19845. +    }
  19846. +
  19847. +    if (I_ISTRIP(tty))
  19848. +        c &= 0x7f;
  19849. +    if (I_IUCLC(tty) && L_IEXTEN(tty))
  19850. +        c=tolower(c);
  19851. +
  19852. +    /*
  19853. +     * If the previous character was LNEXT, or we know that this
  19854. +     * character is not one of the characters that we'll have to
  19855. +     * handle specially, do shortcut processing to speed things
  19856. +     * up.
  19857. +     */
  19858. +    if (!test_bit(c, &tty->process_char_map) || tty->lnext) {
  19859. +        finish_erasing(tty);
  19860. +        tty->lnext = 0;
  19861. +        if (L_ECHO(tty)) {
  19862. +            if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  19863. +                put_char('\a', tty); /* beep if no space */
  19864. +                return;
  19865. +            }
  19866. +            /* Record the column of first canon char. */
  19867. +            if (tty->canon_head == tty->read_head)
  19868. +                tty->canon_column = tty->column;
  19869. +            echo_char(c, tty);
  19870. +        }
  19871. +        if (I_PARMRK(tty) && c == (unsigned char) '\377')
  19872. +            put_tty_queue(c, tty);
  19873. +        put_tty_queue(c, tty);
  19874. +        return;
  19875. +    }
  19876. +
  19877. +    if (c == '\r') {
  19878. +        if (I_IGNCR(tty))
  19879. +            return;
  19880. +        if (I_ICRNL(tty))
  19881. +            c = '\n';
  19882. +    } else if (c == '\n' && I_INLCR(tty))
  19883. +        c = '\r';
  19884. +    if (I_IXON(tty)) {
  19885. +        if (c == START_CHAR(tty)) {
  19886. +            start_tty(tty);
  19887. +            return;
  19888. +        }
  19889. +        if (c == STOP_CHAR(tty)) {
  19890. +            stop_tty(tty);
  19891. +            return;
  19892. +        }
  19893. +    }
  19894. +    if (L_ISIG(tty)) {
  19895. +        if (c == INTR_CHAR(tty)) {
  19896. +            isig(SIGINT, tty);
  19897. +            return;
  19898. +        }
  19899. +        if (c == QUIT_CHAR(tty)) {
  19900. +            isig(SIGQUIT, tty);
  19901. +            return;
  19902. +        }
  19903. +        if (c == SUSP_CHAR(tty)) {
  19904. +            if (!is_orphaned_pgrp(tty->pgrp))
  19905. +                isig(SIGTSTP, tty);
  19906. +            return;
  19907. +        }
  19908. +    }
  19909. +    if (L_ICANON(tty)) {
  19910. +        if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
  19911. +            (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
  19912. +            eraser(c, tty);
  19913. +            return;
  19914. +        }
  19915. +        if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
  19916. +            tty->lnext = 1;
  19917. +            if (L_ECHO(tty)) {
  19918. +                finish_erasing(tty);
  19919. +                if (L_ECHOCTL(tty)) {
  19920. +                    put_char('^', tty);
  19921. +                    put_char('\b', tty);
  19922. +                }
  19923. +            }
  19924. +            return;
  19925. +        }
  19926. +        if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
  19927. +            L_IEXTEN(tty)) {
  19928. +            unsigned long tail = tty->canon_head;
  19929. +
  19930. +            finish_erasing(tty);
  19931. +            echo_char(c, tty);
  19932. +            opost('\n', tty);
  19933. +            while (tail != tty->read_head) {
  19934. +                echo_char(tty->read_buf[tail], tty);
  19935. +                tail = (tail+1) & (N_TTY_BUF_SIZE-1);
  19936. +            }
  19937. +            return;
  19938. +        }
  19939. +        if (c == '\n') {
  19940. +            if (L_ECHO(tty) || L_ECHONL(tty)) {
  19941. +                if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  19942. +                    put_char('\a', tty);
  19943. +                    return;
  19944. +                }
  19945. +                opost('\n', tty);
  19946. +            }
  19947. +            goto handle_newline;
  19948. +        }
  19949. +        if (c == EOF_CHAR(tty)) {
  19950. +                if (tty->canon_head != tty->read_head)
  19951. +                    set_bit(TTY_PUSH, &tty->flags);
  19952. +            c = __DISABLED_CHAR;
  19953. +            goto handle_newline;
  19954. +        }
  19955. +        if ((c == EOL_CHAR(tty)) ||
  19956. +            (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
  19957. +            /*
  19958. +             * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
  19959. +             */
  19960. +            if (L_ECHO(tty)) {
  19961. +                if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  19962. +                    put_char('\a', tty);
  19963. +                    return;
  19964. +                }
  19965. +                /* Record the column of first canon char. */
  19966. +                if (tty->canon_head == tty->read_head)
  19967. +                    tty->canon_column = tty->column;
  19968. +                echo_char(c, tty);
  19969. +            }
  19970. +            /*
  19971. +             * XXX does PARMRK doubling happen for
  19972. +             * EOL_CHAR and EOL2_CHAR?
  19973. +             */
  19974. +            if (I_PARMRK(tty) && c == (unsigned char) '\377')
  19975. +                put_tty_queue(c, tty);
  19976. +
  19977. +        handle_newline:
  19978. +            set_bit(tty->read_head, &tty->read_flags);
  19979. +            put_tty_queue(c, tty);
  19980. +            tty->canon_head = tty->read_head;
  19981. +            tty->canon_data++;
  19982. +            if (tty->fasync)
  19983. +                kill_fasync(tty->fasync, SIGIO);
  19984. +            if (tty->read_wait)
  19985. +                wake_up_interruptible(&tty->read_wait);
  19986. +            return;
  19987. +        }
  19988. +    }
  19989. +
  19990. +    finish_erasing(tty);
  19991. +    if (L_ECHO(tty)) {
  19992. +        if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
  19993. +            put_char('\a', tty); /* beep if no space */
  19994. +            return;
  19995. +        }
  19996. +        if (c == '\n')
  19997. +            opost('\n', tty);
  19998. +        else {
  19999. +            /* Record the column of first canon char. */
  20000. +            if (tty->canon_head == tty->read_head)
  20001. +                tty->canon_column = tty->column;
  20002. +            echo_char(c, tty);
  20003. +        }
  20004. +    }
  20005. +
  20006. +    if (I_PARMRK(tty) && c == (unsigned char) '\377')
  20007. +        put_tty_queue(c, tty);
  20008. +
  20009. +    put_tty_queue(c, tty);
  20010. +}
  20011. +
  20012. +static void n_tty_receive_buf(struct tty_struct *tty, unsigned char *cp,
  20013. +                  char *fp, int count)
  20014. +{
  20015. +    unsigned char *p;
  20016. +    char *f, flags = 0;
  20017. +    int    i;
  20018. +
  20019. +    if (!tty->read_buf)
  20020. +        return;
  20021. +
  20022. +    if (tty->real_raw) {
  20023. +        i = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
  20024. +                   N_TTY_BUF_SIZE - tty->read_head));
  20025. +        memcpy(tty->read_buf + tty->read_head, cp, i);
  20026. +        tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
  20027. +        tty->read_cnt += i;
  20028. +        cp += i;
  20029. +        count -= i;
  20030. +
  20031. +        i = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
  20032. +                   N_TTY_BUF_SIZE - tty->read_head));
  20033. +        memcpy(tty->read_buf + tty->read_head, cp, i);
  20034. +        tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
  20035. +        tty->read_cnt += i;
  20036. +    } else {
  20037. +        for (i=count, p = cp, f = fp; i; i--, p++) {
  20038. +            if (f)
  20039. +                flags = *f++;
  20040. +            switch (flags) {
  20041. +            case TTY_NORMAL:
  20042. +                n_tty_receive_char(tty, *p);
  20043. +                break;
  20044. +            case TTY_BREAK:
  20045. +                n_tty_receive_break(tty);
  20046. +                break;
  20047. +            case TTY_PARITY:
  20048. +            case TTY_FRAME:
  20049. +                n_tty_receive_parity_error(tty, *p);
  20050. +                break;
  20051. +            case TTY_OVERRUN:
  20052. +                n_tty_receive_overrun(tty);
  20053. +                break;
  20054. +            default:
  20055. +                printk("%s: unknown flag %d\n", tty_name(tty),
  20056. +                       flags);
  20057. +                break;
  20058. +            }
  20059. +        }
  20060. +        if (tty->driver.flush_chars)
  20061. +            tty->driver.flush_chars(tty);
  20062. +    }
  20063. +
  20064. +    if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) {
  20065. +        if (tty->fasync)
  20066. +            kill_fasync(tty->fasync, SIGIO);
  20067. +        if (tty->read_wait)
  20068. +            wake_up_interruptible(&tty->read_wait);
  20069. +    }
  20070. +
  20071. +    if ((tty->read_cnt >= TTY_THRESHOLD_THROTTLE) &&
  20072. +        tty->driver.throttle &&
  20073. +        !set_bit(TTY_THROTTLED, &tty->flags))
  20074. +        tty->driver.throttle(tty);
  20075. +}
  20076. +
  20077. +static int n_tty_receive_room(struct tty_struct *tty)
  20078. +{
  20079. +    int    left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
  20080. +
  20081. +    /*
  20082. +     * If we are doing input canonicalization, let as many
  20083. +     * characters through as possible, so that the excess
  20084. +     * characters can be "beeped".
  20085. +     */
  20086. +    if (L_ICANON(tty))
  20087. +        return N_TTY_BUF_SIZE;
  20088. +
  20089. +    if (left > 0)
  20090. +        return left;
  20091. +    return 0;
  20092. +}
  20093. +
  20094. +int is_ignored(int sig)
  20095. +{
  20096. +    return ((current->blocked & (1<<(sig-1))) ||
  20097. +            (current->sigaction[sig-1].sa_handler == SIG_IGN));
  20098. +}
  20099. +
  20100. +static void n_tty_set_termios(struct tty_struct *tty, struct termios * old)
  20101. +{
  20102. +    if (!tty)
  20103. +        return;
  20104. +
  20105. +    tty->icanon = (L_ICANON(tty) != 0);
  20106. +    if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
  20107. +        I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
  20108. +        I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
  20109. +        I_PARMRK(tty)) {
  20110. +        cli();
  20111. +        memset(tty->process_char_map, 0, 256/32);
  20112. +
  20113. +        if (I_IGNCR(tty) || I_ICRNL(tty))
  20114. +            set_bit('\r', &tty->process_char_map);
  20115. +        if (I_INLCR(tty))
  20116. +            set_bit('\n', &tty->process_char_map);
  20117. +
  20118. +        if (L_ICANON(tty)) {
  20119. +            set_bit(ERASE_CHAR(tty), &tty->process_char_map);
  20120. +            set_bit(KILL_CHAR(tty), &tty->process_char_map);
  20121. +            set_bit(EOF_CHAR(tty), &tty->process_char_map);
  20122. +            set_bit('\n', &tty->process_char_map);
  20123. +            set_bit(EOL_CHAR(tty), &tty->process_char_map);
  20124. +            if (L_IEXTEN(tty)) {
  20125. +                set_bit(WERASE_CHAR(tty),
  20126. +                    &tty->process_char_map);
  20127. +                set_bit(LNEXT_CHAR(tty),
  20128. +                    &tty->process_char_map);
  20129. +                set_bit(EOL2_CHAR(tty),
  20130. +                    &tty->process_char_map);
  20131. +                if (L_ECHO(tty))
  20132. +                    set_bit(REPRINT_CHAR(tty),
  20133. +                        &tty->process_char_map);
  20134. +            }
  20135. +        }
  20136. +        if (I_IXON(tty)) {
  20137. +            set_bit(START_CHAR(tty), &tty->process_char_map);
  20138. +            set_bit(STOP_CHAR(tty), &tty->process_char_map);
  20139. +        }
  20140. +        if (L_ISIG(tty)) {
  20141. +            set_bit(INTR_CHAR(tty), &tty->process_char_map);
  20142. +            set_bit(QUIT_CHAR(tty), &tty->process_char_map);
  20143. +            set_bit(SUSP_CHAR(tty), &tty->process_char_map);
  20144. +        }
  20145. +        clear_bit(__DISABLED_CHAR, &tty->process_char_map);
  20146. +        sti();
  20147. +        tty->raw = 0;
  20148. +        tty->real_raw = 0;
  20149. +    } else {
  20150. +        tty->raw = 1;
  20151. +        if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
  20152. +            (I_IGNPAR(tty) || !I_INPCK(tty)) &&
  20153. +            (tty->driver.flags & TTY_DRIVER_REAL_RAW))
  20154. +            tty->real_raw = 1;
  20155. +        else
  20156. +            tty->real_raw = 0;
  20157. +    }
  20158. +}
  20159. +
  20160. +static void n_tty_close(struct tty_struct *tty)
  20161. +{
  20162. +    tty_wait_until_sent(tty, 0);
  20163. +    n_tty_flush_buffer(tty);
  20164. +    if (tty->read_buf) {
  20165. +        kfree_s(tty->read_buf,N_TTY_BUF_SIZE);
  20166. +        tty->read_buf = 0;
  20167. +    }
  20168. +}
  20169. +
  20170. +static int n_tty_open(struct tty_struct *tty)
  20171. +{
  20172. +    if (!tty)
  20173. +        return -EINVAL;
  20174. +
  20175. +    if (!tty->read_buf) {
  20176. +        tty->read_buf = (unsigned char *)
  20177. +            kmalloc(N_TTY_BUF_SIZE, intr_count ? GFP_ATOMIC : GFP_KERNEL);
  20178. +        if (!tty->read_buf)
  20179. +            return -ENOMEM;
  20180. +    }
  20181. +    memset(tty->read_buf, 0, N_TTY_BUF_SIZE);
  20182. +    tty->read_head = tty->read_tail = tty->read_cnt = 0;
  20183. +    memset(tty->read_flags, 0, sizeof(tty->read_flags));
  20184. +    n_tty_set_termios(tty, 0);
  20185. +    tty->minimum_to_wake = 1;
  20186. +    return 0;
  20187. +}
  20188. +
  20189. +static inline int input_available_p(struct tty_struct *tty, int amt)
  20190. +{
  20191. +    if (L_ICANON(tty)) {
  20192. +        if (tty->canon_data)
  20193. +            return 1;
  20194. +    } else if (tty->read_cnt >= (amt ? amt : 1))
  20195. +        return 1;
  20196. +
  20197. +    return 0;
  20198. +}
  20199. +
  20200. +/*
  20201. + * Helper function to speed up read_chan.  It is only called when
  20202. + * ICANON is off; it copies characters straight from the tty queue to
  20203. + * user space directly.  It can be profitably called twice; once to
  20204. + * drain the space from the tail pointer to the (physical) end of the
  20205. + * buffer, and once to drain the space from the (physical) beginning of
  20206. + * the buffer to head pointer.
  20207. + */
  20208. +static inline void copy_from_read_buf(struct tty_struct *tty,
  20209. +                      unsigned char **b,
  20210. +                      unsigned int *nr)
  20211. +
  20212. +{
  20213. +    int    n;
  20214. +
  20215. +    n = MIN(*nr, MIN(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail));
  20216. +    if (!n)
  20217. +        return;
  20218. +    memcpy_tofs(*b, &tty->read_buf[tty->read_tail], n);
  20219. +    tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
  20220. +    tty->read_cnt -= n;
  20221. +    *b += n;
  20222. +    *nr -= n;
  20223. +}
  20224. +
  20225. +static int read_chan(struct tty_struct *tty, struct file *file,
  20226. +             unsigned char *buf, unsigned int nr)
  20227. +{
  20228. +    int c;
  20229. +    unsigned char *b = buf;
  20230. +    int minimum, time;
  20231. +    int retval = 0;
  20232. +    int size;
  20233. +    struct wait_queue wait = { current, NULL };
  20234. +
  20235. +do_it_again:
  20236. +
  20237. +    if (!tty->read_buf) {
  20238. +        printk("n_tty_read_chan: called with read_buf == NULL?!?\n");
  20239. +        return -EIO;
  20240. +    }
  20241. +
  20242. +    /* Job control check -- must be done at start and after
  20243. +       every sleep (POSIX.1 7.1.1.4). */
  20244. +    /* NOTE: not yet done after every sleep pending a thorough
  20245. +       check of the logic of this change. -- jlc */
  20246. +    /* don't stop on /dev/console */
  20247. +    if (file->f_inode->i_rdev != CONSOLE_DEV &&
  20248. +        current->tty == tty) {
  20249. +        if (tty->pgrp <= 0)
  20250. +            printk("read_chan: tty->pgrp <= 0!\n");
  20251. +        else if (current->pgrp != tty->pgrp) {
  20252. +            if (is_ignored(SIGTTIN) ||
  20253. +                is_orphaned_pgrp(current->pgrp))
  20254. +                return -EIO;
  20255. +printk("read_chan: suspending: tpgrp = %p, ttypgrp = %p\n",current->pgrp, tty->pgrp);
  20256. +            kill_pg(current->pgrp, SIGTTIN, 1);
  20257. +            return -ERESTARTSYS;
  20258. +        }
  20259. +    }
  20260. +
  20261. +    if (L_ICANON(tty)) {
  20262. +        minimum = time = 0;
  20263. +        current->timeout = (unsigned long) -1;
  20264. +    } else {
  20265. +        time = (HZ / 10) * TIME_CHAR(tty);
  20266. +        minimum = MIN_CHAR(tty);
  20267. +        if (minimum) {
  20268. +              current->timeout = (unsigned long) -1;
  20269. +            if (time)
  20270. +                tty->minimum_to_wake = 1;
  20271. +            else if (!tty->read_wait ||
  20272. +                 (tty->minimum_to_wake > minimum))
  20273. +                tty->minimum_to_wake = minimum;
  20274. +        } else {
  20275. +            if (time) {
  20276. +                current->timeout = time + jiffies;
  20277. +                time = 0;
  20278. +            } else
  20279. +                current->timeout = 0;
  20280. +            tty->minimum_to_wake = minimum = 1;
  20281. +        }
  20282. +    }
  20283. +
  20284. +    add_wait_queue(&tty->read_wait, &wait);
  20285. +    while (1) {
  20286. +        /* First test for status change. */
  20287. +        if (tty->packet && tty->link->ctrl_status) {
  20288. +            if (b != buf)
  20289. +                break;
  20290. +            put_fs_byte(tty->link->ctrl_status, b++);
  20291. +            tty->link->ctrl_status = 0;
  20292. +            break;
  20293. +        }
  20294. +        /* This statement must be first before checking for input
  20295. +           so that any interrupt will set the state back to
  20296. +           TASK_RUNNING. */
  20297. +        current->state = TASK_INTERRUPTIBLE;
  20298. +
  20299. +        if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
  20300. +            ((minimum - (b - buf)) >= 1))
  20301. +            tty->minimum_to_wake = (minimum - (b - buf));
  20302. +
  20303. +        if (!input_available_p(tty, 0)) {
  20304. +            if (tty->flags & (1 << TTY_SLAVE_CLOSED)) {
  20305. +                retval = -EIO;
  20306. +                break;
  20307. +            }
  20308. +            if (tty_hung_up_p(file))
  20309. +                break;
  20310. +            if (!current->timeout)
  20311. +                break;
  20312. +            if (file->f_flags & O_NONBLOCK) {
  20313. +                retval = -EAGAIN;
  20314. +                break;
  20315. +            }
  20316. +            if (current->signal & ~current->blocked) {
  20317. +                retval = -ERESTARTSYS;
  20318. +                break;
  20319. +            }
  20320. +            schedule();
  20321. +            continue;
  20322. +        }
  20323. +        current->state = TASK_RUNNING;
  20324. +
  20325. +        /* Deal with packet mode. */
  20326. +        if (tty->packet && b == buf) {
  20327. +            put_fs_byte(TIOCPKT_DATA, b++);
  20328. +            nr--;
  20329. +        }
  20330. +
  20331. +        if (L_ICANON(tty)) {
  20332. +            while (1) {
  20333. +                int eol;
  20334. +
  20335. +                disable_bh(TQUEUE_BH);
  20336. +                if (!tty->read_cnt) {
  20337. +                    enable_bh(TQUEUE_BH);
  20338. +                    break;
  20339. +                }
  20340. +                eol = clear_bit(tty->read_tail,
  20341. +                        &tty->read_flags);
  20342. +                c = tty->read_buf[tty->read_tail];
  20343. +                tty->read_tail = ((tty->read_tail+1) &
  20344. +                          (N_TTY_BUF_SIZE-1));
  20345. +                tty->read_cnt--;
  20346. +                enable_bh(TQUEUE_BH);
  20347. +                if (!eol) {
  20348. +                    put_fs_byte(c, b++);
  20349. +                    if (--nr)
  20350. +                        continue;
  20351. +                    break;
  20352. +                }
  20353. +                if (--tty->canon_data < 0) {
  20354. +                    tty->canon_data = 0;
  20355. +                }
  20356. +                if (c != __DISABLED_CHAR) {
  20357. +                    put_fs_byte(c, b++);
  20358. +                    nr--;
  20359. +                }
  20360. +                break;
  20361. +            }
  20362. +        } else {
  20363. +            disable_bh(TQUEUE_BH);
  20364. +            copy_from_read_buf(tty, &b, &nr);
  20365. +            copy_from_read_buf(tty, &b, &nr);
  20366. +            enable_bh(TQUEUE_BH);
  20367. +        }
  20368. +
  20369. +        /* If there is enough space in the read buffer now, let the
  20370. +           low-level driver know. */
  20371. +        if (tty->driver.unthrottle &&
  20372. +            (tty->read_cnt <= TTY_THRESHOLD_UNTHROTTLE)
  20373. +            && clear_bit(TTY_THROTTLED, &tty->flags))
  20374. +            tty->driver.unthrottle(tty);
  20375. +
  20376. +        if (b - buf >= minimum || !nr)
  20377. +            break;
  20378. +        if (time)
  20379. +            current->timeout = time + jiffies;
  20380. +    }
  20381. +    remove_wait_queue(&tty->read_wait, &wait);
  20382. +
  20383. +    if (!tty->read_wait)
  20384. +        tty->minimum_to_wake = minimum;
  20385. +
  20386. +    current->state = TASK_RUNNING;
  20387. +    current->timeout = 0;
  20388. +    size = b - buf;
  20389. +    if (size && nr)
  20390. +            clear_bit(TTY_PUSH, &tty->flags);
  20391. +        if (!size && clear_bit(TTY_PUSH, &tty->flags))
  20392. +                goto do_it_again;
  20393. +    if (!size && !retval)
  20394. +            clear_bit(TTY_PUSH, &tty->flags);
  20395. +        return (size ? size : retval);
  20396. +}
  20397. +
  20398. +static int write_chan(struct tty_struct * tty, struct file * file,
  20399. +              unsigned char * buf, unsigned int nr)
  20400. +{
  20401. +    int c;
  20402. +    unsigned char *b = buf;
  20403. +    int retval = 0;
  20404. +    struct wait_queue wait = { current, NULL };
  20405. +
  20406. +    /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
  20407. +    if (L_TOSTOP(tty) && file->f_inode->i_rdev != CONSOLE_DEV) {
  20408. +        retval = tty_check_change(tty);
  20409. +        if (retval)
  20410. +            return retval;
  20411. +    }
  20412. +
  20413. +    add_wait_queue(&tty->write_wait, &wait);
  20414. +    while (1) {
  20415. +        current->state = TASK_INTERRUPTIBLE;
  20416. +        if (current->signal & ~current->blocked) {
  20417. +            retval = -ERESTARTSYS;
  20418. +            break;
  20419. +        }
  20420. +        if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
  20421. +            retval = -EIO;
  20422. +            break;
  20423. +        }
  20424. +        if (O_OPOST(tty)) {
  20425. +            while (nr > 0) {
  20426. +                c = get_fs_byte(b);
  20427. +                if (opost(c, tty) < 0)
  20428. +                    break;
  20429. +                b++; nr--;
  20430. +            }
  20431. +            if (tty->driver.flush_chars)
  20432. +                tty->driver.flush_chars(tty);
  20433. +        } else {
  20434. +            c = tty->driver.write(tty, 1, b, nr);
  20435. +            b += c;
  20436. +            nr -= c;
  20437. +        }
  20438. +        if (!nr)
  20439. +            break;
  20440. +        if (file->f_flags & O_NONBLOCK) {
  20441. +            retval = -EAGAIN;
  20442. +            break;
  20443. +        }
  20444. +        schedule();
  20445. +    }
  20446. +    current->state = TASK_RUNNING;
  20447. +    remove_wait_queue(&tty->write_wait, &wait);
  20448. +    return (b - buf) ? b - buf : retval;
  20449. +}
  20450. +
  20451. +static int normal_select(struct tty_struct * tty, struct inode * inode,
  20452. +             struct file * file, int sel_type, select_table *wait)
  20453. +{
  20454. +    switch (sel_type) {
  20455. +        case SEL_IN:
  20456. +            if (input_available_p(tty, TIME_CHAR(tty) ? 0 :
  20457. +                          MIN_CHAR(tty)))
  20458. +                return 1;
  20459. +            /* fall through */
  20460. +        case SEL_EX:
  20461. +            if (tty->packet && tty->link->ctrl_status)
  20462. +                return 1;
  20463. +            if (tty->flags & (1 << TTY_SLAVE_CLOSED))
  20464. +                return 1;
  20465. +            if (tty_hung_up_p(file))
  20466. +                return 1;
  20467. +            if (!tty->read_wait) {
  20468. +                if (MIN_CHAR(tty) && !TIME_CHAR(tty))
  20469. +                    tty->minimum_to_wake = MIN_CHAR(tty);
  20470. +                else
  20471. +                    tty->minimum_to_wake = 1;
  20472. +            }
  20473. +            select_wait(&tty->read_wait, wait);
  20474. +            return 0;
  20475. +        case SEL_OUT:
  20476. +            if (tty->driver.chars_in_buffer(tty) < WAKEUP_CHARS)
  20477. +                return 1;
  20478. +            select_wait(&tty->write_wait, wait);
  20479. +            return 0;
  20480. +    }
  20481. +    return 0;
  20482. +}
  20483. +
  20484. +struct tty_ldisc tty_ldisc_N_TTY = {
  20485. +    TTY_LDISC_MAGIC,    /* magic */
  20486. +    0,            /* num */
  20487. +    0,            /* flags */
  20488. +    n_tty_open,        /* open */
  20489. +    n_tty_close,        /* close */
  20490. +    n_tty_flush_buffer,    /* flush_buffer */
  20491. +    n_tty_chars_in_buffer,    /* chars_in_buffer */
  20492. +    read_chan,        /* read */
  20493. +    write_chan,        /* write */
  20494. +    n_tty_ioctl,        /* ioctl */
  20495. +    n_tty_set_termios,    /* set_termios */
  20496. +    normal_select,        /* select */
  20497. +    n_tty_receive_buf,    /* receive_buf */
  20498. +    n_tty_receive_room,    /* receive_room */
  20499. +    0            /* write_wakeup */
  20500. +};
  20501. +
  20502. diff -r -u -N linux.orig/arch/arm/drivers/char/ptr.c linux.arm/arch/arm/drivers/char/ptr.c
  20503. --- linux.orig/arch/arm/drivers/char/ptr.c    Thu Jan  1 01:00:00 1970
  20504. +++ linux.arm/arch/arm/drivers/char/ptr.c    Fri Oct 27 23:14:20 1995
  20505. @@ -0,0 +1,210 @@
  20506. +/*
  20507. + * ptr.c
  20508. + *
  20509. + * Archimedes pointer driver
  20510. + *
  20511. + * By R.M.King
  20512. + *
  20513. + * This pointer driver provides a total of 5 possible pointers.
  20514. + *
  20515. + */
  20516. +#include <linux/errno.h>
  20517. +#include <linux/mm.h>
  20518. +
  20519. +#include <asm/segment.h>
  20520. +
  20521. +extern void vidc_write(int reg, int val);
  20522. +extern void memc_write(int reg, int val);
  20523. +
  20524. +/* Have to go into a separate file */
  20525. +#define N_PTRS 5
  20526. +
  20527. +#define ARC_MOUSE_ON        0x7A01
  20528. +#define ARC_MOUSE_OFF        0x7A02
  20529. +#define ARC_MOUSE_SETPOS    0x7A03
  20530. +#define ARC_MOUSE_SHAPE        0x7A04
  20531. +#define ARC_MOUSE_SELECT    0x7A05
  20532. +
  20533. +#define MAX_X 799
  20534. +#define MAX_Y 599
  20535. +
  20536. +struct pointer_define
  20537. +{
  20538. +  unsigned char no;
  20539. +  unsigned char x;    /* X size */
  20540. +  unsigned char y;    /* Y size */
  20541. +  unsigned char x_hot;    /* Hot spot X offset */
  20542. +  unsigned char y_hot;    /* Hot spot Y offset */
  20543. +  char ndata[1];
  20544. +};
  20545. +
  20546. +static unsigned char current_ptr=0;
  20547. +static unsigned long ptr_y=0;
  20548. +static unsigned long ptr_x=0;
  20549. +static int ptr_toupdate=0;
  20550. +static int ptr_displayed=0;
  20551. +
  20552. +static struct ptr_data
  20553. +{
  20554. +    unsigned char x_size;
  20555. +    unsigned char y_size;
  20556. +    unsigned char x_hot;
  20557. +    unsigned char y_hot;
  20558. +} data[N_PTRS];
  20559. +
  20560. +void ptr_update(void)
  20561. +{
  20562. +    long y;
  20563. +    y = ptr_y - (int)data[current_ptr].y_hot;
  20564. +    if(ptr_toupdate & 3)
  20565. +    {
  20566. +         long x,ry,ey;
  20567. +        x  = 195 + ptr_x - (int)data[current_ptr].x_hot;
  20568. +        ry = 23 + (y < 0 ? 0 : y);
  20569. +        ey = 23 + y + (int)data[current_ptr].y_size;
  20570. +
  20571. +        if(ey < 7)
  20572. +            ey=7;
  20573. +
  20574. +        vidc_write(0x98, (x  << 13));
  20575. +        vidc_write(0xB8, (ry << 14));
  20576. +        vidc_write(0xBC, (ey << 14));
  20577. +    }
  20578. +    if(ptr_toupdate & 3)
  20579. +    {
  20580. +        if(y < 0)
  20581. +            memc_write(3, (0x40100+0x300*current_ptr+8*(-y))>>2);
  20582. +        else
  20583. +            memc_write(3, (0x40100+0x300*current_ptr)>>2);
  20584. +    }
  20585. +
  20586. +    if(ptr_toupdate & 4)
  20587. +    {
  20588. +        vidc_write(0x98, 0);
  20589. +        vidc_write(0xB8, 0);
  20590. +        vidc_write(0xBC, 0x4000);
  20591. +    }
  20592. +    ptr_toupdate = 0;
  20593. +}
  20594. +
  20595. +int ptr_ioctl(struct tty_struct *tty, struct file * file,
  20596. +    unsigned int cmd, unsigned long arg)
  20597. +{
  20598. +    int i;
  20599. +    /* Check to make sure that this tty is local */
  20600. +
  20601. +    switch(cmd)
  20602. +    {
  20603. +        case ARC_MOUSE_ON:
  20604. +            ptr_displayed = 1;
  20605. +            ptr_toupdate |= 3;
  20606. +            return 0;
  20607. +
  20608. +        case ARC_MOUSE_OFF:
  20609. +            ptr_displayed = 0;
  20610. +            ptr_toupdate |= 4;
  20611. +            return 0;
  20612. +
  20613. +        case ARC_MOUSE_SETPOS:
  20614. +            i = verify_area(VERIFY_READ, (void *)arg, 8);
  20615. +            if(i)
  20616. +                return i;
  20617. +            ptr_x = get_fs_long((unsigned long *)arg);
  20618. +            ptr_y = get_fs_long(((unsigned long *)arg)+1);
  20619. +            if(ptr_x > MAX_X)
  20620. +              ptr_x = MAX_X;
  20621. +            if(ptr_y > MAX_Y)
  20622. +              ptr_y = MAX_Y;
  20623. +
  20624. +            ptr_toupdate |= ptr_displayed?3:0;
  20625. +            return 0;
  20626. +
  20627. +        case ARC_MOUSE_SHAPE:
  20628. +        {
  20629. +            struct pointer_define ptrdef;
  20630. +            int total_bytes,ptrbuf,y;
  20631. +            unsigned char ptr;
  20632. +
  20633. +            i = verify_area(VERIFY_READ, (void *)arg,
  20634. +                    sizeof(struct pointer_define)-1);
  20635. +            if (i)
  20636. +                return i;
  20637. +
  20638. +            memcpy_fromfs((void *)&ptrdef, (void *)arg,
  20639. +                sizeof(struct pointer_define)-1);
  20640. +
  20641. +            total_bytes = ptrdef.x * ptrdef.y / 4;
  20642. +            ptr = ptrdef.no;
  20643. +
  20644. +            if(total_bytes > 0x300 || ptr > 4)
  20645. +                return -EINVAL;
  20646. +            i = verify_area(VERIFY_READ,
  20647. +                (void *)(arg + sizeof(struct pointer_define)-1), total_bytes);
  20648. +            if (i)
  20649. +                return i;
  20650. +
  20651. +            /* Hmm. Or shall I switch it off, update & switch on? */
  20652. +            if(ptr == current_ptr && ptr_displayed)
  20653. +                return -EBUSY;
  20654. +
  20655. +            data[ptr].x_size = ptrdef.x;
  20656. +            data[ptr].y_size = ptrdef.y;
  20657. +            data[ptr].x_hot  = ptrdef.x_hot;
  20658. +            data[ptr].y_hot  = ptrdef.y_hot;
  20659. +
  20660. +            ptrbuf = 0x100 + 0x300 * ptr;
  20661. +            memset((void *)ptrbuf, 0, 0x300);
  20662. +
  20663. +            for(y=0; y < ptrdef.y; y++)
  20664. +            {
  20665. +                memcpy_fromfs((void *)(ptrbuf + 8 * y),
  20666. +                    (void *)(arg + 5 + y*ptrdef.x/4),
  20667. +                    ptrdef.x / 4);
  20668. +            }
  20669. +            return 0;
  20670. +                }
  20671. +        case ARC_MOUSE_SELECT:
  20672. +            if(arg > 4)
  20673. +                return -EINVAL;
  20674. +
  20675. +            current_ptr = arg;
  20676. +            ptr_toupdate |= ptr_displayed?3:0;
  20677. +            return 0;
  20678. +    }
  20679. +    return -EINVAL;
  20680. +}
  20681. +
  20682. +void ptr_concontrol(int on_off, unsigned int pos)
  20683. +{
  20684. +  if(on_off)
  20685. +  {
  20686. +    if(!ptr_displayed)
  20687. +    {
  20688. +      int i;
  20689. +      current_ptr = 0;
  20690. +      ptr_displayed = 1;
  20691. +      data[0].x_size = 4;
  20692. +      data[0].y_size = 8;
  20693. +      data[0].x_hot  = 0;
  20694. +      data[0].y_hot  = 0;
  20695. +      for(i = 0x100; i < 0x300; i++)
  20696. +        *(unsigned char *)i=0x55 << (i & 1);
  20697. +    }
  20698. +
  20699. +    ptr_x = pos % (MAX_X+1);
  20700. +    ptr_y = pos / (MAX_X+1);
  20701. +
  20702. +    if(ptr_y > MAX_Y)
  20703. +      ptr_y = MAX_Y;
  20704. +
  20705. +    ptr_toupdate |= 3;
  20706. +  }
  20707. +  else
  20708. +  {
  20709. +    if(ptr_displayed)
  20710. +    {
  20711. +      ptr_displayed = 0;
  20712. +      ptr_toupdate |= 4;
  20713. +    }
  20714. +  }
  20715. +}
  20716. diff -r -u -N linux.orig/arch/arm/drivers/char/pty.c linux.arm/arch/arm/drivers/char/pty.c
  20717. --- linux.orig/arch/arm/drivers/char/pty.c    Thu Jan  1 01:00:00 1970
  20718. +++ linux.arm/arch/arm/drivers/char/pty.c    Fri Oct 27 23:14:25 1995
  20719. @@ -0,0 +1,262 @@
  20720. +/*
  20721. + *  linux/drivers/char/pty.c
  20722. + *
  20723. + *  Copyright (C) 1991, 1992  Linus Torvalds
  20724. + */
  20725. +
  20726. +/*
  20727. + *    pty.c
  20728. + *
  20729. + * This module exports the following pty function:
  20730. + *
  20731. + *     int  pty_open(struct tty_struct * tty, struct file * filp);
  20732. + */
  20733. +
  20734. +#include <linux/errno.h>
  20735. +#include <linux/sched.h>
  20736. +#include <linux/interrupt.h>
  20737. +#include <linux/tty.h>
  20738. +#include <linux/tty_flip.h>
  20739. +#include <linux/fcntl.h>
  20740. +#include <linux/string.h>
  20741. +#include <linux/major.h>
  20742. +#include <linux/mm.h>
  20743. +
  20744. +#include <asm/segment.h>
  20745. +#include <asm/system.h>
  20746. +#include <asm/bitops.h>
  20747. +
  20748. +struct pty_struct {
  20749. +    int    magic;
  20750. +    struct wait_queue * open_wait;
  20751. +};
  20752. +
  20753. +#define PTY_MAGIC 0x5001
  20754. +#define PTY_BUF_SIZE 4096/2
  20755. +/*
  20756. + * tmp_buf is used as a temporary buffer by pty_write.  We need to
  20757. + * lock it in case the memcpy_fromfs blocks while swapping in a page,
  20758. + * and some other program tries to do a pty write at the same time.
  20759. + * Since the lock will only come under contention when the system is
  20760. + * swapping and available memory is low, it makes sense to share one
  20761. + * buffer across all the PTY's, since it significantly saves memory if
  20762. + * large numbers of PTY's are open.
  20763. + */
  20764. +static unsigned char *tmp_buf;
  20765. +static struct semaphore tmp_buf_sem = MUTEX;
  20766. +
  20767. +struct tty_driver pty_driver, pty_slave_driver;
  20768. +static int pty_refcount;
  20769. +
  20770. +static struct tty_struct *pty_table[NR_PTYS];
  20771. +static struct termios *pty_termios[NR_PTYS];
  20772. +static struct termios *pty_termios_locked[NR_PTYS];
  20773. +static struct tty_struct *ttyp_table[NR_PTYS];
  20774. +static struct termios *ttyp_termios[NR_PTYS];
  20775. +static struct termios *ttyp_termios_locked[NR_PTYS];
  20776. +static struct pty_struct pty_state[NR_PTYS];
  20777. +
  20778. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  20779. +
  20780. +static void pty_close(struct tty_struct * tty, struct file * filp)
  20781. +{
  20782. +    if (!tty)
  20783. +        return;
  20784. +    if (tty->driver.subtype == PTY_TYPE_MASTER) {
  20785. +        if (tty->count > 1)
  20786. +            printk("master pty_close: count = %d!!\n", tty->count);
  20787. +    } else {
  20788. +        if (tty->count > 2)
  20789. +            return;
  20790. +    }
  20791. +    wake_up_interruptible(&tty->read_wait);
  20792. +    wake_up_interruptible(&tty->write_wait);
  20793. +    if (!tty->link)
  20794. +        return;
  20795. +    wake_up_interruptible(&tty->link->read_wait);
  20796. +    wake_up_interruptible(&tty->link->write_wait);
  20797. +    if (tty->driver.subtype == PTY_TYPE_MASTER)
  20798. +        tty_hangup(tty->link);
  20799. +    else {
  20800. +        start_tty(tty);
  20801. +        set_bit(TTY_SLAVE_CLOSED, &tty->link->flags);
  20802. +    }
  20803. +}
  20804. +
  20805. +/*
  20806. + * The unthrottle routine is called by the line discipline to signal
  20807. + * that it can receive more characters.  For PTY's, the TTY_THROTTLED
  20808. + * flag is always set, to force the line discipline to always call the
  20809. + * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
  20810. + * characters in the queue.  This is necessary since each time this
  20811. + * happens, we need to wake up any sleeping processes that could be
  20812. + * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
  20813. + * for the pty buffer to be drained.
  20814. + */
  20815. +static void pty_unthrottle(struct tty_struct * tty)
  20816. +{
  20817. +    struct tty_struct *o_tty = tty->link;
  20818. +
  20819. +    if (!o_tty)
  20820. +        return;
  20821. +
  20822. +    if ((o_tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  20823. +        o_tty->ldisc.write_wakeup)
  20824. +        (o_tty->ldisc.write_wakeup)(o_tty);
  20825. +    wake_up_interruptible(&o_tty->write_wait);
  20826. +    set_bit(TTY_THROTTLED, &tty->flags);
  20827. +}
  20828. +
  20829. +static int pty_write(struct tty_struct * tty, int from_user,
  20830. +               unsigned char *buf, int count)
  20831. +{
  20832. +    struct tty_struct *to = tty->link;
  20833. +    int    c=0, n, r;
  20834. +    char    *temp_buffer;
  20835. +
  20836. +    if (!to || tty->stopped)
  20837. +        return 0;
  20838. +
  20839. +    if (from_user) {
  20840. +        down(&tmp_buf_sem);
  20841. +        temp_buffer = tmp_buf +
  20842. +            ((tty->driver.subtype-1) * PTY_BUF_SIZE);
  20843. +        while (count > 0) {
  20844. +            n = MIN(count, PTY_BUF_SIZE);
  20845. +            memcpy_fromfs(temp_buffer, buf, n);
  20846. +            r = to->ldisc.receive_room(to);
  20847. +            if (r <= 0)
  20848. +                break;
  20849. +            n = MIN(n, r);
  20850. +            to->ldisc.receive_buf(to, temp_buffer, 0, n);
  20851. +            buf += n;  c+= n;
  20852. +            count -= n;
  20853. +        }
  20854. +        up(&tmp_buf_sem);
  20855. +    } else {
  20856. +        c = MIN(count, to->ldisc.receive_room(to));
  20857. +        to->ldisc.receive_buf(to, buf, 0, c);
  20858. +    }
  20859. +
  20860. +    return c;
  20861. +}
  20862. +
  20863. +static int pty_write_room(struct tty_struct *tty)
  20864. +{
  20865. +    struct tty_struct *to = tty->link;
  20866. +
  20867. +    if (!to || tty->stopped)
  20868. +        return 0;
  20869. +
  20870. +    return to->ldisc.receive_room(to);
  20871. +}
  20872. +
  20873. +static int pty_chars_in_buffer(struct tty_struct *tty)
  20874. +{
  20875. +    struct tty_struct *to = tty->link;
  20876. +
  20877. +    if (!to || !to->ldisc.chars_in_buffer)
  20878. +        return 0;
  20879. +
  20880. +    return to->ldisc.chars_in_buffer(to);
  20881. +}
  20882. +
  20883. +static void pty_flush_buffer(struct tty_struct *tty)
  20884. +{
  20885. +    struct tty_struct *to = tty->link;
  20886. +
  20887. +    if (!to)
  20888. +        return;
  20889. +
  20890. +    if (to->ldisc.flush_buffer)
  20891. +        to->ldisc.flush_buffer(to);
  20892. +
  20893. +    if (to->packet) {
  20894. +        tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
  20895. +        wake_up_interruptible(&to->read_wait);
  20896. +    }
  20897. +}
  20898. +
  20899. +int pty_open(struct tty_struct *tty, struct file * filp)
  20900. +{
  20901. +    int    line;
  20902. +    struct    pty_struct *pty;
  20903. +
  20904. +    if (!tty || !tty->link)
  20905. +        return -ENODEV;
  20906. +    line = MINOR(tty->device) - tty->driver.minor_start;
  20907. +    if ((line < 0) || (line >= NR_PTYS))
  20908. +        return -ENODEV;
  20909. +    pty = pty_state + line;
  20910. +    tty->driver_data = pty;
  20911. +
  20912. +    if (!tmp_buf) {
  20913. +        tmp_buf = (unsigned char *) kmalloc(PTY_BUF_SIZE*2,GFP_KERNEL);
  20914. +        if (!tmp_buf)
  20915. +            return -ENOMEM;
  20916. +    }
  20917. +
  20918. +    if (tty->driver.subtype == PTY_TYPE_SLAVE)
  20919. +        clear_bit(TTY_SLAVE_CLOSED, &tty->link->flags);
  20920. +    wake_up_interruptible(&pty->open_wait);
  20921. +    set_bit(TTY_THROTTLED, &tty->flags);
  20922. +    if (filp->f_flags & O_NDELAY)
  20923. +        return 0;
  20924. +    while (!tty->link->count && !(current->signal & ~current->blocked))
  20925. +        interruptible_sleep_on(&pty->open_wait);
  20926. +    if (!tty->link->count)
  20927. +        return -ERESTARTSYS;
  20928. +    return 0;
  20929. +}
  20930. +
  20931. +long pty_init(long kmem_start)
  20932. +{
  20933. +    memset(&pty_state, 0, sizeof(pty_state));
  20934. +    memset(&pty_driver, 0, sizeof(struct tty_driver));
  20935. +    pty_driver.magic = TTY_DRIVER_MAGIC;
  20936. +    pty_driver.name = "pty";
  20937. +    pty_driver.major = TTY_MAJOR;
  20938. +    pty_driver.minor_start = 128;
  20939. +    pty_driver.num = NR_PTYS;
  20940. +    pty_driver.type = TTY_DRIVER_TYPE_PTY;
  20941. +    pty_driver.subtype = PTY_TYPE_MASTER;
  20942. +    pty_driver.init_termios = tty_std_termios;
  20943. +    pty_driver.init_termios.c_iflag = 0;
  20944. +    pty_driver.init_termios.c_oflag = 0;
  20945. +    pty_driver.init_termios.c_cflag = B38400 | CS8 | CREAD;
  20946. +    pty_driver.init_termios.c_lflag = 0;
  20947. +    pty_driver.flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW;
  20948. +    pty_driver.refcount = &pty_refcount;
  20949. +    pty_driver.table = pty_table;
  20950. +    pty_driver.termios = pty_termios;
  20951. +    pty_driver.termios_locked = pty_termios_locked;
  20952. +    pty_driver.other = &pty_slave_driver;
  20953. +
  20954. +    pty_driver.open = pty_open;
  20955. +    pty_driver.close = pty_close;
  20956. +    pty_driver.write = pty_write;
  20957. +    pty_driver.write_room = pty_write_room;
  20958. +    pty_driver.flush_buffer = pty_flush_buffer;
  20959. +    pty_driver.chars_in_buffer = pty_chars_in_buffer;
  20960. +    pty_driver.unthrottle = pty_unthrottle;
  20961. +
  20962. +    pty_slave_driver = pty_driver;
  20963. +    pty_slave_driver.name = "ttyp";
  20964. +    pty_slave_driver.subtype = PTY_TYPE_SLAVE;
  20965. +    pty_slave_driver.minor_start = 192;
  20966. +    pty_slave_driver.init_termios = tty_std_termios;
  20967. +    pty_slave_driver.init_termios.c_cflag = B38400 | CS8 | CREAD;
  20968. +    pty_slave_driver.table = ttyp_table;
  20969. +    pty_slave_driver.termios = ttyp_termios;
  20970. +    pty_slave_driver.termios_locked = ttyp_termios_locked;
  20971. +    pty_slave_driver.other = &pty_driver;
  20972. +
  20973. +    tmp_buf = 0;
  20974. +
  20975. +    if (tty_register_driver(&pty_driver))
  20976. +        panic("Couldn't register pty driver");
  20977. +    if (tty_register_driver(&pty_slave_driver))
  20978. +        panic("Couldn't register pty slave driver");
  20979. +
  20980. +    return kmem_start;
  20981. +}
  20982. diff -r -u -N linux.orig/arch/arm/drivers/char/serial.c linux.arm/arch/arm/drivers/char/serial.c
  20983. --- linux.orig/arch/arm/drivers/char/serial.c    Thu Jan  1 01:00:00 1970
  20984. +++ linux.arm/arch/arm/drivers/char/serial.c    Fri Oct 27 23:14:26 1995
  20985. @@ -0,0 +1,2691 @@
  20986. +/*
  20987. + *  linux/arch/arm/drivers/char/serial.c
  20988. + *
  20989. + *  Copyright (C) 1991, 1992  Linus Torvalds
  20990. + *
  20991. + *  Extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92.  Now
  20992. + *  much more extensible to support other serial cards based on the
  20993. + *  16450/16550A UART's.  Added support for the AST FourPort and the
  20994. + *  Accent Async board.  
  20995. + *
  20996. + *  set_serial_info fixed to set the flags, custom divisor, and uart
  20997. + *     type fields.  Fix suggested by Michael K. Johnson 12/12/92.
  20998. + *
  20999. + * This module exports the following rs232 io functions:
  21000. + *
  21001. + *    long rs_init(long);
  21002. + *     int  rs_open(struct tty_struct * tty, struct file * filp)
  21003. + *
  21004. + *  Slight modifications for ARM
  21005. + */
  21006. +
  21007. +#include <linux/errno.h>
  21008. +#include <linux/signal.h>
  21009. +#include <linux/sched.h>
  21010. +#include <linux/timer.h>
  21011. +#include <linux/interrupt.h>
  21012. +#include <linux/tty.h>
  21013. +#include <linux/tty_flip.h>
  21014. +#include <linux/serial.h>
  21015. +#include <linux/serial_reg.h>
  21016. +#include <linux/config.h>
  21017. +#include <linux/major.h>
  21018. +#include <linux/string.h>
  21019. +#include <linux/fcntl.h>
  21020. +#include <linux/ptrace.h>
  21021. +#include <linux/major.h>
  21022. +#include <linux/ioport.h>
  21023. +#include <linux/mm.h>
  21024. +
  21025. +#include <asm/system.h>
  21026. +#include <asm/io.h>
  21027. +#include <asm/segment.h>
  21028. +#include <asm/bitops.h>
  21029. +
  21030. +DECLARE_TASK_QUEUE(tq_serial);
  21031. +
  21032. +struct tty_driver serial_driver, callout_driver;
  21033. +static int serial_refcount;
  21034. +
  21035. +/* serial subtype definitions */
  21036. +#define SERIAL_TYPE_NORMAL    1
  21037. +#define SERIAL_TYPE_CALLOUT    2
  21038. +
  21039. +/* number of characters left in xmit buffer before we ask for more */
  21040. +#define WAKEUP_CHARS 256
  21041. +
  21042. +/*
  21043. + * Serial driver configuration section.  Here are the various options:
  21044. + *
  21045. + * CONFIG_HUB6
  21046. + *        Enables support for the venerable Bell Technologies
  21047. + *        HUB6 card.
  21048. + *
  21049. + * SERIAL_PARANOIA_CHECK
  21050. + *         Check the magic number for the async_structure where
  21051. + *         ever possible.
  21052. + */
  21053. +
  21054. +#define SERIAL_PARANOIA_CHECK
  21055. +#define CONFIG_SERIAL_NOPAUSE_IO
  21056. +#define SERIAL_DO_RESTART
  21057. +
  21058. +#undef SERIAL_DEBUG_INTR
  21059. +#undef SERIAL_DEBUG_OPEN
  21060. +#undef SERIAL_DEBUG_FLOW
  21061. +
  21062. +#define RS_STROBE_TIME 10
  21063. +#define RS_ISR_PASS_LIMIT 256
  21064. +
  21065. +#define _INLINE_ inline
  21066. +  
  21067. +/*
  21068. + * IRQ_timeout        - How long the timeout should be for each IRQ
  21069. + *                 should be after the IRQ has been active.
  21070. + */
  21071. +
  21072. +static struct async_struct *IRQ_ports[16];
  21073. +static struct rs_multiport_struct rs_multiport[16];
  21074. +static int IRQ_timeout[16];
  21075. +static volatile int rs_irq_triggered;
  21076. +static volatile int rs_triggered;
  21077. +static int rs_wild_int_mask;
  21078. +
  21079. +static void autoconfig(struct async_struct * info);
  21080. +static void change_speed(struct async_struct *info);
  21081. +    
  21082. +/*
  21083. + * This assumes you have a 1.8432 MHz clock for your UART.
  21084. + *
  21085. + * It'd be nice if someone built a serial card with a 24.576 MHz
  21086. + * clock, since the 16550A is capable of handling a top speed of 1.5
  21087. + * megabits/second; but this requires the faster clock.
  21088. + */
  21089. +#define BASE_BAUD ( 1843200 / 16 )
  21090. +
  21091. +#define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST )
  21092. +
  21093. +struct async_struct rs_table[] = {
  21094. +    /* UART CLK   PORT IRQ     FLAGS        */
  21095. +    { 0, BASE_BAUD, 0x3F8,10, STD_COM_FLAGS },    /* ttyS0 */
  21096. +    { 0, BASE_BAUD, 0x2F8,10, STD_COM_FLAGS },    /* ttyS1 */
  21097. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS2 */
  21098. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS3 */
  21099. +
  21100. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },     /* ttyS4 */
  21101. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS5 */
  21102. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS6 */
  21103. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS7 */
  21104. +
  21105. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS8 */
  21106. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS9 */
  21107. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS10 */
  21108. +    { 0, BASE_BAUD, 0    , 0, STD_COM_FLAGS },    /* ttyS11 */
  21109. +    
  21110. +};
  21111. +
  21112. +#define NR_PORTS    (sizeof(rs_table)/sizeof(struct async_struct))
  21113. +
  21114. +static struct tty_struct *serial_table[NR_PORTS];
  21115. +static struct termios *serial_termios[NR_PORTS];
  21116. +static struct termios *serial_termios_locked[NR_PORTS];
  21117. +
  21118. +#ifndef MIN
  21119. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  21120. +#endif
  21121. +
  21122. +/*
  21123. + * tmp_buf is used as a temporary buffer by serial_write.  We need to
  21124. + * lock it in case the memcpy_fromfs blocks while swapping in a page,
  21125. + * and some other program tries to do a serial write at the same time.
  21126. + * Since the lock will only come under contention when the system is
  21127. + * swapping and available memory is low, it makes sense to share one
  21128. + * buffer across all the serial ports, since it significantly saves
  21129. + * memory if large numbers of serial ports are open.
  21130. + */
  21131. +static unsigned char *tmp_buf = 0;
  21132. +static struct semaphore tmp_buf_sem = MUTEX;
  21133. +
  21134. +static inline int serial_paranoia_check(struct async_struct *info,
  21135. +                    dev_t device, const char *routine)
  21136. +{
  21137. +#ifdef SERIAL_PARANOIA_CHECK
  21138. +    static const char *badmagic =
  21139. +        "Warning: bad magic number for serial struct (%d, %d) in %s\n";
  21140. +    static const char *badinfo =
  21141. +        "Warning: null async_struct for (%d, %d) in %s\n";
  21142. +
  21143. +    if (!info) {
  21144. +        printk(badinfo, MAJOR(device), MINOR(device), routine);
  21145. +        return 1;
  21146. +    }
  21147. +    if (info->magic != SERIAL_MAGIC) {
  21148. +        printk(badmagic, MAJOR(device), MINOR(device), routine);
  21149. +        return 1;
  21150. +    }
  21151. +#endif
  21152. +    return 0;
  21153. +}
  21154. +
  21155. +/*
  21156. + * This is used to figure out the divisor speeds and the timeouts
  21157. + */
  21158. +static int baud_table[] = {
  21159. +    0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  21160. +    9600, 19200, 38400, 57600, 115200, 0 };
  21161. +
  21162. +static inline unsigned int serial_in(struct async_struct *info, int offset)
  21163. +{
  21164. +#ifdef CONFIG_HUB6
  21165. +    if (info->hub6) {
  21166. +    outb(info->hub6 - 1 + offset, info->port);
  21167. +    return inb(info->port+1);
  21168. +    } else
  21169. +#endif
  21170. +    return inb(info->port + offset);
  21171. +}
  21172. +
  21173. +static inline unsigned int serial_inp(struct async_struct *info, int offset)
  21174. +{
  21175. +#ifdef CONFIG_HUB6
  21176. +    if (info->hub6) {
  21177. +    outb(info->hub6 - 1 + offset, info->port);
  21178. +    return inb_p(info->port+1);
  21179. +    } else
  21180. +#endif
  21181. +#ifdef CONFIG_SERIAL_NOPAUSE_IO
  21182. +    return inb(info->port + offset);
  21183. +#else
  21184. +    return inb_p(info->port + offset);
  21185. +#endif
  21186. +}
  21187. +
  21188. +static inline void serial_out(struct async_struct *info, int offset, int value)
  21189. +{
  21190. +#ifdef CONFIG_HUB6
  21191. +    if (info->hub6) {
  21192. +    outb(info->hub6 - 1 + offset, info->port);
  21193. +    outb(value, info->port+1);
  21194. +    } else
  21195. +#endif
  21196. +    outb(value, info->port+offset);
  21197. +}
  21198. +
  21199. +static inline void serial_outp(struct async_struct *info, int offset,
  21200. +                   int value)
  21201. +{
  21202. +#ifdef CONFIG_HUB6
  21203. +    if (info->hub6) {
  21204. +    outb(info->hub6 - 1 + offset, info->port);
  21205. +    outb_p(value, info->port+1);
  21206. +    } else
  21207. +#endif
  21208. +#ifdef CONFIG_SERIAL_NOPAUSE_IO
  21209. +    outb(value, info->port+offset);
  21210. +#else
  21211. +        outb_p(value, info->port+offset);
  21212. +#endif
  21213. +}
  21214. +
  21215. +/*
  21216. + * ------------------------------------------------------------
  21217. + * rs_stop() and rs_start()
  21218. + *
  21219. + * This routines are called before setting or resetting tty->stopped.
  21220. + * They enable or disable transmitter interrupts, as necessary.
  21221. + * ------------------------------------------------------------
  21222. + */
  21223. +static void rs_stop(struct tty_struct *tty)
  21224. +{
  21225. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  21226. +    unsigned long flags;
  21227. +
  21228. +    if (serial_paranoia_check(info, tty->device, "rs_stop"))
  21229. +        return;
  21230. +    
  21231. +    save_flags(flags); cli();
  21232. +    if (info->IER & UART_IER_THRI) {
  21233. +        info->IER &= ~UART_IER_THRI;
  21234. +        serial_out(info, UART_IER, info->IER);
  21235. +    }
  21236. +    restore_flags(flags);
  21237. +}
  21238. +
  21239. +static void rs_start(struct tty_struct *tty)
  21240. +{
  21241. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  21242. +    unsigned long flags;
  21243. +    
  21244. +    if (serial_paranoia_check(info, tty->device, "rs_start"))
  21245. +        return;
  21246. +    
  21247. +    save_flags(flags); cli();
  21248. +    if (info->xmit_cnt && info->xmit_buf && !(info->IER & UART_IER_THRI)) {
  21249. +        info->IER |= UART_IER_THRI;
  21250. +        serial_out(info, UART_IER, info->IER);
  21251. +    }
  21252. +    restore_flags(flags);
  21253. +}
  21254. +
  21255. +/*
  21256. + * ----------------------------------------------------------------------
  21257. + *
  21258. + * Here starts the interrupt handling routines.  All of the following
  21259. + * subroutines are declared as inline and are folded into
  21260. + * rs_interrupt().  They were separated out for readability's sake.
  21261. + *
  21262. + * Note: rs_interrupt() is a "fast" interrupt, which means that it
  21263. + * runs with interrupts turned off.  People who may want to modify
  21264. + * rs_interrupt() should try to keep the interrupt handler as fast as
  21265. + * possible.  After you are done making modifications, it is not a bad
  21266. + * idea to do:
  21267. + * 
  21268. + * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
  21269. + *
  21270. + * and look at the resulting assemble code in serial.s.
  21271. + *
  21272. + *                 - Ted Ts'o (tytso@mit.edu), 7-Mar-93
  21273. + * -----------------------------------------------------------------------
  21274. + */
  21275. +
  21276. +/*
  21277. + * This is the serial driver's interrupt routine while we are probing
  21278. + * for submarines.
  21279. + */
  21280. +static void rs_probe(int irq, struct pt_regs * regs)
  21281. +{
  21282. +    rs_irq_triggered = irq;
  21283. +    rs_triggered |= 1 << irq;
  21284. +    return;
  21285. +}
  21286. +
  21287. +/*
  21288. + * This routine is used by the interrupt handler to schedule
  21289. + * processing in the software interrupt portion of the driver.
  21290. + */
  21291. +static _INLINE_ void rs_sched_event(struct async_struct *info,
  21292. +                  int event)
  21293. +{
  21294. +    info->event |= 1 << event;
  21295. +    queue_task_irq_off(&info->tqueue, &tq_serial);
  21296. +    mark_bh(SERIAL_BH);
  21297. +}
  21298. +
  21299. +static _INLINE_ void receive_chars(struct async_struct *info,
  21300. +                 int *status)
  21301. +{
  21302. +    struct tty_struct *tty = info->tty;
  21303. +    unsigned char ch;
  21304. +    int ignored = 0;
  21305. +
  21306. +    do {
  21307. +        ch = serial_inp(info, UART_RX);
  21308. +        if (*status & info->ignore_status_mask) {
  21309. +            if (++ignored > 100)
  21310. +                break;
  21311. +            goto ignore_char;
  21312. +        }
  21313. +        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  21314. +            break;
  21315. +        tty->flip.count++;
  21316. +        if (*status & (UART_LSR_BI)) {
  21317. +            printk("handling break....");
  21318. +            *tty->flip.flag_buf_ptr++ = TTY_BREAK;
  21319. +            if (info->flags & ASYNC_SAK)
  21320. +                do_SAK(tty);
  21321. +        } else if (*status & UART_LSR_PE)
  21322. +            *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  21323. +        else if (*status & UART_LSR_FE)
  21324. +            *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  21325. +        else if (*status & UART_LSR_OE) 
  21326. +            *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  21327. +        else
  21328. +            *tty->flip.flag_buf_ptr++ = 0;
  21329. +        *tty->flip.char_buf_ptr++ = ch;
  21330. +    ignore_char:
  21331. +        *status = serial_inp(info, UART_LSR) & info->read_status_mask;
  21332. +    } while (*status & UART_LSR_DR);
  21333. +    queue_task_irq_off(&tty->flip.tqueue, &tq_timer);
  21334. +#ifdef SERIAL_DEBUG_INTR
  21335. +    printk("DR...");
  21336. +#endif
  21337. +}
  21338. +
  21339. +static _INLINE_ void transmit_chars(struct async_struct *info, int *intr_done)
  21340. +{
  21341. +    int count;
  21342. +    
  21343. +    if (info->x_char) {
  21344. +        serial_outp(info, UART_TX, info->x_char);
  21345. +        info->x_char = 0;
  21346. +        if (intr_done)
  21347. +            *intr_done = 0;
  21348. +        return;
  21349. +    }
  21350. +    if ((info->xmit_cnt <= 0) || info->tty->stopped ||
  21351. +        info->tty->hw_stopped) {
  21352. +        info->IER &= ~UART_IER_THRI;
  21353. +        serial_out(info, UART_IER, info->IER);
  21354. +        return;
  21355. +    }
  21356. +    
  21357. +    count = info->xmit_fifo_size;
  21358. +    do {
  21359. +        serial_out(info, UART_TX, info->xmit_buf[info->xmit_tail++]);
  21360. +        info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  21361. +        if (--info->xmit_cnt <= 0)
  21362. +            break;
  21363. +    } while (--count > 0);
  21364. +    
  21365. +    if (info->xmit_cnt < WAKEUP_CHARS)
  21366. +        rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  21367. +
  21368. +#ifdef SERIAL_DEBUG_INTR
  21369. +    printk("THRE...");
  21370. +#endif
  21371. +    if (intr_done)
  21372. +        *intr_done = 0;
  21373. +
  21374. +    if (info->xmit_cnt <= 0) {
  21375. +        info->IER &= ~UART_IER_THRI;
  21376. +        serial_out(info, UART_IER, info->IER);
  21377. +    }
  21378. +}
  21379. +
  21380. +static _INLINE_ void check_modem_status(struct async_struct *info)
  21381. +{
  21382. +    int    status;
  21383. +    
  21384. +    status = serial_in(info, UART_MSR);
  21385. +
  21386. +    if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
  21387. +#if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
  21388. +        printk("ttys%d CD now %s...", info->line,
  21389. +               (status & UART_MSR_DCD) ? "on" : "off");
  21390. +#endif        
  21391. +        if (status & UART_MSR_DCD)
  21392. +            wake_up_interruptible(&info->open_wait);
  21393. +        else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  21394. +               (info->flags & ASYNC_CALLOUT_NOHUP))) {
  21395. +#ifdef SERIAL_DEBUG_OPEN
  21396. +            printk("scheduling hangup...");
  21397. +#endif
  21398. +            queue_task_irq_off(&info->tqueue_hangup,
  21399. +                       &tq_scheduler);
  21400. +        }
  21401. +    }
  21402. +    if (info->flags & ASYNC_CTS_FLOW) {
  21403. +        if (info->tty->hw_stopped) {
  21404. +            if (status & UART_MSR_CTS) {
  21405. +#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  21406. +                printk("CTS tx start...");
  21407. +#endif
  21408. +                info->tty->hw_stopped = 0;
  21409. +                info->IER |= UART_IER_THRI;
  21410. +                serial_out(info, UART_IER, info->IER);
  21411. +                rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  21412. +                return;
  21413. +            }
  21414. +        } else {
  21415. +            if (!(status & UART_MSR_CTS)) {
  21416. +#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  21417. +                printk("CTS tx stop...");
  21418. +#endif
  21419. +                info->tty->hw_stopped = 1;
  21420. +                info->IER &= ~UART_IER_THRI;
  21421. +                serial_out(info, UART_IER, info->IER);
  21422. +            }
  21423. +        }
  21424. +    }
  21425. +}
  21426. +
  21427. +/*
  21428. + * This is the serial driver's generic interrupt routine
  21429. + */
  21430. +static void rs_interrupt(int irq, struct pt_regs * regs)
  21431. +{
  21432. +    int status;
  21433. +    struct async_struct * info;
  21434. +    int pass_counter = 0;
  21435. +    struct async_struct *end_mark = 0;
  21436. +    int first_multi = 0;
  21437. +    struct rs_multiport_struct *multi;
  21438. +
  21439. +#ifdef SERIAL_DEBUG_INTR
  21440. +    printk("rs_interrupt(%d)...", irq);
  21441. +#endif
  21442. +    
  21443. +    info = IRQ_ports[irq];
  21444. +    if (!info)
  21445. +        return;
  21446. +    
  21447. +    multi = &rs_multiport[irq];
  21448. +    if (multi->port_monitor)
  21449. +        first_multi = inb(multi->port_monitor);
  21450. +
  21451. +    do {
  21452. +        if (!info->tty ||
  21453. +            (serial_in(info, UART_IIR) & UART_IIR_NO_INT)) {
  21454. +            if (!end_mark)
  21455. +                end_mark = info;
  21456. +            goto next;
  21457. +        }
  21458. +        end_mark = 0;
  21459. +
  21460. +        info->last_active = jiffies;
  21461. +
  21462. +        status = serial_inp(info, UART_LSR) & info->read_status_mask;
  21463. +#ifdef SERIAL_DEBUG_INTR
  21464. +        printk("status = %x...", status);
  21465. +#endif
  21466. +        if (status & UART_LSR_DR)
  21467. +            receive_chars(info, &status);
  21468. +        check_modem_status(info);
  21469. +        if (status & UART_LSR_THRE)
  21470. +            transmit_chars(info, 0);
  21471. +
  21472. +    next:
  21473. +        info = info->next_port;
  21474. +        if (!info) {
  21475. +            info = IRQ_ports[irq];
  21476. +            if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  21477. +#if 0
  21478. +                printk("rs loop break\n");
  21479. +#endif
  21480. +                break;     /* Prevent infinite loops */
  21481. +            }
  21482. +            continue;
  21483. +        }
  21484. +    } while (end_mark != info);
  21485. +    if (multi->port_monitor)
  21486. +        printk("rs port monitor (normal) irq %d: 0x%x, 0x%x\n",
  21487. +               info->irq, first_multi, inb(multi->port_monitor));
  21488. +#ifdef SERIAL_DEBUG_INTR
  21489. +    printk("end.\n");
  21490. +#endif
  21491. +}
  21492. +
  21493. +/*
  21494. + * This is the serial driver's interrupt routine for a single port
  21495. + */
  21496. +static void rs_interrupt_single(int irq, struct pt_regs * regs)
  21497. +{
  21498. +    int status;
  21499. +    int pass_counter = 0;
  21500. +    int first_multi = 0;
  21501. +    struct async_struct * info;
  21502. +    struct rs_multiport_struct *multi;
  21503. +    
  21504. +#ifdef SERIAL_DEBUG_INTR
  21505. +    printk("rs_interrupt_single(%d)...", irq);
  21506. +#endif
  21507. +    
  21508. +    info = IRQ_ports[irq];
  21509. +    if (!info || !info->tty)
  21510. +        return;
  21511. +
  21512. +    multi = &rs_multiport[irq];
  21513. +    if (multi->port_monitor)
  21514. +        first_multi = inb(multi->port_monitor);
  21515. +
  21516. +    do {
  21517. +        status = serial_inp(info, UART_LSR) & info->read_status_mask;
  21518. +#ifdef SERIAL_DEBUG_INTR
  21519. +        printk("status = %x...", status);
  21520. +#endif
  21521. +        if (status & UART_LSR_DR)
  21522. +            receive_chars(info, &status);
  21523. +        check_modem_status(info);
  21524. +        if (status & UART_LSR_THRE)
  21525. +            transmit_chars(info, 0);
  21526. +        if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  21527. +#if 0
  21528. +            printk("rs_single loop break.\n");
  21529. +#endif
  21530. +            break;
  21531. +        }
  21532. +    } while (!(serial_in(info, UART_IIR) & UART_IIR_NO_INT));
  21533. +    info->last_active = jiffies;
  21534. +    if (multi->port_monitor)
  21535. +        printk("rs port monitor (single) irq %d: 0x%x, 0x%x\n",
  21536. +               info->irq, first_multi, inb(multi->port_monitor));
  21537. +#ifdef SERIAL_DEBUG_INTR
  21538. +    printk("end.\n");
  21539. +#endif
  21540. +}
  21541. +
  21542. +/*
  21543. + * This is the serial driver's for multiport boards
  21544. + */
  21545. +static void rs_interrupt_multi(int irq, struct pt_regs * regs)
  21546. +{
  21547. +    int status;
  21548. +    struct async_struct * info;
  21549. +    int pass_counter = 0;
  21550. +    int first_multi= 0;
  21551. +    struct rs_multiport_struct *multi;
  21552. +
  21553. +#ifdef SERIAL_DEBUG_INTR
  21554. +    printk("rs_interrupt_multi(%d)...", irq);
  21555. +#endif
  21556. +    
  21557. +    info = IRQ_ports[irq];
  21558. +    if (!info)
  21559. +        return;
  21560. +    multi = &rs_multiport[irq];
  21561. +    if (!multi->port1) {
  21562. +        /* Should never happen */
  21563. +        printk("rs_interrupt_multi: NULL port1!\n");
  21564. +        return;
  21565. +    }
  21566. +    if (multi->port_monitor)
  21567. +        first_multi = inb(multi->port_monitor);
  21568. +    
  21569. +    while (1) {
  21570. +        if (!info->tty ||
  21571. +            (serial_in(info, UART_IIR) & UART_IIR_NO_INT))
  21572. +            goto next;
  21573. +
  21574. +        info->last_active = jiffies;
  21575. +
  21576. +        status = serial_inp(info, UART_LSR) & info->read_status_mask;
  21577. +#ifdef SERIAL_DEBUG_INTR
  21578. +        printk("status = %x...", status);
  21579. +#endif
  21580. +        if (status & UART_LSR_DR)
  21581. +            receive_chars(info, &status);
  21582. +        check_modem_status(info);
  21583. +        if (status & UART_LSR_THRE)
  21584. +            transmit_chars(info, 0);
  21585. +
  21586. +    next:
  21587. +        info = info->next_port;
  21588. +        if (info)
  21589. +            continue;
  21590. +
  21591. +        info = IRQ_ports[irq];
  21592. +        if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  21593. +#if 1
  21594. +            printk("rs_multi loop break\n");
  21595. +#endif
  21596. +            break;     /* Prevent infinite loops */
  21597. +        }
  21598. +        if (multi->port_monitor)
  21599. +            printk("rs port monitor irq %d: 0x%x, 0x%x\n",
  21600. +                   info->irq, first_multi,
  21601. +                   inb(multi->port_monitor));
  21602. +        if ((inb(multi->port1) & multi->mask1) != multi->match1)
  21603. +            continue;
  21604. +        if (!multi->port2)
  21605. +            break;
  21606. +        if ((inb(multi->port2) & multi->mask2) != multi->match2)
  21607. +            continue;
  21608. +        if (!multi->port3)
  21609. +            break;
  21610. +        if ((inb(multi->port3) & multi->mask3) != multi->match3)
  21611. +            continue;
  21612. +        if (!multi->port4)
  21613. +            break;
  21614. +        if ((inb(multi->port4) & multi->mask4) == multi->match4)
  21615. +            continue;
  21616. +        break;
  21617. +    } 
  21618. +#ifdef SERIAL_DEBUG_INTR
  21619. +    printk("end.\n");
  21620. +#endif
  21621. +}
  21622. +
  21623. +
  21624. +/*
  21625. + * -------------------------------------------------------------------
  21626. + * Here ends the serial interrupt routines.
  21627. + * -------------------------------------------------------------------
  21628. + */
  21629. +
  21630. +/*
  21631. + * This routine is used to handle the "bottom half" processing for the
  21632. + * serial driver, known also the "software interrupt" processing.
  21633. + * This processing is done at the kernel interrupt level, after the
  21634. + * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  21635. + * is where time-consuming activities which can not be done in the
  21636. + * interrupt driver proper are done; the interrupt driver schedules
  21637. + * them using rs_sched_event(), and they get done here.
  21638. + */
  21639. +static void do_serial_bh(void *unused)
  21640. +{
  21641. +    run_task_queue(&tq_serial);
  21642. +}
  21643. +
  21644. +static void do_softint(void *private_)
  21645. +{
  21646. +    struct async_struct    *info = (struct async_struct *) private_;
  21647. +    struct tty_struct    *tty;
  21648. +    
  21649. +    tty = info->tty;
  21650. +    if (!tty)
  21651. +        return;
  21652. +
  21653. +    if (clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  21654. +        if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  21655. +            tty->ldisc.write_wakeup)
  21656. +            (tty->ldisc.write_wakeup)(tty);
  21657. +        wake_up_interruptible(&tty->write_wait);
  21658. +    }
  21659. +}
  21660. +
  21661. +/*
  21662. + * This routine is called from the scheduler tqueue when the interrupt
  21663. + * routine has signalled that a hangup has occurred.  The path of
  21664. + * hangup processing is:
  21665. + *
  21666. + *     serial interrupt routine -> (scheduler tqueue) ->
  21667. + *     do_serial_hangup() -> tty->hangup() -> rs_hangup()
  21668. + * 
  21669. + */
  21670. +static void do_serial_hangup(void *private_)
  21671. +{
  21672. +    struct async_struct    *info = (struct async_struct *) private_;
  21673. +    struct tty_struct    *tty;
  21674. +    
  21675. +    tty = info->tty;
  21676. +    if (!tty)
  21677. +        return;
  21678. +
  21679. +    tty_hangup(tty);
  21680. +}
  21681. +
  21682. +
  21683. +/*
  21684. + * This subroutine is called when the RS_TIMER goes off.  It is used
  21685. + * by the serial driver to handle ports that do not have an interrupt
  21686. + * (irq=0).  This doesn't work very well for 16450's, but gives barely
  21687. + * passable results for a 16550A.  (Although at the expense of much
  21688. + * CPU overhead).
  21689. + */
  21690. +static void rs_timer(void)
  21691. +{
  21692. +    static unsigned long last_strobe = 0;
  21693. +    struct async_struct *info;
  21694. +    unsigned int    i;
  21695. +
  21696. +    if ((jiffies - last_strobe) >= RS_STROBE_TIME*HZ) {
  21697. +        for (i=1; i < 16; i++) {
  21698. +            info = IRQ_ports[i];
  21699. +            if (!info)
  21700. +                continue;
  21701. +            cli();
  21702. +            if (info->next_port) {
  21703. +                do {
  21704. +                    serial_out(info, UART_IER, 0);
  21705. +                    info->IER |= UART_IER_THRI;
  21706. +                    serial_out(info, UART_IER, info->IER);
  21707. +                    info = info->next_port;
  21708. +                } while (info);
  21709. +                if (rs_multiport[i].port1)
  21710. +                    rs_interrupt_multi(i, NULL);
  21711. +                else
  21712. +                    rs_interrupt(i, NULL);
  21713. +            } else
  21714. +                rs_interrupt_single(i, NULL);
  21715. +            sti();
  21716. +        }
  21717. +    }
  21718. +    last_strobe = jiffies;
  21719. +    timer_table[RS_TIMER].expires = jiffies + RS_STROBE_TIME * HZ;
  21720. +    timer_active |= 1 << RS_TIMER;
  21721. +
  21722. +    if (IRQ_ports[0]) {
  21723. +        cli();
  21724. +        rs_interrupt(0, NULL);
  21725. +        sti();
  21726. +
  21727. +        timer_table[RS_TIMER].expires = jiffies + IRQ_timeout[0] - 2;
  21728. +    }
  21729. +}
  21730. +
  21731. +/*
  21732. + * ---------------------------------------------------------------
  21733. + * Low level utility subroutines for the serial driver:  routines to
  21734. + * figure out the appropriate timeout for an interrupt chain, routines
  21735. + * to initialize and startup a serial port, and routines to shutdown a
  21736. + * serial port.  Useful stuff like that.
  21737. + * ---------------------------------------------------------------
  21738. + */
  21739. +
  21740. +/*
  21741. + * Grab all interrupts in preparation for doing an automatic irq
  21742. + * detection.  dontgrab is a mask of irq's _not_ to grab.  Returns a
  21743. + * mask of irq's which were grabbed and should therefore be freed
  21744. + * using free_all_interrupts().
  21745. + */
  21746. +static int grab_all_interrupts(int dontgrab)
  21747. +{
  21748. +    int             irq_lines = 0;
  21749. +    int            i, mask;
  21750. +    
  21751. +    for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
  21752. +        if (!(mask & dontgrab) && !request_irq(i, rs_probe, SA_INTERRUPT, "serial probe")) {
  21753. +            irq_lines |= mask;
  21754. +        }
  21755. +    }
  21756. +    return irq_lines;
  21757. +}
  21758. +
  21759. +/*
  21760. + * Release all interrupts grabbed by grab_all_interrupts
  21761. + */
  21762. +static void free_all_interrupts(int irq_lines)
  21763. +{
  21764. +    int    i;
  21765. +    
  21766. +    for (i = 0; i < 16; i++) {
  21767. +        if (irq_lines & (1 << i))
  21768. +            free_irq(i);
  21769. +    }
  21770. +}
  21771. +
  21772. +/*
  21773. + * This routine figures out the correct timeout for a particular IRQ.
  21774. + * It uses the smallest timeout of all of the serial ports in a
  21775. + * particular interrupt chain.  Now only used for IRQ 0....
  21776. + */
  21777. +static void figure_IRQ_timeout(int irq)
  21778. +{
  21779. +    struct    async_struct    *info;
  21780. +    int    timeout = 6000;    /* 60 seconds === a long time :-) */
  21781. +
  21782. +    info = IRQ_ports[irq];
  21783. +    if (!info) {
  21784. +        IRQ_timeout[irq] = 6000;
  21785. +        return;
  21786. +    }
  21787. +    while (info) {
  21788. +        if (info->timeout < timeout)
  21789. +            timeout = info->timeout;
  21790. +        info = info->next_port;
  21791. +    }
  21792. +    if (!irq)
  21793. +        timeout = timeout / 2;
  21794. +    IRQ_timeout[irq] = timeout ? timeout : 1;
  21795. +}
  21796. +
  21797. +static int startup(struct async_struct * info)
  21798. +{
  21799. +    unsigned short ICP;
  21800. +    unsigned long flags;
  21801. +    int    retval;
  21802. +    void (*handler)(int, struct pt_regs *);
  21803. +
  21804. +    if (info->flags & ASYNC_INITIALIZED)
  21805. +        return 0;
  21806. +
  21807. +    if (!info->port || !info->type) {
  21808. +        if (info->tty)
  21809. +            set_bit(TTY_IO_ERROR, &info->tty->flags);
  21810. +        return 0;
  21811. +    }
  21812. +
  21813. +    if (!info->xmit_buf) {
  21814. +        info->xmit_buf = (unsigned char *) get_free_page(GFP_KERNEL);
  21815. +        if (!info->xmit_buf)
  21816. +            return -ENOMEM;
  21817. +    }
  21818. +
  21819. +    save_flags(flags); cli();
  21820. +
  21821. +#ifdef SERIAL_DEBUG_OPEN
  21822. +    printk("starting up ttys%d (irq %d)...", info->line, info->irq);
  21823. +#endif
  21824. +
  21825. +    /*
  21826. +     * Clear the FIFO buffers and disable them
  21827. +     * (they will be reenabled in change_speed())
  21828. +     */
  21829. +    if (info->type == PORT_16650) {
  21830. +        serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  21831. +                         UART_FCR_CLEAR_XMIT));
  21832. +        info->xmit_fifo_size = 1; /* disabled for now */
  21833. +    } else if (info->type == PORT_16550A) {
  21834. +        serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  21835. +                         UART_FCR_CLEAR_XMIT));
  21836. +        info->xmit_fifo_size = 16;
  21837. +    } else
  21838. +        info->xmit_fifo_size = 1;
  21839. +
  21840. +    /*
  21841. +     * At this point there's no way the LSR could still be 0xFF;
  21842. +     * if it is, then bail out, because there's likely no UART
  21843. +     * here.
  21844. +     */
  21845. +    if (serial_inp(info, UART_LSR) == 0xff) {
  21846. +        restore_flags(flags);
  21847. +        if (suser()) {
  21848. +            if (info->tty)
  21849. +                set_bit(TTY_IO_ERROR, &info->tty->flags);
  21850. +            return 0;
  21851. +        } else
  21852. +            return -ENODEV;
  21853. +    }
  21854. +    
  21855. +    /*
  21856. +     * Allocate the IRQ if necessary
  21857. +     */
  21858. +    if (info->irq && (!IRQ_ports[info->irq] ||
  21859. +              !IRQ_ports[info->irq]->next_port)) {
  21860. +        if (IRQ_ports[info->irq]) {
  21861. +            free_irq(info->irq);
  21862. +            if (rs_multiport[info->irq].port1)
  21863. +                handler = rs_interrupt_multi;
  21864. +            else
  21865. +                handler = rs_interrupt;
  21866. +        } else 
  21867. +            handler = rs_interrupt_single;
  21868. +
  21869. +        retval = request_irq(info->irq, handler, SA_INTERRUPT, "serial");
  21870. +        if (retval) {
  21871. +            restore_flags(flags);
  21872. +            if (suser()) {
  21873. +                if (info->tty)
  21874. +                    set_bit(TTY_IO_ERROR,
  21875. +                        &info->tty->flags);
  21876. +                return 0;
  21877. +            } else
  21878. +                return retval;
  21879. +        }
  21880. +    }
  21881. +
  21882. +    /*
  21883. +     * Clear the interrupt registers.
  21884. +     */
  21885. +     /* (void) serial_inp(info, UART_LSR); */   /* (see above) */
  21886. +    (void) serial_inp(info, UART_RX);
  21887. +    (void) serial_inp(info, UART_IIR);
  21888. +    (void) serial_inp(info, UART_MSR);
  21889. +
  21890. +    /*
  21891. +     * Now, initialize the UART 
  21892. +     */
  21893. +    serial_outp(info, UART_LCR, UART_LCR_WLEN8);    /* reset DLAB */
  21894. +    if (info->flags & ASYNC_FOURPORT) {
  21895. +        info->MCR = UART_MCR_DTR | UART_MCR_RTS;
  21896. +        info->MCR_noint = UART_MCR_DTR | UART_MCR_OUT1;
  21897. +    } else {
  21898. +        info->MCR = UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2;
  21899. +        info->MCR_noint = UART_MCR_DTR | UART_MCR_RTS;
  21900. +    }
  21901. +#ifdef __alpha__
  21902. +    info->MCR |= UART_MCR_OUT1 | UART_MCR_OUT2;
  21903. +    info->MCR_noint |= UART_MCR_OUT1 | UART_MCR_OUT2;
  21904. +#endif
  21905. +    if (info->irq == 0)
  21906. +        info->MCR = info->MCR_noint;
  21907. +    serial_outp(info, UART_MCR, info->MCR);
  21908. +    
  21909. +    /*
  21910. +     * Finally, enable interrupts
  21911. +     */
  21912. +    info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
  21913. +    serial_outp(info, UART_IER, info->IER);    /* enable interrupts */
  21914. +    
  21915. +    if (info->flags & ASYNC_FOURPORT) {
  21916. +        /* Enable interrupts on the AST Fourport board */
  21917. +        ICP = (info->port & 0xFE0) | 0x01F;
  21918. +        outb_p(0x80, ICP);
  21919. +        (void) inb_p(ICP);
  21920. +    }
  21921. +
  21922. +    /*
  21923. +     * And clear the interrupt registers again for luck.
  21924. +     */
  21925. +    (void)serial_inp(info, UART_LSR);
  21926. +    (void)serial_inp(info, UART_RX);
  21927. +    (void)serial_inp(info, UART_IIR);
  21928. +    (void)serial_inp(info, UART_MSR);
  21929. +
  21930. +    if (info->tty)
  21931. +        clear_bit(TTY_IO_ERROR, &info->tty->flags);
  21932. +    info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  21933. +
  21934. +    /*
  21935. +     * Insert serial port into IRQ chain.
  21936. +     */
  21937. +    info->prev_port = 0;
  21938. +    info->next_port = IRQ_ports[info->irq];
  21939. +    if (info->next_port)
  21940. +        info->next_port->prev_port = info;
  21941. +    IRQ_ports[info->irq] = info;
  21942. +    figure_IRQ_timeout(info->irq);
  21943. +
  21944. +    /*
  21945. +     * Set up serial timers...
  21946. +     */
  21947. +    timer_table[RS_TIMER].expires = jiffies + 2;
  21948. +    timer_active |= 1 << RS_TIMER;
  21949. +
  21950. +    /*
  21951. +     * and set the speed of the serial port
  21952. +     */
  21953. +    change_speed(info);
  21954. +
  21955. +    info->flags |= ASYNC_INITIALIZED;
  21956. +    restore_flags(flags);
  21957. +    return 0;
  21958. +}
  21959. +
  21960. +/*
  21961. + * This routine will shutdown a serial port; interrupts are disabled, and
  21962. + * DTR is dropped if the hangup on close termio flag is on.
  21963. + */
  21964. +static void shutdown(struct async_struct * info)
  21965. +{
  21966. +    unsigned long    flags;
  21967. +    int        retval;
  21968. +
  21969. +    if (!(info->flags & ASYNC_INITIALIZED))
  21970. +        return;
  21971. +
  21972. +#ifdef SERIAL_DEBUG_OPEN
  21973. +    printk("Shutting down serial port %d (irq %d)....", info->line,
  21974. +           info->irq);
  21975. +#endif
  21976. +    
  21977. +    save_flags(flags); cli(); /* Disable interrupts */
  21978. +    
  21979. +    /*
  21980. +     * First unlink the serial port from the IRQ chain...
  21981. +     */
  21982. +    if (info->next_port)
  21983. +        info->next_port->prev_port = info->prev_port;
  21984. +    if (info->prev_port)
  21985. +        info->prev_port->next_port = info->next_port;
  21986. +    else
  21987. +        IRQ_ports[info->irq] = info->next_port;
  21988. +    figure_IRQ_timeout(info->irq);
  21989. +    
  21990. +    /*
  21991. +     * Free the IRQ, if necessary
  21992. +     */
  21993. +    if (info->irq && (!IRQ_ports[info->irq] ||
  21994. +              !IRQ_ports[info->irq]->next_port)) {
  21995. +        if (IRQ_ports[info->irq]) {
  21996. +            free_irq(info->irq);
  21997. +            retval = request_irq(info->irq, rs_interrupt_single, SA_INTERRUPT, "serial");
  21998. +            
  21999. +            if (retval)
  22000. +                printk("serial shutdown: request_irq: error %d"
  22001. +                       "  Couldn't reacquire IRQ.\n", retval);
  22002. +        } else
  22003. +            free_irq(info->irq);
  22004. +    }
  22005. +
  22006. +    if (info->xmit_buf) {
  22007. +        free_page((unsigned long) info->xmit_buf);
  22008. +        info->xmit_buf = 0;
  22009. +    }
  22010. +
  22011. +    info->IER = 0;
  22012. +    serial_outp(info, UART_IER, 0x00);    /* disable all intrs */
  22013. +    if (info->flags & ASYNC_FOURPORT) {
  22014. +        /* reset interrupts on the AST Fourport board */
  22015. +        (void) inb((info->port & 0xFE0) | 0x01F);
  22016. +    }
  22017. +    
  22018. +    if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
  22019. +        info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS);
  22020. +        info->MCR_noint &= ~(UART_MCR_DTR|UART_MCR_RTS);
  22021. +    }
  22022. +    serial_outp(info, UART_MCR, info->MCR_noint);
  22023. +
  22024. +    /* disable FIFO's */    
  22025. +    serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  22026. +                     UART_FCR_CLEAR_XMIT));
  22027. +    (void)serial_in(info, UART_RX);    /* read data port to reset things */
  22028. +    
  22029. +    if (info->tty)
  22030. +        set_bit(TTY_IO_ERROR, &info->tty->flags);
  22031. +    
  22032. +    info->flags &= ~ASYNC_INITIALIZED;
  22033. +    restore_flags(flags);
  22034. +}
  22035. +
  22036. +/*
  22037. + * This routine is called to set the UART divisor registers to match
  22038. + * the specified baud rate for a serial port.
  22039. + */
  22040. +static void change_speed(struct async_struct *info)
  22041. +{
  22042. +    unsigned short port;
  22043. +    int    quot = 0;
  22044. +    unsigned cflag,cval,fcr;
  22045. +    int    i;
  22046. +
  22047. +    if (!info->tty || !info->tty->termios)
  22048. +        return;
  22049. +    cflag = info->tty->termios->c_cflag;
  22050. +    if (!(port = info->port))
  22051. +        return;
  22052. +    i = cflag & CBAUD;
  22053. +    if (i & CBAUDEX) {
  22054. +        i &= ~CBAUDEX;
  22055. +        if (i < 1 || i > 2) 
  22056. +            info->tty->termios->c_cflag &= ~CBAUDEX;
  22057. +        else
  22058. +            i += 15;
  22059. +    }
  22060. +    if (i == 15) {
  22061. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  22062. +            i += 1;
  22063. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  22064. +            i += 2;
  22065. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
  22066. +            quot = info->custom_divisor;
  22067. +    }
  22068. +    if (quot) {
  22069. +        info->timeout = ((info->xmit_fifo_size*HZ*15*quot) /
  22070. +                 info->baud_base) + 2;
  22071. +    } else if (baud_table[i] == 134) {
  22072. +        quot = (2*info->baud_base / 269);
  22073. +        info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
  22074. +    } else if (baud_table[i]) {
  22075. +        quot = info->baud_base / baud_table[i];
  22076. +        info->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
  22077. +    } else {
  22078. +        quot = 0;
  22079. +        info->timeout = 0;
  22080. +    }
  22081. +    if (quot) {
  22082. +        info->MCR |= UART_MCR_DTR;
  22083. +        info->MCR_noint |= UART_MCR_DTR;
  22084. +        cli();
  22085. +        serial_out(info, UART_MCR, info->MCR);
  22086. +        sti();
  22087. +    } else {
  22088. +        info->MCR &= ~UART_MCR_DTR;
  22089. +        info->MCR_noint &= ~UART_MCR_DTR;
  22090. +        cli();
  22091. +        serial_out(info, UART_MCR, info->MCR);
  22092. +        sti();
  22093. +        return;
  22094. +    }
  22095. +    /* byte size and parity */
  22096. +    cval = cflag & (CSIZE | CSTOPB);
  22097. +    cval >>= 4;
  22098. +    if (cflag & PARENB)
  22099. +        cval |= UART_LCR_PARITY;
  22100. +    if (!(cflag & PARODD))
  22101. +        cval |= UART_LCR_EPAR;
  22102. +    if (info->type == PORT_16550A) {
  22103. +        if ((info->baud_base / quot) < 2400)
  22104. +            fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
  22105. +        else
  22106. +            fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
  22107. +    } else if (info->type == PORT_16650) {
  22108. +        /*
  22109. +         * On the 16650, we disable the FIFOs altogether
  22110. +         * because of a design bug in how the implement
  22111. +         * things.  We could support it by completely changing
  22112. +         * how we handle the interrupt driver, but not today....
  22113. +         *
  22114. +         * N.B.  Because there's no way to set a FIFO trigger
  22115. +         * at 1 char, we'd probably disable at speed below
  22116. +         * 2400 baud anyway...
  22117. +         */
  22118. +        fcr = 0;
  22119. +    } else
  22120. +        fcr = 0;
  22121. +    
  22122. +    /* CTS flow control flag and modem status interrupts */
  22123. +    info->IER &= ~UART_IER_MSI;
  22124. +    if (cflag & CRTSCTS) {
  22125. +        info->flags |= ASYNC_CTS_FLOW;
  22126. +        info->IER |= UART_IER_MSI;
  22127. +    } else
  22128. +        info->flags &= ~ASYNC_CTS_FLOW;
  22129. +    if (cflag & CLOCAL)
  22130. +        info->flags &= ~ASYNC_CHECK_CD;
  22131. +    else {
  22132. +        info->flags |= ASYNC_CHECK_CD;
  22133. +        info->IER |= UART_IER_MSI;
  22134. +    }
  22135. +    serial_out(info, UART_IER, info->IER);
  22136. +
  22137. +    /*
  22138. +     * Set up parity check flag
  22139. +     */
  22140. +    info->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
  22141. +    if (I_INPCK(info->tty))
  22142. +        info->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
  22143. +    if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
  22144. +        info->read_status_mask |= UART_LSR_BI;
  22145. +    
  22146. +    info->ignore_status_mask = 0;
  22147. +    if (I_IGNPAR(info->tty)) {
  22148. +        info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
  22149. +        info->read_status_mask |= UART_LSR_PE | UART_LSR_FE;
  22150. +    }
  22151. +    if (I_IGNBRK(info->tty)) {
  22152. +        info->ignore_status_mask |= UART_LSR_BI;
  22153. +        info->read_status_mask |= UART_LSR_BI;
  22154. +        /*
  22155. +         * If we're ignore parity and break indicators, ignore 
  22156. +         * overruns too.  (For real raw support).
  22157. +         */
  22158. +        if (I_IGNPAR(info->tty)) {
  22159. +            info->ignore_status_mask |= UART_LSR_OE;
  22160. +            info->read_status_mask |= UART_LSR_OE;
  22161. +        }
  22162. +    }
  22163. +    
  22164. +    cli();
  22165. +    serial_outp(info, UART_LCR, cval | UART_LCR_DLAB);    /* set DLAB */
  22166. +    serial_outp(info, UART_DLL, quot & 0xff);    /* LS of divisor */
  22167. +    serial_outp(info, UART_DLM, quot >> 8);        /* MS of divisor */
  22168. +    serial_outp(info, UART_LCR, cval);        /* reset DLAB */
  22169. +    serial_outp(info, UART_FCR, fcr);     /* set fcr */
  22170. +    sti();
  22171. +}
  22172. +
  22173. +static void rs_put_char(struct tty_struct *tty, unsigned char ch)
  22174. +{
  22175. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22176. +    unsigned long flags;
  22177. +
  22178. +    if (serial_paranoia_check(info, tty->device, "rs_put_char"))
  22179. +        return;
  22180. +
  22181. +    if (!tty || !info->xmit_buf)
  22182. +        return;
  22183. +
  22184. +    save_flags(flags); cli();
  22185. +    if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
  22186. +        restore_flags(flags);
  22187. +        return;
  22188. +    }
  22189. +
  22190. +    info->xmit_buf[info->xmit_head++] = ch;
  22191. +    info->xmit_head &= SERIAL_XMIT_SIZE-1;
  22192. +    info->xmit_cnt++;
  22193. +    restore_flags(flags);
  22194. +}
  22195. +
  22196. +static void rs_flush_chars(struct tty_struct *tty)
  22197. +{
  22198. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22199. +    unsigned long flags;
  22200. +                
  22201. +    if (serial_paranoia_check(info, tty->device, "rs_flush_chars"))
  22202. +        return;
  22203. +
  22204. +    if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  22205. +        !info->xmit_buf)
  22206. +        return;
  22207. +
  22208. +    save_flags(flags); cli();
  22209. +    info->IER |= UART_IER_THRI;
  22210. +    serial_out(info, UART_IER, info->IER);
  22211. +    restore_flags(flags);
  22212. +}
  22213. +
  22214. +static int rs_write(struct tty_struct * tty, int from_user,
  22215. +            unsigned char *buf, int count)
  22216. +{
  22217. +    int    c, total = 0;
  22218. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22219. +    unsigned long flags;
  22220. +                
  22221. +    if (serial_paranoia_check(info, tty->device, "rs_write"))
  22222. +        return 0;
  22223. +
  22224. +    if (!tty || !info->xmit_buf || !tmp_buf)
  22225. +        return 0;
  22226. +        
  22227. +    save_flags(flags);
  22228. +    while (1) {
  22229. +        cli();        
  22230. +        c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  22231. +                   SERIAL_XMIT_SIZE - info->xmit_head));
  22232. +        if (c <= 0)
  22233. +            break;
  22234. +
  22235. +        if (from_user) {
  22236. +            down(&tmp_buf_sem);
  22237. +            memcpy_fromfs(tmp_buf, buf, c);
  22238. +            c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  22239. +                       SERIAL_XMIT_SIZE - info->xmit_head));
  22240. +            memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
  22241. +            up(&tmp_buf_sem);
  22242. +        } else
  22243. +            memcpy(info->xmit_buf + info->xmit_head, buf, c);
  22244. +        info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  22245. +        info->xmit_cnt += c;
  22246. +        restore_flags(flags);
  22247. +        buf += c;
  22248. +        count -= c;
  22249. +        total += c;
  22250. +    }
  22251. +    if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
  22252. +        !(info->IER & UART_IER_THRI)) {
  22253. +        info->IER |= UART_IER_THRI;
  22254. +        serial_out(info, UART_IER, info->IER);
  22255. +    }
  22256. +    restore_flags(flags);
  22257. +    return total;
  22258. +}
  22259. +
  22260. +static int rs_write_room(struct tty_struct *tty)
  22261. +{
  22262. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22263. +    int    ret;
  22264. +                
  22265. +    if (serial_paranoia_check(info, tty->device, "rs_write_room"))
  22266. +        return 0;
  22267. +    ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
  22268. +    if (ret < 0)
  22269. +        ret = 0;
  22270. +    return ret;
  22271. +}
  22272. +
  22273. +static int rs_chars_in_buffer(struct tty_struct *tty)
  22274. +{
  22275. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22276. +                
  22277. +    if (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
  22278. +        return 0;
  22279. +    return info->xmit_cnt;
  22280. +}
  22281. +
  22282. +static void rs_flush_buffer(struct tty_struct *tty)
  22283. +{
  22284. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22285. +                
  22286. +    if (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
  22287. +        return;
  22288. +    cli();
  22289. +    info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  22290. +    sti();
  22291. +    wake_up_interruptible(&tty->write_wait);
  22292. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  22293. +        tty->ldisc.write_wakeup)
  22294. +        (tty->ldisc.write_wakeup)(tty);
  22295. +}
  22296. +
  22297. +/*
  22298. + * ------------------------------------------------------------
  22299. + * rs_throttle()
  22300. + * 
  22301. + * This routine is called by the upper-layer tty layer to signal that
  22302. + * incoming characters should be throttled.
  22303. + * ------------------------------------------------------------
  22304. + */
  22305. +static void rs_throttle(struct tty_struct * tty)
  22306. +{
  22307. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22308. +#ifdef SERIAL_DEBUG_THROTTLE
  22309. +    char    buf[64];
  22310. +    
  22311. +    printk("throttle %s: %d....\n", _tty_name(tty, buf),
  22312. +           tty->ldisc.chars_in_buffer(tty));
  22313. +#endif
  22314. +
  22315. +    if (serial_paranoia_check(info, tty->device, "rs_throttle"))
  22316. +        return;
  22317. +    
  22318. +    if (I_IXOFF(tty))
  22319. +        info->x_char = STOP_CHAR(tty);
  22320. +
  22321. +    info->MCR &= ~UART_MCR_RTS;
  22322. +    info->MCR_noint &= ~UART_MCR_RTS;
  22323. +    cli();
  22324. +    serial_out(info, UART_MCR, info->MCR);
  22325. +    sti();
  22326. +}
  22327. +
  22328. +static void rs_unthrottle(struct tty_struct * tty)
  22329. +{
  22330. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22331. +#ifdef SERIAL_DEBUG_THROTTLE
  22332. +    char    buf[64];
  22333. +    
  22334. +    printk("unthrottle %s: %d....\n", _tty_name(tty, buf),
  22335. +           tty->ldisc.chars_in_buffer(tty));
  22336. +#endif
  22337. +
  22338. +    if (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
  22339. +        return;
  22340. +    
  22341. +    if (I_IXOFF(tty)) {
  22342. +        if (info->x_char)
  22343. +            info->x_char = 0;
  22344. +        else
  22345. +            info->x_char = START_CHAR(tty);
  22346. +    }
  22347. +    info->MCR |= UART_MCR_RTS;
  22348. +    info->MCR_noint |= UART_MCR_RTS;
  22349. +    cli();
  22350. +    serial_out(info, UART_MCR, info->MCR);
  22351. +    sti();
  22352. +}
  22353. +
  22354. +/*
  22355. + * ------------------------------------------------------------
  22356. + * rs_ioctl() and friends
  22357. + * ------------------------------------------------------------
  22358. + */
  22359. +
  22360. +static int get_serial_info(struct async_struct * info,
  22361. +               struct serial_struct * retinfo)
  22362. +{
  22363. +    struct serial_struct tmp;
  22364. +  
  22365. +    if (!retinfo)
  22366. +        return -EFAULT;
  22367. +    memset(&tmp, 0, sizeof(tmp));
  22368. +    tmp.type = info->type;
  22369. +    tmp.line = info->line;
  22370. +    tmp.port = info->port;
  22371. +    tmp.irq = info->irq;
  22372. +    tmp.flags = info->flags;
  22373. +    tmp.baud_base = info->baud_base;
  22374. +    tmp.close_delay = info->close_delay;
  22375. +    tmp.closing_wait = info->closing_wait;
  22376. +    tmp.custom_divisor = info->custom_divisor;
  22377. +    tmp.hub6 = info->hub6;
  22378. +    memcpy_tofs(retinfo,&tmp,sizeof(*retinfo));
  22379. +    return 0;
  22380. +}
  22381. +
  22382. +static int set_serial_info(struct async_struct * info,
  22383. +               struct serial_struct * new_info)
  22384. +{
  22385. +    struct serial_struct new_serial;
  22386. +    struct async_struct old_info;
  22387. +    unsigned int        i,change_irq,change_port;
  22388. +    int             retval = 0;
  22389. +
  22390. +    if (!new_info)
  22391. +        return -EFAULT;
  22392. +    memcpy_fromfs(&new_serial,new_info,sizeof(new_serial));
  22393. +    old_info = *info;
  22394. +
  22395. +    change_irq = new_serial.irq != info->irq;
  22396. +    change_port = (new_serial.port != info->port) || (new_serial.hub6 != info->hub6);
  22397. +
  22398. +    if (!suser()) {
  22399. +        if (change_irq || change_port ||
  22400. +            (new_serial.baud_base != info->baud_base) ||
  22401. +            (new_serial.type != info->type) ||
  22402. +            (new_serial.close_delay != info->close_delay) ||
  22403. +            ((new_serial.flags & ~ASYNC_USR_MASK) !=
  22404. +             (info->flags & ~ASYNC_USR_MASK)))
  22405. +            return -EPERM;
  22406. +        info->flags = ((info->flags & ~ASYNC_USR_MASK) |
  22407. +                   (new_serial.flags & ASYNC_USR_MASK));
  22408. +        info->custom_divisor = new_serial.custom_divisor;
  22409. +        goto check_and_exit;
  22410. +    }
  22411. +
  22412. +    if (new_serial.irq == 2)
  22413. +        new_serial.irq = 9;
  22414. +
  22415. +    if ((new_serial.irq > 15) || (new_serial.port > 0xffff) ||
  22416. +        (new_serial.type < PORT_UNKNOWN) || (new_serial.type > PORT_MAX)) {
  22417. +        return -EINVAL;
  22418. +    }
  22419. +
  22420. +    /* Make sure address is not already in use */
  22421. +    if (new_serial.type) {
  22422. +        for (i = 0 ; i < NR_PORTS; i++)
  22423. +            if ((info != &rs_table[i]) &&
  22424. +                (rs_table[i].port == new_serial.port) &&
  22425. +                rs_table[i].type)
  22426. +                return -EADDRINUSE;
  22427. +    }
  22428. +
  22429. +    if ((change_port || change_irq) && (info->count > 1))
  22430. +        return -EBUSY;
  22431. +
  22432. +    /*
  22433. +     * OK, past this point, all the error checking has been done.
  22434. +     * At this point, we start making changes.....
  22435. +     */
  22436. +
  22437. +    info->baud_base = new_serial.baud_base;
  22438. +    info->flags = ((info->flags & ~ASYNC_FLAGS) |
  22439. +            (new_serial.flags & ASYNC_FLAGS));
  22440. +    info->custom_divisor = new_serial.custom_divisor;
  22441. +    info->type = new_serial.type;
  22442. +    info->close_delay = new_serial.close_delay;
  22443. +    info->closing_wait = new_serial.closing_wait;
  22444. +
  22445. +    release_region(info->port,8);
  22446. +    if (change_port || change_irq) {
  22447. +        /*
  22448. +         * We need to shutdown the serial port at the old
  22449. +         * port/irq combination.
  22450. +         */
  22451. +        shutdown(info);
  22452. +        info->irq = new_serial.irq;
  22453. +        info->port = new_serial.port;
  22454. +        info->hub6 = new_serial.hub6;
  22455. +    }
  22456. +    if(info->type != PORT_UNKNOWN)
  22457. +        request_region(info->port,8,"serial(set)");
  22458. +
  22459. +    
  22460. +check_and_exit:
  22461. +    if (!info->port || !info->type)
  22462. +        return 0;
  22463. +    if (info->flags & ASYNC_INITIALIZED) {
  22464. +        if (((old_info.flags & ASYNC_SPD_MASK) !=
  22465. +             (info->flags & ASYNC_SPD_MASK)) ||
  22466. +            (old_info.custom_divisor != info->custom_divisor))
  22467. +            change_speed(info);
  22468. +    } else
  22469. +        retval = startup(info);
  22470. +    return retval;
  22471. +}
  22472. +
  22473. +
  22474. +/*
  22475. + * get_lsr_info - get line status register info
  22476. + *
  22477. + * Purpose: Let user call ioctl() to get info when the UART physically
  22478. + *         is emptied.  On bus types like RS485, the transmitter must
  22479. + *         release the bus after transmitting. This must be done when
  22480. + *         the transmit shift register is empty, not be done when the
  22481. + *         transmit holding register is empty.  This functionality
  22482. + *         allows RS485 driver to be written in user space. 
  22483. + */
  22484. +static int get_lsr_info(struct async_struct * info, unsigned int *value)
  22485. +{
  22486. +    unsigned char status;
  22487. +    unsigned int result;
  22488. +
  22489. +    cli();
  22490. +    status = serial_in(info, UART_LSR);
  22491. +    sti();
  22492. +    result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0);
  22493. +    put_fs_long(result,(unsigned long *) value);
  22494. +    return 0;
  22495. +}
  22496. +
  22497. +
  22498. +static int get_modem_info(struct async_struct * info, unsigned int *value)
  22499. +{
  22500. +    unsigned char control, status;
  22501. +    unsigned int result;
  22502. +
  22503. +    control = info->MCR;
  22504. +    cli();
  22505. +    status = serial_in(info, UART_MSR);
  22506. +    sti();
  22507. +    result =  ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
  22508. +        | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
  22509. +        | ((status  & UART_MSR_DCD) ? TIOCM_CAR : 0)
  22510. +        | ((status  & UART_MSR_RI) ? TIOCM_RNG : 0)
  22511. +        | ((status  & UART_MSR_DSR) ? TIOCM_DSR : 0)
  22512. +        | ((status  & UART_MSR_CTS) ? TIOCM_CTS : 0);
  22513. +    put_fs_long(result,(unsigned long *) value);
  22514. +    return 0;
  22515. +}
  22516. +
  22517. +static int set_modem_info(struct async_struct * info, unsigned int cmd,
  22518. +              unsigned int *value)
  22519. +{
  22520. +    int error;
  22521. +    unsigned int arg;
  22522. +
  22523. +    error = verify_area(VERIFY_READ, value, sizeof(int));
  22524. +    if (error)
  22525. +        return error;
  22526. +    arg = get_fs_long((unsigned long *) value);
  22527. +    switch (cmd) {
  22528. +    case TIOCMBIS: 
  22529. +        if (arg & TIOCM_RTS) {
  22530. +            info->MCR |= UART_MCR_RTS;
  22531. +            info->MCR_noint |= UART_MCR_RTS;
  22532. +        }
  22533. +        if (arg & TIOCM_DTR) {
  22534. +            info->MCR |= UART_MCR_DTR;
  22535. +            info->MCR_noint |= UART_MCR_DTR;
  22536. +        }
  22537. +        break;
  22538. +    case TIOCMBIC:
  22539. +        if (arg & TIOCM_RTS) {
  22540. +            info->MCR &= ~UART_MCR_RTS;
  22541. +            info->MCR_noint &= ~UART_MCR_RTS;
  22542. +        }
  22543. +        if (arg & TIOCM_DTR) {
  22544. +            info->MCR &= ~UART_MCR_DTR;
  22545. +            info->MCR_noint &= ~UART_MCR_DTR;
  22546. +        }
  22547. +        break;
  22548. +    case TIOCMSET:
  22549. +        info->MCR = ((info->MCR & ~(UART_MCR_RTS | UART_MCR_DTR))
  22550. +                 | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
  22551. +                 | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  22552. +        info->MCR_noint = ((info->MCR_noint
  22553. +                    & ~(UART_MCR_RTS | UART_MCR_DTR))
  22554. +                   | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
  22555. +                   | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  22556. +        break;
  22557. +    default:
  22558. +        return -EINVAL;
  22559. +    }
  22560. +    cli();
  22561. +    serial_out(info, UART_MCR, info->MCR);
  22562. +    sti();
  22563. +    return 0;
  22564. +}
  22565. +
  22566. +static int do_autoconfig(struct async_struct * info)
  22567. +{
  22568. +    int            retval;
  22569. +    
  22570. +    if (!suser())
  22571. +        return -EPERM;
  22572. +    
  22573. +    if (info->count > 1)
  22574. +        return -EBUSY;
  22575. +    
  22576. +    shutdown(info);
  22577. +
  22578. +    cli();
  22579. +    autoconfig(info);
  22580. +    sti();
  22581. +
  22582. +    retval = startup(info);
  22583. +    if (retval)
  22584. +        return retval;
  22585. +    return 0;
  22586. +}
  22587. +
  22588. +
  22589. +/*
  22590. + * This routine sends a break character out the serial port.
  22591. + */
  22592. +static void send_break(    struct async_struct * info, int duration)
  22593. +{
  22594. +    if (!info->port)
  22595. +        return;
  22596. +    current->state = TASK_INTERRUPTIBLE;
  22597. +    current->timeout = jiffies + duration;
  22598. +    cli();
  22599. +    serial_out(info, UART_LCR, serial_inp(info, UART_LCR) | UART_LCR_SBC);
  22600. +    schedule();
  22601. +    serial_out(info, UART_LCR, serial_inp(info, UART_LCR) & ~UART_LCR_SBC);
  22602. +    sti();
  22603. +}
  22604. +
  22605. +/*
  22606. + * This routine returns a bitfield of "wild interrupts".  Basically,
  22607. + * any unclaimed interrupts which is flapping around.
  22608. + */
  22609. +static int check_wild_interrupts(int doprint)
  22610. +{
  22611. +    int    i, mask;
  22612. +    int    wild_interrupts = 0;
  22613. +    int    irq_lines;
  22614. +    unsigned long timeout;
  22615. +    unsigned long flags;
  22616. +    
  22617. +    /* Turn on interrupts (they may be off) */
  22618. +    save_flags(flags); sti();
  22619. +
  22620. +    irq_lines = grab_all_interrupts(0);
  22621. +    
  22622. +    /*
  22623. +     * Delay for 0.1 seconds -- we use a busy loop since this may 
  22624. +     * occur during the bootup sequence
  22625. +     */
  22626. +    timeout = jiffies+10;
  22627. +    while (timeout >= jiffies)
  22628. +        ;
  22629. +    
  22630. +    rs_triggered = 0;    /* Reset after letting things settle */
  22631. +
  22632. +    timeout = jiffies+10;
  22633. +    while (timeout >= jiffies)
  22634. +        ;
  22635. +    
  22636. +    for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
  22637. +        if ((rs_triggered & (1 << i)) &&
  22638. +            (irq_lines & (1 << i))) {
  22639. +            wild_interrupts |= mask;
  22640. +            if (doprint)
  22641. +                printk("Wild interrupt?  (IRQ %d)\n", i);
  22642. +        }
  22643. +    }
  22644. +    free_all_interrupts(irq_lines);
  22645. +    restore_flags(flags);
  22646. +    return wild_interrupts;
  22647. +}
  22648. +
  22649. +static int get_multiport_struct(struct async_struct * info,
  22650. +                struct serial_multiport_struct *retinfo)
  22651. +{
  22652. +    struct serial_multiport_struct ret;
  22653. +    struct rs_multiport_struct *multi;
  22654. +    
  22655. +    multi = &rs_multiport[info->irq];
  22656. +
  22657. +    ret.port_monitor = multi->port_monitor;
  22658. +    
  22659. +    ret.port1 = multi->port1;
  22660. +    ret.mask1 = multi->mask1;
  22661. +    ret.match1 = multi->match1;
  22662. +    
  22663. +    ret.port2 = multi->port2;
  22664. +    ret.mask2 = multi->mask2;
  22665. +    ret.match2 = multi->match2;
  22666. +    
  22667. +    ret.port3 = multi->port3;
  22668. +    ret.mask3 = multi->mask3;
  22669. +    ret.match3 = multi->match3;
  22670. +    
  22671. +    ret.port4 = multi->port4;
  22672. +    ret.mask4 = multi->mask4;
  22673. +    ret.match4 = multi->match4;
  22674. +
  22675. +    ret.irq = info->irq;
  22676. +
  22677. +    memcpy_tofs(retinfo,&ret,sizeof(*retinfo));
  22678. +    return 0;
  22679. +    
  22680. +}
  22681. +
  22682. +static int set_multiport_struct(struct async_struct * info,
  22683. +                struct serial_multiport_struct *in_multi)
  22684. +{
  22685. +    struct serial_multiport_struct new_multi;
  22686. +    struct rs_multiport_struct *multi;
  22687. +    int    was_multi, now_multi;
  22688. +    int    retval;
  22689. +    void (*handler)(int, struct pt_regs *);
  22690. +
  22691. +    if (!suser())
  22692. +        return -EPERM;
  22693. +    if (!in_multi)
  22694. +        return -EFAULT;
  22695. +    memcpy_fromfs(&new_multi, in_multi,
  22696. +              sizeof(struct serial_multiport_struct));
  22697. +
  22698. +    if (new_multi.irq != info->irq || info->irq == 0 ||
  22699. +        !IRQ_ports[info->irq])
  22700. +        return -EINVAL;
  22701. +
  22702. +    multi = &rs_multiport[info->irq];
  22703. +    was_multi = (multi->port1 != 0);
  22704. +    
  22705. +    multi->port_monitor = new_multi.port_monitor;
  22706. +    
  22707. +    multi->port1 = new_multi.port1;
  22708. +    multi->mask1 = new_multi.mask1;
  22709. +    multi->match1 = new_multi.match1;
  22710. +
  22711. +    multi->port2 = new_multi.port2;
  22712. +    multi->mask2 = new_multi.mask2;
  22713. +    multi->match2 = new_multi.match2;
  22714. +
  22715. +    multi->port3 = new_multi.port3;
  22716. +    multi->mask3 = new_multi.mask3;
  22717. +    multi->match3 = new_multi.match3;
  22718. +
  22719. +    multi->port4 = new_multi.port4;
  22720. +    multi->mask4 = new_multi.mask4;
  22721. +    multi->match4 = new_multi.match4;
  22722. +
  22723. +    now_multi = (multi->port1 != 0);
  22724. +    
  22725. +    if (IRQ_ports[info->irq]->next_port &&
  22726. +        (was_multi != now_multi)) {
  22727. +        free_irq(info->irq);
  22728. +        if (now_multi)
  22729. +            handler = rs_interrupt_multi;
  22730. +        else
  22731. +            handler = rs_interrupt;
  22732. +
  22733. +        retval = request_irq(info->irq, handler, SA_INTERRUPT,
  22734. +                     "serial");
  22735. +        if (retval) {
  22736. +            printk("Couldn't reallocate serial interrupt "
  22737. +                   "driver!!\n");
  22738. +        }
  22739. +    }
  22740. +
  22741. +    return 0;
  22742. +}
  22743. +
  22744. +static int rs_ioctl(struct tty_struct *tty, struct file * file,
  22745. +            unsigned int cmd, unsigned long arg)
  22746. +{
  22747. +    int error;
  22748. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  22749. +    int retval;
  22750. +
  22751. +    if (serial_paranoia_check(info, tty->device, "rs_ioctl"))
  22752. +        return -ENODEV;
  22753. +
  22754. +    if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
  22755. +        (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
  22756. +        (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
  22757. +        if (tty->flags & (1 << TTY_IO_ERROR))
  22758. +            return -EIO;
  22759. +    }
  22760. +    
  22761. +    switch (cmd) {
  22762. +        case TCSBRK:    /* SVID version: non-zero arg --> no break */
  22763. +            retval = tty_check_change(tty);
  22764. +            if (retval)
  22765. +                return retval;
  22766. +            tty_wait_until_sent(tty, 0);
  22767. +            if (!arg)
  22768. +                send_break(info, HZ/4);    /* 1/4 second */
  22769. +            return 0;
  22770. +        case TCSBRKP:    /* support for POSIX tcsendbreak() */
  22771. +            retval = tty_check_change(tty);
  22772. +            if (retval)
  22773. +                return retval;
  22774. +            tty_wait_until_sent(tty, 0);
  22775. +            send_break(info, arg ? arg*(HZ/10) : HZ/4);
  22776. +            return 0;
  22777. +        case TIOCGSOFTCAR:
  22778. +            error = verify_area(VERIFY_WRITE, (void *) arg,sizeof(long));
  22779. +            if (error)
  22780. +                return error;
  22781. +            put_fs_long(C_CLOCAL(tty) ? 1 : 0,
  22782. +                    (unsigned long *) arg);
  22783. +            return 0;
  22784. +        case TIOCSSOFTCAR:
  22785. +            arg = get_fs_long((unsigned long *) arg);
  22786. +            tty->termios->c_cflag =
  22787. +                ((tty->termios->c_cflag & ~CLOCAL) |
  22788. +                 (arg ? CLOCAL : 0));
  22789. +            return 0;
  22790. +        case TIOCMGET:
  22791. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  22792. +                sizeof(unsigned int));
  22793. +            if (error)
  22794. +                return error;
  22795. +            return get_modem_info(info, (unsigned int *) arg);
  22796. +        case TIOCMBIS:
  22797. +        case TIOCMBIC:
  22798. +        case TIOCMSET:
  22799. +            return set_modem_info(info, cmd, (unsigned int *) arg);
  22800. +        case TIOCGSERIAL:
  22801. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  22802. +                        sizeof(struct serial_struct));
  22803. +            if (error)
  22804. +                return error;
  22805. +            return get_serial_info(info,
  22806. +                           (struct serial_struct *) arg);
  22807. +        case TIOCSSERIAL:
  22808. +            return set_serial_info(info,
  22809. +                           (struct serial_struct *) arg);
  22810. +        case TIOCSERCONFIG:
  22811. +            return do_autoconfig(info);
  22812. +
  22813. +        case TIOCSERGWILD:
  22814. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  22815. +                        sizeof(int));
  22816. +            if (error)
  22817. +                return error;
  22818. +            put_fs_long(rs_wild_int_mask, (unsigned long *) arg);
  22819. +            return 0;
  22820. +
  22821. +        case TIOCSERGETLSR: /* Get line status register */
  22822. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  22823. +                sizeof(unsigned int));
  22824. +            if (error)
  22825. +                return error;
  22826. +            else
  22827. +                return get_lsr_info(info, (unsigned int *) arg);
  22828. +
  22829. +        case TIOCSERSWILD:
  22830. +            if (!suser())
  22831. +                return -EPERM;
  22832. +            rs_wild_int_mask = get_fs_long((unsigned long *) arg);
  22833. +            if (rs_wild_int_mask < 0)
  22834. +                rs_wild_int_mask = check_wild_interrupts(0);
  22835. +            return 0;
  22836. +
  22837. +        case TIOCSERGSTRUCT:
  22838. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  22839. +                        sizeof(struct async_struct));
  22840. +            if (error)
  22841. +                return error;
  22842. +            memcpy_tofs((struct async_struct *) arg,
  22843. +                    info, sizeof(struct async_struct));
  22844. +            return 0;
  22845. +            
  22846. +        case TIOCSERGETMULTI:
  22847. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  22848. +                    sizeof(struct serial_multiport_struct));
  22849. +            if (error)
  22850. +                return error;
  22851. +            return get_multiport_struct(info,
  22852. +                       (struct serial_multiport_struct *) arg);
  22853. +        case TIOCSERSETMULTI:
  22854. +            return set_multiport_struct(info,
  22855. +                       (struct serial_multiport_struct *) arg);
  22856. +        default:
  22857. +            return -ENOIOCTLCMD;
  22858. +        }
  22859. +    return 0;
  22860. +}
  22861. +
  22862. +static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
  22863. +{
  22864. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  22865. +
  22866. +    if (tty->termios->c_cflag == old_termios->c_cflag)
  22867. +        return;
  22868. +
  22869. +    change_speed(info);
  22870. +
  22871. +    if ((old_termios->c_cflag & CRTSCTS) &&
  22872. +        !(tty->termios->c_cflag & CRTSCTS)) {
  22873. +        tty->hw_stopped = 0;
  22874. +        rs_start(tty);
  22875. +    }
  22876. +
  22877. +#if 0
  22878. +    /*
  22879. +     * No need to wake up processes in open wait, since they
  22880. +     * sample the CLOCAL flag once, and don't recheck it.
  22881. +     * XXX  It's not clear whether the current behavior is correct
  22882. +     * or not.  Hence, this may change.....
  22883. +     */
  22884. +    if (!(old_termios->c_cflag & CLOCAL) &&
  22885. +        (tty->termios->c_cflag & CLOCAL))
  22886. +        wake_up_interruptible(&info->open_wait);
  22887. +#endif
  22888. +}
  22889. +
  22890. +/*
  22891. + * ------------------------------------------------------------
  22892. + * rs_close()
  22893. + * 
  22894. + * This routine is called when the serial port gets closed.  First, we
  22895. + * wait for the last remaining data to be sent.  Then, we unlink its
  22896. + * async structure from the interrupt chain if necessary, and we free
  22897. + * that IRQ if nothing is left in the chain.
  22898. + * ------------------------------------------------------------
  22899. + */
  22900. +static void rs_close(struct tty_struct *tty, struct file * filp)
  22901. +{
  22902. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  22903. +    unsigned long flags;
  22904. +    unsigned long timeout;
  22905. +
  22906. +    if (!info || serial_paranoia_check(info, tty->device, "rs_close"))
  22907. +        return;
  22908. +    
  22909. +    save_flags(flags); cli();
  22910. +    
  22911. +    if (tty_hung_up_p(filp)) {
  22912. +        restore_flags(flags);
  22913. +        return;
  22914. +    }
  22915. +    
  22916. +#ifdef SERIAL_DEBUG_OPEN
  22917. +    printk("rs_close ttys%d, count = %d\n", info->line, info->count);
  22918. +#endif
  22919. +    if ((tty->count == 1) && (info->count != 1)) {
  22920. +        /*
  22921. +         * Uh, oh.  tty->count is 1, which means that the tty
  22922. +         * structure will be freed.  Info->count should always
  22923. +         * be one in these conditions.  If it's greater than
  22924. +         * one, we've got real problems, since it means the
  22925. +         * serial port won't be shutdown.
  22926. +         */
  22927. +        printk("rs_close: bad serial port count; tty->count is 1, "
  22928. +               "info->count is %d\n", info->count);
  22929. +        info->count = 1;
  22930. +    }
  22931. +    if (--info->count < 0) {
  22932. +        printk("rs_close: bad serial port count for ttys%d: %d\n",
  22933. +               info->line, info->count);
  22934. +        info->count = 0;
  22935. +    }
  22936. +    if (info->count) {
  22937. +        restore_flags(flags);
  22938. +        return;
  22939. +    }
  22940. +    info->flags |= ASYNC_CLOSING;
  22941. +    /*
  22942. +     * Save the termios structure, since this port may have
  22943. +     * separate termios for callout and dialin.
  22944. +     */
  22945. +    if (info->flags & ASYNC_NORMAL_ACTIVE)
  22946. +        info->normal_termios = *tty->termios;
  22947. +    if (info->flags & ASYNC_CALLOUT_ACTIVE)
  22948. +        info->callout_termios = *tty->termios;
  22949. +    /*
  22950. +     * Now we wait for the transmit buffer to clear; and we notify 
  22951. +     * the line discipline to only process XON/XOFF characters.
  22952. +     */
  22953. +    tty->closing = 1;
  22954. +    if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  22955. +        tty_wait_until_sent(tty, info->closing_wait);
  22956. +    /*
  22957. +     * At this point we stop accepting input.  To do this, we
  22958. +     * disable the receive line status interrupts, and tell the
  22959. +     * interrupt driver to stop checking the data ready bit in the
  22960. +     * line status register.
  22961. +     */
  22962. +    info->IER &= ~UART_IER_RLSI;
  22963. +    info->read_status_mask &= ~UART_LSR_DR;
  22964. +    if (info->flags & ASYNC_INITIALIZED) {
  22965. +        serial_out(info, UART_IER, info->IER);
  22966. +        /*
  22967. +         * Before we drop DTR, make sure the UART transmitter
  22968. +         * has completely drained; this is especially
  22969. +         * important if there is a transmit FIFO!
  22970. +         */
  22971. +        timeout = jiffies+HZ;
  22972. +        while (!(serial_inp(info, UART_LSR) & UART_LSR_TEMT)) {
  22973. +            current->state = TASK_INTERRUPTIBLE;
  22974. +            current->timeout = jiffies + info->timeout;
  22975. +            schedule();
  22976. +            if (jiffies > timeout)
  22977. +                break;
  22978. +        }
  22979. +    }
  22980. +    shutdown(info);
  22981. +    if (tty->driver.flush_buffer)
  22982. +        tty->driver.flush_buffer(tty);
  22983. +    if (tty->ldisc.flush_buffer)
  22984. +        tty->ldisc.flush_buffer(tty);
  22985. +    tty->closing = 0;
  22986. +    info->event = 0;
  22987. +    info->tty = 0;
  22988. +    if (tty->ldisc.num != ldiscs[N_TTY].num) {
  22989. +        if (tty->ldisc.close)
  22990. +            (tty->ldisc.close)(tty);
  22991. +        tty->ldisc = ldiscs[N_TTY];
  22992. +        tty->termios->c_line = N_TTY;
  22993. +        if (tty->ldisc.open)
  22994. +            (tty->ldisc.open)(tty);
  22995. +    }
  22996. +    if (info->blocked_open) {
  22997. +        if (info->close_delay) {
  22998. +            current->state = TASK_INTERRUPTIBLE;
  22999. +            current->timeout = jiffies + info->close_delay;
  23000. +            schedule();
  23001. +        }
  23002. +        wake_up_interruptible(&info->open_wait);
  23003. +    }
  23004. +    info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  23005. +             ASYNC_CLOSING);
  23006. +    wake_up_interruptible(&info->close_wait);
  23007. +    restore_flags(flags);
  23008. +}
  23009. +
  23010. +/*
  23011. + * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
  23012. + */
  23013. +void rs_hangup(struct tty_struct *tty)
  23014. +{
  23015. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  23016. +    
  23017. +    if (serial_paranoia_check(info, tty->device, "rs_hangup"))
  23018. +        return;
  23019. +    
  23020. +    rs_flush_buffer(tty);
  23021. +    shutdown(info);
  23022. +    info->event = 0;
  23023. +    info->count = 0;
  23024. +    info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  23025. +    info->tty = 0;
  23026. +    wake_up_interruptible(&info->open_wait);
  23027. +}
  23028. +
  23029. +/*
  23030. + * ------------------------------------------------------------
  23031. + * rs_open() and friends
  23032. + * ------------------------------------------------------------
  23033. + */
  23034. +static int block_til_ready(struct tty_struct *tty, struct file * filp,
  23035. +               struct async_struct *info)
  23036. +{
  23037. +    struct wait_queue wait = { current, NULL };
  23038. +    int        retval;
  23039. +    int        do_clocal = 0;
  23040. +
  23041. +    /*
  23042. +     * If the device is in the middle of being closed, then block
  23043. +     * until it's done, and then try again.
  23044. +     */
  23045. +    if (info->flags & ASYNC_CLOSING) {
  23046. +        interruptible_sleep_on(&info->close_wait);
  23047. +#ifdef SERIAL_DO_RESTART
  23048. +        if (info->flags & ASYNC_HUP_NOTIFY)
  23049. +            return -EAGAIN;
  23050. +        else
  23051. +            return -ERESTARTSYS;
  23052. +#else
  23053. +        return -EAGAIN;
  23054. +#endif
  23055. +    }
  23056. +
  23057. +    /*
  23058. +     * If this is a callout device, then just make sure the normal
  23059. +     * device isn't being used.
  23060. +     */
  23061. +    if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  23062. +        if (info->flags & ASYNC_NORMAL_ACTIVE)
  23063. +            return -EBUSY;
  23064. +        if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  23065. +            (info->flags & ASYNC_SESSION_LOCKOUT) &&
  23066. +            (info->session != current->session))
  23067. +            return -EBUSY;
  23068. +        if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  23069. +            (info->flags & ASYNC_PGRP_LOCKOUT) &&
  23070. +            (info->pgrp != current->pgrp))
  23071. +            return -EBUSY;
  23072. +        info->flags |= ASYNC_CALLOUT_ACTIVE;
  23073. +        return 0;
  23074. +    }
  23075. +    
  23076. +    /*
  23077. +     * If non-blocking mode is set, or the port is not enabled,
  23078. +     * then make the check up front and then exit.
  23079. +     */
  23080. +    if ((filp->f_flags & O_NONBLOCK) ||
  23081. +        (tty->flags & (1 << TTY_IO_ERROR))) {
  23082. +        if (info->flags & ASYNC_CALLOUT_ACTIVE)
  23083. +            return -EBUSY;
  23084. +        info->flags |= ASYNC_NORMAL_ACTIVE;
  23085. +        return 0;
  23086. +    }
  23087. +
  23088. +    if (info->flags & ASYNC_CALLOUT_ACTIVE) {
  23089. +        if (info->normal_termios.c_cflag & CLOCAL)
  23090. +            do_clocal = 1;
  23091. +    } else {
  23092. +        if (tty->termios->c_cflag & CLOCAL)
  23093. +            do_clocal = 1;
  23094. +    }
  23095. +    
  23096. +    /*
  23097. +     * Block waiting for the carrier detect and the line to become
  23098. +     * free (i.e., not in use by the callout).  While we are in
  23099. +     * this loop, info->count is dropped by one, so that
  23100. +     * rs_close() knows when to free things.  We restore it upon
  23101. +     * exit, either normal or abnormal.
  23102. +     */
  23103. +    retval = 0;
  23104. +    add_wait_queue(&info->open_wait, &wait);
  23105. +#ifdef SERIAL_DEBUG_OPEN
  23106. +    printk("block_til_ready before block: ttys%d, count = %d\n",
  23107. +           info->line, info->count);
  23108. +#endif
  23109. +    info->count--;
  23110. +    info->blocked_open++;
  23111. +    while (1) {
  23112. +        cli();
  23113. +        if (!(info->flags & ASYNC_CALLOUT_ACTIVE))
  23114. +            serial_out(info, UART_MCR,
  23115. +                   serial_inp(info, UART_MCR) |
  23116. +                   (UART_MCR_DTR | UART_MCR_RTS));
  23117. +        sti();
  23118. +        current->state = TASK_INTERRUPTIBLE;
  23119. +        if (tty_hung_up_p(filp) ||
  23120. +            !(info->flags & ASYNC_INITIALIZED)) {
  23121. +#ifdef SERIAL_DO_RESTART
  23122. +            if (info->flags & ASYNC_HUP_NOTIFY)
  23123. +                retval = -EAGAIN;
  23124. +            else
  23125. +                retval = -ERESTARTSYS;    
  23126. +#else
  23127. +            retval = -EAGAIN;
  23128. +#endif
  23129. +            break;
  23130. +        }
  23131. +        if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  23132. +            !(info->flags & ASYNC_CLOSING) &&
  23133. +            (do_clocal || (serial_in(info, UART_MSR) &
  23134. +                   UART_MSR_DCD)))
  23135. +            break;
  23136. +        if (current->signal & ~current->blocked) {
  23137. +            retval = -ERESTARTSYS;
  23138. +            break;
  23139. +        }
  23140. +#ifdef SERIAL_DEBUG_OPEN
  23141. +        printk("block_til_ready blocking: ttys%d, count = %d\n",
  23142. +               info->line, info->count);
  23143. +#endif
  23144. +        schedule();
  23145. +    }
  23146. +    current->state = TASK_RUNNING;
  23147. +    remove_wait_queue(&info->open_wait, &wait);
  23148. +    if (!tty_hung_up_p(filp))
  23149. +        info->count++;
  23150. +    info->blocked_open--;
  23151. +#ifdef SERIAL_DEBUG_OPEN
  23152. +    printk("block_til_ready after blocking: ttys%d, count = %d\n",
  23153. +           info->line, info->count);
  23154. +#endif
  23155. +    if (retval)
  23156. +        return retval;
  23157. +    info->flags |= ASYNC_NORMAL_ACTIVE;
  23158. +    return 0;
  23159. +}    
  23160. +
  23161. +/*
  23162. + * This routine is called whenever a serial port is opened.  It
  23163. + * enables interrupts for a serial port, linking in its async structure into
  23164. + * the IRQ chain.   It also performs the serial-specific
  23165. + * initialization for the tty structure.
  23166. + */
  23167. +int rs_open(struct tty_struct *tty, struct file * filp)
  23168. +{
  23169. +    struct async_struct    *info;
  23170. +    int             retval, line;
  23171. +
  23172. +    line = MINOR(tty->device) - tty->driver.minor_start;
  23173. +    if ((line < 0) || (line >= NR_PORTS))
  23174. +        return -ENODEV;
  23175. +    info = rs_table + line;
  23176. +    if (serial_paranoia_check(info, tty->device, "rs_open"))
  23177. +        return -ENODEV;
  23178. +
  23179. +#ifdef SERIAL_DEBUG_OPEN
  23180. +    printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
  23181. +           info->count);
  23182. +#endif
  23183. +    info->count++;
  23184. +    tty->driver_data = info;
  23185. +    info->tty = tty;
  23186. +
  23187. +    if (!tmp_buf) {
  23188. +        tmp_buf = (unsigned char *) get_free_page(GFP_KERNEL);
  23189. +        if (!tmp_buf)
  23190. +            return -ENOMEM;
  23191. +    }
  23192. +    
  23193. +    /*
  23194. +     * Start up serial port
  23195. +     */
  23196. +    retval = startup(info);
  23197. +    if (retval)
  23198. +        return retval;
  23199. +
  23200. +    retval = block_til_ready(tty, filp, info);
  23201. +    if (retval) {
  23202. +#ifdef SERIAL_DEBUG_OPEN
  23203. +        printk("rs_open returning after block_til_ready with %d\n",
  23204. +               retval);
  23205. +#endif
  23206. +        return retval;
  23207. +    }
  23208. +
  23209. +    if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
  23210. +        if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  23211. +            *tty->termios = info->normal_termios;
  23212. +        else 
  23213. +            *tty->termios = info->callout_termios;
  23214. +        change_speed(info);
  23215. +    }
  23216. +
  23217. +    info->session = current->session;
  23218. +    info->pgrp = current->pgrp;
  23219. +
  23220. +#ifdef SERIAL_DEBUG_OPEN
  23221. +    printk("rs_open ttys%d successful...", info->line);
  23222. +#endif
  23223. +    return 0;
  23224. +}
  23225. +
  23226. +/*
  23227. + * ---------------------------------------------------------------------
  23228. + * rs_init() and friends
  23229. + *
  23230. + * rs_init() is called at boot-time to initialize the serial driver.
  23231. + * ---------------------------------------------------------------------
  23232. + */
  23233. +
  23234. +/*
  23235. + * This routine prints out the appropriate serial driver version
  23236. + * number, and identifies which options were configured into this
  23237. + * driver.
  23238. + */
  23239. +static void show_serial_version(void)
  23240. +{
  23241. +    printk("Serial driver version 4.11 with");
  23242. +#ifdef CONFIG_HUB6
  23243. +    printk(" HUB-6");
  23244. +#define SERIAL_OPT
  23245. +#endif
  23246. +#ifdef SERIAL_OPT
  23247. +    printk(" enabled\n");
  23248. +#else
  23249. +    printk(" no serial options enabled\n");
  23250. +#endif
  23251. +#undef SERIAL_OPT
  23252. +}
  23253. +
  23254. +/*
  23255. + * This routine is called by do_auto_irq(); it attempts to determine
  23256. + * which interrupt a serial port is configured to use.  It is not
  23257. + * fool-proof, but it works a large part of the time.
  23258. + */
  23259. +static int get_auto_irq(struct async_struct *info)
  23260. +{
  23261. +    unsigned char save_MCR, save_IER, save_ICP=0;
  23262. +    unsigned short ICP=0, port = info->port;
  23263. +    unsigned long timeout;
  23264. +    
  23265. +    /*
  23266. +     * Enable interrupts and see who answers
  23267. +     */
  23268. +    rs_irq_triggered = 0;
  23269. +    cli();
  23270. +    save_IER = serial_inp(info, UART_IER);
  23271. +    save_MCR = serial_inp(info, UART_MCR);
  23272. +    if (info->flags & ASYNC_FOURPORT)  {
  23273. +        serial_outp(info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
  23274. +        serial_outp(info, UART_IER, 0x0f);    /* enable all intrs */
  23275. +        ICP = (port & 0xFE0) | 0x01F;
  23276. +        save_ICP = inb_p(ICP);
  23277. +        outb_p(0x80, ICP);
  23278. +        (void) inb_p(ICP);
  23279. +    } else {
  23280. +        serial_outp(info, UART_MCR,
  23281. +                UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
  23282. +        serial_outp(info, UART_IER, 0x0f);    /* enable all intrs */
  23283. +    }
  23284. +    sti();
  23285. +    /*
  23286. +     * Next, clear the interrupt registers.
  23287. +     */
  23288. +    (void)serial_inp(info, UART_LSR);
  23289. +    (void)serial_inp(info, UART_RX);
  23290. +    (void)serial_inp(info, UART_IIR);
  23291. +    (void)serial_inp(info, UART_MSR);
  23292. +    
  23293. +    timeout = jiffies+2;
  23294. +    while (timeout >= jiffies) {
  23295. +        if (rs_irq_triggered)
  23296. +            break;
  23297. +    }
  23298. +    /*
  23299. +     * Now check to see if we got any business, and clean up.
  23300. +     */
  23301. +    cli();
  23302. +    serial_outp(info, UART_IER, save_IER);
  23303. +    serial_outp(info, UART_MCR, save_MCR);
  23304. +    if (info->flags & ASYNC_FOURPORT)
  23305. +        outb_p(save_ICP, ICP);
  23306. +    sti();
  23307. +    return(rs_irq_triggered);
  23308. +}
  23309. +
  23310. +/*
  23311. + * Calls get_auto_irq() multiple times, to make sure we don't get
  23312. + * faked out by random interrupts
  23313. + */
  23314. +static int do_auto_irq(struct async_struct * info)
  23315. +{
  23316. +    unsigned         port = info->port;
  23317. +    int             irq_lines = 0;
  23318. +    int            irq_try_1 = 0, irq_try_2 = 0;
  23319. +    int            retries;
  23320. +    unsigned long flags;
  23321. +
  23322. +    if (!port)
  23323. +        return 0;
  23324. +
  23325. +    /* Turn on interrupts (they may be off) */
  23326. +    save_flags(flags); sti();
  23327. +
  23328. +    irq_lines = grab_all_interrupts(rs_wild_int_mask);
  23329. +    
  23330. +    for (retries = 0; retries < 5; retries++) {
  23331. +        if (!irq_try_1)
  23332. +            irq_try_1 = get_auto_irq(info);
  23333. +        if (!irq_try_2)
  23334. +            irq_try_2 = get_auto_irq(info);
  23335. +        if (irq_try_1 && irq_try_2) {
  23336. +            if (irq_try_1 == irq_try_2)
  23337. +                break;
  23338. +            irq_try_1 = irq_try_2 = 0;
  23339. +        }
  23340. +    }
  23341. +    restore_flags(flags);
  23342. +    free_all_interrupts(irq_lines);
  23343. +    return (irq_try_1 == irq_try_2) ? irq_try_1 : 0;
  23344. +}
  23345. +
  23346. +/*
  23347. + * This routine is called by rs_init() to initialize a specific serial
  23348. + * port.  It determines what type of UART ship this serial port is
  23349. + * using: 8250, 16450, 16550, 16550A.  The important question is
  23350. + * whether or not this UART is a 16550A or not, since this will
  23351. + * determine whether or not we can use its FIFO features or not.
  23352. + */
  23353. +static void autoconfig(struct async_struct * info)
  23354. +{
  23355. +    unsigned char status1, status2, scratch, scratch2;
  23356. +    unsigned port = info->port;
  23357. +    unsigned long flags;
  23358. +
  23359. +    info->type = PORT_UNKNOWN;
  23360. +    
  23361. +    if (!port)
  23362. +        return;
  23363. +
  23364. +    save_flags(flags); cli();
  23365. +    
  23366. +    /*
  23367. +     * Do a simple existence test first; if we fail this, there's
  23368. +     * no point trying anything else.
  23369. +     *
  23370. +     * 0x80 is used as a nonsense port to prevent against false
  23371. +     * positives due to ISA bus float.  The assumption is that
  23372. +     * 0x80 is a non-existent port; which should be safe since
  23373. +     * include/asm/io.h also makes this assumption.
  23374. +     */
  23375. +    scratch = serial_inp(info, UART_IER);
  23376. +    serial_outp(info, UART_IER, 0);
  23377. +    outb(0xff, 0x080);
  23378. +    scratch2 = serial_inp(info, UART_IER);
  23379. +    serial_outp(info, UART_IER, scratch);
  23380. +    if (scratch2) {
  23381. +        restore_flags(flags);
  23382. +        return;        /* We failed; there's nothing here */
  23383. +    }
  23384. +
  23385. +    /* 
  23386. +     * Check to see if a UART is really there.  Certain broken
  23387. +     * internal modems based on the Rockwell chipset fail this
  23388. +     * test, because they apparently don't implement the loopback
  23389. +     * test mode.  So this test is skipped on the COM 1 through
  23390. +     * COM 4 ports.  This *should* be safe, since no board
  23391. +     * manufacturer would be stupid enough to design a board
  23392. +     * that conflicts with COM 1-4 --- we hope!
  23393. +     */
  23394. +    if (!(info->flags & ASYNC_SKIP_TEST)) {
  23395. +        scratch = serial_inp(info, UART_MCR);
  23396. +        serial_outp(info, UART_MCR, UART_MCR_LOOP | scratch);
  23397. +        scratch2 = serial_inp(info, UART_MSR);
  23398. +        serial_outp(info, UART_MCR, UART_MCR_LOOP | 0x0A);
  23399. +        status1 = serial_inp(info, UART_MSR) & 0xF0;
  23400. +        serial_outp(info, UART_MCR, scratch);
  23401. +        serial_outp(info, UART_MSR, scratch2);
  23402. +        if (status1 != 0x90) {
  23403. +            restore_flags(flags);
  23404. +            return;
  23405. +        }
  23406. +    } 
  23407. +    
  23408. +    /*
  23409. +     * If the AUTO_IRQ flag is set, try to do the automatic IRQ
  23410. +     * detection.
  23411. +     */
  23412. +    if (info->flags & ASYNC_AUTO_IRQ)
  23413. +        info->irq = do_auto_irq(info);
  23414. +        
  23415. +    scratch2 = serial_in(info, UART_LCR);
  23416. +    serial_outp(info, UART_LCR, scratch2 | UART_LCR_DLAB);
  23417. +    serial_outp(info, UART_EFR, 0);    /* EFR is the same as FCR */
  23418. +    serial_outp(info, UART_LCR, scratch2);
  23419. +    serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO);
  23420. +    scratch = serial_in(info, UART_IIR) >> 6;
  23421. +    info->xmit_fifo_size = 1;
  23422. +    switch (scratch) {
  23423. +        case 0:
  23424. +            info->type = PORT_16450;
  23425. +            break;
  23426. +        case 1:
  23427. +            info->type = PORT_UNKNOWN;
  23428. +            break;
  23429. +        case 2:
  23430. +            info->type = PORT_16550;
  23431. +            break;
  23432. +        case 3:
  23433. +            serial_outp(info, UART_LCR, scratch2 | UART_LCR_DLAB);
  23434. +            if (serial_in(info, UART_EFR) == 0) {
  23435. +                info->type = PORT_16650;
  23436. +                info->xmit_fifo_size = 32;
  23437. +            } else {
  23438. +                info->type = PORT_16550A;
  23439. +                info->xmit_fifo_size = 16;
  23440. +            }
  23441. +            serial_outp(info, UART_LCR, scratch2);
  23442. +            break;
  23443. +    }
  23444. +    if (info->type == PORT_16450) {
  23445. +        scratch = serial_in(info, UART_SCR);
  23446. +        serial_outp(info, UART_SCR, 0xa5);
  23447. +        status1 = serial_in(info, UART_SCR);
  23448. +        serial_outp(info, UART_SCR, 0x5a);
  23449. +        status2 = serial_in(info, UART_SCR);
  23450. +        serial_outp(info, UART_SCR, scratch);
  23451. +
  23452. +        if ((status1 != 0xa5) || (status2 != 0x5a))
  23453. +            info->type = PORT_8250;
  23454. +    }
  23455. +    request_region(info->port,8,"serial(auto)");
  23456. +
  23457. +    /*
  23458. +     * Reset the UART.
  23459. +     */
  23460. +#ifdef __alpha__
  23461. +    /*
  23462. +     * I wonder what DEC did to the OUT1 and OUT2 lines?
  23463. +     * clearing them results in endless interrupts.
  23464. +     */
  23465. +    serial_outp(info, UART_MCR, 0x0c);
  23466. +#else
  23467. +    serial_outp(info, UART_MCR, 0x00);
  23468. +#endif
  23469. +    serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  23470. +                     UART_FCR_CLEAR_XMIT));
  23471. +    (void)serial_in(info, UART_RX);
  23472. +    
  23473. +    restore_flags(flags);
  23474. +}
  23475. +
  23476. +/*
  23477. + * The serial driver boot-time initialization code!
  23478. + */
  23479. +long rs_init(long kmem_start)
  23480. +{
  23481. +    int i;
  23482. +    struct async_struct * info;
  23483. +    
  23484. +    bh_base[SERIAL_BH].routine = do_serial_bh;
  23485. +    enable_bh(SERIAL_BH);
  23486. +    timer_table[RS_TIMER].fn = rs_timer;
  23487. +    timer_table[RS_TIMER].expires = 0;
  23488. +#ifdef CONFIG_AUTO_IRQ
  23489. +    rs_wild_int_mask = check_wild_interrupts(1);
  23490. +#endif
  23491. +
  23492. +    for (i = 0; i < 16; i++) {
  23493. +        IRQ_ports[i] = 0;
  23494. +        IRQ_timeout[i] = 0;
  23495. +        memset(&rs_multiport[i], 0, sizeof(struct rs_multiport_struct));
  23496. +    }
  23497. +    
  23498. +    show_serial_version();
  23499. +
  23500. +    /* Initialize the tty_driver structure */
  23501. +    
  23502. +    memset(&serial_driver, 0, sizeof(struct tty_driver));
  23503. +    serial_driver.magic = TTY_DRIVER_MAGIC;
  23504. +    serial_driver.name = "ttyS";
  23505. +    serial_driver.major = TTY_MAJOR;
  23506. +    serial_driver.minor_start = 64;
  23507. +    serial_driver.num = NR_PORTS;
  23508. +    serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  23509. +    serial_driver.subtype = SERIAL_TYPE_NORMAL;
  23510. +    serial_driver.init_termios = tty_std_termios;
  23511. +    serial_driver.init_termios.c_cflag =
  23512. +        B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  23513. +    serial_driver.flags = TTY_DRIVER_REAL_RAW;
  23514. +    serial_driver.refcount = &serial_refcount;
  23515. +    serial_driver.table = serial_table;
  23516. +    serial_driver.termios = serial_termios;
  23517. +    serial_driver.termios_locked = serial_termios_locked;
  23518. +
  23519. +    serial_driver.open = rs_open;
  23520. +    serial_driver.close = rs_close;
  23521. +    serial_driver.write = rs_write;
  23522. +    serial_driver.put_char = rs_put_char;
  23523. +    serial_driver.flush_chars = rs_flush_chars;
  23524. +    serial_driver.write_room = rs_write_room;
  23525. +    serial_driver.chars_in_buffer = rs_chars_in_buffer;
  23526. +    serial_driver.flush_buffer = rs_flush_buffer;
  23527. +    serial_driver.ioctl = rs_ioctl;
  23528. +    serial_driver.throttle = rs_throttle;
  23529. +    serial_driver.unthrottle = rs_unthrottle;
  23530. +    serial_driver.set_termios = rs_set_termios;
  23531. +    serial_driver.stop = rs_stop;
  23532. +    serial_driver.start = rs_start;
  23533. +    serial_driver.hangup = rs_hangup;
  23534. +
  23535. +    /*
  23536. +     * The callout device is just like normal device except for
  23537. +     * major number and the subtype code.
  23538. +     */
  23539. +    callout_driver = serial_driver;
  23540. +    callout_driver.name = "cua";
  23541. +    callout_driver.major = TTYAUX_MAJOR;
  23542. +    callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  23543. +
  23544. +    if (tty_register_driver(&serial_driver))
  23545. +        panic("Couldn't register serial driver\n");
  23546. +    if (tty_register_driver(&callout_driver))
  23547. +        panic("Couldn't register callout driver\n");
  23548. +    
  23549. +    for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
  23550. +        info->magic = SERIAL_MAGIC;
  23551. +        info->line = i;
  23552. +        info->tty = 0;
  23553. +        info->type = PORT_UNKNOWN;
  23554. +        info->custom_divisor = 0;
  23555. +        info->close_delay = 50;
  23556. +        info->closing_wait = 3000;
  23557. +        info->x_char = 0;
  23558. +        info->event = 0;
  23559. +        info->count = 0;
  23560. +        info->blocked_open = 0;
  23561. +        info->tqueue.routine = do_softint;
  23562. +        info->tqueue.data = info;
  23563. +        info->tqueue_hangup.routine = do_serial_hangup;
  23564. +        info->tqueue_hangup.data = info;
  23565. +        info->callout_termios =callout_driver.init_termios;
  23566. +        info->normal_termios = serial_driver.init_termios;
  23567. +        info->open_wait = 0;
  23568. +        info->close_wait = 0;
  23569. +        info->next_port = 0;
  23570. +        info->prev_port = 0;
  23571. +        if (info->irq == 2)
  23572. +            info->irq = 9;
  23573. +        if (!(info->flags & ASYNC_BOOT_AUTOCONF))
  23574. +            continue;
  23575. +        autoconfig(info);
  23576. +        if (info->type == PORT_UNKNOWN)
  23577. +            continue;
  23578. +        printk("tty%02d%s at 0x%04x (irq = %d)", info->line, 
  23579. +               (info->flags & ASYNC_FOURPORT) ? " FourPort" : "",
  23580. +               info->port, info->irq);
  23581. +        switch (info->type) {
  23582. +            case PORT_8250:
  23583. +                printk(" is a 8250\n");
  23584. +                break;
  23585. +            case PORT_16450:
  23586. +                printk(" is a 16450\n");
  23587. +                break;
  23588. +            case PORT_16550:
  23589. +                printk(" is a 16550\n");
  23590. +                break;
  23591. +            case PORT_16550A:
  23592. +                printk(" is a 16550A\n");
  23593. +                break;
  23594. +            case PORT_16650:
  23595. +                printk(" is a 16650\n");
  23596. +                break;
  23597. +            default:
  23598. +                printk("\n");
  23599. +                break;
  23600. +        }
  23601. +    }
  23602. +    return kmem_start;
  23603. +}
  23604. +
  23605. +/*
  23606. + * register_serial and unregister_serial allows for serial ports to be
  23607. + * configured at run-time, to support PCMCIA modems.
  23608. + */
  23609. +int register_serial(struct serial_struct *req)
  23610. +{
  23611. +    int i;
  23612. +    unsigned long flags;
  23613. +    struct async_struct *info;
  23614. +
  23615. +    save_flags(flags);
  23616. +    cli();
  23617. +    for (i = 0; i < NR_PORTS; i++) {
  23618. +        if (rs_table[i].port == req->port)
  23619. +            break;
  23620. +    }
  23621. +    if (i == NR_PORTS) {
  23622. +        for (i = 0; i < NR_PORTS; i++)
  23623. +            if ((rs_table[i].type == PORT_UNKNOWN) &&
  23624. +                (rs_table[i].count == 0))
  23625. +                break;
  23626. +    }
  23627. +    if (i == NR_PORTS) {
  23628. +        restore_flags(flags);
  23629. +        return -1;
  23630. +    }
  23631. +    info = &rs_table[i];
  23632. +    if (rs_table[i].count) {
  23633. +        restore_flags(flags);
  23634. +        printk("Couldn't configure serial #%d (port=%d,irq=%d): "
  23635. +               "device already open\n", i, req->port, req->irq);
  23636. +        return -1;
  23637. +    }
  23638. +    info->irq = req->irq;
  23639. +    info->port = req->port;
  23640. +    autoconfig(info);
  23641. +    if (info->type == PORT_UNKNOWN) {
  23642. +        restore_flags(flags);
  23643. +        printk("register_serial(): autoconfig failed\n");
  23644. +        return -1;
  23645. +    }
  23646. +    printk("tty%02d at 0x%04x (irq = %d)", info->line, 
  23647. +           info->port, info->irq);
  23648. +    switch (info->type) {
  23649. +    case PORT_8250:
  23650. +        printk(" is a 8250\n"); break;
  23651. +    case PORT_16450:
  23652. +        printk(" is a 16450\n"); break;
  23653. +    case PORT_16550:
  23654. +        printk(" is a 16550\n"); break;
  23655. +    case PORT_16550A:
  23656. +        printk(" is a 16550A\n"); break;
  23657. +    default:
  23658. +        printk("\n"); break;
  23659. +    }
  23660. +    restore_flags(flags);
  23661. +    return info->line;
  23662. +}
  23663. +
  23664. +void unregister_serial(int line)
  23665. +{
  23666. +    unsigned long flags;
  23667. +    struct async_struct *info = &rs_table[line];
  23668. +
  23669. +    save_flags(flags);
  23670. +    cli();
  23671. +    if (info->tty)
  23672. +        tty_hangup(info->tty);
  23673. +    info->type = PORT_UNKNOWN;
  23674. +    printk("tty%02d unloaded\n", info->line);
  23675. +    restore_flags(flags);
  23676. +}
  23677. diff -r -u -N linux.orig/arch/arm/drivers/char/serial.c.orig linux.arm/arch/arm/drivers/char/serial.c.orig
  23678. --- linux.orig/arch/arm/drivers/char/serial.c.orig    Thu Jan  1 01:00:00 1970
  23679. +++ linux.arm/arch/arm/drivers/char/serial.c.orig    Fri Oct 27 23:14:39 1995
  23680. @@ -0,0 +1,2478 @@
  23681. +/*
  23682. + *  linux/drivers/char/serial.c
  23683. + *
  23684. + *  Copyright (C) 1991, 1992  Linus Torvalds
  23685. + *
  23686. + *  Extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92.  Now
  23687. + *  much more extensible to support other serial cards based on the
  23688. + *  16450/16550A UART's.  Added support for the AST FourPort and the
  23689. + *  Accent Async board.
  23690. + *
  23691. + *  set_serial_info fixed to set the flags, custom divisor, and uart
  23692. + *     type fields.  Fix suggested by Michael K. Johnson 12/12/92.
  23693. + *
  23694. + * This module exports the following rs232 io functions:
  23695. + *
  23696. + *    long rs_init(long);
  23697. + *     int  rs_open(struct tty_struct * tty, struct file * filp)
  23698. + */
  23699. +
  23700. +#include <linux/config.h>
  23701. +#include <linux/errno.h>
  23702. +#include <linux/signal.h>
  23703. +#include <linux/sched.h>
  23704. +#include <linux/timer.h>
  23705. +#include <linux/interrupt.h>
  23706. +#include <linux/tty.h>
  23707. +#include <linux/tty_flip.h>
  23708. +#include <linux/serial.h>
  23709. +#include <linux/serial_reg.h>
  23710. +#include <linux/major.h>
  23711. +#include <linux/string.h>
  23712. +#include <linux/fcntl.h>
  23713. +#include <linux/ptrace.h>
  23714. +#include <linux/major.h>
  23715. +#include <linux/mm.h>
  23716. +
  23717. +#include <asm/system.h>
  23718. +#include <asm/io.h>
  23719. +#include <asm/segment.h>
  23720. +#include <asm/bitops.h>
  23721. +
  23722. +DECLARE_TASK_QUEUE(tq_serial);
  23723. +
  23724. +struct tty_driver serial_driver, callout_driver;
  23725. +static int serial_refcount;
  23726. +
  23727. +/* serial subtype definitions */
  23728. +#define SERIAL_TYPE_NORMAL    1
  23729. +#define SERIAL_TYPE_CALLOUT    2
  23730. +
  23731. +/* number of characters left in xmit buffer before we ask for more */
  23732. +#define WAKEUP_CHARS 256
  23733. +
  23734. +/*
  23735. + * Serial driver configuration section.  Here are the various options:
  23736. + *
  23737. + * CONFIG_HUB6
  23738. + *        Enables support for the venerable Bell Technologies
  23739. + *        HUB6 card.
  23740. + *
  23741. + * SERIAL_PARANOIA_CHECK
  23742. + *         Check the magic number for the async_structure where
  23743. + *         ever possible.
  23744. + */
  23745. +int ser_check=0;
  23746. +#define SERIAL_PARANOIA_CHECK
  23747. +#define CONFIG_SERIAL_NOPAUSE_IO
  23748. +#define SERIAL_DO_RESTART
  23749. +#define CONFIG_SERIAL_NEW_ISR
  23750. +
  23751. +#undef SERIAL_DEBUG_INTR
  23752. +#undef SERIAL_DEBUG_OPEN
  23753. +#undef SERIAL_DEBUG_FLOW
  23754. +
  23755. +#define _INLINE_ inline
  23756. +
  23757. +/*
  23758. + * IRQ_timeout        - How long the timeout should be for each IRQ
  23759. + *                 should be after the IRQ has been active.
  23760. + */
  23761. +
  23762. +static struct async_struct *IRQ_ports[16];
  23763. +static int IRQ_timeout[16];
  23764. +static volatile int rs_irq_triggered;
  23765. +static volatile int rs_triggered;
  23766. +static int rs_wild_int_mask;
  23767. +
  23768. +static void autoconfig(struct async_struct * info);
  23769. +static void change_speed(struct async_struct *info);
  23770. +
  23771. +/*
  23772. + * This assumes you have a 1.8432 MHz clock for your UART.
  23773. + *
  23774. + * It'd be nice if someone built a serial card with a 24.576 MHz
  23775. + * clock, since the 16550A is capable of handling a top speed of 1.5
  23776. + * megabits/second; but this requires the faster clock.
  23777. + */
  23778. +#define BASE_BAUD ( 1843200 / 16 )
  23779. +
  23780. +/* Standard COM flags (except for COM4, because of the 8514 problem) */
  23781. +#define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST )
  23782. +#define STD_COM4_FLAGS ASYNC_BOOT_AUTOCONF
  23783. +
  23784. +#define FOURPORT_FLAGS ASYNC_FOURPORT
  23785. +#define ACCENT_FLAGS 0
  23786. +#define BOCA_FLAGS 0
  23787. +#define HUB6_FLAGS 0
  23788. +
  23789. +/*
  23790. + * The following define the access methods for the HUB6 card. All
  23791. + * access is through two ports for all 24 possible chips. The card is
  23792. + * selected through the high 2 bits, the port on that card with the
  23793. + * "middle" 3 bits, and the register on that port with the bottom
  23794. + * 3 bits.
  23795. + *
  23796. + * While the access port and interrupt is configurable, the default
  23797. + * port locations are 0x302 for the port control register, and 0x303
  23798. + * for the data read/write register. Normally, the interrupt is at irq3
  23799. + * but can be anything from 3 to 7 inclusive. Note that using 3 will
  23800. + * require disabling com2.
  23801. + */
  23802. +
  23803. +#define C_P(card,port) (((card)<<6|(port)<<3) + 1)
  23804. +
  23805. +struct async_struct rs_table[] = {
  23806. +    /* UART CLK   PORT IRQ     FLAGS        */
  23807. +#ifdef __arm__
  23808. +    { 0, BASE_BAUD, 0x3F8,10, STD_COM_FLAGS },
  23809. +    { 0, BASE_BAUD, 0x2F8,10, STD_COM_FLAGS }
  23810. +#define PODULE
  23811. +#ifdef PODULE
  23812. +       ,{ 0, BASE_BAUD,     0, 0, STD_COM_FLAGS },
  23813. +    { 0, BASE_BAUD,     0, 0, STD_COM_FLAGS },
  23814. +    { 0, BASE_BAUD,     0, 0, STD_COM_FLAGS },
  23815. +    { 0, BASE_BAUD,     0, 0, STD_COM_FLAGS },
  23816. +    { 0, BASE_BAUD,     0, 0, STD_COM_FLAGS },
  23817. +    { 0, BASE_BAUD,     0, 0, STD_COM_FLAGS },
  23818. +    { 0, BASE_BAUD,     0, 0, STD_COM_FLAGS },
  23819. +    { 0, BASE_BAUD,     0, 0, STD_COM_FLAGS }
  23820. +#endif
  23821. +#else
  23822. +    { 0, BASE_BAUD, 0x3F8, 4, STD_COM_FLAGS },    /* ttyS0 */
  23823. +    { 0, BASE_BAUD, 0x2F8, 3, STD_COM_FLAGS },    /* ttyS1 */
  23824. +    { 0, BASE_BAUD, 0x3E8, 4, STD_COM_FLAGS },    /* ttyS2 */
  23825. +    { 0, BASE_BAUD, 0x2E8, 3, STD_COM4_FLAGS },    /* ttyS3 */
  23826. +
  23827. +    { 0, BASE_BAUD, 0x1A0, 9, FOURPORT_FLAGS },     /* ttyS4 */
  23828. +    { 0, BASE_BAUD, 0x1A8, 9, FOURPORT_FLAGS },    /* ttyS5 */
  23829. +    { 0, BASE_BAUD, 0x1B0, 9, FOURPORT_FLAGS },    /* ttyS6 */
  23830. +    { 0, BASE_BAUD, 0x1B8, 9, FOURPORT_FLAGS },    /* ttyS7 */
  23831. +
  23832. +    { 0, BASE_BAUD, 0x2A0, 5, FOURPORT_FLAGS },    /* ttyS8 */
  23833. +    { 0, BASE_BAUD, 0x2A8, 5, FOURPORT_FLAGS },    /* ttyS9 */
  23834. +    { 0, BASE_BAUD, 0x2B0, 5, FOURPORT_FLAGS },    /* ttyS10 */
  23835. +    { 0, BASE_BAUD, 0x2B8, 5, FOURPORT_FLAGS },    /* ttyS11 */
  23836. +
  23837. +    { 0, BASE_BAUD, 0x330, 4, ACCENT_FLAGS },    /* ttyS12 */
  23838. +    { 0, BASE_BAUD, 0x338, 4, ACCENT_FLAGS },    /* ttyS13 */
  23839. +    { 0, BASE_BAUD, 0x000, 0, 0 },    /* ttyS14 (spare; user configurable) */
  23840. +    { 0, BASE_BAUD, 0x000, 0, 0 },    /* ttyS15 (spare; user configurable) */
  23841. +
  23842. +    { 0, BASE_BAUD, 0x100, 12, BOCA_FLAGS },    /* ttyS16 */
  23843. +    { 0, BASE_BAUD, 0x108, 12, BOCA_FLAGS },    /* ttyS17 */
  23844. +    { 0, BASE_BAUD, 0x110, 12, BOCA_FLAGS },    /* ttyS18 */
  23845. +    { 0, BASE_BAUD, 0x118, 12, BOCA_FLAGS },    /* ttyS19 */
  23846. +    { 0, BASE_BAUD, 0x120, 12, BOCA_FLAGS },    /* ttyS20 */
  23847. +    { 0, BASE_BAUD, 0x128, 12, BOCA_FLAGS },    /* ttyS21 */
  23848. +    { 0, BASE_BAUD, 0x130, 12, BOCA_FLAGS },    /* ttyS22 */
  23849. +    { 0, BASE_BAUD, 0x138, 12, BOCA_FLAGS },    /* ttyS23 */
  23850. +    { 0, BASE_BAUD, 0x140, 12, BOCA_FLAGS },    /* ttyS24 */
  23851. +    { 0, BASE_BAUD, 0x148, 12, BOCA_FLAGS },    /* ttyS25 */
  23852. +    { 0, BASE_BAUD, 0x150, 12, BOCA_FLAGS },    /* ttyS26 */
  23853. +    { 0, BASE_BAUD, 0x158, 12, BOCA_FLAGS },    /* ttyS27 */
  23854. +    { 0, BASE_BAUD, 0x160, 12, BOCA_FLAGS },    /* ttyS28 */
  23855. +    { 0, BASE_BAUD, 0x168, 12, BOCA_FLAGS },    /* ttyS29 */
  23856. +    { 0, BASE_BAUD, 0x170, 12, BOCA_FLAGS },    /* ttyS30 */
  23857. +    { 0, BASE_BAUD, 0x178, 12, BOCA_FLAGS },    /* ttyS31 */
  23858. +
  23859. +/* You can have up to four HUB6's in the system, but I've only
  23860. + * included two cards here for a total of twelve ports.
  23861. + */
  23862. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,0) },    /* ttyS32 */
  23863. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,1) },    /* ttyS33 */
  23864. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,2) },    /* ttyS34 */
  23865. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,3) },    /* ttyS35 */
  23866. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,4) },    /* ttyS36 */
  23867. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,5) },    /* ttyS37 */
  23868. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,0) },    /* ttyS32 */
  23869. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,1) },    /* ttyS33 */
  23870. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,2) },    /* ttyS34 */
  23871. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,3) },    /* ttyS35 */
  23872. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,4) },    /* ttyS36 */
  23873. +    { 0, BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,5) },    /* ttyS37 */
  23874. +#endif
  23875. +};
  23876. +
  23877. +#define NR_PORTS    (sizeof(rs_table)/sizeof(struct async_struct))
  23878. +#ifdef PODULE
  23879. +int dser_sport = 2; /* This is the start of the serial port NULL entries */
  23880. +#endif
  23881. +
  23882. +static struct tty_struct *serial_table[NR_PORTS];
  23883. +static struct termios *serial_termios[NR_PORTS];
  23884. +static struct termios *serial_termios_locked[NR_PORTS];
  23885. +
  23886. +#ifndef MIN
  23887. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  23888. +#endif
  23889. +
  23890. +/*
  23891. + * tmp_buf is used as a temporary buffer by serial_write.  We need to
  23892. + * lock it in case the memcpy_fromfs blocks while swapping in a page,
  23893. + * and some other program tries to do a serial write at the same time.
  23894. + * Since the lock will only come under contention when the system is
  23895. + * swapping and available memory is low, it makes sense to share one
  23896. + * buffer across all the serial ports, since it significantly saves
  23897. + * memory if large numbers of serial ports are open.
  23898. + */
  23899. +static unsigned char *tmp_buf = 0;
  23900. +static struct semaphore tmp_buf_sem = MUTEX;
  23901. +
  23902. +static inline int serial_paranoia_check(struct async_struct *info,
  23903. +                    dev_t device, const char *routine)
  23904. +{
  23905. +#ifdef SERIAL_PARANOIA_CHECK
  23906. +    static const char *badmagic =
  23907. +        "Warning: bad magic number for serial struct (%d, %d) in %s\n";
  23908. +    static const char *badinfo =
  23909. +        "Warning: null async_struct for (%d, %d) in %s\n";
  23910. +
  23911. +    if (!info) {
  23912. +        printk(badinfo, MAJOR(device), MINOR(device), routine);
  23913. +        return 1;
  23914. +    }
  23915. +    if (info->magic != SERIAL_MAGIC) {
  23916. +        printk(badmagic, MAJOR(device), MINOR(device), routine);
  23917. +        return 1;
  23918. +    }
  23919. +#endif
  23920. +    return 0;
  23921. +}
  23922. +
  23923. +/*
  23924. + * This is used to figure out the divisor speeds and the timeouts
  23925. + */
  23926. +static int baud_table[] = {
  23927. +    0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  23928. +    9600, 19200, 38400, 57600, 115200, 0 };
  23929. +
  23930. +static inline unsigned int serial_in(struct async_struct *info, int offset)
  23931. +{
  23932. +#ifdef CONFIG_HUB6
  23933. +    if (info->hub6) {
  23934. +    outb(info->hub6 - 1 + offset, info->port);
  23935. +    return inb(info->port+1);
  23936. +    } else
  23937. +#endif
  23938. +    return inb(info->port + offset);
  23939. +}
  23940. +
  23941. +static inline unsigned int serial_inp(struct async_struct *info, int offset)
  23942. +{
  23943. +#ifdef CONFIG_HUB6
  23944. +    if (info->hub6) {
  23945. +    outb(info->hub6 - 1 + offset, info->port);
  23946. +    return inb_p(info->port+1);
  23947. +    } else
  23948. +#endif
  23949. +#ifdef CONFIG_SERIAL_NOPAUSE_IO
  23950. +    return inb(info->port + offset);
  23951. +#else
  23952. +    return inb_p(info->port + offset);
  23953. +#endif
  23954. +}
  23955. +
  23956. +static inline void serial_out(struct async_struct *info, int offset, int value)
  23957. +{
  23958. +#ifdef CONFIG_HUB6
  23959. +    if (info->hub6) {
  23960. +    outb(info->hub6 - 1 + offset, info->port);
  23961. +    outb(value, info->port+1);
  23962. +    } else
  23963. +#endif
  23964. +    outb(value, info->port+offset);
  23965. +}
  23966. +
  23967. +static inline void serial_outp(struct async_struct *info, int offset,
  23968. +                   int value)
  23969. +{
  23970. +#ifdef CONFIG_HUB6
  23971. +    if (info->hub6) {
  23972. +    outb(info->hub6 - 1 + offset, info->port);
  23973. +    outb_p(value, info->port+1);
  23974. +    } else
  23975. +#endif
  23976. +#ifdef CONFIG_SERIAL_NOPAUSE_IO
  23977. +    outb(value, info->port+offset);
  23978. +#else
  23979. +        outb_p(value, info->port+offset);
  23980. +#endif
  23981. +}
  23982. +
  23983. +/*
  23984. + * ------------------------------------------------------------
  23985. + * rs_stop() and rs_start()
  23986. + *
  23987. + * This routines are called before setting or resetting tty->stopped.
  23988. + * They enable or disable transmitter interrupts, as necessary.
  23989. + * ------------------------------------------------------------
  23990. + */
  23991. +static void rs_stop(struct tty_struct *tty)
  23992. +{
  23993. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  23994. +    unsigned long flags;
  23995. +
  23996. +    if (serial_paranoia_check(info, tty->device, "rs_stop"))
  23997. +        return;
  23998. +
  23999. +    save_flags(flags); cli();
  24000. +    if (info->IER & UART_IER_THRI) {
  24001. +        info->IER &= ~UART_IER_THRI;
  24002. +        serial_out(info, UART_IER, info->IER);
  24003. +    }
  24004. +    restore_flags(flags);
  24005. +}
  24006. +
  24007. +static void rs_start(struct tty_struct *tty)
  24008. +{
  24009. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  24010. +    unsigned long flags;
  24011. +
  24012. +    if (serial_paranoia_check(info, tty->device, "rs_start"))
  24013. +        return;
  24014. +
  24015. +    save_flags(flags); cli();
  24016. +    if (info->xmit_cnt && info->xmit_buf && !(info->IER & UART_IER_THRI)) {
  24017. +        info->IER |= UART_IER_THRI;
  24018. +        serial_out(info, UART_IER, info->IER);
  24019. +    }
  24020. +    restore_flags(flags);
  24021. +}
  24022. +
  24023. +/*
  24024. + * ----------------------------------------------------------------------
  24025. + *
  24026. + * Here starts the interrupt handling routines.  All of the following
  24027. + * subroutines are declared as inline and are folded into
  24028. + * rs_interrupt().  They were separated out for readability's sake.
  24029. + *
  24030. + * Note: rs_interrupt() is a "fast" interrupt, which means that it
  24031. + * runs with interrupts turned off.  People who may want to modify
  24032. + * rs_interrupt() should try to keep the interrupt handler as fast as
  24033. + * possible.  After you are done making modifications, it is not a bad
  24034. + * idea to do:
  24035. + *
  24036. + * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
  24037. + *
  24038. + * and look at the resulting assemble code in serial.s.
  24039. + *
  24040. + *                 - Ted Ts'o (tytso@mit.edu), 7-Mar-93
  24041. + * -----------------------------------------------------------------------
  24042. + */
  24043. +
  24044. +/*
  24045. + * This is the serial driver's interrupt routine while we are probing
  24046. + * for submarines.
  24047. + */
  24048. +static void rs_probe(int irq)
  24049. +{
  24050. +    rs_irq_triggered = irq;
  24051. +    rs_triggered |= 1 << irq;
  24052. +    return;
  24053. +}
  24054. +
  24055. +/*
  24056. + * This routine is used by the interrupt handler to schedule
  24057. + * processing in the software interrupt portion of the driver.
  24058. + */
  24059. +static _INLINE_ void rs_sched_event(struct async_struct *info,
  24060. +                  int event)
  24061. +{
  24062. +    info->event |= 1 << event;
  24063. +    queue_task_irq_off(&info->tqueue, &tq_serial);
  24064. +    mark_bh(SERIAL_BH);
  24065. +}
  24066. +
  24067. +static _INLINE_ void receive_chars(struct async_struct *info,
  24068. +                 int *status)
  24069. +{
  24070. +    struct tty_struct *tty = info->tty;
  24071. +    unsigned char ch;
  24072. +
  24073. +    do {
  24074. +        ch = serial_inp(info, UART_RX);
  24075. +        if (*status & (info->ignore_status_mask & ~UART_LSR_OE))/* RMK - stupid to ignore errors! */
  24076. +            continue;
  24077. +        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  24078. +            break;
  24079. +        tty->flip.count++;
  24080. +        if (*status & info->read_status_mask) {
  24081. +            if (*status & (UART_LSR_BI)) {
  24082. +                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
  24083. +                if (info->flags & ASYNC_SAK)
  24084. +                    do_SAK(tty);
  24085. +            } else if (*status & UART_LSR_PE)
  24086. +                *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  24087. +            else if (*status & UART_LSR_FE)
  24088. +                *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  24089. +            else if (*status & UART_LSR_OE)
  24090. +                *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  24091. +            else
  24092. +                *tty->flip.flag_buf_ptr++ = 0;
  24093. +        } else
  24094. +            *tty->flip.flag_buf_ptr++ = 0;
  24095. +        *tty->flip.char_buf_ptr++ = ch;
  24096. +    } while ((*status = serial_inp(info, UART_LSR)) & UART_LSR_DR);
  24097. +    queue_task_irq_off(&tty->flip.tqueue, &tq_timer);
  24098. +#ifdef SERIAL_DEBUG_INTR
  24099. +    printk("DR...");
  24100. +#endif
  24101. +}
  24102. +
  24103. +static _INLINE_ void transmit_chars(struct async_struct *info, int *intr_done)
  24104. +{
  24105. +    int count;
  24106. +
  24107. +    if (info->x_char) {
  24108. +        serial_outp(info, UART_TX, info->x_char);
  24109. +        info->x_char = 0;
  24110. +        if (intr_done)
  24111. +            *intr_done = 0;
  24112. +        return;
  24113. +    }
  24114. +    if ((info->xmit_cnt <= 0) || info->tty->stopped ||
  24115. +        info->tty->hw_stopped) {
  24116. +        info->IER &= ~UART_IER_THRI;
  24117. +#ifdef CONFIG_SERIAL_NEW_ISR
  24118. +        serial_out(info, UART_IER, info->IER);
  24119. +#endif
  24120. +        return;
  24121. +    }
  24122. +
  24123. +    count = info->xmit_fifo_size;
  24124. +    do {
  24125. +        serial_out(info, UART_TX, info->xmit_buf[info->xmit_tail++]);
  24126. +        info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  24127. +        if (--info->xmit_cnt <= 0)
  24128. +            break;
  24129. +    } while (--count > 0);
  24130. +
  24131. +    if (info->xmit_cnt < WAKEUP_CHARS)
  24132. +        rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  24133. +
  24134. +#ifdef SERIAL_DEBUG_INTR
  24135. +    printk("THRE...");
  24136. +#endif
  24137. +    if (intr_done)
  24138. +        *intr_done = 0;
  24139. +
  24140. +    if (info->xmit_cnt <= 0) {
  24141. +        info->IER &= ~UART_IER_THRI;
  24142. +#ifdef CONFIG_SERIAL_NEW_ISR
  24143. +        serial_out(info, UART_IER, info->IER);
  24144. +#endif
  24145. +    }
  24146. +}
  24147. +
  24148. +static _INLINE_ void check_modem_status(struct async_struct *info)
  24149. +{
  24150. +    int    status;
  24151. +
  24152. +    status = serial_in(info, UART_MSR);
  24153. +
  24154. +    if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
  24155. +#if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
  24156. +        printk("ttys%d CD now %s...\n", info->line,
  24157. +               (status & UART_MSR_DCD) ? "on" : "off");
  24158. +#endif
  24159. +        if (status & UART_MSR_DCD)
  24160. +            wake_up_interruptible(&info->open_wait);
  24161. +        else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  24162. +               (info->flags & ASYNC_CALLOUT_NOHUP))) {
  24163. +#ifdef SERIAL_DEBUG_OPEN
  24164. +            printk("scheduling hangup...\n");
  24165. +#endif
  24166. +            rs_sched_event(info, RS_EVENT_HANGUP);
  24167. +        }
  24168. +    }
  24169. +    if (info->flags & ASYNC_CTS_FLOW) {
  24170. +        if (info->tty->hw_stopped) {
  24171. +            if (status & UART_MSR_CTS) {
  24172. +#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  24173. +                printk("CTS tx start...");
  24174. +#endif
  24175. +                info->tty->hw_stopped = 0;
  24176. +                info->IER |= UART_IER_THRI;
  24177. +#ifdef CONFIG_SERIAL_NEW_ISR
  24178. +                serial_out(info, UART_IER, info->IER);
  24179. +#endif
  24180. +                rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  24181. +                return;
  24182. +            }
  24183. +        } else {
  24184. +            if (!(status & UART_MSR_CTS)) {
  24185. +#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  24186. +                printk("CTS tx stop...");
  24187. +#endif
  24188. +                info->tty->hw_stopped = 1;
  24189. +                info->IER &= ~UART_IER_THRI;
  24190. +#ifdef CONFIG_SERIAL_NEW_ISR
  24191. +                serial_out(info, UART_IER, info->IER);
  24192. +#endif
  24193. +            }
  24194. +        }
  24195. +    }
  24196. +}
  24197. +
  24198. +#ifdef CONFIG_SERIAL_NEW_ISR
  24199. +/*
  24200. + * This is the serial driver's generic interrupt routine
  24201. + */
  24202. +static void rs_interrupt(int irq)
  24203. +{
  24204. +    int status;
  24205. +    struct async_struct * info;
  24206. +    int pass_counter = 0;
  24207. +    struct async_struct *end_mark = 0;
  24208. +
  24209. +#ifdef SERIAL_DEBUG_INTR
  24210. +    printk("rs_interrupt(%d)...", irq);
  24211. +#endif
  24212. +
  24213. +    info = IRQ_ports[irq];
  24214. +    if (!info)
  24215. +        return;
  24216. +
  24217. +    do {
  24218. +        if (!info->tty ||
  24219. +            (serial_in(info, UART_IIR) & UART_IIR_NO_INT)) {
  24220. +            if (!end_mark)
  24221. +                end_mark = info;
  24222. +            goto next;
  24223. +        }
  24224. +        end_mark = 0;
  24225. +
  24226. +        info->last_active = jiffies;
  24227. +
  24228. +        status = serial_inp(info, UART_LSR);
  24229. +        if (status & UART_LSR_DR)
  24230. +            receive_chars(info, &status);
  24231. +        check_modem_status(info);
  24232. +        if (status & UART_LSR_THRE)
  24233. +            transmit_chars(info, 0);
  24234. +
  24235. +    next:
  24236. +        info = info->next_port;
  24237. +        if (!info) {
  24238. +            info = IRQ_ports[irq];
  24239. +            if (pass_counter++ > 64) {
  24240. +#if 0
  24241. +                printk("rs loop break\n");
  24242. +#endif
  24243. +                break;     /* Prevent infinite loops */
  24244. +            }
  24245. +            continue;
  24246. +        }
  24247. +    } while (end_mark != info);
  24248. +}
  24249. +
  24250. +/*
  24251. + * This is the serial driver's interrupt routine for a single port
  24252. + */
  24253. +static void rs_interrupt_single(int irq)
  24254. +{
  24255. +    int status;
  24256. +    int pass_counter = 0;
  24257. +    struct async_struct * info;
  24258. +
  24259. +#ifdef SERIAL_DEBUG_INTR
  24260. +    printk("rs_interrupt_single(%d)...", irq);
  24261. +#endif
  24262. +
  24263. +    info = IRQ_ports[irq];
  24264. +    if (!info || !info->tty)
  24265. +        return;
  24266. +
  24267. +    do {
  24268. +        status = serial_inp(info, UART_LSR);
  24269. +        if (status & UART_LSR_DR)
  24270. +            receive_chars(info, &status);
  24271. +        check_modem_status(info);
  24272. +        if (status & UART_LSR_THRE)
  24273. +            transmit_chars(info, 0);
  24274. +        if (pass_counter++ > 64) {
  24275. +#if 0
  24276. +            printk("rs_single loop break.\n");
  24277. +#endif
  24278. +            break;
  24279. +        }
  24280. +    } while (!(serial_in(info, UART_IIR) & UART_IIR_NO_INT));
  24281. +    info->last_active = jiffies;
  24282. +}
  24283. +
  24284. +#else /* CONFIG_SERIAL_NEW_ISR */
  24285. +
  24286. +/*
  24287. + * This is the serial driver's generic interrupt routine
  24288. + */
  24289. +static void rs_interrupt(int irq)
  24290. +{
  24291. +    int status;
  24292. +    struct async_struct * info;
  24293. +    int done = 1, pass_counter = 0;
  24294. +
  24295. +
  24296. +#ifdef SERIAL_DEBUG_INTR
  24297. +    printk("rs_interrupt(%d)...", irq);
  24298. +#endif
  24299. +
  24300. +    info = IRQ_ports[irq];
  24301. +    if (!info)
  24302. +        return;
  24303. +
  24304. +    while (1) {
  24305. +        if (!info->tty)
  24306. +            goto next;
  24307. +
  24308. +        serial_outp(info, UART_IER, 0);
  24309. +        status = serial_inp(info, UART_LSR);
  24310. +        if (status & UART_LSR_DR) {
  24311. +            receive_chars(info, &status);
  24312. +            done = 0;
  24313. +        }
  24314. +        check_modem_status(info);
  24315. +        if (status & UART_LSR_THRE)
  24316. +            transmit_chars(info, &done);
  24317. +
  24318. +    next:
  24319. +        info = info->next_port;
  24320. +        if (!info) {
  24321. +            info = IRQ_ports[irq];
  24322. +            if (done)
  24323. +                break;
  24324. +            done = 1;
  24325. +            if (pass_counter++ > 64) {
  24326. +#if 0
  24327. +                printk("rs loop break\n");
  24328. +#endif
  24329. +                break;     /* Prevent infinite loops */
  24330. +            }
  24331. +        }
  24332. +    }
  24333. +
  24334. +    /*
  24335. +     * Reset the IER registers; info is already set up from the
  24336. +     * above while loop.
  24337. +     */
  24338. +    do
  24339. +        serial_outp(info, UART_IER, info->IER);
  24340. +    while ((info = info->next_port) != NULL);
  24341. +}
  24342. +
  24343. +/*
  24344. + * This is the serial driver's interrupt routine for a single port
  24345. + */
  24346. +static void rs_interrupt_single(int irq)
  24347. +{
  24348. +    int status;
  24349. +    struct async_struct * info;
  24350. +
  24351. +
  24352. +#ifdef SERIAL_DEBUG_INTR
  24353. +    printk("rs_interrupt_single(%d)...", irq);
  24354. +#endif
  24355. +
  24356. +    info = IRQ_ports[irq];
  24357. +    if (!info || !info->tty)
  24358. +        return;
  24359. +
  24360. +    serial_outp(info, UART_IER, 0);
  24361. +    status = serial_inp(info, UART_LSR);
  24362. +    if (status & UART_LSR_DR)
  24363. +        receive_chars(info, &status);
  24364. +    check_modem_status(info);
  24365. +    if (status & UART_LSR_THRE)
  24366. +        transmit_chars(info, 0);
  24367. +
  24368. +    /*
  24369. +     * Reset the IER register
  24370. +     */
  24371. +    serial_outp(info, UART_IER, info->IER);
  24372. +}
  24373. +
  24374. +#endif /* CONFIG_SERIAL_NEW_ISR */
  24375. +
  24376. +/*
  24377. + * -------------------------------------------------------------------
  24378. + * Here ends the serial interrupt routines.
  24379. + * -------------------------------------------------------------------
  24380. + */
  24381. +
  24382. +/*
  24383. + * This routine is used to handle the "bottom half" processing for the
  24384. + * serial driver, known also the "software interrupt" processing.
  24385. + * This processing is done at the kernel interrupt level, after the
  24386. + * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  24387. + * is where time-consuming activities which can not be done in the
  24388. + * interrupt driver proper are done; the interrupt driver schedules
  24389. + * them using rs_sched_event(), and they get done here.
  24390. + */
  24391. +static void do_serial_bh(void *unused)
  24392. +{
  24393. +    run_task_queue(&tq_serial);
  24394. +}
  24395. +
  24396. +static void do_softint(void *private_)
  24397. +{
  24398. +    struct async_struct    *info = (struct async_struct *) private_;
  24399. +    struct tty_struct    *tty;
  24400. +
  24401. +    tty = info->tty;
  24402. +    if (!tty)
  24403. +        return;
  24404. +
  24405. +    if (clear_bit(RS_EVENT_HANGUP, &info->event)) {
  24406. +        tty_hangup(tty);
  24407. +        wake_up_interruptible(&info->open_wait);
  24408. +        info->flags &= ~(ASYNC_NORMAL_ACTIVE|
  24409. +                 ASYNC_CALLOUT_ACTIVE);
  24410. +    }
  24411. +    if (clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  24412. +        if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  24413. +            tty->ldisc.write_wakeup)
  24414. +            (tty->ldisc.write_wakeup)(tty);
  24415. +        wake_up_interruptible(&tty->write_wait);
  24416. +    }
  24417. +}
  24418. +
  24419. +/*
  24420. + * This subroutine is called when the RS_TIMER goes off.  It is used
  24421. + * by the serial driver to handle ports that do not have an interrupt
  24422. + * (irq=0).  This doesn't work very well for 16450's, but gives barely
  24423. + * passable results for a 16550A.  (Although at the expense of much
  24424. + * CPU overhead).
  24425. + */
  24426. +static void rs_timer(void)
  24427. +{
  24428. +    static unsigned long last_strobe = 0;
  24429. +    struct async_struct *info;
  24430. +    unsigned int    i;
  24431. +
  24432. +    if ((jiffies - last_strobe) >= 60*HZ) {
  24433. +        for (i=1; i < 16; i++) {
  24434. +            info = IRQ_ports[i];
  24435. +            if (!info)
  24436. +                continue;
  24437. +            cli();
  24438. +            if (info->next_port) {
  24439. +                do {
  24440. +                    serial_out(info, UART_IER, 0);
  24441. +                    info->IER |= UART_IER_THRI;
  24442. +                    serial_out(info, UART_IER, info->IER);
  24443. +                    info = info->next_port;
  24444. +                } while (info);
  24445. +                rs_interrupt(i);
  24446. +            } else
  24447. +                rs_interrupt_single(i);
  24448. +            sti();
  24449. +        }
  24450. +    }
  24451. +    last_strobe = jiffies;
  24452. +    timer_table[RS_TIMER].expires = jiffies + 60 * HZ;
  24453. +    timer_active |= 1 << RS_TIMER;
  24454. +
  24455. +    if (IRQ_ports[0]) {
  24456. +        cli();
  24457. +        rs_interrupt(0);
  24458. +        sti();
  24459. +
  24460. +        timer_table[RS_TIMER].expires = jiffies + IRQ_timeout[0] - 2;
  24461. +    }
  24462. +}
  24463. +
  24464. +/*
  24465. + * ---------------------------------------------------------------
  24466. + * Low level utility subroutines for the serial driver:  routines to
  24467. + * figure out the appropriate timeout for an interrupt chain, routines
  24468. + * to initialize and startup a serial port, and routines to shutdown a
  24469. + * serial port.  Useful stuff like that.
  24470. + * ---------------------------------------------------------------
  24471. + */
  24472. +
  24473. +/*
  24474. + * Grab all interrupts in preparation for doing an automatic irq
  24475. + * detection.  dontgrab is a mask of irq's _not_ to grab.  Returns a
  24476. + * mask of irq's which were grabbed and should therefore be freed
  24477. + * using free_all_interrupts().
  24478. + */
  24479. +static int grab_all_interrupts(int dontgrab)
  24480. +{
  24481. +    int             irq_lines = 0;
  24482. +    int            i, mask;
  24483. +
  24484. +    for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
  24485. +        if (!(mask & dontgrab) && !request_irq(i, rs_probe, SA_INTERRUPT, "serial probe")) {
  24486. +            irq_lines |= mask;
  24487. +        }
  24488. +    }
  24489. +    return irq_lines;
  24490. +}
  24491. +
  24492. +/*
  24493. + * Release all interrupts grabbed by grab_all_interrupts
  24494. + */
  24495. +static void free_all_interrupts(int irq_lines)
  24496. +{
  24497. +    int    i;
  24498. +
  24499. +    for (i = 0; i < 16; i++) {
  24500. +        if (irq_lines & (1 << i))
  24501. +            free_irq(i);
  24502. +    }
  24503. +}
  24504. +
  24505. +/*
  24506. + * This routine figures out the correct timeout for a particular IRQ.
  24507. + * It uses the smallest timeout of all of the serial ports in a
  24508. + * particular interrupt chain.  Now only used for IRQ 0....
  24509. + */
  24510. +static void figure_IRQ_timeout(int irq)
  24511. +{
  24512. +    struct    async_struct    *info;
  24513. +    int    timeout = 6000;    /* 60 seconds === a long time :-) */
  24514. +
  24515. +    info = IRQ_ports[irq];
  24516. +    if (!info) {
  24517. +        IRQ_timeout[irq] = 6000;
  24518. +        return;
  24519. +    }
  24520. +    while (info) {
  24521. +        if (info->timeout < timeout)
  24522. +            timeout = info->timeout;
  24523. +        info = info->next_port;
  24524. +    }
  24525. +    if (!irq)
  24526. +        timeout = timeout / 2;
  24527. +    IRQ_timeout[irq] = timeout ? timeout : 1;
  24528. +}
  24529. +
  24530. +static int startup(struct async_struct * info)
  24531. +{
  24532. +    unsigned short ICP;
  24533. +    unsigned long flags;
  24534. +    int    retval;
  24535. +    void (*handler)(int);
  24536. +
  24537. +    if (info->flags & ASYNC_INITIALIZED)
  24538. +        return 0;
  24539. +
  24540. +    if (!info->port || !info->type) {
  24541. +        if (info->tty)
  24542. +            set_bit(TTY_IO_ERROR, &info->tty->flags);
  24543. +        return 0;
  24544. +    }
  24545. +
  24546. +    if (!info->xmit_buf) {
  24547. +        info->xmit_buf = (unsigned char *) kmalloc(SERIAL_XMIT_SIZE,GFP_KERNEL);
  24548. +        if (!info->xmit_buf)
  24549. +            return -ENOMEM;
  24550. +    }
  24551. +
  24552. +    save_flags(flags); cli();
  24553. +
  24554. +#ifdef SERIAL_DEBUG_OPEN
  24555. +    printk("starting up ttys%d (irq %d)...\n", info->line, info->irq);
  24556. +#endif
  24557. +
  24558. +    /*
  24559. +     * Clear the FIFO buffers and disable them
  24560. +     * (they will be reenabled in change_speed())
  24561. +     */
  24562. +    if (info->type == PORT_16550A) {
  24563. +        serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  24564. +                         UART_FCR_CLEAR_XMIT));
  24565. +        info->xmit_fifo_size = 16;
  24566. +    } else
  24567. +        info->xmit_fifo_size = 1;
  24568. +
  24569. +    /*
  24570. +     * At this point there's no way the LSR could still be 0xFF;
  24571. +     * if it is, then bail out, because there's likely no UART
  24572. +     * here.
  24573. +     */
  24574. +    if (serial_inp(info, UART_LSR) == 0xff) {
  24575. +        restore_flags(flags);
  24576. +        if (suser()) {
  24577. +            if (info->tty)
  24578. +                set_bit(TTY_IO_ERROR, &info->tty->flags);
  24579. +            return 0;
  24580. +        } else
  24581. +            return -ENODEV;
  24582. +    }
  24583. +
  24584. +    /*
  24585. +     * Allocate the IRQ if necessary
  24586. +     */
  24587. +    if (info->irq && (!IRQ_ports[info->irq] ||
  24588. +              !IRQ_ports[info->irq]->next_port)) {
  24589. +        if (IRQ_ports[info->irq]) {
  24590. +            free_irq(info->irq);
  24591. +            handler = rs_interrupt;
  24592. +        } else
  24593. +            handler = rs_interrupt_single;
  24594. +
  24595. +        retval = request_irq(info->irq, handler, SA_INTERRUPT, "serial");
  24596. +        if (retval) {
  24597. +            restore_flags(flags);
  24598. +            if (suser()) {
  24599. +                if (info->tty)
  24600. +                    set_bit(TTY_IO_ERROR,
  24601. +                        &info->tty->flags);
  24602. +                return 0;
  24603. +            } else
  24604. +                return retval;
  24605. +        }
  24606. +    }
  24607. +
  24608. +    /*
  24609. +     * Clear the interrupt registers.
  24610. +     */
  24611. +     /* (void) serial_inp(info, UART_LSR); */   /* (see above) */
  24612. +    (void) serial_inp(info, UART_RX);
  24613. +    (void) serial_inp(info, UART_IIR);
  24614. +    (void) serial_inp(info, UART_MSR);
  24615. +
  24616. +    /*
  24617. +     * Now, initialize the UART
  24618. +     */
  24619. +    serial_outp(info, UART_LCR, UART_LCR_WLEN8);    /* reset DLAB */
  24620. +    if (info->flags & ASYNC_FOURPORT) {
  24621. +        info->MCR = UART_MCR_DTR | UART_MCR_RTS;
  24622. +        info->MCR_noint = UART_MCR_DTR | UART_MCR_OUT1;
  24623. +    } else {
  24624. +        info->MCR = UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2;
  24625. +        info->MCR_noint = UART_MCR_DTR | UART_MCR_RTS;
  24626. +    }
  24627. +    if (info->irq == 0)
  24628. +        info->MCR = info->MCR_noint;
  24629. +    serial_outp(info, UART_MCR, info->MCR);
  24630. +
  24631. +    /*
  24632. +     * Finally, enable interrupts
  24633. +     */
  24634. +    info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
  24635. +    serial_outp(info, UART_IER, info->IER);    /* enable interrupts */
  24636. +
  24637. +    if (info->flags & ASYNC_FOURPORT) {
  24638. +        /* Enable interrupts on the AST Fourport board */
  24639. +        ICP = (info->port & 0xFE0) | 0x01F;
  24640. +        outb_p(0x80, ICP);
  24641. +        (void) inb_p(ICP);
  24642. +    }
  24643. +
  24644. +    /*
  24645. +     * And clear the interrupt registers again for luck.
  24646. +     */
  24647. +    (void)serial_inp(info, UART_LSR);
  24648. +    (void)serial_inp(info, UART_RX);
  24649. +    (void)serial_inp(info, UART_IIR);
  24650. +    (void)serial_inp(info, UART_MSR);
  24651. +
  24652. +    if (info->tty)
  24653. +        clear_bit(TTY_IO_ERROR, &info->tty->flags);
  24654. +    info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  24655. +
  24656. +    /*
  24657. +     * Insert serial port into IRQ chain.
  24658. +     */
  24659. +    info->prev_port = 0;
  24660. +    info->next_port = IRQ_ports[info->irq];
  24661. +    if (info->next_port)
  24662. +        info->next_port->prev_port = info;
  24663. +    IRQ_ports[info->irq] = info;
  24664. +    figure_IRQ_timeout(info->irq);
  24665. +
  24666. +    /*
  24667. +     * Set up serial timers...
  24668. +     */
  24669. +    timer_table[RS_TIMER].expires = jiffies + 2;
  24670. +    timer_active |= 1 << RS_TIMER;
  24671. +
  24672. +    /*
  24673. +     * and set the speed of the serial port
  24674. +     */
  24675. +    change_speed(info);
  24676. +
  24677. +    info->flags |= ASYNC_INITIALIZED;
  24678. +    restore_flags(flags);
  24679. +    return 0;
  24680. +}
  24681. +
  24682. +/*
  24683. + * This routine will shutdown a serial port; interrupts are disabled, and
  24684. + * DTR is dropped if the hangup on close termio flag is on.
  24685. + */
  24686. +static void shutdown(struct async_struct * info)
  24687. +{
  24688. +    unsigned long    flags;
  24689. +    int        retval;
  24690. +
  24691. +    if (!(info->flags & ASYNC_INITIALIZED))
  24692. +        return;
  24693. +#ifdef SERIAL_DEBUG_OPEN
  24694. +    printk("Shutting down serial port %d (irq %d)....\n", info->line,
  24695. +           info->irq);
  24696. +#endif
  24697. +
  24698. +    save_flags(flags); cli(); /* Disable interrupts */
  24699. +
  24700. +    /*
  24701. +     * First unlink the serial port from the IRQ chain...
  24702. +     */
  24703. +    if (info->next_port)
  24704. +        info->next_port->prev_port = info->prev_port;
  24705. +    if (info->prev_port)
  24706. +        info->prev_port->next_port = info->next_port;
  24707. +    else
  24708. +        IRQ_ports[info->irq] = info->next_port;
  24709. +    figure_IRQ_timeout(info->irq);
  24710. +
  24711. +    /*
  24712. +     * Free the IRQ, if necessary
  24713. +     */
  24714. +    if (info->irq && (!IRQ_ports[info->irq] ||
  24715. +              !IRQ_ports[info->irq]->next_port)) {
  24716. +        if (IRQ_ports[info->irq]) {
  24717. +            free_irq(info->irq);
  24718. +            retval = request_irq(info->irq, rs_interrupt_single, SA_INTERRUPT, "serial");
  24719. +
  24720. +            if (retval)
  24721. +                printk("serial shutdown: request_irq: error %d"
  24722. +                       "  Couldn't reacquire IRQ.\n", retval);
  24723. +        } else
  24724. +            free_irq(info->irq);
  24725. +    }
  24726. +    if (info->xmit_buf) {
  24727. +        kfree_s(info->xmit_buf, SERIAL_XMIT_SIZE);
  24728. +        info->xmit_buf = 0;
  24729. +    }
  24730. +
  24731. +    info->IER = 0;
  24732. +    serial_outp(info, UART_IER, 0x00);    /* disable all intrs */
  24733. +    if (info->flags & ASYNC_FOURPORT) {
  24734. +        /* reset interrupts on the AST Fourport board */
  24735. +        (void) inb((info->port & 0xFE0) | 0x01F);
  24736. +    }
  24737. +
  24738. +    if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
  24739. +        info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS);
  24740. +        info->MCR_noint &= ~(UART_MCR_DTR|UART_MCR_RTS);
  24741. +    }
  24742. +    serial_outp(info, UART_MCR, info->MCR_noint);
  24743. +
  24744. +    /* disable FIFO's */
  24745. +    serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  24746. +                     UART_FCR_CLEAR_XMIT));
  24747. +    (void)serial_in(info, UART_RX);    /* read data port to reset things */
  24748. +
  24749. +    if (info->tty)
  24750. +        set_bit(TTY_IO_ERROR, &info->tty->flags);
  24751. +
  24752. +    info->flags &= ~ASYNC_INITIALIZED;
  24753. +    restore_flags(flags);
  24754. +}
  24755. +
  24756. +/*
  24757. + * This routine is called to set the UART divisor registers to match
  24758. + * the specified baud rate for a serial port.
  24759. + */
  24760. +static void change_speed(struct async_struct *info)
  24761. +{
  24762. +    unsigned short port;
  24763. +    int    quot = 0;
  24764. +    unsigned cflag,cval,fcr;
  24765. +    int    i;
  24766. +
  24767. +    if (!info->tty || !info->tty->termios)
  24768. +        return;
  24769. +    cflag = info->tty->termios->c_cflag;
  24770. +    if (!(port = info->port))
  24771. +        return;
  24772. +    i = cflag & CBAUD;
  24773. +
  24774. +    if (i == 15) {
  24775. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  24776. +            i += 1;
  24777. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  24778. +            i += 2;
  24779. +        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
  24780. +            quot = info->custom_divisor;
  24781. +    }
  24782. +    if (quot) {
  24783. +        info->timeout = ((info->xmit_fifo_size*HZ*15*quot) /
  24784. +                 info->baud_base) + 2;
  24785. +    } else if (baud_table[i] == 134) {
  24786. +        quot = (2*info->baud_base / 269);
  24787. +        info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
  24788. +    } else if (baud_table[i]) {
  24789. +        quot = info->baud_base / baud_table[i];
  24790. +        info->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
  24791. +    } else {
  24792. +        quot = 0;
  24793. +        info->timeout = 0;
  24794. +    }
  24795. +    if (quot) {
  24796. +        info->MCR |= UART_MCR_DTR;
  24797. +        info->MCR_noint |= UART_MCR_DTR;
  24798. +        cli();
  24799. +        serial_out(info, UART_MCR, info->MCR);
  24800. +        sti();
  24801. +    } else {
  24802. +        info->MCR &= ~UART_MCR_DTR;
  24803. +        info->MCR_noint &= ~UART_MCR_DTR;
  24804. +        cli();
  24805. +        serial_out(info, UART_MCR, info->MCR);
  24806. +        sti();
  24807. +        return;
  24808. +    }
  24809. +    /* byte size and parity */
  24810. +    cval = cflag & (CSIZE | CSTOPB);
  24811. +    cval >>= 4;
  24812. +    if (cflag & PARENB)
  24813. +        cval |= UART_LCR_PARITY;
  24814. +    if (!(cflag & PARODD))
  24815. +        cval |= UART_LCR_EPAR;
  24816. +    if (info->type == PORT_16550A) {
  24817. +        if ((info->baud_base / quot) < 2400)
  24818. +            fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
  24819. +        else
  24820. +            fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
  24821. +    } else
  24822. +        fcr = 0;
  24823. +
  24824. +    /* CTS flow control flag and modem status interrupts */
  24825. +    info->IER &= ~UART_IER_MSI;
  24826. +    if (cflag & CRTSCTS) {
  24827. +        info->flags |= ASYNC_CTS_FLOW;
  24828. +        info->IER |= UART_IER_MSI;
  24829. +    } else
  24830. +        info->flags &= ~ASYNC_CTS_FLOW;
  24831. +    if (cflag & CLOCAL)
  24832. +        info->flags &= ~ASYNC_CHECK_CD;
  24833. +    else {
  24834. +        info->flags |= ASYNC_CHECK_CD;
  24835. +        info->IER |= UART_IER_MSI;
  24836. +    }
  24837. +    serial_out(info, UART_IER, info->IER);
  24838. +
  24839. +    /*
  24840. +     * Set up parity check flag
  24841. +     */
  24842. +    info->read_status_mask = UART_LSR_OE;
  24843. +    if (I_INPCK(info->tty))
  24844. +        info->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
  24845. +    if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
  24846. +        info->read_status_mask |= UART_LSR_BI;
  24847. +
  24848. +    info->ignore_status_mask = 0;
  24849. +    if (I_IGNPAR(info->tty))
  24850. +        info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
  24851. +    if (I_IGNBRK(info->tty)) {
  24852. +        info->ignore_status_mask |= UART_LSR_BI;
  24853. +        /*
  24854. +         * If we're ignore parity and break indicators, ignore
  24855. +         * overruns too.  (For real raw support).
  24856. +         */
  24857. +        if (I_IGNPAR(info->tty))
  24858. +            info->ignore_status_mask |= UART_LSR_OE;
  24859. +    }
  24860. +
  24861. +    cli();
  24862. +    serial_outp(info, UART_LCR, cval | UART_LCR_DLAB);    /* set DLAB */
  24863. +    serial_outp(info, UART_DLL, quot & 0xff);    /* LS of divisor */
  24864. +    serial_outp(info, UART_DLM, quot >> 8);        /* MS of divisor */
  24865. +    serial_outp(info, UART_LCR, cval);        /* reset DLAB */
  24866. +    serial_outp(info, UART_FCR, fcr);     /* set fcr */
  24867. +    sti();
  24868. +}
  24869. +
  24870. +static void rs_put_char(struct tty_struct *tty, unsigned char ch)
  24871. +{
  24872. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  24873. +    unsigned long flags;
  24874. +
  24875. +    if (serial_paranoia_check(info, tty->device, "rs_put_char"))
  24876. +        return;
  24877. +
  24878. +    if (!tty || !info->xmit_buf)
  24879. +        return;
  24880. +
  24881. +    save_flags(flags); cli();
  24882. +    if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
  24883. +        restore_flags(flags);
  24884. +        return;
  24885. +    }
  24886. +
  24887. +    info->xmit_buf[info->xmit_head++] = ch;
  24888. +    info->xmit_head &= SERIAL_XMIT_SIZE-1;
  24889. +    info->xmit_cnt++;
  24890. +    restore_flags(flags);
  24891. +}
  24892. +
  24893. +static void rs_flush_chars(struct tty_struct *tty)
  24894. +{
  24895. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  24896. +    unsigned long flags;
  24897. +
  24898. +    if (serial_paranoia_check(info, tty->device, "rs_flush_chars"))
  24899. +        return;
  24900. +
  24901. +    if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  24902. +        !info->xmit_buf)
  24903. +        return;
  24904. +
  24905. +    save_flags(flags); cli();
  24906. +    info->IER |= UART_IER_THRI;
  24907. +    serial_out(info, UART_IER, info->IER);
  24908. +    restore_flags(flags);
  24909. +}
  24910. +
  24911. +static int rs_write(struct tty_struct * tty, int from_user,
  24912. +            unsigned char *buf, int count)
  24913. +{
  24914. +    int    c, total = 0;
  24915. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  24916. +    unsigned long flags;
  24917. +
  24918. +    if (serial_paranoia_check(info, tty->device, "rs_write"))
  24919. +        return 0;
  24920. +
  24921. +    if (!tty || !info->xmit_buf || !tmp_buf)
  24922. +        return 0;
  24923. +
  24924. +    save_flags(flags);
  24925. +    while (1) {
  24926. +        cli();
  24927. +        c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  24928. +                   SERIAL_XMIT_SIZE - info->xmit_head));
  24929. +        if (c <= 0)
  24930. +            break;
  24931. +
  24932. +        if (from_user) {
  24933. +            down(&tmp_buf_sem);
  24934. +            memcpy_fromfs(tmp_buf, buf, c);
  24935. +            c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  24936. +                       SERIAL_XMIT_SIZE - info->xmit_head));
  24937. +            memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
  24938. +            up(&tmp_buf_sem);
  24939. +        } else
  24940. +            memcpy(info->xmit_buf + info->xmit_head, buf, c);
  24941. +        info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  24942. +        info->xmit_cnt += c;
  24943. +        restore_flags(flags);
  24944. +        buf += c;
  24945. +        count -= c;
  24946. +        total += c;
  24947. +    }
  24948. +    if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
  24949. +        !(info->IER & UART_IER_THRI)) {
  24950. +        info->IER |= UART_IER_THRI;
  24951. +        serial_out(info, UART_IER, info->IER);
  24952. +    }
  24953. +    restore_flags(flags);
  24954. +    return total;
  24955. +}
  24956. +
  24957. +static int rs_write_room(struct tty_struct *tty)
  24958. +{
  24959. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  24960. +    int    ret;
  24961. +
  24962. +    if (serial_paranoia_check(info, tty->device, "rs_write_room"))
  24963. +        return 0;
  24964. +    ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
  24965. +    if (ret < 0)
  24966. +        ret = 0;
  24967. +    return ret;
  24968. +}
  24969. +
  24970. +static int rs_chars_in_buffer(struct tty_struct *tty)
  24971. +{
  24972. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  24973. +
  24974. +    if (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
  24975. +        return 0;
  24976. +    return info->xmit_cnt;
  24977. +}
  24978. +
  24979. +static void rs_flush_buffer(struct tty_struct *tty)
  24980. +{
  24981. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  24982. +
  24983. +    if (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
  24984. +        return;
  24985. +    cli();
  24986. +    info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  24987. +    sti();
  24988. +    wake_up_interruptible(&tty->write_wait);
  24989. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  24990. +        tty->ldisc.write_wakeup)
  24991. +        (tty->ldisc.write_wakeup)(tty);
  24992. +}
  24993. +
  24994. +/*
  24995. + * ------------------------------------------------------------
  24996. + * rs_throttle()
  24997. + *
  24998. + * This routine is called by the upper-layer tty layer to signal that
  24999. + * incoming characters should be throttled.
  25000. + * ------------------------------------------------------------
  25001. + */
  25002. +static void rs_throttle(struct tty_struct * tty)
  25003. +{
  25004. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  25005. +#ifdef SERIAL_DEBUG_THROTTLE
  25006. +    char    buf[64];
  25007. +
  25008. +    printk("throttle %s: %d....\n", _tty_name(tty, buf),
  25009. +           tty->ldisc.chars_in_buffer(tty));
  25010. +#endif
  25011. +
  25012. +    if (serial_paranoia_check(info, tty->device, "rs_throttle"))
  25013. +        return;
  25014. +
  25015. +    if (I_IXOFF(tty))
  25016. +        info->x_char = STOP_CHAR(tty);
  25017. +
  25018. +    info->MCR &= ~UART_MCR_RTS;
  25019. +    info->MCR_noint &= ~UART_MCR_RTS;
  25020. +    cli();
  25021. +    serial_out(info, UART_MCR, info->MCR);
  25022. +    sti();
  25023. +}
  25024. +
  25025. +static void rs_unthrottle(struct tty_struct * tty)
  25026. +{
  25027. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  25028. +#ifdef SERIAL_DEBUG_THROTTLE
  25029. +    char    buf[64];
  25030. +
  25031. +    printk("unthrottle %s: %d....\n", _tty_name(tty, buf),
  25032. +           tty->ldisc.chars_in_buffer(tty));
  25033. +#endif
  25034. +
  25035. +    if (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
  25036. +        return;
  25037. +
  25038. +    if (I_IXOFF(tty)) {
  25039. +        if (info->x_char)
  25040. +            info->x_char = 0;
  25041. +        else
  25042. +            info->x_char = START_CHAR(tty);
  25043. +    }
  25044. +    info->MCR |= UART_MCR_RTS;
  25045. +    info->MCR_noint |= UART_MCR_RTS;
  25046. +    cli();
  25047. +    serial_out(info, UART_MCR, info->MCR);
  25048. +    sti();
  25049. +}
  25050. +
  25051. +/*
  25052. + * ------------------------------------------------------------
  25053. + * rs_ioctl() and friends
  25054. + * ------------------------------------------------------------
  25055. + */
  25056. +
  25057. +static int get_serial_info(struct async_struct * info,
  25058. +               struct serial_struct * retinfo)
  25059. +{
  25060. +    struct serial_struct tmp;
  25061. +
  25062. +    if (!retinfo)
  25063. +        return -EFAULT;
  25064. +    memset(&tmp, 0, sizeof(tmp));
  25065. +    tmp.type = info->type;
  25066. +    tmp.line = info->line;
  25067. +    tmp.port = info->port;
  25068. +    tmp.irq = info->irq;
  25069. +    tmp.flags = info->flags;
  25070. +    tmp.baud_base = info->baud_base;
  25071. +    tmp.close_delay = info->close_delay;
  25072. +    tmp.custom_divisor = info->custom_divisor;
  25073. +    tmp.hub6 = info->hub6;
  25074. +    memcpy_tofs(retinfo,&tmp,sizeof(*retinfo));
  25075. +    return 0;
  25076. +}
  25077. +
  25078. +static int set_serial_info(struct async_struct * info,
  25079. +               struct serial_struct * new_info)
  25080. +{
  25081. +    struct serial_struct new_serial;
  25082. +    struct async_struct old_info;
  25083. +    unsigned int        i,change_irq,change_port;
  25084. +    int             retval = 0;
  25085. +
  25086. +    if (!new_info)
  25087. +        return -EFAULT;
  25088. +    memcpy_fromfs(&new_serial,new_info,sizeof(new_serial));
  25089. +    old_info = *info;
  25090. +
  25091. +    change_irq = new_serial.irq != info->irq;
  25092. +    change_port = (new_serial.port != info->port) || (new_serial.hub6 != info->hub6);
  25093. +
  25094. +    if (!suser()) {
  25095. +        if (change_irq || change_port ||
  25096. +            (new_serial.baud_base != info->baud_base) ||
  25097. +            (new_serial.type != info->type) ||
  25098. +            (new_serial.close_delay != info->close_delay) ||
  25099. +            ((new_serial.flags & ~ASYNC_USR_MASK) !=
  25100. +             (info->flags & ~ASYNC_USR_MASK)))
  25101. +            return -EPERM;
  25102. +        info->flags = ((info->flags & ~ASYNC_USR_MASK) |
  25103. +                   (new_serial.flags & ASYNC_USR_MASK));
  25104. +        info->custom_divisor = new_serial.custom_divisor;
  25105. +        goto check_and_exit;
  25106. +    }
  25107. +
  25108. +    if (new_serial.irq == 2)
  25109. +        new_serial.irq = 9;
  25110. +    if ((new_serial.irq > 31) || (new_serial.port > 0xffff) ||
  25111. +        (new_serial.type < PORT_UNKNOWN) || (new_serial.type > PORT_MAX)) {
  25112. +        return -EINVAL;
  25113. +    }
  25114. +
  25115. +    /* Make sure address is not already in use */
  25116. +    if (new_serial.type) {
  25117. +        for (i = 0 ; i < NR_PORTS; i++)
  25118. +            if ((info != &rs_table[i]) &&
  25119. +                (rs_table[i].port == new_serial.port) &&
  25120. +                rs_table[i].type)
  25121. +                return -EADDRINUSE;
  25122. +    }
  25123. +
  25124. +    if ((change_port || change_irq) && (info->count > 1))
  25125. +        return -EBUSY;
  25126. +
  25127. +    /*
  25128. +     * OK, past this point, all the error checking has been done.
  25129. +     * At this point, we start making changes.....
  25130. +     */
  25131. +
  25132. +    info->baud_base = new_serial.baud_base;
  25133. +    info->flags = ((info->flags & ~ASYNC_FLAGS) |
  25134. +            (new_serial.flags & ASYNC_FLAGS));
  25135. +    info->custom_divisor = new_serial.custom_divisor;
  25136. +    info->type = new_serial.type;
  25137. +    info->close_delay = new_serial.close_delay;
  25138. +
  25139. +    if (change_port || change_irq) {
  25140. +        /*
  25141. +         * We need to shutdown the serial port at the old
  25142. +         * port/irq combination.
  25143. +         */
  25144. +        shutdown(info);
  25145. +        info->irq = new_serial.irq;
  25146. +        info->port = new_serial.port;
  25147. +        info->hub6 = new_serial.hub6;
  25148. +    }
  25149. +
  25150. +check_and_exit:
  25151. +    if (!info->port || !info->type)
  25152. +        return 0;
  25153. +    if (info->flags & ASYNC_INITIALIZED) {
  25154. +        if (((old_info.flags & ASYNC_SPD_MASK) !=
  25155. +             (info->flags & ASYNC_SPD_MASK)) ||
  25156. +            (old_info.custom_divisor != info->custom_divisor))
  25157. +            change_speed(info);
  25158. +    } else
  25159. +        retval = startup(info);
  25160. +    return retval;
  25161. +}
  25162. +
  25163. +static int get_modem_info(struct async_struct * info, unsigned int *value)
  25164. +{
  25165. +    unsigned char control, status;
  25166. +    unsigned int result;
  25167. +
  25168. +    control = info->MCR;
  25169. +    cli();
  25170. +    status = serial_in(info, UART_MSR);
  25171. +    sti();
  25172. +    result =  ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
  25173. +        | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
  25174. +        | ((status  & UART_MSR_DCD) ? TIOCM_CAR : 0)
  25175. +        | ((status  & UART_MSR_RI) ? TIOCM_RNG : 0)
  25176. +        | ((status  & UART_MSR_DSR) ? TIOCM_DSR : 0)
  25177. +        | ((status  & UART_MSR_CTS) ? TIOCM_CTS : 0);
  25178. +    put_fs_long(result,(unsigned long *) value);
  25179. +    return 0;
  25180. +}
  25181. +
  25182. +static int set_modem_info(struct async_struct * info, unsigned int cmd,
  25183. +              unsigned int *value)
  25184. +{
  25185. +    unsigned int arg = get_fs_long((unsigned long *) value);
  25186. +
  25187. +    switch (cmd) {
  25188. +    case TIOCMBIS:
  25189. +        if (arg & TIOCM_RTS) {
  25190. +            info->MCR |= UART_MCR_RTS;
  25191. +            info->MCR_noint |= UART_MCR_RTS;
  25192. +        }
  25193. +        if (arg & TIOCM_DTR) {
  25194. +            info->MCR |= UART_MCR_DTR;
  25195. +            info->MCR_noint |= UART_MCR_DTR;
  25196. +        }
  25197. +        break;
  25198. +    case TIOCMBIC:
  25199. +        if (arg & TIOCM_RTS) {
  25200. +            info->MCR &= ~UART_MCR_RTS;
  25201. +            info->MCR_noint &= ~UART_MCR_RTS;
  25202. +        }
  25203. +        if (arg & TIOCM_DTR) {
  25204. +            info->MCR &= ~UART_MCR_DTR;
  25205. +            info->MCR_noint &= ~UART_MCR_DTR;
  25206. +        }
  25207. +        break;
  25208. +    case TIOCMSET:
  25209. +        info->MCR = ((info->MCR & ~(UART_MCR_RTS | UART_MCR_DTR))
  25210. +                 | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
  25211. +                 | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  25212. +        info->MCR_noint = ((info->MCR_noint
  25213. +                    & ~(UART_MCR_RTS | UART_MCR_DTR))
  25214. +                   | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
  25215. +                   | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  25216. +        break;
  25217. +    default:
  25218. +        return -EINVAL;
  25219. +    }
  25220. +    cli();
  25221. +    serial_out(info, UART_MCR, info->MCR);
  25222. +    sti();
  25223. +    return 0;
  25224. +}
  25225. +
  25226. +static int do_autoconfig(struct async_struct * info)
  25227. +{
  25228. +    int            retval;
  25229. +
  25230. +    if (!suser())
  25231. +        return -EPERM;
  25232. +
  25233. +    if (info->count > 1)
  25234. +        return -EBUSY;
  25235. +
  25236. +    shutdown(info);
  25237. +
  25238. +    cli();
  25239. +    autoconfig(info);
  25240. +    sti();
  25241. +
  25242. +    retval = startup(info);
  25243. +    if (retval)
  25244. +        return retval;
  25245. +    return 0;
  25246. +}
  25247. +
  25248. +
  25249. +/*
  25250. + * This routine sends a break character out the serial port.
  25251. + */
  25252. +static void send_break(    struct async_struct * info, int duration)
  25253. +{
  25254. +    if (!info->port)
  25255. +        return;
  25256. +    current->state = TASK_INTERRUPTIBLE;
  25257. +    current->timeout = jiffies + duration;
  25258. +    cli();
  25259. +    serial_out(info, UART_LCR, serial_inp(info, UART_LCR) | UART_LCR_SBC);
  25260. +    schedule();
  25261. +    serial_out(info, UART_LCR, serial_inp(info, UART_LCR) & ~UART_LCR_SBC);
  25262. +    sti();
  25263. +}
  25264. +
  25265. +/*
  25266. + * This routine returns a bitfield of "wild interrupts".  Basically,
  25267. + * any unclaimed interrupts which is flapping around.
  25268. + */
  25269. +static int check_wild_interrupts(int doprint)
  25270. +{
  25271. +    int    i, mask;
  25272. +    int    wild_interrupts = 0;
  25273. +    int    irq_lines;
  25274. +    unsigned long timeout;
  25275. +    unsigned long flags;
  25276. +
  25277. +    /* Turn on interrupts (they may be off) */
  25278. +    save_flags(flags); sti();
  25279. +
  25280. +    irq_lines = grab_all_interrupts(0);
  25281. +
  25282. +    /*
  25283. +     * Delay for 0.1 seconds -- we use a busy loop since this may
  25284. +     * occur during the bootup sequence
  25285. +     */
  25286. +    timeout = jiffies+10;
  25287. +    while (timeout >= jiffies)
  25288. +        ;
  25289. +
  25290. +    rs_triggered = 0;    /* Reset after letting things settle */
  25291. +
  25292. +    timeout = jiffies+10;
  25293. +    while (timeout >= jiffies)
  25294. +        ;
  25295. +
  25296. +    for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
  25297. +        if ((rs_triggered & (1 << i)) &&
  25298. +            (irq_lines & (1 << i))) {
  25299. +            wild_interrupts |= mask;
  25300. +            if (doprint)
  25301. +                printk("Wild interrupt?  (IRQ %d)\n", i);
  25302. +        }
  25303. +    }
  25304. +    free_all_interrupts(irq_lines);
  25305. +    restore_flags(flags);
  25306. +    return wild_interrupts;
  25307. +}
  25308. +
  25309. +static int rs_ioctl(struct tty_struct *tty, struct file * file,
  25310. +            unsigned int cmd, unsigned long arg)
  25311. +{
  25312. +    int error;
  25313. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  25314. +    int retval;
  25315. +
  25316. +    if (serial_paranoia_check(info, tty->device, "rs_ioctl"))
  25317. +        return -ENODEV;
  25318. +
  25319. +    switch (cmd) {
  25320. +        case TCSBRK:    /* SVID version: non-zero arg --> no break */
  25321. +            retval = tty_check_change(tty);
  25322. +            if (retval)
  25323. +                return retval;
  25324. +            tty_wait_until_sent(tty, 0);
  25325. +            if (!arg)
  25326. +                send_break(info, HZ/4);    /* 1/4 second */
  25327. +            return 0;
  25328. +        case TCSBRKP:    /* support for POSIX tcsendbreak() */
  25329. +            retval = tty_check_change(tty);
  25330. +            if (retval)
  25331. +                return retval;
  25332. +            tty_wait_until_sent(tty, 0);
  25333. +            send_break(info, arg ? arg*(HZ/10) : HZ/4);
  25334. +            return 0;
  25335. +        case TIOCGSOFTCAR:
  25336. +            error = verify_area(VERIFY_WRITE, (void *) arg,sizeof(long));
  25337. +            if (error)
  25338. +                return error;
  25339. +            put_fs_long(C_CLOCAL(tty) ? 1 : 0,
  25340. +                    (unsigned long *) arg);
  25341. +            return 0;
  25342. +        case TIOCSSOFTCAR:
  25343. +            arg = get_fs_long((unsigned long *) arg);
  25344. +            tty->termios->c_cflag =
  25345. +                ((tty->termios->c_cflag & ~CLOCAL) |
  25346. +                 (arg ? CLOCAL : 0));
  25347. +            return 0;
  25348. +        case TIOCMGET:
  25349. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  25350. +                sizeof(unsigned int));
  25351. +            if (error)
  25352. +                return error;
  25353. +            return get_modem_info(info, (unsigned int *) arg);
  25354. +        case TIOCMBIS:
  25355. +        case TIOCMBIC:
  25356. +        case TIOCMSET:
  25357. +            return set_modem_info(info, cmd, (unsigned int *) arg);
  25358. +        case TIOCGSERIAL:
  25359. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  25360. +                        sizeof(struct serial_struct));
  25361. +            if (error)
  25362. +                return error;
  25363. +            return get_serial_info(info,
  25364. +                           (struct serial_struct *) arg);
  25365. +        case TIOCSSERIAL:
  25366. +            return set_serial_info(info,
  25367. +                           (struct serial_struct *) arg);
  25368. +        case TIOCSERCONFIG:
  25369. +            return do_autoconfig(info);
  25370. +
  25371. +        case TIOCSERGWILD:
  25372. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  25373. +                        sizeof(int));
  25374. +            if (error)
  25375. +                return error;
  25376. +            put_fs_long(rs_wild_int_mask, (unsigned long *) arg);
  25377. +            return 0;
  25378. +
  25379. +        case TIOCSERSWILD:
  25380. +            if (!suser())
  25381. +                return -EPERM;
  25382. +            rs_wild_int_mask = get_fs_long((unsigned long *) arg);
  25383. +            if (rs_wild_int_mask < 0)
  25384. +                rs_wild_int_mask = check_wild_interrupts(0);
  25385. +            return 0;
  25386. +
  25387. +        case TIOCSERGSTRUCT:
  25388. +            error = verify_area(VERIFY_WRITE, (void *) arg,
  25389. +                        sizeof(struct async_struct));
  25390. +            if (error)
  25391. +                return error;
  25392. +            memcpy_tofs((struct async_struct *) arg,
  25393. +                    info, sizeof(struct async_struct));
  25394. +            return 0;
  25395. +
  25396. +        default:
  25397. +            return -ENOIOCTLCMD;
  25398. +        }
  25399. +    return 0;
  25400. +}
  25401. +
  25402. +static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
  25403. +{
  25404. +    struct async_struct *info = (struct async_struct *)tty->driver_data;
  25405. +
  25406. +    if (tty->termios->c_cflag == old_termios->c_cflag)
  25407. +        return;
  25408. +
  25409. +    change_speed(info);
  25410. +
  25411. +    if ((old_termios->c_cflag & CRTSCTS) &&
  25412. +        !(tty->termios->c_cflag & CRTSCTS)) {
  25413. +        tty->hw_stopped = 0;
  25414. +        rs_start(tty);
  25415. +    }
  25416. +
  25417. +    if (!(old_termios->c_cflag & CLOCAL) &&
  25418. +        (tty->termios->c_cflag & CLOCAL))
  25419. +        wake_up_interruptible(&info->open_wait);
  25420. +}
  25421. +
  25422. +/*
  25423. + * ------------------------------------------------------------
  25424. + * rs_close()
  25425. + *
  25426. + * This routine is called when the serial port gets closed.  First, we
  25427. + * wait for the last remaining data to be sent.  Then, we unlink its
  25428. + * async structure from the interrupt chain if necessary, and we free
  25429. + * that IRQ if nothing is left in the chain.
  25430. + * ------------------------------------------------------------
  25431. + */
  25432. +static void rs_close(struct tty_struct *tty, struct file * filp)
  25433. +{
  25434. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  25435. +    unsigned long flags;
  25436. +    unsigned long timeout;
  25437. +
  25438. +    if (!info || serial_paranoia_check(info, tty->device, "rs_close"))
  25439. +        return;
  25440. +
  25441. +    save_flags(flags); cli();
  25442. +
  25443. +    if (tty_hung_up_p(filp)) {
  25444. +        restore_flags(flags);
  25445. +        return;
  25446. +    }
  25447. +
  25448. +#ifdef SERIAL_DEBUG_OPEN
  25449. +    printk("rs_close ttys%d, count = %d\n", info->line, info->count);
  25450. +#endif
  25451. +    if ((tty->count == 1) && (info->count != 1)) {
  25452. +        /*
  25453. +         * Uh, oh.  tty->count is 1, which means that the tty
  25454. +         * structure will be freed.  Info->count should always
  25455. +         * be one in these conditions.  If it's greater than
  25456. +         * one, we've got real problems, since it means the
  25457. +         * serial port won't be shutdown.
  25458. +         */
  25459. +        printk("rs_close: bad serial port count; tty->count is 1, "
  25460. +               "info->count is %d\n", info->count);
  25461. +        info->count = 1;
  25462. +    }
  25463. +    if (--info->count < 0) {
  25464. +        printk("rs_close: bad serial port count for ttys%d: %d\n",
  25465. +               info->line, info->count);
  25466. +        info->count = 0;
  25467. +    }
  25468. +    if (info->count) {
  25469. +        restore_flags(flags);
  25470. +        return;
  25471. +    }
  25472. +    info->flags |= ASYNC_CLOSING;
  25473. +    /*
  25474. +     * Save the termios structure, since this port may have
  25475. +     * separate termios for callout and dialin.
  25476. +     */
  25477. +    if (info->flags & ASYNC_NORMAL_ACTIVE)
  25478. +        info->normal_termios = *tty->termios;
  25479. +    if (info->flags & ASYNC_CALLOUT_ACTIVE)
  25480. +        info->callout_termios = *tty->termios;
  25481. +    if (info->flags & ASYNC_INITIALIZED) {
  25482. +        tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
  25483. +        /*
  25484. +         * Before we drop DTR, make sure the UART transmitter
  25485. +         * has completely drained; this is especially
  25486. +         * important if there is a transmit FIFO!
  25487. +         */
  25488. +        timeout = jiffies+HZ;
  25489. +        while (!(serial_inp(info, UART_LSR) & UART_LSR_TEMT)) {
  25490. +            current->state = TASK_INTERRUPTIBLE;
  25491. +            current->timeout = jiffies + info->timeout;
  25492. +            schedule();
  25493. +            if (jiffies > timeout)
  25494. +                break;
  25495. +        }
  25496. +    }
  25497. +    shutdown(info);
  25498. +    if (tty->driver.flush_buffer)
  25499. +        tty->driver.flush_buffer(tty);
  25500. +    if (tty->ldisc.flush_buffer)
  25501. +        tty->ldisc.flush_buffer(tty);
  25502. +    info->event = 0;
  25503. +    info->tty = 0;
  25504. +    if (tty->ldisc.num != ldiscs[N_TTY].num) {
  25505. +        if (tty->ldisc.close)
  25506. +            (tty->ldisc.close)(tty);
  25507. +        tty->ldisc = ldiscs[N_TTY];
  25508. +        tty->termios->c_line = N_TTY;
  25509. +        if (tty->ldisc.open)
  25510. +            (tty->ldisc.open)(tty);
  25511. +    }
  25512. +    if (info->blocked_open) {
  25513. +        if (info->close_delay) {
  25514. +            current->state = TASK_INTERRUPTIBLE;
  25515. +            current->timeout = jiffies + info->close_delay;
  25516. +            schedule();
  25517. +        }
  25518. +        wake_up_interruptible(&info->open_wait);
  25519. +    }
  25520. +    info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  25521. +             ASYNC_CLOSING);
  25522. +    wake_up_interruptible(&info->close_wait);
  25523. +    restore_flags(flags);
  25524. +}
  25525. +
  25526. +/*
  25527. + * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
  25528. + */
  25529. +void rs_hangup(struct tty_struct *tty)
  25530. +{
  25531. +    struct async_struct * info = (struct async_struct *)tty->driver_data;
  25532. +
  25533. +    if (serial_paranoia_check(info, tty->device, "rs_hangup"))
  25534. +        return;
  25535. +
  25536. +    shutdown(info);
  25537. +    info->event = 0;
  25538. +    info->count = 0;
  25539. +    info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  25540. +    info->tty = 0;
  25541. +    wake_up_interruptible(&info->open_wait);
  25542. +}
  25543. +
  25544. +/*
  25545. + * ------------------------------------------------------------
  25546. + * rs_open() and friends
  25547. + * ------------------------------------------------------------
  25548. + */
  25549. +static int block_til_ready(struct tty_struct *tty, struct file * filp,
  25550. +               struct async_struct *info)
  25551. +{
  25552. +    int        retval;
  25553. +    int        do_clocal = 0;
  25554. +    struct wait_queue wait = { current, NULL };
  25555. +
  25556. +    /*
  25557. +     * If the device is in the middle of being closed, then block
  25558. +     * until it's done, and then try again.
  25559. +     */
  25560. +    if (info->flags & ASYNC_CLOSING) {
  25561. +        interruptible_sleep_on(&info->close_wait);
  25562. +#ifdef SERIAL_DO_RESTART
  25563. +        if (info->flags & ASYNC_HUP_NOTIFY)
  25564. +            return -EAGAIN;
  25565. +        else
  25566. +            return -ERESTARTSYS;
  25567. +#else
  25568. +        return -EAGAIN;
  25569. +#endif
  25570. +    }
  25571. +
  25572. +    /*
  25573. +     * If this is a callout device, then just make sure the normal
  25574. +     * device isn't being used.
  25575. +     */
  25576. +    if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  25577. +        if (info->flags & ASYNC_NORMAL_ACTIVE)
  25578. +            return -EBUSY;
  25579. +        if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  25580. +            (info->flags & ASYNC_SESSION_LOCKOUT) &&
  25581. +            (info->session != current->session))
  25582. +            return -EBUSY;
  25583. +        if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  25584. +            (info->flags & ASYNC_PGRP_LOCKOUT) &&
  25585. +            (info->pgrp != current->pgrp))
  25586. +            return -EBUSY;
  25587. +        info->flags |= ASYNC_CALLOUT_ACTIVE;
  25588. +        return 0;
  25589. +    }
  25590. +
  25591. +    /*
  25592. +     * If non-blocking mode is set, then make the check up front
  25593. +     * and then exit.
  25594. +     */
  25595. +    if (filp->f_flags & O_NONBLOCK) {
  25596. +        if (info->flags & ASYNC_CALLOUT_ACTIVE)
  25597. +            return -EBUSY;
  25598. +        info->flags |= ASYNC_NORMAL_ACTIVE;
  25599. +        return 0;
  25600. +    }
  25601. +
  25602. +    if (info->normal_termios.c_cflag & CLOCAL)
  25603. +        do_clocal = 1;
  25604. +
  25605. +    /*
  25606. +     * Block waiting for the carrier detect and the line to become
  25607. +     * free (i.e., not in use by the callout).  While we are in
  25608. +     * this loop, info->count is dropped by one, so that
  25609. +     * rs_close() knows when to free things.  We restore it upon
  25610. +     * exit, either normal or abnormal.
  25611. +     */
  25612. +    retval = 0;
  25613. +    add_wait_queue(&info->open_wait, &wait);
  25614. +#ifdef SERIAL_DEBUG_OPEN
  25615. +    printk("block_til_ready before block: ttys%d, count = %d\n",
  25616. +           info->line, info->count);
  25617. +#endif
  25618. +    info->count--;
  25619. +    info->blocked_open++;
  25620. +    while (1) {
  25621. +        cli();
  25622. +        if (!(info->flags & ASYNC_CALLOUT_ACTIVE))
  25623. +            serial_out(info, UART_MCR,
  25624. +                   serial_inp(info, UART_MCR) |
  25625. +                   (UART_MCR_DTR | UART_MCR_RTS));
  25626. +        sti();
  25627. +        current->state = TASK_INTERRUPTIBLE;
  25628. +        if (tty_hung_up_p(filp) ||
  25629. +            !(info->flags & ASYNC_INITIALIZED)) {
  25630. +#ifdef SERIAL_DO_RESTART
  25631. +            if (info->flags & ASYNC_HUP_NOTIFY)
  25632. +                retval = -EAGAIN;
  25633. +            else
  25634. +                retval = -ERESTARTSYS;
  25635. +#else
  25636. +            retval = -EAGAIN;
  25637. +#endif
  25638. +            break;
  25639. +        }
  25640. +        if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  25641. +            !(info->flags & ASYNC_CLOSING) &&
  25642. +            (do_clocal || (serial_in(info, UART_MSR) &
  25643. +                   UART_MSR_DCD)))
  25644. +            break;
  25645. +        if (current->signal & ~current->blocked) {
  25646. +            retval = -ERESTARTSYS;
  25647. +            break;
  25648. +        }
  25649. +#ifdef SERIAL_DEBUG_OPEN
  25650. +        printk("block_til_ready blocking: ttys%d, count = %d\n",
  25651. +               info->line, info->count);
  25652. +#endif
  25653. +        schedule();
  25654. +    }
  25655. +    current->state = TASK_RUNNING;
  25656. +    remove_wait_queue(&info->open_wait, &wait);
  25657. +    if (!tty_hung_up_p(filp))
  25658. +        info->count++;
  25659. +    info->blocked_open--;
  25660. +#ifdef SERIAL_DEBUG_OPEN
  25661. +    printk("block_til_ready after blocking: ttys%d, count = %d\n",
  25662. +           info->line, info->count);
  25663. +#endif
  25664. +    if (retval)
  25665. +        return retval;
  25666. +    info->flags |= ASYNC_NORMAL_ACTIVE;
  25667. +    return 0;
  25668. +}
  25669. +
  25670. +/*
  25671. + * This routine is called whenever a serial port is opened.  It
  25672. + * enables interrupts for a serial port, linking in its async structure into
  25673. + * the IRQ chain.   It also performs the serial-specific
  25674. + * initialization for the tty structure.
  25675. + */
  25676. +int rs_open(struct tty_struct *tty, struct file * filp)
  25677. +{
  25678. +    struct async_struct    *info;
  25679. +    int             retval, line;
  25680. +
  25681. +    line = MINOR(tty->device) - tty->driver.minor_start;
  25682. +    if ((line < 0) || (line >= NR_PORTS))
  25683. +        return -ENODEV;
  25684. +    info = rs_table + line;
  25685. +    if (serial_paranoia_check(info, tty->device, "rs_open"))
  25686. +        return -ENODEV;
  25687. +
  25688. +#ifdef SERIAL_DEBUG_OPEN
  25689. +    printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
  25690. +           info->count);
  25691. +#endif
  25692. +    info->count++;
  25693. +    tty->driver_data = info;
  25694. +    info->tty = tty;
  25695. +
  25696. +    if (!tmp_buf) {
  25697. +        tmp_buf = (unsigned char *) kmalloc(SERIAL_XMIT_SIZE,GFP_KERNEL);
  25698. +        if (!tmp_buf)
  25699. +            return -ENOMEM;
  25700. +    }
  25701. +
  25702. +    /*
  25703. +     * Start up serial port
  25704. +     */
  25705. +    retval = startup(info);
  25706. +    if (retval)
  25707. +        return retval;
  25708. +
  25709. +    retval = block_til_ready(tty, filp, info);
  25710. +    if (retval) {
  25711. +#ifdef SERIAL_DEBUG_OPEN
  25712. +        printk("rs_open returning after block_til_ready with %d\n",
  25713. +               retval);
  25714. +#endif
  25715. +        return retval;
  25716. +    }
  25717. +
  25718. +    if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
  25719. +        if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  25720. +            *tty->termios = info->normal_termios;
  25721. +        else
  25722. +            *tty->termios = info->callout_termios;
  25723. +        change_speed(info);
  25724. +    }
  25725. +
  25726. +    info->session = current->session;
  25727. +    info->pgrp = current->pgrp;
  25728. +
  25729. +#ifdef SERIAL_DEBUG_OPEN
  25730. +    printk("rs_open ttys%d successful...\n", info->line);
  25731. +#endif
  25732. +    return 0;
  25733. +}
  25734. +
  25735. +/*
  25736. + * ---------------------------------------------------------------------
  25737. + * rs_init() and friends
  25738. + *
  25739. + * rs_init() is called at boot-time to initialize the serial driver.
  25740. + * ---------------------------------------------------------------------
  25741. + */
  25742. +
  25743. +/*
  25744. + * This routine prints out the appropriate serial driver version
  25745. + * number, and identifies which options were configured into this
  25746. + * driver.
  25747. + */
  25748. +static void show_serial_version(void)
  25749. +{
  25750. +    printk("Serial driver version 4.00 with");
  25751. +#ifdef CONFIG_HUB6
  25752. +    printk(" HUB-6");
  25753. +#define SERIAL_OPT
  25754. +#endif
  25755. +#ifdef SERIAL_OPT
  25756. +    printk(" enabled\n");
  25757. +#else
  25758. +    printk(" no serial options enabled\n");
  25759. +#endif
  25760. +#undef SERIAL_OPT
  25761. +}
  25762. +
  25763. +/*
  25764. + * This routine is called by do_auto_irq(); it attempts to determine
  25765. + * which interrupt a serial port is configured to use.  It is not
  25766. + * fool-proof, but it works a large part of the time.
  25767. + */
  25768. +static int get_auto_irq(struct async_struct *info)
  25769. +{
  25770. +    unsigned char save_MCR, save_IER, save_ICP=0;
  25771. +    unsigned short ICP=0, port = info->port;
  25772. +    unsigned long timeout;
  25773. +
  25774. +    /*
  25775. +     * Enable interrupts and see who answers
  25776. +     */
  25777. +    rs_irq_triggered = 0;
  25778. +    cli();
  25779. +    save_IER = serial_inp(info, UART_IER);
  25780. +    save_MCR = serial_inp(info, UART_MCR);
  25781. +    if (info->flags & ASYNC_FOURPORT)  {
  25782. +        serial_outp(info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
  25783. +        serial_outp(info, UART_IER, 0x0f);    /* enable all intrs */
  25784. +        ICP = (port & 0xFE0) | 0x01F;
  25785. +        save_ICP = inb_p(ICP);
  25786. +        outb_p(0x80, ICP);
  25787. +        (void) inb_p(ICP);
  25788. +    } else {
  25789. +        serial_outp(info, UART_MCR,
  25790. +                UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
  25791. +        serial_outp(info, UART_IER, 0x0f);    /* enable all intrs */
  25792. +    }
  25793. +    sti();
  25794. +    /*
  25795. +     * Next, clear the interrupt registers.
  25796. +     */
  25797. +    (void)serial_inp(info, UART_LSR);
  25798. +    (void)serial_inp(info, UART_RX);
  25799. +    (void)serial_inp(info, UART_IIR);
  25800. +    (void)serial_inp(info, UART_MSR);
  25801. +
  25802. +    timeout = jiffies+2;
  25803. +    while (timeout >= jiffies) {
  25804. +        if (rs_irq_triggered)
  25805. +            break;
  25806. +    }
  25807. +    /*
  25808. +     * Now check to see if we got any business, and clean up.
  25809. +     */
  25810. +    cli();
  25811. +    serial_outp(info, UART_IER, save_IER);
  25812. +    serial_outp(info, UART_MCR, save_MCR);
  25813. +    if (info->flags & ASYNC_FOURPORT)
  25814. +        outb_p(save_ICP, ICP);
  25815. +    sti();
  25816. +    return(rs_irq_triggered);
  25817. +}
  25818. +
  25819. +/*
  25820. + * Calls get_auto_irq() multiple times, to make sure we don't get
  25821. + * faked out by random interrupts
  25822. + */
  25823. +static int do_auto_irq(struct async_struct * info)
  25824. +{
  25825. +    unsigned         port = info->port;
  25826. +    int             irq_lines = 0;
  25827. +    int            irq_try_1 = 0, irq_try_2 = 0;
  25828. +    int            retries;
  25829. +    unsigned long flags;
  25830. +
  25831. +    if (!port)
  25832. +        return 0;
  25833. +
  25834. +    /* Turn on interrupts (they may be off) */
  25835. +    save_flags(flags); sti();
  25836. +
  25837. +    irq_lines = grab_all_interrupts(rs_wild_int_mask);
  25838. +
  25839. +    for (retries = 0; retries < 5; retries++) {
  25840. +        if (!irq_try_1)
  25841. +            irq_try_1 = get_auto_irq(info);
  25842. +        if (!irq_try_2)
  25843. +            irq_try_2 = get_auto_irq(info);
  25844. +        if (irq_try_1 && irq_try_2) {
  25845. +            if (irq_try_1 == irq_try_2)
  25846. +                break;
  25847. +            irq_try_1 = irq_try_2 = 0;
  25848. +        }
  25849. +    }
  25850. +    restore_flags(flags);
  25851. +    free_all_interrupts(irq_lines);
  25852. +    return (irq_try_1 == irq_try_2) ? irq_try_1 : 0;
  25853. +}
  25854. +
  25855. +/*
  25856. + * This routine is called by rs_init() to initialize a specific serial
  25857. + * port.  It determines what type of UART ship this serial port is
  25858. + * using: 8250, 16450, 16550, 16550A.  The important question is
  25859. + * whether or not this UART is a 16550A or not, since this will
  25860. + * determine whether or not we can use its FIFO features or not.
  25861. + */
  25862. +static void autoconfig(struct async_struct * info)
  25863. +{
  25864. +    unsigned char status1, status2, scratch, scratch2;
  25865. +    unsigned port = info->port;
  25866. +    unsigned long flags;
  25867. +
  25868. +    info->type = PORT_UNKNOWN;
  25869. +
  25870. +    if (!port)
  25871. +        return;
  25872. +
  25873. +    save_flags(flags); cli();
  25874. +
  25875. +    /*
  25876. +     * Do a simple existence test first; if we fail this, there's
  25877. +     * no point trying anything else.
  25878. +     *
  25879. +     * 0x80 is used as a nonsense port to prevent against false
  25880. +     * positives due to ISA bus float.  The assumption is that
  25881. +     * 0x80 is a non-existent port; which should be safe since
  25882. +     * include/asm/io.h also makes this assumption.
  25883. +     */
  25884. +    scratch = serial_inp(info, UART_IER);
  25885. +    serial_outp(info, UART_IER, 0);
  25886. +    outb(0xff, 0x080);
  25887. +    scratch2 = serial_inp(info, UART_IER);
  25888. +    serial_outp(info, UART_IER, scratch);
  25889. +    if (scratch2) {
  25890. +        restore_flags(flags);
  25891. +        return;        /* We failed; there's nothing here */
  25892. +    }
  25893. +
  25894. +    /*
  25895. +     * Check to see if a UART is really there.  Certain broken
  25896. +     * internal modems based on the Rockwell chipset fail this
  25897. +     * test, because they apparently don't implement the loopback
  25898. +     * test mode.  So this test is skipped on the COM 1 through
  25899. +     * COM 4 ports.  This *should* be safe, since no board
  25900. +     * manufacturer would be stupid enough to design a board
  25901. +     * that conflicts with COM 1-4 --- we hope!
  25902. +     */
  25903. +    if (!(info->flags & ASYNC_SKIP_TEST)) {
  25904. +        scratch = serial_inp(info, UART_MCR);
  25905. +        serial_outp(info, UART_MCR, UART_MCR_LOOP | scratch);
  25906. +        scratch2 = serial_inp(info, UART_MSR);
  25907. +        serial_outp(info, UART_MCR, UART_MCR_LOOP | 0x0A);
  25908. +        status1 = serial_inp(info, UART_MSR) & 0xF0;
  25909. +        serial_outp(info, UART_MCR, scratch);
  25910. +        serial_outp(info, UART_MSR, scratch2);
  25911. +        if (status1 != 0x90) {
  25912. +            restore_flags(flags);
  25913. +            return;
  25914. +        }
  25915. +    }
  25916. +
  25917. +    /*
  25918. +     * If the AUTO_IRQ flag is set, try to do the automatic IRQ
  25919. +     * detection.
  25920. +     */
  25921. +    if (info->flags & ASYNC_AUTO_IRQ)
  25922. +        info->irq = do_auto_irq(info);
  25923. +
  25924. +    serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO);
  25925. +    scratch = serial_in(info, UART_IIR) >> 6;
  25926. +    info->xmit_fifo_size = 1;
  25927. +    switch (scratch) {
  25928. +        case 0:
  25929. +            info->type = PORT_16450;
  25930. +            break;
  25931. +        case 1:
  25932. +            info->type = PORT_UNKNOWN;
  25933. +            break;
  25934. +        case 2:
  25935. +            info->type = PORT_16550;
  25936. +            break;
  25937. +        case 3:
  25938. +            info->type = PORT_16550A;
  25939. +            info->xmit_fifo_size = 16;
  25940. +            break;
  25941. +    }
  25942. +    if (info->type == PORT_16450) {
  25943. +        scratch = serial_in(info, UART_SCR);
  25944. +        serial_outp(info, UART_SCR, 0xa5);
  25945. +        status1 = serial_in(info, UART_SCR);
  25946. +        serial_outp(info, UART_SCR, 0x5a);
  25947. +        status2 = serial_in(info, UART_SCR);
  25948. +        serial_outp(info, UART_SCR, scratch);
  25949. +
  25950. +        if ((status1 != 0xa5) || (status2 != 0x5a))
  25951. +            info->type = PORT_8250;
  25952. +    }
  25953. +
  25954. +    /*
  25955. +     * Reset the UART.
  25956. +     */
  25957. +    serial_outp(info, UART_MCR, 0x00);
  25958. +    serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
  25959. +                     UART_FCR_CLEAR_XMIT));
  25960. +    (void)serial_in(info, UART_RX);
  25961. +
  25962. +    restore_flags(flags);
  25963. +}
  25964. +
  25965. +/*
  25966. + * The serial driver boot-time initialization code!
  25967. + */
  25968. +long rs_init(long kmem_start)
  25969. +{
  25970. +    int i;
  25971. +    struct async_struct * info;
  25972. +
  25973. +    bh_base[SERIAL_BH].routine = do_serial_bh;
  25974. +    enable_bh(SERIAL_BH);
  25975. +    timer_table[RS_TIMER].fn = rs_timer;
  25976. +    timer_table[RS_TIMER].expires = 0;
  25977. +#ifdef CONFIG_AUTO_IRQ
  25978. +    rs_wild_int_mask = check_wild_interrupts(1);
  25979. +#endif
  25980. +
  25981. +    for (i = 0; i < 16; i++) {
  25982. +        IRQ_ports[i] = 0;
  25983. +        IRQ_timeout[i] = 0;
  25984. +    }
  25985. +
  25986. +    show_serial_version();
  25987. +
  25988. +    /* Initialize the tty_driver structure */
  25989. +
  25990. +    memset(&serial_driver, 0, sizeof(struct tty_driver));
  25991. +    serial_driver.magic = TTY_DRIVER_MAGIC;
  25992. +    serial_driver.name = "ttyS";
  25993. +    serial_driver.major = TTY_MAJOR;
  25994. +    serial_driver.minor_start = 64;
  25995. +    serial_driver.num = NR_PORTS;
  25996. +    serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  25997. +    serial_driver.subtype = SERIAL_TYPE_NORMAL;
  25998. +    serial_driver.init_termios = tty_std_termios;
  25999. +    serial_driver.init_termios.c_cflag =
  26000. +        B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  26001. +    serial_driver.flags = TTY_DRIVER_REAL_RAW;
  26002. +    serial_driver.refcount = &serial_refcount;
  26003. +    serial_driver.table = serial_table;
  26004. +    serial_driver.termios = serial_termios;
  26005. +    serial_driver.termios_locked = serial_termios_locked;
  26006. +
  26007. +    serial_driver.open = rs_open;
  26008. +    serial_driver.close = rs_close;
  26009. +    serial_driver.write = rs_write;
  26010. +    serial_driver.put_char = rs_put_char;
  26011. +    serial_driver.flush_chars = rs_flush_chars;
  26012. +    serial_driver.write_room = rs_write_room;
  26013. +    serial_driver.chars_in_buffer = rs_chars_in_buffer;
  26014. +    serial_driver.flush_buffer = rs_flush_buffer;
  26015. +    serial_driver.ioctl = rs_ioctl;
  26016. +    serial_driver.throttle = rs_throttle;
  26017. +    serial_driver.unthrottle = rs_unthrottle;
  26018. +    serial_driver.set_termios = rs_set_termios;
  26019. +    serial_driver.stop = rs_stop;
  26020. +    serial_driver.start = rs_start;
  26021. +    serial_driver.hangup = rs_hangup;
  26022. +
  26023. +    /*
  26024. +     * The callout device is just like normal device except for
  26025. +     * major number and the subtype code.
  26026. +     */
  26027. +    callout_driver = serial_driver;
  26028. +    callout_driver.name = "cua";
  26029. +    callout_driver.major = TTYAUX_MAJOR;
  26030. +    callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  26031. +
  26032. +    if (tty_register_driver(&serial_driver))
  26033. +        panic("Couldn't register serial driver\n");
  26034. +    if (tty_register_driver(&callout_driver))
  26035. +        panic("Couldn't register callout driver\n");
  26036. +
  26037. +    for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
  26038. +        info->magic = SERIAL_MAGIC;
  26039. +        info->line = i;
  26040. +        info->tty = 0;
  26041. +        info->type = PORT_UNKNOWN;
  26042. +        info->custom_divisor = 0;
  26043. +        info->close_delay = 50;
  26044. +        info->x_char = 0;
  26045. +        info->event = 0;
  26046. +        info->count = 0;
  26047. +        info->blocked_open = 0;
  26048. +        info->tqueue.routine = do_softint;
  26049. +        info->tqueue.data = info;
  26050. +        info->callout_termios =callout_driver.init_termios;
  26051. +        info->normal_termios = serial_driver.init_termios;
  26052. +        info->open_wait = 0;
  26053. +        info->close_wait = 0;
  26054. +        info->next_port = 0;
  26055. +        info->prev_port = 0;
  26056. +        if (info->irq == 2)
  26057. +            info->irq = 9;
  26058. +        if (!(info->flags & ASYNC_BOOT_AUTOCONF))
  26059. +            continue;
  26060. +        autoconfig(info);
  26061. +        if (info->type == PORT_UNKNOWN)
  26062. +            continue;
  26063. +        printk("tty%02d%s at 0x%04x (irq = %d)", info->line,
  26064. +               (info->flags & ASYNC_FOURPORT) ? " FourPort" : "",
  26065. +               info->port, info->irq);
  26066. +        switch (info->type) {
  26067. +            case PORT_8250:
  26068. +                printk(" is a 8250\n");
  26069. +                break;
  26070. +            case PORT_16450:
  26071. +                printk(" is a 16450\n");
  26072. +                break;
  26073. +            case PORT_16550:
  26074. +                printk(" is a 16550\n");
  26075. +                break;
  26076. +            case PORT_16550A:
  26077. +                printk(" is a 16550A\n");
  26078. +                break;
  26079. +            default:
  26080. +                printk("\n");
  26081. +                break;
  26082. +        }
  26083. +    }
  26084. +    return kmem_start;
  26085. +}
  26086. +
  26087. +/*
  26088. + * register_serial and unregister_serial allows for serial ports to be
  26089. + * configured at run-time, to support PCMCIA modems.
  26090. + */
  26091. +int register_serial(struct serial_struct *req)
  26092. +{
  26093. +    int i;
  26094. +    unsigned long flags;
  26095. +    struct async_struct *info;
  26096. +
  26097. +    save_flags(flags);
  26098. +    cli();
  26099. +    for (i = 0; i < NR_PORTS; i++) {
  26100. +        if (rs_table[i].port == req->port)
  26101. +            break;
  26102. +    }
  26103. +    if (i == NR_PORTS) {
  26104. +        for (i = 0; i < NR_PORTS; i++)
  26105. +            if ((rs_table[i].type == PORT_UNKNOWN) &&
  26106. +                (rs_table[i].count == 0))
  26107. +                break;
  26108. +    }
  26109. +    if (i == NR_PORTS) {
  26110. +        restore_flags(flags);
  26111. +        return -1;
  26112. +    }
  26113. +    info = &rs_table[i];
  26114. +    if (rs_table[i].count) {
  26115. +        restore_flags(flags);
  26116. +        printk("Couldn't configure serial #%d (port=%d,irq=%d): "
  26117. +               "device already open\n", i, req->port, req->irq);
  26118. +        return -1;
  26119. +    }
  26120. +    info->irq = req->irq;
  26121. +    info->port = req->port;
  26122. +    autoconfig(info);
  26123. +    if (info->type == PORT_UNKNOWN) {
  26124. +        restore_flags(flags);
  26125. +        printk("register_serial(): autoconfig failed\n");
  26126. +        return -1;
  26127. +    }
  26128. +    printk("tty%02d at 0x%04x (irq = %d)", info->line,
  26129. +           info->port, info->irq);
  26130. +    switch (info->type) {
  26131. +    case PORT_8250:
  26132. +        printk(" is a 8250\n"); break;
  26133. +    case PORT_16450:
  26134. +        printk(" is a 16450\n"); break;
  26135. +    case PORT_16550:
  26136. +        printk(" is a 16550\n"); break;
  26137. +    case PORT_16550A:
  26138. +        printk(" is a 16550A\n"); break;
  26139. +    default:
  26140. +        printk("\n"); break;
  26141. +    }
  26142. +    restore_flags(flags);
  26143. +    return info->line;
  26144. +}
  26145. +
  26146. +void unregister_serial(int line)
  26147. +{
  26148. +    unsigned long flags;
  26149. +    struct async_struct *info = &rs_table[line];
  26150. +
  26151. +    save_flags(flags);
  26152. +    cli();
  26153. +    if (info->tty)
  26154. +        tty_hangup(info->tty);
  26155. +    info->type = PORT_UNKNOWN;
  26156. +    printk("tty%02d unloaded\n", info->line);
  26157. +    restore_flags(flags);
  26158. +}
  26159. diff -r -u -N linux.orig/arch/arm/drivers/char/tty_diff linux.arm/arch/arm/drivers/char/tty_diff
  26160. --- linux.orig/arch/arm/drivers/char/tty_diff    Thu Jan  1 01:00:00 1970
  26161. +++ linux.arm/arch/arm/drivers/char/tty_diff    Fri Oct 27 23:14:40 1995
  26162. @@ -0,0 +1,605 @@
  26163. +--- tty_io.c    Fri Jul 14 00:07:27 1995
  26164. ++++ ../../../../drivers/char/tty_io.c    Sun Sep 24 11:09:57 1995
  26165. +@@ -52,6 +52,7 @@
  26166. + #include <linux/mm.h>
  26167. + #include <linux/string.h>
  26168. + #include <linux/malloc.h>
  26169. ++#include <linux/config.h>
  26170. + 
  26171. + #include <asm/segment.h>
  26172. + #include <asm/system.h>
  26173. +@@ -59,18 +60,27 @@
  26174. + 
  26175. + #include "kbd_kern.h"
  26176. + #include "vt_kern.h"
  26177. ++/* This to come */
  26178. ++/*#include "selection.h"*/
  26179. + 
  26180. + #define CONSOLE_DEV MKDEV(TTY_MAJOR,0)
  26181. + #define TTY_DEV MKDEV(TTYAUX_MAJOR,0)
  26182. + 
  26183. + #undef TTY_DEBUG_HANGUP
  26184. + 
  26185. ++/* These to go */
  26186. + extern int set_selection(const int arg, struct tty_struct *tty);
  26187. + extern int paste_selection(struct tty_struct *tty);
  26188. + extern int sel_loadlut(const int arg);
  26189. + extern int mouse_reporting(void);
  26190. + extern int shift_state;
  26191. + extern int do_screendump(int arg);
  26192. ++#define TTY_PARANOIA_CHECK
  26193. ++#define CHECK_TTY_COUNT
  26194. ++
  26195. ++extern void do_blank_screen(int nopowersave);
  26196. ++extern void do_unblank_screen(void);
  26197. ++/*extern void set_vesa_blanking(const unsigned long arg);*/
  26198. + 
  26199. + struct termios tty_std_termios;        /* for the benefit of tty drivers  */
  26200. + struct tty_driver *tty_drivers = NULL;    /* linked list of tty drivers */
  26201. +@@ -78,10 +80,12 @@
  26202. + 
  26203. + /*
  26204. +  * fg_console is the current virtual console,
  26205. ++ * last_console is the last used one
  26206. +  * redirect is the pseudo-tty that console output
  26207. +  * is redirected to if asked by TIOCCONS.
  26208. +  */
  26209. + int fg_console = 0;
  26210. ++int last_console = 0;
  26211. + struct tty_struct * redirect = NULL;
  26212. + struct wait_queue * keypress_wait = NULL;
  26213. + 
  26214. +@@ -123,8 +127,6 @@
  26215. +     return(_tty_name(tty, buf));
  26216. + }
  26217. + 
  26218. +-#define TTY_PARANOIA_CHECK
  26219. +-
  26220. + inline int tty_paranoia_check(struct tty_struct *tty, dev_t device,
  26221. +                   const char *routine)
  26222. + {
  26223. +@@ -146,18 +148,45 @@
  26224. +     return 0;
  26225. + }
  26226. + 
  26227. ++static int check_tty_count(struct tty_struct *tty, const char *routine)
  26228. ++{
  26229. ++#ifdef CHECK_TTY_COUNT
  26230. ++    struct file *f;
  26231. ++    int i, count = 0;
  26232. ++    
  26233. ++    for (f = first_file, i=0; i<nr_files; i++, f = f->f_next) {
  26234. ++        if (!f->f_count)
  26235. ++            continue;
  26236. ++        if (f->private_data == tty) {
  26237. ++            count++;
  26238. ++        }
  26239. ++    }
  26240. ++    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  26241. ++        tty->driver.subtype == PTY_TYPE_SLAVE &&
  26242. ++        tty->link && tty->link->count)
  26243. ++        count++;
  26244. ++    if (tty->count != count) {
  26245. ++        printk("Warning: dev (%d, %d) tty->count(%d) != #fd's(%d) in %s\n",
  26246. ++               MAJOR(tty->device), MINOR(tty->device), tty->count,
  26247. ++               count, routine);
  26248. ++        return count;
  26249. ++       }    
  26250. ++#endif
  26251. ++    return 0;
  26252. ++}
  26253. ++
  26254. + int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
  26255. + {
  26256. +     if (disc < N_TTY || disc >= NR_LDISCS)
  26257. +         return -EINVAL;
  26258. +
  26259. +     if (new_ldisc) {
  26260. +         ldiscs[disc] = *new_ldisc;
  26261. +         ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
  26262. +         ldiscs[disc].num = disc;
  26263. +     } else
  26264. +         memset(&ldiscs[disc], 0, sizeof(struct tty_ldisc));
  26265. +
  26266. +     return 0;
  26267. + }
  26268. + 
  26269. +@@ -175,6 +204,8 @@
  26270. +         return 0;    /* We are already in the desired discipline */
  26271. +     o_ldisc = tty->ldisc;
  26272. + 
  26273. ++    tty_wait_until_sent(tty, 0);
  26274. ++    
  26275. +     /* Shutdown the current discipline. */
  26276. +     if (tty->ldisc.close)
  26277. +         (tty->ldisc.close)(tty);
  26278. +@@ -313,6 +344,7 @@
  26279. + 
  26280. +     if (!tty)
  26281. +         return;
  26282. ++    check_tty_count(tty, "do_tty_hangup");
  26283. +     for (filp = first_file, i=0; i<nr_files; i++, filp = filp->f_next) {
  26284. +         if (!filp->f_count)
  26285. +             continue;
  26286. +@@ -352,18 +384,22 @@
  26287. +                        -i);
  26288. +         }
  26289. +     }
  26290. +-
  26291. +-    if (tty->session > 0) {
  26292. +-        kill_sl(tty->session,SIGHUP,1);
  26293. +-        kill_sl(tty->session,SIGCONT,1);
  26294. +-    }
  26295. +-    tty->flags = 0;
  26296. +-    tty->session = 0;
  26297. +-    tty->pgrp = -1;
  26298. ++    
  26299. +      for_each_task(p) {
  26300. ++        if ((tty->session > 0) && (p->session == tty->session) &&
  26301. ++            p->leader) {
  26302. ++            send_sig(SIGHUP,p,1);
  26303. ++            send_sig(SIGCONT,p,1);
  26304. ++            if (tty->pgrp > 0)
  26305. ++                p->tty_old_pgrp = tty->pgrp;
  26306. ++        }
  26307. +         if (p->tty == tty)
  26308. +             p->tty = NULL;
  26309. +     }
  26310. ++    tty->flags = 0;
  26311. ++    tty->session = 0;
  26312. ++    tty->pgrp = -1;
  26313. ++    tty->ctrl_status = 0;
  26314. +     if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS)
  26315. +         *tty->termios = tty->driver.init_termios;
  26316. +     if (tty->driver.hangup)
  26317. +@@ -406,13 +442,19 @@
  26318. +     struct tty_struct *tty = current->tty;
  26319. +     struct task_struct *p;
  26320. + 
  26321. +-    if (!tty)
  26322. ++    if (!tty) {
  26323. ++        if (current->tty_old_pgrp) {
  26324. ++            kill_pg(current->tty_old_pgrp, SIGHUP, priv);
  26325. ++            kill_pg(current->tty_old_pgrp, SIGCONT, priv);
  26326. ++        }
  26327. +         return;
  26328. +-
  26329. ++    }
  26330. +     if (tty->pgrp > 0) {
  26331. +         kill_pg(tty->pgrp, SIGHUP, priv);
  26332. +         kill_pg(tty->pgrp, SIGCONT, priv);
  26333. +     }
  26334. ++
  26335. ++    current->tty_old_pgrp = 0;
  26336. +     tty->session = 0;
  26337. +     tty->pgrp = -1;
  26338. + 
  26339. +@@ -466,6 +508,7 @@
  26340. +                 return;
  26341. +         if (!vc_cons_allocated(new_console))
  26342. +                 return;
  26343. ++    last_console = fg_console;
  26344. + 
  26345. +     /*
  26346. +      * If we're switching, we could be going from KD_GRAPHICS to
  26347. +@@ -511,11 +554,9 @@
  26348. +     if (old_vc_mode != vt_cons[new_console]->vc_mode)
  26349. +     {
  26350. +         if (vt_cons[new_console]->vc_mode == KD_TEXT)
  26351. +-            unblank_screen();
  26352. +-        else {
  26353. +-            timer_active &= ~(1<<BLANK_TIMER);
  26354. +-            blank_screen();
  26355. +-        }
  26356. ++            do_unblank_screen();
  26357. ++        else
  26358. ++            do_blank_screen(1);
  26359. +     }
  26360. + 
  26361. +     /*
  26362. +@@ -715,7 +756,7 @@
  26363. +     struct tty_struct *tty, **tty_loc, *o_tty, **o_tty_loc;
  26364. +     struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
  26365. +     struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
  26366. +-    struct tty_driver *driver;
  26367. ++    struct tty_driver *driver;    
  26368. +     int retval;
  26369. +     int idx;
  26370. + 
  26371. +@@ -733,6 +774,7 @@
  26372. +     tty_loc = &driver->table[idx];
  26373. +     tp_loc = &driver->termios[idx];
  26374. +     ltp_loc = &driver->termios_locked[idx];
  26375. ++
  26376. + repeat:
  26377. +     retval = -EAGAIN;
  26378. +     if (driver->type == TTY_DRIVER_TYPE_PTY &&
  26379. +@@ -772,9 +813,10 @@
  26380. + 
  26381. +         if (!*o_tty_loc && !o_tty) {
  26382. +             dev_t     o_device;
  26383. ++            
  26384. +             o_tty = (struct tty_struct *)
  26385. +                 kmalloc(sizeof(struct tty_struct),
  26386. +                     GFP_KERNEL);
  26387. +             if (!o_tty)
  26388. +                 goto end_init;
  26389. +             o_device = MKDEV(driver->other->major,
  26390. +@@ -800,7 +841,7 @@
  26391. +             memset(o_ltp, 0, sizeof(struct termios));
  26392. +             goto repeat;
  26393. +         }
  26394. +-
  26395. ++        
  26396. +     }
  26397. +     /* Now we have allocated all the structures: update all the pointers.. */
  26398. +     if (!*tp_loc) {
  26399. +@@ -826,8 +867,15 @@
  26400. +             }
  26401. +         }
  26402. +         tty = NULL;
  26403. +-    } else
  26404. ++    } else {
  26405. ++        if ((*tty_loc)->flags & (1 << TTY_CLOSING)) {
  26406. ++            printk("Attempt to open closing tty %s.\n",
  26407. ++                   tty_name(*tty_loc));
  26408. ++            printk("Ack!!!!  This should never happen!!\n");
  26409. ++            return -EINVAL;
  26410. ++        }
  26411. +         (*tty_loc)->count++;
  26412. ++    }
  26413. +     if (driver->type == TTY_DRIVER_TYPE_PTY) {
  26414. +         if (!*o_tp_loc) {
  26415. +             *o_tp_loc = o_tp;
  26416. +@@ -887,12 +935,13 @@
  26417. +     struct termios *tp, *o_tp, *ltp, *o_ltp;
  26418. +     struct task_struct **p;
  26419. +     int    idx;
  26420. +-
  26421. +-
  26422. ++    
  26423. +     tty = (struct tty_struct *)filp->private_data;
  26424. +     if (tty_paranoia_check(tty, filp->f_inode->i_rdev, "release_dev"))
  26425. +         return;
  26426. + 
  26427. ++    check_tty_count(tty, "release_dev");
  26428. ++
  26429. +     tty_fasync(filp->f_inode, filp, 0);
  26430. + 
  26431. +     tp = tty->termios;
  26432. +@@ -955,7 +1004,7 @@
  26433. +         }
  26434. +     }
  26435. + #endif
  26436. +-
  26437. ++    
  26438. +     if (tty->driver.close)
  26439. +         tty->driver.close(tty, filp);
  26440. +     if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  26441. +@@ -974,6 +1023,9 @@
  26442. +     if (tty->count)
  26443. +         return;
  26444. + 
  26445. ++    /*
  26446. ++     * We're committed; at this point, we must not block!
  26447. ++     */
  26448. +     if (o_tty) {
  26449. +         if (o_tty->count)
  26450. +             return;
  26451. +@@ -981,10 +1033,11 @@
  26452. +         tty->driver.other->termios[idx] = NULL;
  26453. +         kfree_s(o_tp, sizeof(struct termios));
  26454. +     }
  26455. +-
  26456. ++    
  26457. + #ifdef TTY_DEBUG_HANGUP
  26458. +     printk("freeing tty structure...");
  26459. + #endif
  26460. ++    tty->flags |= (1 << TTY_CLOSING);
  26461. + 
  26462. +     /*
  26463. +      * Make sure there aren't any processes that still think this
  26464. +@@ -1007,7 +1060,12 @@
  26465. +         (tty->ldisc.close)(tty);
  26466. +     tty->ldisc = ldiscs[N_TTY];
  26467. +     tty->termios->c_line = N_TTY;
  26468. +-
  26469. ++    if (o_tty) {
  26470. ++        if (o_tty->ldisc.close)
  26471. ++            (o_tty->ldisc.close)(o_tty);
  26472. ++        o_tty->ldisc = ldiscs[N_TTY];
  26473. ++    }
  26474. ++    
  26475. +     tty->driver.table[idx] = NULL;
  26476. +     if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS) {
  26477. +         tty->driver.termios[idx] = NULL;
  26478. +@@ -1036,11 +1094,12 @@
  26479. +     sti();
  26480. +     tty->magic = 0;
  26481. +     (*tty->driver.refcount)--;
  26482. +     kfree_s(tty,sizeof(struct tty_struct));
  26483. ++    filp->private_data = 0;
  26484. +     if (o_tty) {
  26485. +         o_tty->magic = 0;
  26486. +         (*o_tty->driver.refcount)--;
  26487. +         kfree_s(o_tty,sizeof(struct tty_struct));
  26488. +     }
  26489. + }
  26490. + 
  26491. +@@ -1077,11 +1136,12 @@
  26492. +         noctty = 1;
  26493. +     }
  26494. +     minor = MINOR(device);
  26495. +-
  26496. ++    
  26497. +     retval = init_dev(device, &tty);
  26498. +-    filp->private_data = tty;
  26499. +     if (retval)
  26500. +         return retval;
  26501. ++    filp->private_data = tty;
  26502. ++    check_tty_count(tty, "tty_open");
  26503. +     if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  26504. +         tty->driver.subtype == PTY_TYPE_MASTER)
  26505. +         noctty = 1;
  26506. +@@ -1118,6 +1178,7 @@
  26507. +         !current->tty &&
  26508. +         tty->session == 0) {
  26509. +         current->tty = tty;
  26510. ++        current->tty_old_pgrp = 0;
  26511. +         tty->session = current->session;
  26512. +         tty->pgrp = current->pgrp;
  26513. +     }
  26514. +@@ -1190,13 +1251,14 @@
  26515. +         if (!tty->fasync && !tty->read_wait)
  26516. +             tty->minimum_to_wake = N_TTY_BUF_SIZE;
  26517. +     }
  26518. +-    return 0;
  26519. ++    return 0;    
  26520. + }
  26521. + 
  26522. ++#if 0
  26523. + /*
  26524. +  * XXX does anyone use this anymore?!?
  26525. +  */
  26526. +-static int do_get_ps_info(int arg)
  26527. ++static int do_get_ps_info(unsigned long arg)
  26528. + {
  26529. +     struct tstruct {
  26530. +         int flag;
  26531. +@@ -1207,7 +1269,7 @@
  26532. +     struct task_struct **p;
  26533. +     char *c, *d;
  26534. +     int i, n = 0;
  26535. +-
  26536. ++    
  26537. +     i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct tstruct));
  26538. +     if (i)
  26539. +         return i;
  26540. +@@ -1220,10 +1282,11 @@
  26541. +                 put_fs_byte(*c++, d++);
  26542. +             put_fs_long(1, (unsigned long *)(ts->present+n));
  26543. +         }
  26544. +-        else
  26545. ++        else    
  26546. +             put_fs_long(0, (unsigned long *)(ts->present+n));
  26547. +-    return(0);
  26548. ++    return(0);            
  26549. + }
  26550. ++#endif
  26551. + 
  26552. + static int tty_ioctl(struct inode * inode, struct file * file,
  26553. +              unsigned int cmd, unsigned long arg)
  26554. +@@ -1235,7 +1298,7 @@
  26555. +     pid_t pgrp;
  26556. +     unsigned char    ch;
  26557. +     char    mbz = 0;
  26558. +-
  26559. ++    
  26560. +     tty = (struct tty_struct *)file->private_data;
  26561. +     if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
  26562. +         return -EINVAL;
  26563. +@@ -1268,7 +1331,7 @@
  26564. +             retval = verify_area(VERIFY_READ, (void *) arg,
  26565. +                          sizeof (struct winsize));
  26566. +             if (retval)
  26567. +-                return retval;
  26568. ++                return retval;            
  26569. +             memcpy_fromfs(&tmp_ws, (struct winsize *) arg,
  26570. +                       sizeof (struct winsize));
  26571. +             if (memcmp(&tmp_ws, &tty->winsize,
  26572. +@@ -1344,6 +1407,7 @@
  26573. +                     return -EPERM;
  26574. +             }
  26575. +             current->tty = tty;
  26576. ++            current->tty_old_pgrp = 0;
  26577. +             tty->session = current->session;
  26578. +             tty->pgrp = current->pgrp;
  26579. +             return 0;
  26580. +@@ -1389,39 +1453,61 @@
  26581. +             arg = get_fs_long((unsigned long *) arg);
  26582. +             return tty_set_ldisc(tty, arg);
  26583. +         case TIOCLINUX:
  26584. ++            if (tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)
  26585. ++                return -EINVAL;
  26586. ++            if (current->tty != tty && !suser())
  26587. ++                return -EPERM;
  26588. +             retval = verify_area(VERIFY_READ, (void *) arg, 1);
  26589. +             if (retval)
  26590. +                 return retval;
  26591. +-            switch (get_fs_byte((char *)arg))
  26592. ++            switch (retval = get_fs_byte((char *)arg))
  26593. +             {
  26594. +                 case 0:
  26595. +-                    return do_screendump(arg);
  26596. ++                case 8:
  26597. ++                case 9:
  26598. ++                    printk("TIOCLINUX (0/8/9) ioctl is gone - use /dev/vcs\n");
  26599. ++                    return -EINVAL;
  26600. ++#if 0
  26601. +                 case 1:
  26602. +                     printk("Deprecated TIOCLINUX (1) ioctl\n");
  26603. +                     return do_get_ps_info(arg);
  26604. ++#endif
  26605. +                 case 2:
  26606. +                     return set_selection(arg, tty);
  26607. +                 case 3:
  26608. +                     return paste_selection(tty);
  26609. +                 case 4:
  26610. +-                    unblank_screen();
  26611. ++                    do_unblank_screen();
  26612. +                     return 0;
  26613. +                 case 5:
  26614. +                     return sel_loadlut(arg);
  26615. +                 case 6:
  26616. +-            /* Make it possible to react to Shift+Mousebutton */
  26617. +-            /* Note that shift_state is an undocumented
  26618. +-               kernel-internal variable; programs not closely
  26619. +-               related to the kernel should not use this. */
  26620. +-                    put_fs_byte(0, arg);
  26621. +-/*                     put_fs_byte(shift_state,arg); */
  26622. ++            /*
  26623. ++             * Make it possible to react to Shift+Mousebutton.
  26624. ++             * Note that 'shift_state' is an undocumented
  26625. ++             * kernel-internal variable; programs not closely
  26626. ++             * related to the kernel should not use this.
  26627. ++             */
  26628. ++                    put_fs_byte(shift_state,arg);
  26629. +                     return 0;
  26630. +                 case 7:
  26631. +                     put_fs_byte(mouse_reporting(),arg);
  26632. +                     return 0;
  26633. +-                default:
  26634. ++/*                case 10:
  26635. ++                    set_vesa_blanking(arg);
  26636. ++                    return 0;*/
  26637. ++                default: 
  26638. +                     return -EINVAL;
  26639. +             }
  26640. ++
  26641. ++        case TIOCTTYGSTRUCT:
  26642. ++            retval = verify_area(VERIFY_WRITE, (void *) arg,
  26643. ++                        sizeof(struct tty_struct));
  26644. ++            if (retval)
  26645. ++                return retval;
  26646. ++            memcpy_tofs((struct tty_struct *) arg,
  26647. ++                    tty, sizeof(struct tty_struct));
  26648. ++            return 0;
  26649. +         default:
  26650. +             if (tty->driver.ioctl) {
  26651. +                 retval = (tty->driver.ioctl)(tty, file,
  26652. +@@ -1445,7 +1531,7 @@
  26653. +  * prevent trojan horses by killing all processes associated with this
  26654. +  * tty when the user hits the "Secure Attention Key".  Required for
  26655. +  * super-paranoid applications --- see the Orange Book for more details.
  26656. +- *
  26657. ++ * 
  26658. +  * This code could be nicer; ideally it should send a HUP, wait a few
  26659. +  * seconds, then send a INT, and then a KILL signal.  But you then
  26660. +  * have to coordinate with the init process, since all processes associated
  26661. +@@ -1461,7 +1547,7 @@
  26662. +     int session;
  26663. +     int        i;
  26664. +     struct file    *filp;
  26665. +-
  26666. ++    
  26667. +     if (!tty)
  26668. +         return;
  26669. +     session  = tty->session;
  26670. +@@ -1520,7 +1606,7 @@
  26671. +     count = tty->flip.count;
  26672. +     tty->flip.count = 0;
  26673. +     sti();
  26674. +-
  26675. ++    
  26676. + #if 0
  26677. +     if (count > tty->max_flip_cnt)
  26678. +         tty->max_flip_cnt = count;
  26679. +@@ -1569,10 +1655,10 @@
  26680. + 
  26681. +     if (!driver->put_char)
  26682. +         driver->put_char = tty_default_put_char;
  26683. +-
  26684. ++    
  26685. +     driver->prev = 0;
  26686. +     driver->next = tty_drivers;
  26687. +-    tty_drivers->prev = driver;
  26688. ++    if (tty_drivers) tty_drivers->prev = driver;
  26689. +     tty_drivers = driver;
  26690. +     return error;
  26691. + }
  26692. +@@ -1585,31 +1671,32 @@
  26693. +     int    retval;
  26694. +     struct tty_driver *p;
  26695. +     int    found = 0;
  26696. +-    int    major_inuse = 0;
  26697. +-
  26698. +-    if (driver->refcount)
  26699. ++    char *othername = NULL;
  26700. ++    
  26701. ++    if (*driver->refcount)
  26702. +         return -EBUSY;
  26703. + 
  26704. +     for (p = tty_drivers; p; p = p->next) {
  26705. +         if (p == driver)
  26706. +             found++;
  26707. +         else if (p->major == driver->major)
  26708. +-            major_inuse++;
  26709. ++            othername = p->name;
  26710. +     }
  26711. + 
  26712. +-    if (!major_inuse) {
  26713. ++    if (othername == NULL) {
  26714. +         retval = unregister_chrdev(driver->major, driver->name);
  26715. +         if (retval)
  26716. +             return retval;
  26717. +-    }
  26718. ++    } else
  26719. ++        register_chrdev(driver->major, othername, &tty_fops);
  26720. + 
  26721. +     if (driver->prev)
  26722. +         driver->prev->next = driver->next;
  26723. +     else
  26724. +         tty_drivers = driver->next;
  26725. +-
  26726. ++    
  26727. +     if (driver->next)
  26728. +-        driver->next = driver->next->prev;
  26729. ++        driver->next->prev = driver->prev;
  26730. + 
  26731. +     return 0;
  26732. + }
  26733. +@@ -1628,20 +1715,19 @@
  26734. +     (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
  26735. + 
  26736. +     /*
  26737. +-     * Set up the standard termios.  Individual tty drivers may
  26738. ++     * Set up the standard termios.  Individual tty drivers may 
  26739. +      * deviate from this; this is used as a template.
  26740. +      */
  26741. +-
  26742. +     memset(&tty_std_termios, 0, sizeof(struct termios));
  26743. +     memcpy(tty_std_termios.c_cc, INIT_C_CC, NCCS);
  26744. +-
  26745. +     tty_std_termios.c_iflag = ICRNL | IXON;
  26746. +     tty_std_termios.c_oflag = OPOST | ONLCR;
  26747. +     tty_std_termios.c_cflag = B38400 | CS8 | CREAD;
  26748. +     tty_std_termios.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
  26749. +         ECHOCTL | ECHOKE | IEXTEN;
  26750. ++
  26751. +     /*
  26752. +-     * set up the console device so that later boot sequences can
  26753. ++     * set up the console device so that later boot sequences can 
  26754. +      * inform about problems etc..
  26755. +      */
  26756. +     return con_init(kmem_start);
  26757. +@@ -1662,6 +1748,10 @@
  26758. + 
  26759. +     kmem_start = kbd_init(kmem_start);
  26760. +     kmem_start = rs_init(kmem_start);
  26761. ++#ifdef CONFIG_CYCLADES
  26762. ++    kmem_start = cy_init(kmem_start);
  26763. ++#endif
  26764. +     kmem_start = pty_init(kmem_start);
  26765. ++    kmem_start = vcs_init(kmem_start);
  26766. +     return kmem_start;
  26767. + }
  26768. diff -r -u -N linux.orig/arch/arm/drivers/char/tty_io.c linux.arm/arch/arm/drivers/char/tty_io.c
  26769. --- linux.orig/arch/arm/drivers/char/tty_io.c    Thu Jan  1 01:00:00 1970
  26770. +++ linux.arm/arch/arm/drivers/char/tty_io.c    Fri Oct 27 23:14:27 1995
  26771. @@ -0,0 +1,1767 @@
  26772. +/*
  26773. + *  linux/drivers/char/tty_io.c
  26774. + *
  26775. + *  Copyright (C) 1991, 1992  Linus Torvalds
  26776. + */
  26777. +
  26778. +/*
  26779. + * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
  26780. + * or rs-channels. It also implements echoing, cooked mode etc.
  26781. + *
  26782. + * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
  26783. + *
  26784. + * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
  26785. + * tty_struct and tty_queue structures.  Previously there was a array
  26786. + * of 256 tty_struct's which was statically allocated, and the
  26787. + * tty_queue structures were allocated at boot time.  Both are now
  26788. + * dynamically allocated only when the tty is open.
  26789. + *
  26790. + * Also restructured routines so that there is more of a separation
  26791. + * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
  26792. + * the low-level tty routines (serial.c, pty.c, console.c).  This
  26793. + * makes for cleaner and more compact code.  -TYT, 9/17/92
  26794. + *
  26795. + * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
  26796. + * which can be dynamically activated and de-activated by the line
  26797. + * discipline handling modules (like SLIP).
  26798. + *
  26799. + * NOTE: pay no attention to the line discipline code (yet); its
  26800. + * interface is still subject to change in this version...
  26801. + * -- TYT, 1/31/92
  26802. + *
  26803. + * Added functionality to the OPOST tty handling.  No delays, but all
  26804. + * other bits should be there.
  26805. + *    -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
  26806. + *
  26807. + * Rewrote canonical mode and added more termios flags.
  26808. + *     -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
  26809. + */
  26810. +
  26811. +#include <linux/types.h>
  26812. +#include <linux/major.h>
  26813. +#include <linux/errno.h>
  26814. +#include <linux/signal.h>
  26815. +#include <linux/fcntl.h>
  26816. +#include <linux/sched.h>
  26817. +#include <linux/interrupt.h>
  26818. +#include <linux/tty.h>
  26819. +#include <linux/tty_flip.h>
  26820. +#include <linux/timer.h>
  26821. +#include <linux/ctype.h>
  26822. +#include <linux/kd.h>
  26823. +#include <linux/mm.h>
  26824. +#include <linux/string.h>
  26825. +#include <linux/malloc.h>
  26826. +#include <linux/config.h>
  26827. +
  26828. +#include <asm/segment.h>
  26829. +#include <asm/system.h>
  26830. +#include <asm/bitops.h>
  26831. +
  26832. +#include "kbd_kern.h"
  26833. +#include "vt_kern.h"
  26834. +/* This to come */
  26835. +/*#include "selection.h"*/
  26836. +
  26837. +#define CONSOLE_DEV MKDEV(TTY_MAJOR,0)
  26838. +#define TTY_DEV MKDEV(TTYAUX_MAJOR,0)
  26839. +
  26840. +#undef TTY_DEBUG_HANGUP
  26841. +
  26842. +/* These to go */
  26843. +extern int set_selection(const int arg, struct tty_struct *tty);
  26844. +extern int paste_selection(struct tty_struct *tty);
  26845. +extern int sel_loadlut(const int arg);
  26846. +extern int mouse_reporting(void);
  26847. +extern int shift_state;
  26848. +extern int do_screendump(int arg);
  26849. +#define TTY_PARANOIA_CHECK
  26850. +#define CHECK_TTY_COUNT
  26851. +
  26852. +extern void do_blank_screen(int nopowersave);
  26853. +extern void do_unblank_screen(void);
  26854. +/*extern void set_vesa_blanking(const unsigned long arg);*/
  26855. +
  26856. +struct termios tty_std_termios;        /* for the benefit of tty drivers  */
  26857. +struct tty_driver *tty_drivers = NULL;    /* linked list of tty drivers */
  26858. +struct tty_ldisc ldiscs[NR_LDISCS];    /* line disc dispatch table    */
  26859. +
  26860. +/*
  26861. + * fg_console is the current virtual console,
  26862. + * last_console is the last used one
  26863. + * redirect is the pseudo-tty that console output
  26864. + * is redirected to if asked by TIOCCONS.
  26865. + */
  26866. +int fg_console = 0;
  26867. +int last_console = 0;
  26868. +struct tty_struct * redirect = NULL;
  26869. +struct wait_queue * keypress_wait = NULL;
  26870. +
  26871. +static void initialize_tty_struct(struct tty_struct *tty);
  26872. +
  26873. +static int tty_read(struct inode *, struct file *, char *, int);
  26874. +static int tty_write(struct inode *, struct file *, char *, int);
  26875. +static int tty_select(struct inode *, struct file *, int, select_table *);
  26876. +static int tty_open(struct inode *, struct file *);
  26877. +static void tty_release(struct inode *, struct file *);
  26878. +static int tty_ioctl(struct inode * inode, struct file * file,
  26879. +             unsigned int cmd, unsigned long arg);
  26880. +static int tty_fasync(struct inode * inode, struct file * filp, int on);
  26881. +
  26882. +#ifndef MIN
  26883. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  26884. +#endif
  26885. +
  26886. +/*
  26887. + * These two routines return the name of tty.  tty_name() should NOT
  26888. + * be used in interrupt drivers, since it's not re-entrant.  Use
  26889. + * _tty_name() instead.
  26890. + */
  26891. +char *_tty_name(struct tty_struct *tty, char *buf)
  26892. +{
  26893. +    if (tty)
  26894. +        sprintf(buf, "%s%d", tty->driver.name,
  26895. +            MINOR(tty->device) - tty->driver.minor_start +
  26896. +            tty->driver.name_base);
  26897. +    else
  26898. +        strcpy(buf, "NULL tty");
  26899. +    return buf;
  26900. +}
  26901. +
  26902. +char *tty_name(struct tty_struct *tty)
  26903. +{
  26904. +    static char buf[64];
  26905. +
  26906. +    return(_tty_name(tty, buf));
  26907. +}
  26908. +
  26909. +inline int tty_paranoia_check(struct tty_struct *tty, dev_t device,
  26910. +                  const char *routine)
  26911. +{
  26912. +#ifdef TTY_PARANOIA_CHECK
  26913. +    static const char *badmagic =
  26914. +        "Warning: bad magic number for tty struct (%d, %d) in %s\n";
  26915. +    static const char *badtty =
  26916. +        "Warning: null TTY for (%d, %d) in %s\n";
  26917. +
  26918. +    if (!tty) {
  26919. +        printk(badtty, MAJOR(device), MINOR(device), routine);
  26920. +        return 1;
  26921. +    }
  26922. +    if (tty->magic != TTY_MAGIC) {
  26923. +        printk(badmagic, MAJOR(device), MINOR(device), routine);
  26924. +        return 1;
  26925. +    }
  26926. +#endif
  26927. +    return 0;
  26928. +}
  26929. +
  26930. +static int check_tty_count(struct tty_struct *tty, const char *routine)
  26931. +{
  26932. +#ifdef CHECK_TTY_COUNT
  26933. +    struct file *f;
  26934. +    int i, count = 0;
  26935. +    
  26936. +    for (f = first_file, i=0; i<nr_files; i++, f = f->f_next) {
  26937. +        if (!f->f_count)
  26938. +            continue;
  26939. +        if (f->private_data == tty) {
  26940. +            count++;
  26941. +        }
  26942. +    }
  26943. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  26944. +        tty->driver.subtype == PTY_TYPE_SLAVE &&
  26945. +        tty->link && tty->link->count)
  26946. +        count++;
  26947. +    if (tty->count != count) {
  26948. +        printk("Warning: dev (%d, %d) tty->count(%d) != #fd's(%d) in %s\n",
  26949. +               MAJOR(tty->device), MINOR(tty->device), tty->count,
  26950. +               count, routine);
  26951. +        return count;
  26952. +       }    
  26953. +#endif
  26954. +    return 0;
  26955. +}
  26956. +
  26957. +int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
  26958. +{
  26959. +    if (disc < N_TTY || disc >= NR_LDISCS)
  26960. +        return -EINVAL;
  26961. +
  26962. +    if (new_ldisc) {
  26963. +        ldiscs[disc] = *new_ldisc;
  26964. +        ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
  26965. +        ldiscs[disc].num = disc;
  26966. +    } else
  26967. +        memset(&ldiscs[disc], 0, sizeof(struct tty_ldisc));
  26968. +
  26969. +    return 0;
  26970. +}
  26971. +
  26972. +/* Set the discipline of a tty line. */
  26973. +static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
  26974. +{
  26975. +    int    retval = 0;
  26976. +    struct    tty_ldisc o_ldisc;
  26977. +
  26978. +    if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS) ||
  26979. +        !(ldiscs[ldisc].flags & LDISC_FLAG_DEFINED))
  26980. +        return -EINVAL;
  26981. +
  26982. +    if (tty->ldisc.num == ldisc)
  26983. +        return 0;    /* We are already in the desired discipline */
  26984. +    o_ldisc = tty->ldisc;
  26985. +
  26986. +    tty_wait_until_sent(tty, 0);
  26987. +    
  26988. +    /* Shutdown the current discipline. */
  26989. +    if (tty->ldisc.close)
  26990. +        (tty->ldisc.close)(tty);
  26991. +
  26992. +    /* Now set up the new line discipline. */
  26993. +    tty->ldisc = ldiscs[ldisc];
  26994. +    tty->termios->c_line = ldisc;
  26995. +    if (tty->ldisc.open)
  26996. +        retval = (tty->ldisc.open)(tty);
  26997. +    if (retval < 0) {
  26998. +        tty->ldisc = o_ldisc;
  26999. +        tty->termios->c_line = tty->ldisc.num;
  27000. +        if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
  27001. +            tty->ldisc = ldiscs[N_TTY];
  27002. +            tty->termios->c_line = N_TTY;
  27003. +            if (tty->ldisc.open) {
  27004. +                int r = tty->ldisc.open(tty);
  27005. +
  27006. +                if (r < 0)
  27007. +                    panic("Couldn't open N_TTY ldisc for "
  27008. +                          "%s --- error %d.",
  27009. +                          tty_name(tty), r);
  27010. +            }
  27011. +        }
  27012. +    }
  27013. +    if (tty->ldisc.num != o_ldisc.num && tty->driver.set_ldisc)
  27014. +        tty->driver.set_ldisc(tty);
  27015. +    return retval;
  27016. +}
  27017. +
  27018. +/*
  27019. + * This routine returns a tty driver structure, given a device number
  27020. + */
  27021. +struct tty_driver *get_tty_driver(dev_t device)
  27022. +{
  27023. +    int    major, minor;
  27024. +    struct tty_driver *p;
  27025. +
  27026. +    minor = MINOR(device);
  27027. +    major = MAJOR(device);
  27028. +
  27029. +    for (p = tty_drivers; p; p = p->next) {
  27030. +        if (p->major != major)
  27031. +            continue;
  27032. +        if (minor < p->minor_start)
  27033. +            continue;
  27034. +        if (minor >= p->minor_start + p->num)
  27035. +            continue;
  27036. +        return p;
  27037. +    }
  27038. +    return NULL;
  27039. +}
  27040. +
  27041. +/*
  27042. + * If we try to write to, or set the state of, a terminal and we're
  27043. + * not in the foreground, send a SIGTTOU.  If the signal is blocked or
  27044. + * ignored, go ahead and perform the operation.  (POSIX 7.2)
  27045. + */
  27046. +int tty_check_change(struct tty_struct * tty)
  27047. +{
  27048. +    if (current->tty != tty)
  27049. +        return 0;
  27050. +    if (tty->pgrp <= 0) {
  27051. +        printk("tty_check_change: tty->pgrp <= 0!\n");
  27052. +        return 0;
  27053. +    }
  27054. +    if (current->pgrp == tty->pgrp)
  27055. +        return 0;
  27056. +    if (is_ignored(SIGTTOU))
  27057. +        return 0;
  27058. +    if (is_orphaned_pgrp(current->pgrp))
  27059. +        return -EIO;
  27060. +    (void) kill_pg(current->pgrp,SIGTTOU,1);
  27061. +    return -ERESTARTSYS;
  27062. +}
  27063. +
  27064. +static int hung_up_tty_read(struct inode * inode, struct file * file, char * buf, int count)
  27065. +{
  27066. +    return 0;
  27067. +}
  27068. +
  27069. +static int hung_up_tty_write(struct inode * inode, struct file * file, char * buf, int count)
  27070. +{
  27071. +    return -EIO;
  27072. +}
  27073. +
  27074. +static int hung_up_tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
  27075. +{
  27076. +    return 1;
  27077. +}
  27078. +
  27079. +static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
  27080. +                 unsigned int cmd, unsigned long arg)
  27081. +{
  27082. +    return -EIO;
  27083. +}
  27084. +
  27085. +static int tty_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
  27086. +{
  27087. +    return -ESPIPE;
  27088. +}
  27089. +
  27090. +static struct file_operations tty_fops = {
  27091. +    tty_lseek,
  27092. +    tty_read,
  27093. +    tty_write,
  27094. +    NULL,        /* tty_readdir */
  27095. +    tty_select,
  27096. +    tty_ioctl,
  27097. +    NULL,        /* tty_mmap */
  27098. +    tty_open,
  27099. +    tty_release,
  27100. +    NULL,        /* tty_fsync */
  27101. +    tty_fasync
  27102. +};
  27103. +
  27104. +static struct file_operations hung_up_tty_fops = {
  27105. +    tty_lseek,
  27106. +    hung_up_tty_read,
  27107. +    hung_up_tty_write,
  27108. +    NULL,        /* hung_up_tty_readdir */
  27109. +    hung_up_tty_select,
  27110. +    hung_up_tty_ioctl,
  27111. +    NULL,        /* hung_up_tty_mmap */
  27112. +    NULL,        /* hung_up_tty_open */
  27113. +    tty_release,    /* hung_up_tty_release */
  27114. +    NULL,        /* hung_up_tty_fsync  */
  27115. +    NULL        /* hung_up_tty_fasync */
  27116. +};
  27117. +
  27118. +void do_tty_hangup(struct tty_struct * tty, struct file_operations *fops)
  27119. +{
  27120. +    int i;
  27121. +    struct file * filp;
  27122. +    struct task_struct *p;
  27123. +
  27124. +    if (!tty)
  27125. +        return;
  27126. +    check_tty_count(tty, "do_tty_hangup");
  27127. +    for (filp = first_file, i=0; i<nr_files; i++, filp = filp->f_next) {
  27128. +        if (!filp->f_count)
  27129. +            continue;
  27130. +        if (filp->private_data != tty)
  27131. +            continue;
  27132. +        if (filp->f_inode && filp->f_inode->i_rdev == CONSOLE_DEV)
  27133. +            continue;
  27134. +        if (filp->f_op != &tty_fops)
  27135. +            continue;
  27136. +        tty_fasync(filp->f_inode, filp, 0);
  27137. +        filp->f_op = fops;
  27138. +    }
  27139. +
  27140. +    if (tty->ldisc.flush_buffer)
  27141. +        tty->ldisc.flush_buffer(tty);
  27142. +    if (tty->driver.flush_buffer)
  27143. +        tty->driver.flush_buffer(tty);
  27144. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  27145. +        tty->ldisc.write_wakeup)
  27146. +        (tty->ldisc.write_wakeup)(tty);
  27147. +    wake_up_interruptible(&tty->write_wait);
  27148. +    wake_up_interruptible(&tty->read_wait);
  27149. +
  27150. +    /*
  27151. +     * Shutdown the current line discipline, and reset it to
  27152. +     * N_TTY.
  27153. +     */
  27154. +    if (tty->ldisc.num != ldiscs[N_TTY].num) {
  27155. +        if (tty->ldisc.close)
  27156. +            (tty->ldisc.close)(tty);
  27157. +        tty->ldisc = ldiscs[N_TTY];
  27158. +        tty->termios->c_line = N_TTY;
  27159. +        if (tty->ldisc.open) {
  27160. +            i = (tty->ldisc.open)(tty);
  27161. +            if (i < 0)
  27162. +                printk("do_tty_hangup: N_TTY open: error %d\n",
  27163. +                       -i);
  27164. +        }
  27165. +    }
  27166. +    
  27167. +     for_each_task(p) {
  27168. +        if ((tty->session > 0) && (p->session == tty->session) &&
  27169. +            p->leader) {
  27170. +            send_sig(SIGHUP,p,1);
  27171. +            send_sig(SIGCONT,p,1);
  27172. +            if (tty->pgrp > 0)
  27173. +                p->tty_old_pgrp = tty->pgrp;
  27174. +        }
  27175. +        if (p->tty == tty)
  27176. +            p->tty = NULL;
  27177. +    }
  27178. +    tty->flags = 0;
  27179. +    tty->session = 0;
  27180. +    tty->pgrp = -1;
  27181. +    tty->ctrl_status = 0;
  27182. +    if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS)
  27183. +        *tty->termios = tty->driver.init_termios;
  27184. +    if (tty->driver.hangup)
  27185. +        (tty->driver.hangup)(tty);
  27186. +}
  27187. +
  27188. +void tty_hangup(struct tty_struct * tty)
  27189. +{
  27190. +#ifdef TTY_DEBUG_HANGUP
  27191. +    printk("%s hangup...\n", tty_name(tty));
  27192. +#endif
  27193. +    do_tty_hangup(tty, &hung_up_tty_fops);
  27194. +}
  27195. +
  27196. +void tty_vhangup(struct tty_struct * tty)
  27197. +{
  27198. +#ifdef TTY_DEBUG_HANGUP
  27199. +    printk("%s vhangup...\n", tty_name(tty));
  27200. +#endif
  27201. +    do_tty_hangup(tty, &hung_up_tty_fops);
  27202. +}
  27203. +
  27204. +int tty_hung_up_p(struct file * filp)
  27205. +{
  27206. +    return (filp->f_op == &hung_up_tty_fops);
  27207. +}
  27208. +
  27209. +/*
  27210. + * This function is typically called only by the session leader, when
  27211. + * it wants to disassociate itself from its controlling tty.
  27212. + *
  27213. + * It performs the following functions:
  27214. + *     (1)  Sends a SIGHUP and SIGCONT to the foreground process group
  27215. + *     (2)  Clears the tty from being controlling the session
  27216. + *     (3)  Clears the controlling tty for all processes in the
  27217. + *         session group.
  27218. + */
  27219. +void disassociate_ctty(int priv)
  27220. +{
  27221. +    struct tty_struct *tty = current->tty;
  27222. +    struct task_struct *p;
  27223. +
  27224. +    if (!tty) {
  27225. +        if (current->tty_old_pgrp) {
  27226. +            kill_pg(current->tty_old_pgrp, SIGHUP, priv);
  27227. +            kill_pg(current->tty_old_pgrp, SIGCONT, priv);
  27228. +        }
  27229. +        return;
  27230. +    }
  27231. +    if (tty->pgrp > 0) {
  27232. +        kill_pg(tty->pgrp, SIGHUP, priv);
  27233. +        kill_pg(tty->pgrp, SIGCONT, priv);
  27234. +    }
  27235. +
  27236. +    current->tty_old_pgrp = 0;
  27237. +    tty->session = 0;
  27238. +    tty->pgrp = -1;
  27239. +
  27240. +    for_each_task(p)
  27241. +          if (p->session == current->session)
  27242. +            p->tty = NULL;
  27243. +}
  27244. +
  27245. +/*
  27246. + * Sometimes we want to wait until a particular VT has been activated. We
  27247. + * do it in a very simple manner. Everybody waits on a single queue and
  27248. + * get woken up at once. Those that are satisfied go on with their business,
  27249. + * while those not ready go back to sleep. Seems overkill to add a wait
  27250. + * to each vt just for this - usually this does nothing!
  27251. + */
  27252. +static struct wait_queue *vt_activate_queue = NULL;
  27253. +
  27254. +/*
  27255. + * Sleeps until a vt is activated, or the task is interrupted. Returns
  27256. + * 0 if activation, -1 if interrupted.
  27257. + */
  27258. +int vt_waitactive(void)
  27259. +{
  27260. +    interruptible_sleep_on(&vt_activate_queue);
  27261. +    return (current->signal & ~current->blocked) ? -1 : 0;
  27262. +}
  27263. +
  27264. +#define vt_wake_waitactive() wake_up(&vt_activate_queue)
  27265. +
  27266. +void reset_vc(unsigned int new_console)
  27267. +{
  27268. +    vt_cons[new_console]->vc_mode = KD_TEXT;
  27269. +    kbd_table[new_console].kbdmode = VC_XLATE;
  27270. +    vt_cons[new_console]->vt_mode.mode = VT_AUTO;
  27271. +    vt_cons[new_console]->vt_mode.waitv = 0;
  27272. +    vt_cons[new_console]->vt_mode.relsig = 0;
  27273. +    vt_cons[new_console]->vt_mode.acqsig = 0;
  27274. +    vt_cons[new_console]->vt_mode.frsig = 0;
  27275. +    vt_cons[new_console]->vt_pid = -1;
  27276. +    vt_cons[new_console]->vt_newvt = -1;
  27277. +}
  27278. +
  27279. +/*
  27280. + * Performs the back end of a vt switch
  27281. + */
  27282. +void complete_change_console(unsigned int new_console)
  27283. +{
  27284. +    unsigned char old_vc_mode;
  27285. +
  27286. +        if (new_console == fg_console)
  27287. +                return;
  27288. +        if (!vc_cons_allocated(new_console))
  27289. +                return;
  27290. +    last_console = fg_console;
  27291. +
  27292. +    /*
  27293. +     * If we're switching, we could be going from KD_GRAPHICS to
  27294. +     * KD_TEXT mode or vice versa, which means we need to blank or
  27295. +     * unblank the screen later.
  27296. +     */
  27297. +    old_vc_mode = vt_cons[fg_console]->vc_mode;
  27298. +    update_screen(new_console);
  27299. +
  27300. +    /*
  27301. +     * If this new console is under process control, send it a signal
  27302. +     * telling it that it has acquired. Also check if it has died and
  27303. +     * clean up (similar to logic employed in change_console())
  27304. +     */
  27305. +    if (vt_cons[new_console]->vt_mode.mode == VT_PROCESS)
  27306. +    {
  27307. +        /*
  27308. +         * Send the signal as privileged - kill_proc() will
  27309. +         * tell us if the process has gone or something else
  27310. +         * is awry
  27311. +         */
  27312. +        if (kill_proc(vt_cons[new_console]->vt_pid,
  27313. +                  vt_cons[new_console]->vt_mode.acqsig,
  27314. +                  1) != 0)
  27315. +        {
  27316. +        /*
  27317. +         * The controlling process has died, so we revert back to
  27318. +         * normal operation. In this case, we'll also change back
  27319. +         * to KD_TEXT mode. I'm not sure if this is strictly correct
  27320. +         * but it saves the agony when the X server dies and the screen
  27321. +         * remains blanked due to KD_GRAPHICS! It would be nice to do
  27322. +         * this outside of VT_PROCESS but there is no single process
  27323. +         * to account for and tracking tty count may be undesirable.
  27324. +         */
  27325. +                reset_vc(new_console);
  27326. +        }
  27327. +    }
  27328. +
  27329. +    /*
  27330. +     * We do this here because the controlling process above may have
  27331. +     * gone, and so there is now a new vc_mode
  27332. +     */
  27333. +    if (old_vc_mode != vt_cons[new_console]->vc_mode)
  27334. +    {
  27335. +        if (vt_cons[new_console]->vc_mode == KD_TEXT)
  27336. +            do_unblank_screen();
  27337. +        else
  27338. +            do_blank_screen(1);
  27339. +    }
  27340. +
  27341. +    /*
  27342. +     * Wake anyone waiting for their VT to activate
  27343. +     */
  27344. +    vt_wake_waitactive();
  27345. +    return;
  27346. +}
  27347. +
  27348. +/*
  27349. + * Performs the front-end of a vt switch
  27350. + */
  27351. +void change_console(unsigned int new_console)
  27352. +{
  27353. +        if (new_console == fg_console)
  27354. +                return;
  27355. +        if (!vc_cons_allocated(new_console))
  27356. +        return;
  27357. +
  27358. +    /*
  27359. +     * If this vt is in process mode, then we need to handshake with
  27360. +     * that process before switching. Essentially, we store where that
  27361. +     * vt wants to switch to and wait for it to tell us when it's done
  27362. +     * (via VT_RELDISP ioctl).
  27363. +     *
  27364. +     * We also check to see if the controlling process still exists.
  27365. +     * If it doesn't, we reset this vt to auto mode and continue.
  27366. +     * This is a cheap way to track process control. The worst thing
  27367. +     * that can happen is: we send a signal to a process, it dies, and
  27368. +     * the switch gets "lost" waiting for a response; hopefully, the
  27369. +     * user will try again, we'll detect the process is gone (unless
  27370. +     * the user waits just the right amount of time :-) and revert the
  27371. +     * vt to auto control.
  27372. +     */
  27373. +    if (vt_cons[fg_console]->vt_mode.mode == VT_PROCESS)
  27374. +    {
  27375. +        /*
  27376. +         * Send the signal as privileged - kill_proc() will
  27377. +         * tell us if the process has gone or something else
  27378. +         * is awry
  27379. +         */
  27380. +        if (kill_proc(vt_cons[fg_console]->vt_pid,
  27381. +                  vt_cons[fg_console]->vt_mode.relsig,
  27382. +                  1) == 0)
  27383. +        {
  27384. +            /*
  27385. +             * It worked. Mark the vt to switch to and
  27386. +             * return. The process needs to send us a
  27387. +             * VT_RELDISP ioctl to complete the switch.
  27388. +             */
  27389. +            vt_cons[fg_console]->vt_newvt = new_console;
  27390. +            return;
  27391. +        }
  27392. +
  27393. +        /*
  27394. +         * The controlling process has died, so we revert back to
  27395. +         * normal operation. In this case, we'll also change back
  27396. +         * to KD_TEXT mode. I'm not sure if this is strictly correct
  27397. +         * but it saves the agony when the X server dies and the screen
  27398. +         * remains blanked due to KD_GRAPHICS! It would be nice to do
  27399. +         * this outside of VT_PROCESS but there is no single process
  27400. +         * to account for and tracking tty count may be undesirable.
  27401. +         */
  27402. +        reset_vc(fg_console);
  27403. +
  27404. +        /*
  27405. +         * Fall through to normal (VT_AUTO) handling of the switch...
  27406. +         */
  27407. +    }
  27408. +
  27409. +    /*
  27410. +     * Ignore all switches in KD_GRAPHICS+VT_AUTO mode
  27411. +     */
  27412. +    if (vt_cons[fg_console]->vc_mode == KD_GRAPHICS)
  27413. +        return;
  27414. +
  27415. +    complete_change_console(new_console);
  27416. +}
  27417. +
  27418. +void wait_for_keypress(void)
  27419. +{
  27420. +    sleep_on(&keypress_wait);
  27421. +}
  27422. +
  27423. +void stop_tty(struct tty_struct *tty)
  27424. +{
  27425. +    if (tty->stopped)
  27426. +        return;
  27427. +    tty->stopped = 1;
  27428. +    if (tty->link && tty->link->packet) {
  27429. +        tty->ctrl_status &= ~TIOCPKT_START;
  27430. +        tty->ctrl_status |= TIOCPKT_STOP;
  27431. +        wake_up_interruptible(&tty->link->read_wait);
  27432. +    }
  27433. +    if (tty->driver.stop)
  27434. +        (tty->driver.stop)(tty);
  27435. +}
  27436. +
  27437. +void start_tty(struct tty_struct *tty)
  27438. +{
  27439. +    if (!tty->stopped)
  27440. +        return;
  27441. +    tty->stopped = 0;
  27442. +    if (tty->link && tty->link->packet) {
  27443. +        tty->ctrl_status &= ~TIOCPKT_STOP;
  27444. +        tty->ctrl_status |= TIOCPKT_START;
  27445. +        wake_up_interruptible(&tty->link->read_wait);
  27446. +    }
  27447. +    if (tty->driver.start)
  27448. +        (tty->driver.start)(tty);
  27449. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  27450. +        tty->ldisc.write_wakeup)
  27451. +        (tty->ldisc.write_wakeup)(tty);
  27452. +    wake_up_interruptible(&tty->write_wait);
  27453. +}
  27454. +
  27455. +static int tty_read(struct inode * inode, struct file * file, char * buf, int count)
  27456. +{
  27457. +    int i;
  27458. +    struct tty_struct * tty;
  27459. +
  27460. +    tty = (struct tty_struct *)file->private_data;
  27461. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_read"))
  27462. +        return -EIO;
  27463. +    if (!tty || (tty->flags & (1 << TTY_IO_ERROR)))
  27464. +        return -EIO;
  27465. +
  27466. +    /* This check not only needs to be done before reading, but also
  27467. +       whenever read_chan() gets woken up after sleeping, so I've
  27468. +       moved it to there.  This should only be done for the N_TTY
  27469. +       line discipline, anyway.  Same goes for write_chan(). -- jlc. */
  27470. +#if 0
  27471. +    if ((inode->i_rdev != CONSOLE_DEV) && /* don't stop on /dev/console */
  27472. +        (tty->pgrp > 0) &&
  27473. +        (current->tty == tty) &&
  27474. +        (tty->pgrp != current->pgrp))
  27475. +        if (is_ignored(SIGTTIN) || is_orphaned_pgrp(current->pgrp))
  27476. +            return -EIO;
  27477. +        else {
  27478. +            (void) kill_pg(current->pgrp, SIGTTIN, 1);
  27479. +            return -ERESTARTSYS;
  27480. +        }
  27481. +#endif
  27482. +    if (tty->ldisc.read)
  27483. +        /* XXX casts are for what kernel-wide prototypes should be. */
  27484. +        i = (tty->ldisc.read)(tty,file,(unsigned char *)buf,(unsigned int)count);
  27485. +    else
  27486. +        i = -EIO;
  27487. +    if (i > 0)
  27488. +        inode->i_atime = CURRENT_TIME;
  27489. +    return i;
  27490. +}
  27491. +
  27492. +static int tty_write(struct inode * inode, struct file * file, char * buf, int count)
  27493. +{
  27494. +    int i, is_console;
  27495. +    struct tty_struct * tty;
  27496. +
  27497. +    is_console = (inode->i_rdev == CONSOLE_DEV);
  27498. +
  27499. +    if (is_console && redirect)
  27500. +        tty = redirect;
  27501. +    else
  27502. +        tty = (struct tty_struct *)file->private_data;
  27503. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_write"))
  27504. +        return -EIO;
  27505. +    if (!tty || !tty->driver.write || (tty->flags & (1 << TTY_IO_ERROR)))
  27506. +        return -EIO;
  27507. +#if 0
  27508. +    if (!is_console && L_TOSTOP(tty) && (tty->pgrp > 0) &&
  27509. +        (current->tty == tty) && (tty->pgrp != current->pgrp)) {
  27510. +        if (is_orphaned_pgrp(current->pgrp))
  27511. +            return -EIO;
  27512. +        if (!is_ignored(SIGTTOU)) {
  27513. +            (void) kill_pg(current->pgrp, SIGTTOU, 1);
  27514. +            return -ERESTARTSYS;
  27515. +        }
  27516. +    }
  27517. +#endif
  27518. +    if (tty->ldisc.write)
  27519. +        /* XXX casts are for what kernel-wide prototypes should be. */
  27520. +        i = (tty->ldisc.write)(tty,file,(unsigned char *)buf,(unsigned int)count);
  27521. +    else
  27522. +        i = -EIO;
  27523. +    if (i > 0)
  27524. +        inode->i_mtime = CURRENT_TIME;
  27525. +    return i;
  27526. +}
  27527. +
  27528. +/*
  27529. + * This is so ripe with races that you should *really* not touch this
  27530. + * unless you know exactly what you are doing. All the changes have to be
  27531. + * made atomically, or there may be incorrect pointers all over the place.
  27532. + */
  27533. +static int init_dev(dev_t device, struct tty_struct **ret_tty)
  27534. +{
  27535. +    struct tty_struct *tty, **tty_loc, *o_tty, **o_tty_loc;
  27536. +    struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
  27537. +    struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
  27538. +    struct tty_driver *driver;    
  27539. +    int retval;
  27540. +    int idx;
  27541. +
  27542. +    driver = get_tty_driver(device);
  27543. +    if (!driver)
  27544. +        return -ENODEV;
  27545. +
  27546. +    idx = MINOR(device) - driver->minor_start;
  27547. +    tty = o_tty = NULL;
  27548. +    tp = o_tp = NULL;
  27549. +    ltp = o_ltp = NULL;
  27550. +    o_tty_loc = NULL;
  27551. +    o_tp_loc = o_ltp_loc = NULL;
  27552. +
  27553. +    tty_loc = &driver->table[idx];
  27554. +    tp_loc = &driver->termios[idx];
  27555. +    ltp_loc = &driver->termios_locked[idx];
  27556. +
  27557. +repeat:
  27558. +    retval = -EAGAIN;
  27559. +    if (driver->type == TTY_DRIVER_TYPE_PTY &&
  27560. +        driver->subtype == PTY_TYPE_MASTER &&
  27561. +        *tty_loc && (*tty_loc)->count)
  27562. +        goto end_init;
  27563. +    retval = -ENOMEM;
  27564. +    if (!*tty_loc && !tty) {
  27565. +        if (!(tty = (struct tty_struct*) kmalloc(sizeof(struct tty_struct),
  27566. +                            GFP_KERNEL)))
  27567. +            goto end_init;
  27568. +        initialize_tty_struct(tty);
  27569. +        tty->device = device;
  27570. +        tty->driver = *driver;
  27571. +        goto repeat;
  27572. +    }
  27573. +    if (!*tp_loc && !tp) {
  27574. +        tp = (struct termios *) kmalloc(sizeof(struct termios),
  27575. +                        GFP_KERNEL);
  27576. +        if (!tp)
  27577. +            goto end_init;
  27578. +        *tp = driver->init_termios;
  27579. +        goto repeat;
  27580. +    }
  27581. +    if (!*ltp_loc && !ltp) {
  27582. +        ltp = (struct termios *) kmalloc(sizeof(struct termios),
  27583. +                         GFP_KERNEL);
  27584. +        if (!ltp)
  27585. +            goto end_init;
  27586. +        memset(ltp, 0, sizeof(struct termios));
  27587. +        goto repeat;
  27588. +    }
  27589. +    if (driver->type == TTY_DRIVER_TYPE_PTY) {
  27590. +        o_tty_loc = &driver->other->table[idx];
  27591. +        o_tp_loc = &driver->other->termios[idx];
  27592. +        o_ltp_loc = &driver->other->termios_locked[idx];
  27593. +
  27594. +        if (!*o_tty_loc && !o_tty) {
  27595. +            dev_t     o_device;
  27596. +            
  27597. +            o_tty = (struct tty_struct *)
  27598. +                kmalloc(sizeof(struct tty_struct),
  27599. +                    GFP_KERNEL);
  27600. +            if (!o_tty)
  27601. +                goto end_init;
  27602. +            o_device = MKDEV(driver->other->major,
  27603. +                     driver->other->minor_start + idx);
  27604. +            initialize_tty_struct(o_tty);
  27605. +            o_tty->device = o_device;
  27606. +            o_tty->driver = *driver->other;
  27607. +            goto repeat;
  27608. +        }
  27609. +        if (!*o_tp_loc && !o_tp) {
  27610. +            o_tp = (struct termios *)
  27611. +                kmalloc(sizeof(struct termios), GFP_KERNEL);
  27612. +            if (!o_tp)
  27613. +                goto end_init;
  27614. +            *o_tp = driver->other->init_termios;
  27615. +            goto repeat;
  27616. +        }
  27617. +        if (!*o_ltp_loc && !o_ltp) {
  27618. +            o_ltp = (struct termios *)
  27619. +                kmalloc(sizeof(struct termios), GFP_KERNEL);
  27620. +            if (!o_ltp)
  27621. +                goto end_init;
  27622. +            memset(o_ltp, 0, sizeof(struct termios));
  27623. +            goto repeat;
  27624. +        }
  27625. +        
  27626. +    }
  27627. +    /* Now we have allocated all the structures: update all the pointers.. */
  27628. +    if (!*tp_loc) {
  27629. +        *tp_loc = tp;
  27630. +        tp = NULL;
  27631. +    }
  27632. +    if (!*ltp_loc) {
  27633. +        *ltp_loc = ltp;
  27634. +        ltp = NULL;
  27635. +    }
  27636. +    if (!*tty_loc) {
  27637. +        tty->termios = *tp_loc;
  27638. +        tty->termios_locked = *ltp_loc;
  27639. +        *tty_loc = tty;
  27640. +        (*driver->refcount)++;
  27641. +        (*tty_loc)->count++;
  27642. +        if (tty->ldisc.open) {
  27643. +            retval = (tty->ldisc.open)(tty);
  27644. +            if (retval < 0) {
  27645. +                (*tty_loc)->count--;
  27646. +                tty = NULL;
  27647. +                goto end_init;
  27648. +            }
  27649. +        }
  27650. +        tty = NULL;
  27651. +    } else {
  27652. +        if ((*tty_loc)->flags & (1 << TTY_CLOSING)) {
  27653. +            printk("Attempt to open closing tty %s.\n",
  27654. +                   tty_name(*tty_loc));
  27655. +            printk("Ack!!!!  This should never happen!!\n");
  27656. +            return -EINVAL;
  27657. +        }
  27658. +        (*tty_loc)->count++;
  27659. +    }
  27660. +    if (driver->type == TTY_DRIVER_TYPE_PTY) {
  27661. +        if (!*o_tp_loc) {
  27662. +            *o_tp_loc = o_tp;
  27663. +            o_tp = NULL;
  27664. +        }
  27665. +        if (!*o_ltp_loc) {
  27666. +            *o_ltp_loc = o_ltp;
  27667. +            o_ltp = NULL;
  27668. +        }
  27669. +        if (!*o_tty_loc) {
  27670. +            o_tty->termios = *o_tp_loc;
  27671. +            o_tty->termios_locked = *o_ltp_loc;
  27672. +            *o_tty_loc = o_tty;
  27673. +            (*driver->other->refcount)++;
  27674. +            if (o_tty->ldisc.open) {
  27675. +                retval = (o_tty->ldisc.open)(o_tty);
  27676. +                if (retval < 0) {
  27677. +                    (*tty_loc)->count--;
  27678. +                    o_tty = NULL;
  27679. +                    goto end_init;
  27680. +                }
  27681. +            }
  27682. +            o_tty = NULL;
  27683. +        }
  27684. +        (*tty_loc)->link = *o_tty_loc;
  27685. +        (*o_tty_loc)->link = *tty_loc;
  27686. +        if (driver->subtype == PTY_TYPE_MASTER)
  27687. +            (*o_tty_loc)->count++;
  27688. +    }
  27689. +    (*tty_loc)->driver = *driver;
  27690. +    *ret_tty = *tty_loc;
  27691. +    retval = 0;
  27692. +end_init:
  27693. +    if (tty)
  27694. +        kfree_s(tty,sizeof(struct tty_struct));
  27695. +    if (o_tty)
  27696. +        kfree_s(o_tty,sizeof(struct tty_struct));
  27697. +    if (tp)
  27698. +        kfree_s(tp, sizeof(struct termios));
  27699. +    if (o_tp)
  27700. +        kfree_s(o_tp, sizeof(struct termios));
  27701. +    if (ltp)
  27702. +        kfree_s(ltp, sizeof(struct termios));
  27703. +    if (o_ltp)
  27704. +        kfree_s(o_ltp, sizeof(struct termios));
  27705. +    return retval;
  27706. +}
  27707. +
  27708. +/*
  27709. + * Even releasing the tty structures is a tricky business.. We have
  27710. + * to be very careful that the structures are all released at the
  27711. + * same time, as interrupts might otherwise get the wrong pointers.
  27712. + */
  27713. +static void release_dev(struct file * filp)
  27714. +{
  27715. +    struct tty_struct *tty, *o_tty;
  27716. +    struct termios *tp, *o_tp, *ltp, *o_ltp;
  27717. +    struct task_struct **p;
  27718. +    int    idx;
  27719. +    
  27720. +    tty = (struct tty_struct *)filp->private_data;
  27721. +    if (tty_paranoia_check(tty, filp->f_inode->i_rdev, "release_dev"))
  27722. +        return;
  27723. +
  27724. +    check_tty_count(tty, "release_dev");
  27725. +
  27726. +    tty_fasync(filp->f_inode, filp, 0);
  27727. +
  27728. +    tp = tty->termios;
  27729. +    ltp = tty->termios_locked;
  27730. +
  27731. +    idx = MINOR(tty->device) - tty->driver.minor_start;
  27732. +#ifdef TTY_PARANOIA_CHECK
  27733. +    if (idx < 0 || idx >= tty->driver.num) {
  27734. +        printk("release_dev: bad idx when trying to free (%d, %d)\n",
  27735. +               MAJOR(tty->device), MINOR(tty->device));
  27736. +        return;
  27737. +    }
  27738. +    if (tty != tty->driver.table[idx]) {
  27739. +        printk("release_dev: driver.table[%d] not tty for (%d, %d)\n",
  27740. +               idx, MAJOR(tty->device), MINOR(tty->device));
  27741. +        return;
  27742. +    }
  27743. +    if (tp != tty->driver.termios[idx]) {
  27744. +        printk("release_dev: driver.termios[%d] not termios for (%d, %d)\n",
  27745. +               idx, MAJOR(tty->device), MINOR(tty->device));
  27746. +        return;
  27747. +    }
  27748. +    if (ltp != tty->driver.termios_locked[idx]) {
  27749. +        printk("release_dev: driver.termios_locked[%d] not termios_locked for (%d, %d)\n",
  27750. +               idx, MAJOR(tty->device), MINOR(tty->device));
  27751. +        return;
  27752. +    }
  27753. +#endif
  27754. +
  27755. +#ifdef TTY_DEBUG_HANGUP
  27756. +    printk("release_dev of %s (tty count=%d)...", tty_name(tty),
  27757. +           tty->count);
  27758. +#endif
  27759. +
  27760. +    o_tty = tty->link;
  27761. +    o_tp = (o_tty) ? o_tty->termios : NULL;
  27762. +    o_ltp = (o_tty) ? o_tty->termios_locked : NULL;
  27763. +
  27764. +#ifdef TTY_PARANOIA_CHECK
  27765. +    if (tty->driver.other) {
  27766. +        if (o_tty != tty->driver.other->table[idx]) {
  27767. +            printk("release_dev: other->table[%d] not o_tty for (%d, %d)\n",
  27768. +                   idx, MAJOR(tty->device), MINOR(tty->device));
  27769. +            return;
  27770. +        }
  27771. +        if (o_tp != tty->driver.other->termios[idx]) {
  27772. +            printk("release_dev: other->termios[%d] not o_termios for (%d, %d)\n",
  27773. +                   idx, MAJOR(tty->device), MINOR(tty->device));
  27774. +            return;
  27775. +        }
  27776. +        if (o_ltp != tty->driver.other->termios_locked[idx]) {
  27777. +            printk("release_dev: other->termios_locked[%d] not o_termios_locked for (%d, %d)\n",
  27778. +                   idx, MAJOR(tty->device), MINOR(tty->device));
  27779. +            return;
  27780. +        }
  27781. +
  27782. +        if (o_tty->link != tty) {
  27783. +            printk("release_dev: bad pty pointers\n");
  27784. +            return;
  27785. +        }
  27786. +    }
  27787. +#endif
  27788. +    
  27789. +    if (tty->driver.close)
  27790. +        tty->driver.close(tty, filp);
  27791. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  27792. +        tty->driver.subtype == PTY_TYPE_MASTER) {
  27793. +        if (--tty->link->count < 0) {
  27794. +            printk("release_dev: bad pty slave count (%d) for %s\n",
  27795. +                   tty->count, tty_name(tty));
  27796. +            tty->link->count = 0;
  27797. +        }
  27798. +    }
  27799. +    if (--tty->count < 0) {
  27800. +        printk("release_dev: bad tty->count (%d) for %s\n",
  27801. +               tty->count, tty_name(tty));
  27802. +        tty->count = 0;
  27803. +    }
  27804. +    if (tty->count)
  27805. +        return;
  27806. +
  27807. +    /*
  27808. +     * We're committed; at this point, we must not block!
  27809. +     */
  27810. +    if (o_tty) {
  27811. +        if (o_tty->count)
  27812. +            return;
  27813. +        tty->driver.other->table[idx] = NULL;
  27814. +        tty->driver.other->termios[idx] = NULL;
  27815. +        kfree_s(o_tp, sizeof(struct termios));
  27816. +    }
  27817. +    
  27818. +#ifdef TTY_DEBUG_HANGUP
  27819. +    printk("freeing tty structure...");
  27820. +#endif
  27821. +    tty->flags |= (1 << TTY_CLOSING);
  27822. +
  27823. +    /*
  27824. +     * Make sure there aren't any processes that still think this
  27825. +     * tty is their controlling tty.
  27826. +     */
  27827. +    for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
  27828. +        if (*p == 0)
  27829. +            continue;
  27830. +        if ((*p)->tty == tty)
  27831. +            (*p)->tty = NULL;
  27832. +        if (o_tty && (*p)->tty == o_tty)
  27833. +            (*p)->tty = NULL;
  27834. +    }
  27835. +
  27836. +    /*
  27837. +     * Shutdown the current line discipline, and reset it to
  27838. +     * N_TTY.
  27839. +     */
  27840. +    if (tty->ldisc.close)
  27841. +        (tty->ldisc.close)(tty);
  27842. +    tty->ldisc = ldiscs[N_TTY];
  27843. +    tty->termios->c_line = N_TTY;
  27844. +    if (o_tty) {
  27845. +        if (o_tty->ldisc.close)
  27846. +            (o_tty->ldisc.close)(o_tty);
  27847. +        o_tty->ldisc = ldiscs[N_TTY];
  27848. +    }
  27849. +    
  27850. +    tty->driver.table[idx] = NULL;
  27851. +    if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS) {
  27852. +        tty->driver.termios[idx] = NULL;
  27853. +        kfree_s(tp, sizeof(struct termios));
  27854. +    }
  27855. +    if (tty == redirect || o_tty == redirect)
  27856. +        redirect = NULL;
  27857. +    /*
  27858. +     * Make sure that the tty's task queue isn't activated.  If it
  27859. +     * is, take it out of the linked list.
  27860. +     */
  27861. +    cli();
  27862. +    if (tty->flip.tqueue.sync) {
  27863. +        struct tq_struct *tq, *prev;
  27864. +
  27865. +        for (tq=tq_timer, prev=0; tq; prev=tq, tq=tq->next) {
  27866. +            if (tq == &tty->flip.tqueue) {
  27867. +                if (prev)
  27868. +                    prev->next = tq->next;
  27869. +                else
  27870. +                    tq_timer = tq->next;
  27871. +                break;
  27872. +            }
  27873. +        }
  27874. +    }
  27875. +    sti();
  27876. +    tty->magic = 0;
  27877. +    (*tty->driver.refcount)--;
  27878. +    kfree_s(tty,sizeof(struct tty_struct));
  27879. +    filp->private_data = 0;
  27880. +    if (o_tty) {
  27881. +        o_tty->magic = 0;
  27882. +        (*o_tty->driver.refcount)--;
  27883. +        kfree_s(o_tty,sizeof(struct tty_struct));
  27884. +    }
  27885. +}
  27886. +
  27887. +/*
  27888. + * tty_open and tty_release keep up the tty count that contains the
  27889. + * number of opens done on a tty. We cannot use the inode-count, as
  27890. + * different inodes might point to the same tty.
  27891. + *
  27892. + * Open-counting is needed for pty masters, as well as for keeping
  27893. + * track of serial lines: DTR is dropped when the last close happens.
  27894. + * (This is not done solely through tty->count, now.  - Ted 1/27/92)
  27895. + *
  27896. + * The termios state of a pty is reset on first open so that
  27897. + * settings don't persist across reuse.
  27898. + */
  27899. +static int tty_open(struct inode * inode, struct file * filp)
  27900. +{
  27901. +    struct tty_struct *tty;
  27902. +    int minor;
  27903. +    int noctty, retval;
  27904. +    dev_t device;
  27905. +
  27906. +retry_open:
  27907. +    noctty = filp->f_flags & O_NOCTTY;
  27908. +    device = inode->i_rdev;
  27909. +    if (device == TTY_DEV) {
  27910. +        if (!current->tty)
  27911. +            return -ENXIO;
  27912. +        device = current->tty->device;
  27913. +        /* noctty = 1; */
  27914. +    }
  27915. +    if (device == CONSOLE_DEV) {
  27916. +        device = MKDEV(TTY_MAJOR, fg_console+1);
  27917. +        noctty = 1;
  27918. +    }
  27919. +    minor = MINOR(device);
  27920. +    
  27921. +    retval = init_dev(device, &tty);
  27922. +    if (retval)
  27923. +        return retval;
  27924. +    filp->private_data = tty;
  27925. +    check_tty_count(tty, "tty_open");
  27926. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  27927. +        tty->driver.subtype == PTY_TYPE_MASTER)
  27928. +        noctty = 1;
  27929. +#ifdef TTY_DEBUG_HANGUP
  27930. +    printk("opening %s...", tty_name(tty));
  27931. +#endif
  27932. +    if (tty->driver.open)
  27933. +        retval = tty->driver.open(tty, filp);
  27934. +    else
  27935. +        retval = -ENODEV;
  27936. +
  27937. +    if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !suser())
  27938. +        retval = -EBUSY;
  27939. +
  27940. +    if (retval) {
  27941. +#ifdef TTY_DEBUG_HANGUP
  27942. +        printk("error %d in opening %s...", retval, tty_name(tty));
  27943. +#endif
  27944. +
  27945. +        release_dev(filp);
  27946. +        if (retval != -ERESTARTSYS)
  27947. +            return retval;
  27948. +        if (current->signal & ~current->blocked)
  27949. +            return retval;
  27950. +        schedule();
  27951. +        /*
  27952. +         * Need to reset f_op in case a hangup happened.
  27953. +         */
  27954. +        filp->f_op = &tty_fops;
  27955. +        goto retry_open;
  27956. +    }
  27957. +    if (!noctty &&
  27958. +        current->leader &&
  27959. +        !current->tty &&
  27960. +        tty->session == 0) {
  27961. +        current->tty = tty;
  27962. +        current->tty_old_pgrp = 0;
  27963. +        tty->session = current->session;
  27964. +        tty->pgrp = current->pgrp;
  27965. +    }
  27966. +    return 0;
  27967. +}
  27968. +
  27969. +/*
  27970. + * Note that releasing a pty master also releases the child, so
  27971. + * we have to make the redirection checks after that and on both
  27972. + * sides of a pty.
  27973. + */
  27974. +static void tty_release(struct inode * inode, struct file * filp)
  27975. +{
  27976. +    release_dev(filp);
  27977. +}
  27978. +
  27979. +static int tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
  27980. +{
  27981. +    struct tty_struct * tty;
  27982. +
  27983. +    tty = (struct tty_struct *)filp->private_data;
  27984. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_select"))
  27985. +        return 0;
  27986. +
  27987. +    if (tty->ldisc.select)
  27988. +        return (tty->ldisc.select)(tty, inode, filp, sel_type, wait);
  27989. +    return 0;
  27990. +}
  27991. +
  27992. +static int tty_fasync(struct inode * inode, struct file * filp, int on)
  27993. +{
  27994. +    struct tty_struct * tty;
  27995. +    struct fasync_struct *fa, *prev;
  27996. +
  27997. +    tty = (struct tty_struct *)filp->private_data;
  27998. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_fasync"))
  27999. +        return 0;
  28000. +
  28001. +    for (fa = tty->fasync, prev = 0; fa; prev= fa, fa = fa->fa_next) {
  28002. +        if (fa->fa_file == filp)
  28003. +            break;
  28004. +    }
  28005. +
  28006. +    if (on) {
  28007. +        if (fa)
  28008. +            return 0;
  28009. +        fa = (struct fasync_struct *)kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
  28010. +        if (!fa)
  28011. +            return -ENOMEM;
  28012. +        fa->magic = FASYNC_MAGIC;
  28013. +        fa->fa_file = filp;
  28014. +        fa->fa_next = tty->fasync;
  28015. +        tty->fasync = fa;
  28016. +        if (!tty->read_wait)
  28017. +            tty->minimum_to_wake = 1;
  28018. +        if (filp->f_owner == 0) {
  28019. +            if (tty->pgrp)
  28020. +                filp->f_owner = -tty->pgrp;
  28021. +            else
  28022. +                filp->f_owner = current->pid;
  28023. +        }
  28024. +    } else {
  28025. +        if (!fa)
  28026. +            return 0;
  28027. +        if (prev)
  28028. +            prev->fa_next = fa->fa_next;
  28029. +        else
  28030. +            tty->fasync = fa->fa_next;
  28031. +        kfree_s(fa, sizeof(struct fasync_struct));
  28032. +        if (!tty->fasync && !tty->read_wait)
  28033. +            tty->minimum_to_wake = N_TTY_BUF_SIZE;
  28034. +    }
  28035. +    return 0;    
  28036. +}
  28037. +
  28038. +#if 0
  28039. +/*
  28040. + * XXX does anyone use this anymore?!?
  28041. + */
  28042. +static int do_get_ps_info(unsigned long arg)
  28043. +{
  28044. +    struct tstruct {
  28045. +        int flag;
  28046. +        int present[NR_TASKS];
  28047. +        struct task_struct tasks[NR_TASKS];
  28048. +    };
  28049. +    struct tstruct *ts = (struct tstruct *)arg;
  28050. +    struct task_struct **p;
  28051. +    char *c, *d;
  28052. +    int i, n = 0;
  28053. +    
  28054. +    i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct tstruct));
  28055. +    if (i)
  28056. +        return i;
  28057. +    for (p = &FIRST_TASK ; p <= &LAST_TASK ; p++, n++)
  28058. +        if (*p)
  28059. +        {
  28060. +            c = (char *)(*p);
  28061. +            d = (char *)(ts->tasks+n);
  28062. +            for (i=0 ; i<sizeof(struct task_struct) ; i++)
  28063. +                put_fs_byte(*c++, d++);
  28064. +            put_fs_long(1, (unsigned long *)(ts->present+n));
  28065. +        }
  28066. +        else    
  28067. +            put_fs_long(0, (unsigned long *)(ts->present+n));
  28068. +    return(0);            
  28069. +}
  28070. +#endif
  28071. +
  28072. +static int tty_ioctl(struct inode * inode, struct file * file,
  28073. +             unsigned int cmd, unsigned long arg)
  28074. +{
  28075. +    int    retval;
  28076. +    struct tty_struct * tty;
  28077. +    struct tty_struct * real_tty;
  28078. +    struct winsize tmp_ws;
  28079. +    pid_t pgrp;
  28080. +    unsigned char    ch;
  28081. +    char    mbz = 0;
  28082. +    
  28083. +    tty = (struct tty_struct *)file->private_data;
  28084. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
  28085. +        return -EINVAL;
  28086. +
  28087. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  28088. +        tty->driver.subtype == PTY_TYPE_MASTER)
  28089. +        real_tty = tty->link;
  28090. +    else
  28091. +        real_tty = tty;
  28092. +
  28093. +    switch (cmd) {
  28094. +        case TIOCSTI:
  28095. +            if ((current->tty != tty) && !suser())
  28096. +                return -EPERM;
  28097. +            retval = verify_area(VERIFY_READ, (void *) arg, 1);
  28098. +            if (retval)
  28099. +                return retval;
  28100. +            ch = get_fs_byte((char *) arg);
  28101. +            tty->ldisc.receive_buf(tty, &ch, &mbz, 1);
  28102. +            return 0;
  28103. +        case TIOCGWINSZ:
  28104. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  28105. +                         sizeof (struct winsize));
  28106. +            if (retval)
  28107. +                return retval;
  28108. +            memcpy_tofs((struct winsize *) arg, &tty->winsize,
  28109. +                    sizeof (struct winsize));
  28110. +            return 0;
  28111. +        case TIOCSWINSZ:
  28112. +            retval = verify_area(VERIFY_READ, (void *) arg,
  28113. +                         sizeof (struct winsize));
  28114. +            if (retval)
  28115. +                return retval;            
  28116. +            memcpy_fromfs(&tmp_ws, (struct winsize *) arg,
  28117. +                      sizeof (struct winsize));
  28118. +            if (memcmp(&tmp_ws, &tty->winsize,
  28119. +                   sizeof(struct winsize))) {
  28120. +                if (tty->pgrp > 0)
  28121. +                    kill_pg(tty->pgrp, SIGWINCH, 1);
  28122. +                if ((real_tty->pgrp != tty->pgrp) &&
  28123. +                    (real_tty->pgrp > 0))
  28124. +                    kill_pg(real_tty->pgrp, SIGWINCH, 1);
  28125. +            }
  28126. +            tty->winsize = tmp_ws;
  28127. +            real_tty->winsize = tmp_ws;
  28128. +            return 0;
  28129. +        case TIOCCONS:
  28130. +            if (tty->driver.type == TTY_DRIVER_TYPE_CONSOLE) {
  28131. +                if (!suser())
  28132. +                    return -EPERM;
  28133. +                redirect = NULL;
  28134. +                return 0;
  28135. +            }
  28136. +            if (redirect)
  28137. +                return -EBUSY;
  28138. +            redirect = real_tty;
  28139. +            return 0;
  28140. +        case FIONBIO:
  28141. +            retval = verify_area(VERIFY_READ, (void *) arg, sizeof(long));
  28142. +            if (retval)
  28143. +                return retval;
  28144. +            arg = get_fs_long((unsigned long *) arg);
  28145. +            if (arg)
  28146. +                file->f_flags |= O_NONBLOCK;
  28147. +            else
  28148. +                file->f_flags &= ~O_NONBLOCK;
  28149. +            return 0;
  28150. +        case TIOCEXCL:
  28151. +            set_bit(TTY_EXCLUSIVE, &tty->flags);
  28152. +            return 0;
  28153. +        case TIOCNXCL:
  28154. +            clear_bit(TTY_EXCLUSIVE, &tty->flags);
  28155. +            return 0;
  28156. +        case TIOCNOTTY:
  28157. +            if (current->tty != tty)
  28158. +                return -ENOTTY;
  28159. +            if (current->leader)
  28160. +                disassociate_ctty(0);
  28161. +            current->tty = NULL;
  28162. +            return 0;
  28163. +        case TIOCSCTTY:
  28164. +            if (current->leader &&
  28165. +                (current->session == tty->session))
  28166. +                return 0;
  28167. +            /*
  28168. +             * The process must be a session leader and
  28169. +             * not have a controlling tty already.
  28170. +             */
  28171. +            if (!current->leader || current->tty)
  28172. +                return -EPERM;
  28173. +            if (tty->session > 0) {
  28174. +                /*
  28175. +                 * This tty is already the controlling
  28176. +                 * tty for another session group!
  28177. +                 */
  28178. +                if ((arg == 1) && suser()) {
  28179. +                    /*
  28180. +                     * Steal it away
  28181. +                     */
  28182. +                    struct task_struct *p;
  28183. +
  28184. +                    for_each_task(p)
  28185. +                        if (p->tty == tty)
  28186. +                            p->tty = NULL;
  28187. +                } else
  28188. +                    return -EPERM;
  28189. +            }
  28190. +            current->tty = tty;
  28191. +            current->tty_old_pgrp = 0;
  28192. +            tty->session = current->session;
  28193. +            tty->pgrp = current->pgrp;
  28194. +            return 0;
  28195. +        case TIOCGPGRP:
  28196. +            /*
  28197. +             * (tty == real_tty) is a cheap way of
  28198. +             * testing if the tty is NOT a master pty.
  28199. +             */
  28200. +            if (tty == real_tty && current->tty != real_tty)
  28201. +                return -ENOTTY;
  28202. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  28203. +                         sizeof (pid_t));
  28204. +            if (retval)
  28205. +                return retval;
  28206. +            put_fs_long(real_tty->pgrp, (pid_t *) arg);
  28207. +            return 0;
  28208. +        case TIOCSPGRP:
  28209. +            retval = tty_check_change(real_tty);
  28210. +            if (retval)
  28211. +                return retval;
  28212. +            if (!current->tty ||
  28213. +                (current->tty != real_tty) ||
  28214. +                (real_tty->session != current->session))
  28215. +                return -ENOTTY;
  28216. +            pgrp = get_fs_long((pid_t *) arg);
  28217. +            if (pgrp < 0)
  28218. +                return -EINVAL;
  28219. +            if (session_of_pgrp(pgrp) != current->session)
  28220. +                return -EPERM;
  28221. +            real_tty->pgrp = pgrp;
  28222. +            return 0;
  28223. +        case TIOCGETD:
  28224. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  28225. +                         sizeof (unsigned long));
  28226. +            if (retval)
  28227. +                return retval;
  28228. +            put_fs_long(tty->ldisc.num, (unsigned long *) arg);
  28229. +            return 0;
  28230. +        case TIOCSETD:
  28231. +            retval = tty_check_change(tty);
  28232. +            if (retval)
  28233. +                return retval;
  28234. +            arg = get_fs_long((unsigned long *) arg);
  28235. +            return tty_set_ldisc(tty, arg);
  28236. +        case TIOCLINUX:
  28237. +            if (tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)
  28238. +                return -EINVAL;
  28239. +            if (current->tty != tty && !suser())
  28240. +                return -EPERM;
  28241. +            retval = verify_area(VERIFY_READ, (void *) arg, 1);
  28242. +            if (retval)
  28243. +                return retval;
  28244. +            switch (retval = get_fs_byte((char *)arg))
  28245. +            {
  28246. +                case 0:
  28247. +                case 8:
  28248. +                case 9:
  28249. +                    printk("TIOCLINUX (0/8/9) ioctl is gone - use /dev/vcs\n");
  28250. +                    return -EINVAL;
  28251. +#if 0
  28252. +                case 1:
  28253. +                    printk("Deprecated TIOCLINUX (1) ioctl\n");
  28254. +                    return do_get_ps_info(arg);
  28255. +#endif
  28256. +                case 2:
  28257. +                    return set_selection(arg, tty);
  28258. +                case 3:
  28259. +                    return paste_selection(tty);
  28260. +                case 4:
  28261. +                    do_unblank_screen();
  28262. +                    return 0;
  28263. +                case 5:
  28264. +                    return sel_loadlut(arg);
  28265. +                case 6:
  28266. +            /*
  28267. +             * Make it possible to react to Shift+Mousebutton.
  28268. +             * Note that 'shift_state' is an undocumented
  28269. +             * kernel-internal variable; programs not closely
  28270. +             * related to the kernel should not use this.
  28271. +             */
  28272. +                    put_fs_byte(shift_state,arg);
  28273. +                    return 0;
  28274. +                case 7:
  28275. +                    put_fs_byte(mouse_reporting(),arg);
  28276. +                    return 0;
  28277. +/*                case 10:
  28278. +                    set_vesa_blanking(arg);
  28279. +                    return 0;*/
  28280. +                default: 
  28281. +                    return -EINVAL;
  28282. +            }
  28283. +
  28284. +        case TIOCTTYGSTRUCT:
  28285. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  28286. +                        sizeof(struct tty_struct));
  28287. +            if (retval)
  28288. +                return retval;
  28289. +            memcpy_tofs((struct tty_struct *) arg,
  28290. +                    tty, sizeof(struct tty_struct));
  28291. +            return 0;
  28292. +        default:
  28293. +            if (tty->driver.ioctl) {
  28294. +                retval = (tty->driver.ioctl)(tty, file,
  28295. +                                 cmd, arg);
  28296. +                if (retval != -ENOIOCTLCMD)
  28297. +                    return retval;
  28298. +            }
  28299. +            if (tty->ldisc.ioctl) {
  28300. +                retval = (tty->ldisc.ioctl)(tty, file,
  28301. +                                cmd, arg);
  28302. +                if (retval != -ENOIOCTLCMD)
  28303. +                    return retval;
  28304. +            }
  28305. +            return -EINVAL;
  28306. +        }
  28307. +}
  28308. +
  28309. +
  28310. +/*
  28311. + * This implements the "Secure Attention Key" ---  the idea is to
  28312. + * prevent trojan horses by killing all processes associated with this
  28313. + * tty when the user hits the "Secure Attention Key".  Required for
  28314. + * super-paranoid applications --- see the Orange Book for more details.
  28315. + * 
  28316. + * This code could be nicer; ideally it should send a HUP, wait a few
  28317. + * seconds, then send a INT, and then a KILL signal.  But you then
  28318. + * have to coordinate with the init process, since all processes associated
  28319. + * with the current tty must be dead before the new getty is allowed
  28320. + * to spawn.
  28321. + */
  28322. +void do_SAK( struct tty_struct *tty)
  28323. +{
  28324. +#ifdef TTY_SOFT_SAK
  28325. +    tty_hangup(tty);
  28326. +#else
  28327. +    struct task_struct **p;
  28328. +    int session;
  28329. +    int        i;
  28330. +    struct file    *filp;
  28331. +    
  28332. +    if (!tty)
  28333. +        return;
  28334. +    session  = tty->session;
  28335. +    if (tty->ldisc.flush_buffer)
  28336. +        tty->ldisc.flush_buffer(tty);
  28337. +    if (tty->driver.flush_buffer)
  28338. +        tty->driver.flush_buffer(tty);
  28339. +     for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
  28340. +        if (!(*p))
  28341. +            continue;
  28342. +        if (((*p)->tty == tty) ||
  28343. +            ((session > 0) && ((*p)->session == session)))
  28344. +            send_sig(SIGKILL, *p, 1);
  28345. +        else {
  28346. +            for (i=0; i < NR_OPEN; i++) {
  28347. +                filp = (*p)->files->fd[i];
  28348. +                if (filp && (filp->f_op == &tty_fops) &&
  28349. +                    (filp->private_data == tty)) {
  28350. +                    send_sig(SIGKILL, *p, 1);
  28351. +                    break;
  28352. +                }
  28353. +            }
  28354. +        }
  28355. +    }
  28356. +#endif
  28357. +}
  28358. +
  28359. +/*
  28360. + * This routine is called out of the software interrupt to flush data
  28361. + * from the flip buffer to the line discipline.
  28362. + */
  28363. +static void flush_to_ldisc(void *private_)
  28364. +{
  28365. +    struct tty_struct *tty = (struct tty_struct *) private_;
  28366. +    unsigned char    *cp;
  28367. +    char        *fp;
  28368. +    int        count;
  28369. +
  28370. +    if (tty->flip.buf_num) {
  28371. +        cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
  28372. +        fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
  28373. +        tty->flip.buf_num = 0;
  28374. +
  28375. +        cli();
  28376. +        tty->flip.char_buf_ptr = tty->flip.char_buf;
  28377. +        tty->flip.flag_buf_ptr = tty->flip.flag_buf;
  28378. +    } else {
  28379. +        cp = tty->flip.char_buf;
  28380. +        fp = tty->flip.flag_buf;
  28381. +        tty->flip.buf_num = 1;
  28382. +
  28383. +        cli();
  28384. +        tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
  28385. +        tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
  28386. +    }
  28387. +    count = tty->flip.count;
  28388. +    tty->flip.count = 0;
  28389. +    sti();
  28390. +    
  28391. +#if 0
  28392. +    if (count > tty->max_flip_cnt)
  28393. +        tty->max_flip_cnt = count;
  28394. +#endif
  28395. +    tty->ldisc.receive_buf(tty, cp, fp, count);
  28396. +}
  28397. +
  28398. +/*
  28399. + * This subroutine initializes a tty structure.
  28400. + */
  28401. +static void initialize_tty_struct(struct tty_struct *tty)
  28402. +{
  28403. +    memset(tty, 0, sizeof(struct tty_struct));
  28404. +    tty->magic = TTY_MAGIC;
  28405. +    tty->ldisc = ldiscs[N_TTY];
  28406. +    tty->pgrp = -1;
  28407. +    tty->flip.char_buf_ptr = tty->flip.char_buf;
  28408. +    tty->flip.flag_buf_ptr = tty->flip.flag_buf;
  28409. +    tty->flip.tqueue.routine = flush_to_ldisc;
  28410. +    tty->flip.tqueue.data = tty;
  28411. +}
  28412. +
  28413. +/*
  28414. + * The default put_char routine if the driver did not define one.
  28415. + */
  28416. +void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
  28417. +{
  28418. +    tty->driver.write(tty, 0, &ch, 1);
  28419. +}
  28420. +
  28421. +/*
  28422. + * Called by a tty driver to register itself.
  28423. + */
  28424. +int tty_register_driver(struct tty_driver *driver)
  28425. +{
  28426. +    int error;
  28427. +
  28428. +    if (driver->flags & TTY_DRIVER_INSTALLED)
  28429. +        return 0;
  28430. +
  28431. +    error = register_chrdev(driver->major, driver->name, &tty_fops);
  28432. +    if (error < 0)
  28433. +        return error;
  28434. +    else if(driver->major == 0)
  28435. +        driver->major = error;
  28436. +
  28437. +    if (!driver->put_char)
  28438. +        driver->put_char = tty_default_put_char;
  28439. +    
  28440. +    driver->prev = 0;
  28441. +    driver->next = tty_drivers;
  28442. +    if (tty_drivers) tty_drivers->prev = driver;
  28443. +    tty_drivers = driver;
  28444. +    return error;
  28445. +}
  28446. +
  28447. +/*
  28448. + * Called by a tty driver to unregister itself.
  28449. + */
  28450. +int tty_unregister_driver(struct tty_driver *driver)
  28451. +{
  28452. +    int    retval;
  28453. +    struct tty_driver *p;
  28454. +    int    found = 0;
  28455. +    char *othername = NULL;
  28456. +    
  28457. +    if (*driver->refcount)
  28458. +        return -EBUSY;
  28459. +
  28460. +    for (p = tty_drivers; p; p = p->next) {
  28461. +        if (p == driver)
  28462. +            found++;
  28463. +        else if (p->major == driver->major)
  28464. +            othername = p->name;
  28465. +    }
  28466. +
  28467. +    if (othername == NULL) {
  28468. +        retval = unregister_chrdev(driver->major, driver->name);
  28469. +        if (retval)
  28470. +            return retval;
  28471. +    } else
  28472. +        register_chrdev(driver->major, othername, &tty_fops);
  28473. +
  28474. +    if (driver->prev)
  28475. +        driver->prev->next = driver->next;
  28476. +    else
  28477. +        tty_drivers = driver->next;
  28478. +    
  28479. +    if (driver->next)
  28480. +        driver->next->prev = driver->prev;
  28481. +
  28482. +    return 0;
  28483. +}
  28484. +
  28485. +
  28486. +/*
  28487. + * Initialize the console device. This is called *early*, so
  28488. + * we can't necessarily depend on lots of kernel help here.
  28489. + * Just do some early initializations, and do the complex setup
  28490. + * later.
  28491. + */
  28492. +long console_init(long kmem_start, long kmem_end)
  28493. +{
  28494. +    /* Setup the default TTY line discipline. */
  28495. +    memset(ldiscs, 0, sizeof(ldiscs));
  28496. +    (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
  28497. +
  28498. +    /*
  28499. +     * Set up the standard termios.  Individual tty drivers may 
  28500. +     * deviate from this; this is used as a template.
  28501. +     */
  28502. +    memset(&tty_std_termios, 0, sizeof(struct termios));
  28503. +    memcpy(tty_std_termios.c_cc, INIT_C_CC, NCCS);
  28504. +    tty_std_termios.c_iflag = ICRNL | IXON;
  28505. +    tty_std_termios.c_oflag = OPOST | ONLCR;
  28506. +    tty_std_termios.c_cflag = B38400 | CS8 | CREAD;
  28507. +    tty_std_termios.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
  28508. +        ECHOCTL | ECHOKE | IEXTEN;
  28509. +
  28510. +    /*
  28511. +     * set up the console device so that later boot sequences can 
  28512. +     * inform about problems etc..
  28513. +     */
  28514. +    return con_init(kmem_start);
  28515. +}
  28516. +
  28517. +/*
  28518. + * Ok, now we can initialize the rest of the tty devices and can count
  28519. + * on memory allocations, interrupts etc..
  28520. + */
  28521. +long tty_init(long kmem_start)
  28522. +{
  28523. +    if (sizeof(struct tty_struct) > PAGE_SIZE)
  28524. +        panic("size of tty structure > PAGE_SIZE!");
  28525. +    if (register_chrdev(TTY_MAJOR,"tty",&tty_fops))
  28526. +        panic("unable to get major %d for tty device", TTY_MAJOR);
  28527. +    if (register_chrdev(TTYAUX_MAJOR,"cua",&tty_fops))
  28528. +        panic("unable to get major %d for tty device", TTYAUX_MAJOR);
  28529. +
  28530. +    kmem_start = kbd_init(kmem_start);
  28531. +    kmem_start = rs_init(kmem_start);
  28532. +#ifdef CONFIG_CYCLADES
  28533. +    kmem_start = cy_init(kmem_start);
  28534. +#endif
  28535. +    kmem_start = pty_init(kmem_start);
  28536. +    kmem_start = vcs_init(kmem_start);
  28537. +    return kmem_start;
  28538. +}
  28539. diff -r -u -N linux.orig/arch/arm/drivers/char/tty_io.c.orig linux.arm/arch/arm/drivers/char/tty_io.c.orig
  28540. --- linux.orig/arch/arm/drivers/char/tty_io.c.orig    Thu Jan  1 01:00:00 1970
  28541. +++ linux.arm/arch/arm/drivers/char/tty_io.c.orig    Fri Oct 27 23:14:41 1995
  28542. @@ -0,0 +1,1667 @@
  28543. +/*
  28544. + *  linux/drivers/char/tty_io.c
  28545. + *
  28546. + *  Copyright (C) 1991, 1992  Linus Torvalds
  28547. + */
  28548. +
  28549. +/*
  28550. + * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
  28551. + * or rs-channels. It also implements echoing, cooked mode etc.
  28552. + *
  28553. + * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
  28554. + *
  28555. + * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
  28556. + * tty_struct and tty_queue structures.  Previously there was a array
  28557. + * of 256 tty_struct's which was statically allocated, and the
  28558. + * tty_queue structures were allocated at boot time.  Both are now
  28559. + * dynamically allocated only when the tty is open.
  28560. + *
  28561. + * Also restructured routines so that there is more of a separation
  28562. + * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
  28563. + * the low-level tty routines (serial.c, pty.c, console.c).  This
  28564. + * makes for cleaner and more compact code.  -TYT, 9/17/92
  28565. + *
  28566. + * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
  28567. + * which can be dynamically activated and de-activated by the line
  28568. + * discipline handling modules (like SLIP).
  28569. + *
  28570. + * NOTE: pay no attention to the line discipline code (yet); its
  28571. + * interface is still subject to change in this version...
  28572. + * -- TYT, 1/31/92
  28573. + *
  28574. + * Added functionality to the OPOST tty handling.  No delays, but all
  28575. + * other bits should be there.
  28576. + *    -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
  28577. + *
  28578. + * Rewrote canonical mode and added more termios flags.
  28579. + *     -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
  28580. + */
  28581. +
  28582. +#include <linux/types.h>
  28583. +#include <linux/major.h>
  28584. +#include <linux/errno.h>
  28585. +#include <linux/signal.h>
  28586. +#include <linux/fcntl.h>
  28587. +#include <linux/sched.h>
  28588. +#include <linux/interrupt.h>
  28589. +#include <linux/tty.h>
  28590. +#include <linux/tty_flip.h>
  28591. +#include <linux/timer.h>
  28592. +#include <linux/ctype.h>
  28593. +#include <linux/kd.h>
  28594. +#include <linux/mm.h>
  28595. +#include <linux/string.h>
  28596. +#include <linux/malloc.h>
  28597. +
  28598. +#include <asm/segment.h>
  28599. +#include <asm/system.h>
  28600. +#include <asm/bitops.h>
  28601. +
  28602. +#include "kbd_kern.h"
  28603. +#include "vt_kern.h"
  28604. +
  28605. +#define CONSOLE_DEV MKDEV(TTY_MAJOR,0)
  28606. +#define TTY_DEV MKDEV(TTYAUX_MAJOR,0)
  28607. +
  28608. +#undef TTY_DEBUG_HANGUP
  28609. +
  28610. +extern int set_selection(const int arg, struct tty_struct *tty);
  28611. +extern int paste_selection(struct tty_struct *tty);
  28612. +extern int sel_loadlut(const int arg);
  28613. +extern int mouse_reporting(void);
  28614. +extern int shift_state;
  28615. +extern int do_screendump(int arg);
  28616. +
  28617. +struct termios tty_std_termios;        /* for the benefit of tty drivers  */
  28618. +struct tty_driver *tty_drivers = NULL;    /* linked list of tty drivers */
  28619. +struct tty_ldisc ldiscs[NR_LDISCS];    /* line disc dispatch table    */
  28620. +
  28621. +/*
  28622. + * fg_console is the current virtual console,
  28623. + * redirect is the pseudo-tty that console output
  28624. + * is redirected to if asked by TIOCCONS.
  28625. + */
  28626. +int fg_console = 0;
  28627. +struct tty_struct * redirect = NULL;
  28628. +struct wait_queue * keypress_wait = NULL;
  28629. +
  28630. +static void initialize_tty_struct(struct tty_struct *tty);
  28631. +
  28632. +static int tty_read(struct inode *, struct file *, char *, int);
  28633. +static int tty_write(struct inode *, struct file *, char *, int);
  28634. +static int tty_select(struct inode *, struct file *, int, select_table *);
  28635. +static int tty_open(struct inode *, struct file *);
  28636. +static void tty_release(struct inode *, struct file *);
  28637. +static int tty_ioctl(struct inode * inode, struct file * file,
  28638. +             unsigned int cmd, unsigned long arg);
  28639. +static int tty_fasync(struct inode * inode, struct file * filp, int on);
  28640. +
  28641. +#ifndef MIN
  28642. +#define MIN(a,b)    ((a) < (b) ? (a) : (b))
  28643. +#endif
  28644. +
  28645. +/*
  28646. + * These two routines return the name of tty.  tty_name() should NOT
  28647. + * be used in interrupt drivers, since it's not re-entrant.  Use
  28648. + * _tty_name() instead.
  28649. + */
  28650. +char *_tty_name(struct tty_struct *tty, char *buf)
  28651. +{
  28652. +    if (tty)
  28653. +        sprintf(buf, "%s%d", tty->driver.name,
  28654. +            MINOR(tty->device) - tty->driver.minor_start +
  28655. +            tty->driver.name_base);
  28656. +    else
  28657. +        strcpy(buf, "NULL tty");
  28658. +    return buf;
  28659. +}
  28660. +
  28661. +char *tty_name(struct tty_struct *tty)
  28662. +{
  28663. +    static char buf[64];
  28664. +
  28665. +    return(_tty_name(tty, buf));
  28666. +}
  28667. +
  28668. +#define TTY_PARANOIA_CHECK
  28669. +
  28670. +inline int tty_paranoia_check(struct tty_struct *tty, dev_t device,
  28671. +                  const char *routine)
  28672. +{
  28673. +#ifdef TTY_PARANOIA_CHECK
  28674. +    static const char *badmagic =
  28675. +        "Warning: bad magic number for tty struct (%d, %d) in %s\n";
  28676. +    static const char *badtty =
  28677. +        "Warning: null TTY for (%d, %d) in %s\n";
  28678. +
  28679. +    if (!tty) {
  28680. +        printk(badtty, MAJOR(device), MINOR(device), routine);
  28681. +        return 1;
  28682. +    }
  28683. +    if (tty->magic != TTY_MAGIC) {
  28684. +        printk(badmagic, MAJOR(device), MINOR(device), routine);
  28685. +        return 1;
  28686. +    }
  28687. +#endif
  28688. +    return 0;
  28689. +}
  28690. +
  28691. +int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
  28692. +{
  28693. +    if (disc < N_TTY || disc >= NR_LDISCS)
  28694. +        return -EINVAL;
  28695. +
  28696. +    if (new_ldisc) {
  28697. +        ldiscs[disc] = *new_ldisc;
  28698. +        ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
  28699. +        ldiscs[disc].num = disc;
  28700. +    } else
  28701. +        memset(&ldiscs[disc], 0, sizeof(struct tty_ldisc));
  28702. +
  28703. +    return 0;
  28704. +}
  28705. +
  28706. +/* Set the discipline of a tty line. */
  28707. +static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
  28708. +{
  28709. +    int    retval = 0;
  28710. +    struct    tty_ldisc o_ldisc;
  28711. +
  28712. +    if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS) ||
  28713. +        !(ldiscs[ldisc].flags & LDISC_FLAG_DEFINED))
  28714. +        return -EINVAL;
  28715. +
  28716. +    if (tty->ldisc.num == ldisc)
  28717. +        return 0;    /* We are already in the desired discipline */
  28718. +    o_ldisc = tty->ldisc;
  28719. +
  28720. +    /* Shutdown the current discipline. */
  28721. +    if (tty->ldisc.close)
  28722. +        (tty->ldisc.close)(tty);
  28723. +
  28724. +    /* Now set up the new line discipline. */
  28725. +    tty->ldisc = ldiscs[ldisc];
  28726. +    tty->termios->c_line = ldisc;
  28727. +    if (tty->ldisc.open)
  28728. +        retval = (tty->ldisc.open)(tty);
  28729. +    if (retval < 0) {
  28730. +        tty->ldisc = o_ldisc;
  28731. +        tty->termios->c_line = tty->ldisc.num;
  28732. +        if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
  28733. +            tty->ldisc = ldiscs[N_TTY];
  28734. +            tty->termios->c_line = N_TTY;
  28735. +            if (tty->ldisc.open) {
  28736. +                int r = tty->ldisc.open(tty);
  28737. +
  28738. +                if (r < 0)
  28739. +                    panic("Couldn't open N_TTY ldisc for "
  28740. +                          "%s --- error %d.",
  28741. +                          tty_name(tty), r);
  28742. +            }
  28743. +        }
  28744. +    }
  28745. +    if (tty->ldisc.num != o_ldisc.num && tty->driver.set_ldisc)
  28746. +        tty->driver.set_ldisc(tty);
  28747. +    return retval;
  28748. +}
  28749. +
  28750. +/*
  28751. + * This routine returns a tty driver structure, given a device number
  28752. + */
  28753. +struct tty_driver *get_tty_driver(dev_t device)
  28754. +{
  28755. +    int    major, minor;
  28756. +    struct tty_driver *p;
  28757. +
  28758. +    minor = MINOR(device);
  28759. +    major = MAJOR(device);
  28760. +
  28761. +    for (p = tty_drivers; p; p = p->next) {
  28762. +        if (p->major != major)
  28763. +            continue;
  28764. +        if (minor < p->minor_start)
  28765. +            continue;
  28766. +        if (minor >= p->minor_start + p->num)
  28767. +            continue;
  28768. +        return p;
  28769. +    }
  28770. +    return NULL;
  28771. +}
  28772. +
  28773. +/*
  28774. + * If we try to write to, or set the state of, a terminal and we're
  28775. + * not in the foreground, send a SIGTTOU.  If the signal is blocked or
  28776. + * ignored, go ahead and perform the operation.  (POSIX 7.2)
  28777. + */
  28778. +int tty_check_change(struct tty_struct * tty)
  28779. +{
  28780. +    if (current->tty != tty)
  28781. +        return 0;
  28782. +    if (tty->pgrp <= 0) {
  28783. +        printk("tty_check_change: tty->pgrp <= 0!\n");
  28784. +        return 0;
  28785. +    }
  28786. +    if (current->pgrp == tty->pgrp)
  28787. +        return 0;
  28788. +    if (is_ignored(SIGTTOU))
  28789. +        return 0;
  28790. +    if (is_orphaned_pgrp(current->pgrp))
  28791. +        return -EIO;
  28792. +    (void) kill_pg(current->pgrp,SIGTTOU,1);
  28793. +    return -ERESTARTSYS;
  28794. +}
  28795. +
  28796. +static int hung_up_tty_read(struct inode * inode, struct file * file, char * buf, int count)
  28797. +{
  28798. +    return 0;
  28799. +}
  28800. +
  28801. +static int hung_up_tty_write(struct inode * inode, struct file * file, char * buf, int count)
  28802. +{
  28803. +    return -EIO;
  28804. +}
  28805. +
  28806. +static int hung_up_tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
  28807. +{
  28808. +    return 1;
  28809. +}
  28810. +
  28811. +static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
  28812. +                 unsigned int cmd, unsigned long arg)
  28813. +{
  28814. +    return -EIO;
  28815. +}
  28816. +
  28817. +static int tty_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
  28818. +{
  28819. +    return -ESPIPE;
  28820. +}
  28821. +
  28822. +static struct file_operations tty_fops = {
  28823. +    tty_lseek,
  28824. +    tty_read,
  28825. +    tty_write,
  28826. +    NULL,        /* tty_readdir */
  28827. +    tty_select,
  28828. +    tty_ioctl,
  28829. +    NULL,        /* tty_mmap */
  28830. +    tty_open,
  28831. +    tty_release,
  28832. +    NULL,        /* tty_fsync */
  28833. +    tty_fasync
  28834. +};
  28835. +
  28836. +static struct file_operations hung_up_tty_fops = {
  28837. +    tty_lseek,
  28838. +    hung_up_tty_read,
  28839. +    hung_up_tty_write,
  28840. +    NULL,        /* hung_up_tty_readdir */
  28841. +    hung_up_tty_select,
  28842. +    hung_up_tty_ioctl,
  28843. +    NULL,        /* hung_up_tty_mmap */
  28844. +    NULL,        /* hung_up_tty_open */
  28845. +    tty_release,    /* hung_up_tty_release */
  28846. +    NULL,        /* hung_up_tty_fsync  */
  28847. +    NULL        /* hung_up_tty_fasync */
  28848. +};
  28849. +
  28850. +void do_tty_hangup(struct tty_struct * tty, struct file_operations *fops)
  28851. +{
  28852. +    int i;
  28853. +    struct file * filp;
  28854. +    struct task_struct *p;
  28855. +
  28856. +    if (!tty)
  28857. +        return;
  28858. +    for (filp = first_file, i=0; i<nr_files; i++, filp = filp->f_next) {
  28859. +        if (!filp->f_count)
  28860. +            continue;
  28861. +        if (filp->private_data != tty)
  28862. +            continue;
  28863. +        if (filp->f_inode && filp->f_inode->i_rdev == CONSOLE_DEV)
  28864. +            continue;
  28865. +        if (filp->f_op != &tty_fops)
  28866. +            continue;
  28867. +        tty_fasync(filp->f_inode, filp, 0);
  28868. +        filp->f_op = fops;
  28869. +    }
  28870. +
  28871. +    if (tty->ldisc.flush_buffer)
  28872. +        tty->ldisc.flush_buffer(tty);
  28873. +    if (tty->driver.flush_buffer)
  28874. +        tty->driver.flush_buffer(tty);
  28875. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  28876. +        tty->ldisc.write_wakeup)
  28877. +        (tty->ldisc.write_wakeup)(tty);
  28878. +    wake_up_interruptible(&tty->write_wait);
  28879. +    wake_up_interruptible(&tty->read_wait);
  28880. +
  28881. +    /*
  28882. +     * Shutdown the current line discipline, and reset it to
  28883. +     * N_TTY.
  28884. +     */
  28885. +    if (tty->ldisc.num != ldiscs[N_TTY].num) {
  28886. +        if (tty->ldisc.close)
  28887. +            (tty->ldisc.close)(tty);
  28888. +        tty->ldisc = ldiscs[N_TTY];
  28889. +        tty->termios->c_line = N_TTY;
  28890. +        if (tty->ldisc.open) {
  28891. +            i = (tty->ldisc.open)(tty);
  28892. +            if (i < 0)
  28893. +                printk("do_tty_hangup: N_TTY open: error %d\n",
  28894. +                       -i);
  28895. +        }
  28896. +    }
  28897. +
  28898. +    if (tty->session > 0) {
  28899. +        kill_sl(tty->session,SIGHUP,1);
  28900. +        kill_sl(tty->session,SIGCONT,1);
  28901. +    }
  28902. +    tty->flags = 0;
  28903. +    tty->session = 0;
  28904. +    tty->pgrp = -1;
  28905. +     for_each_task(p) {
  28906. +        if (p->tty == tty)
  28907. +            p->tty = NULL;
  28908. +    }
  28909. +    if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS)
  28910. +        *tty->termios = tty->driver.init_termios;
  28911. +    if (tty->driver.hangup)
  28912. +        (tty->driver.hangup)(tty);
  28913. +}
  28914. +
  28915. +void tty_hangup(struct tty_struct * tty)
  28916. +{
  28917. +#ifdef TTY_DEBUG_HANGUP
  28918. +    printk("%s hangup...\n", tty_name(tty));
  28919. +#endif
  28920. +    do_tty_hangup(tty, &hung_up_tty_fops);
  28921. +}
  28922. +
  28923. +void tty_vhangup(struct tty_struct * tty)
  28924. +{
  28925. +#ifdef TTY_DEBUG_HANGUP
  28926. +    printk("%s vhangup...\n", tty_name(tty));
  28927. +#endif
  28928. +    do_tty_hangup(tty, &hung_up_tty_fops);
  28929. +}
  28930. +
  28931. +int tty_hung_up_p(struct file * filp)
  28932. +{
  28933. +    return (filp->f_op == &hung_up_tty_fops);
  28934. +}
  28935. +
  28936. +/*
  28937. + * This function is typically called only by the session leader, when
  28938. + * it wants to disassociate itself from its controlling tty.
  28939. + *
  28940. + * It performs the following functions:
  28941. + *     (1)  Sends a SIGHUP and SIGCONT to the foreground process group
  28942. + *     (2)  Clears the tty from being controlling the session
  28943. + *     (3)  Clears the controlling tty for all processes in the
  28944. + *         session group.
  28945. + */
  28946. +void disassociate_ctty(int priv)
  28947. +{
  28948. +    struct tty_struct *tty = current->tty;
  28949. +    struct task_struct *p;
  28950. +
  28951. +    if (!tty)
  28952. +        return;
  28953. +
  28954. +    if (tty->pgrp > 0) {
  28955. +        kill_pg(tty->pgrp, SIGHUP, priv);
  28956. +        kill_pg(tty->pgrp, SIGCONT, priv);
  28957. +    }
  28958. +    tty->session = 0;
  28959. +    tty->pgrp = -1;
  28960. +
  28961. +    for_each_task(p)
  28962. +          if (p->session == current->session)
  28963. +            p->tty = NULL;
  28964. +}
  28965. +
  28966. +/*
  28967. + * Sometimes we want to wait until a particular VT has been activated. We
  28968. + * do it in a very simple manner. Everybody waits on a single queue and
  28969. + * get woken up at once. Those that are satisfied go on with their business,
  28970. + * while those not ready go back to sleep. Seems overkill to add a wait
  28971. + * to each vt just for this - usually this does nothing!
  28972. + */
  28973. +static struct wait_queue *vt_activate_queue = NULL;
  28974. +
  28975. +/*
  28976. + * Sleeps until a vt is activated, or the task is interrupted. Returns
  28977. + * 0 if activation, -1 if interrupted.
  28978. + */
  28979. +int vt_waitactive(void)
  28980. +{
  28981. +    interruptible_sleep_on(&vt_activate_queue);
  28982. +    return (current->signal & ~current->blocked) ? -1 : 0;
  28983. +}
  28984. +
  28985. +#define vt_wake_waitactive() wake_up(&vt_activate_queue)
  28986. +
  28987. +void reset_vc(unsigned int new_console)
  28988. +{
  28989. +    vt_cons[new_console]->vc_mode = KD_TEXT;
  28990. +    kbd_table[new_console].kbdmode = VC_XLATE;
  28991. +    vt_cons[new_console]->vt_mode.mode = VT_AUTO;
  28992. +    vt_cons[new_console]->vt_mode.waitv = 0;
  28993. +    vt_cons[new_console]->vt_mode.relsig = 0;
  28994. +    vt_cons[new_console]->vt_mode.acqsig = 0;
  28995. +    vt_cons[new_console]->vt_mode.frsig = 0;
  28996. +    vt_cons[new_console]->vt_pid = -1;
  28997. +    vt_cons[new_console]->vt_newvt = -1;
  28998. +}
  28999. +
  29000. +/*
  29001. + * Performs the back end of a vt switch
  29002. + */
  29003. +void complete_change_console(unsigned int new_console)
  29004. +{
  29005. +    unsigned char old_vc_mode;
  29006. +
  29007. +        if (new_console == fg_console)
  29008. +                return;
  29009. +        if (!vc_cons_allocated(new_console))
  29010. +                return;
  29011. +
  29012. +    /*
  29013. +     * If we're switching, we could be going from KD_GRAPHICS to
  29014. +     * KD_TEXT mode or vice versa, which means we need to blank or
  29015. +     * unblank the screen later.
  29016. +     */
  29017. +    old_vc_mode = vt_cons[fg_console]->vc_mode;
  29018. +    update_screen(new_console);
  29019. +
  29020. +    /*
  29021. +     * If this new console is under process control, send it a signal
  29022. +     * telling it that it has acquired. Also check if it has died and
  29023. +     * clean up (similar to logic employed in change_console())
  29024. +     */
  29025. +    if (vt_cons[new_console]->vt_mode.mode == VT_PROCESS)
  29026. +    {
  29027. +        /*
  29028. +         * Send the signal as privileged - kill_proc() will
  29029. +         * tell us if the process has gone or something else
  29030. +         * is awry
  29031. +         */
  29032. +        if (kill_proc(vt_cons[new_console]->vt_pid,
  29033. +                  vt_cons[new_console]->vt_mode.acqsig,
  29034. +                  1) != 0)
  29035. +        {
  29036. +        /*
  29037. +         * The controlling process has died, so we revert back to
  29038. +         * normal operation. In this case, we'll also change back
  29039. +         * to KD_TEXT mode. I'm not sure if this is strictly correct
  29040. +         * but it saves the agony when the X server dies and the screen
  29041. +         * remains blanked due to KD_GRAPHICS! It would be nice to do
  29042. +         * this outside of VT_PROCESS but there is no single process
  29043. +         * to account for and tracking tty count may be undesirable.
  29044. +         */
  29045. +                reset_vc(new_console);
  29046. +        }
  29047. +    }
  29048. +
  29049. +    /*
  29050. +     * We do this here because the controlling process above may have
  29051. +     * gone, and so there is now a new vc_mode
  29052. +     */
  29053. +    if (old_vc_mode != vt_cons[new_console]->vc_mode)
  29054. +    {
  29055. +        if (vt_cons[new_console]->vc_mode == KD_TEXT)
  29056. +            unblank_screen();
  29057. +        else {
  29058. +            timer_active &= ~(1<<BLANK_TIMER);
  29059. +            blank_screen();
  29060. +        }
  29061. +    }
  29062. +
  29063. +    /*
  29064. +     * Wake anyone waiting for their VT to activate
  29065. +     */
  29066. +    vt_wake_waitactive();
  29067. +    return;
  29068. +}
  29069. +
  29070. +/*
  29071. + * Performs the front-end of a vt switch
  29072. + */
  29073. +void change_console(unsigned int new_console)
  29074. +{
  29075. +        if (new_console == fg_console)
  29076. +                return;
  29077. +        if (!vc_cons_allocated(new_console))
  29078. +        return;
  29079. +
  29080. +    /*
  29081. +     * If this vt is in process mode, then we need to handshake with
  29082. +     * that process before switching. Essentially, we store where that
  29083. +     * vt wants to switch to and wait for it to tell us when it's done
  29084. +     * (via VT_RELDISP ioctl).
  29085. +     *
  29086. +     * We also check to see if the controlling process still exists.
  29087. +     * If it doesn't, we reset this vt to auto mode and continue.
  29088. +     * This is a cheap way to track process control. The worst thing
  29089. +     * that can happen is: we send a signal to a process, it dies, and
  29090. +     * the switch gets "lost" waiting for a response; hopefully, the
  29091. +     * user will try again, we'll detect the process is gone (unless
  29092. +     * the user waits just the right amount of time :-) and revert the
  29093. +     * vt to auto control.
  29094. +     */
  29095. +    if (vt_cons[fg_console]->vt_mode.mode == VT_PROCESS)
  29096. +    {
  29097. +        /*
  29098. +         * Send the signal as privileged - kill_proc() will
  29099. +         * tell us if the process has gone or something else
  29100. +         * is awry
  29101. +         */
  29102. +        if (kill_proc(vt_cons[fg_console]->vt_pid,
  29103. +                  vt_cons[fg_console]->vt_mode.relsig,
  29104. +                  1) == 0)
  29105. +        {
  29106. +            /*
  29107. +             * It worked. Mark the vt to switch to and
  29108. +             * return. The process needs to send us a
  29109. +             * VT_RELDISP ioctl to complete the switch.
  29110. +             */
  29111. +            vt_cons[fg_console]->vt_newvt = new_console;
  29112. +            return;
  29113. +        }
  29114. +
  29115. +        /*
  29116. +         * The controlling process has died, so we revert back to
  29117. +         * normal operation. In this case, we'll also change back
  29118. +         * to KD_TEXT mode. I'm not sure if this is strictly correct
  29119. +         * but it saves the agony when the X server dies and the screen
  29120. +         * remains blanked due to KD_GRAPHICS! It would be nice to do
  29121. +         * this outside of VT_PROCESS but there is no single process
  29122. +         * to account for and tracking tty count may be undesirable.
  29123. +         */
  29124. +        reset_vc(fg_console);
  29125. +
  29126. +        /*
  29127. +         * Fall through to normal (VT_AUTO) handling of the switch...
  29128. +         */
  29129. +    }
  29130. +
  29131. +    /*
  29132. +     * Ignore all switches in KD_GRAPHICS+VT_AUTO mode
  29133. +     */
  29134. +    if (vt_cons[fg_console]->vc_mode == KD_GRAPHICS)
  29135. +        return;
  29136. +
  29137. +    complete_change_console(new_console);
  29138. +}
  29139. +
  29140. +void wait_for_keypress(void)
  29141. +{
  29142. +    sleep_on(&keypress_wait);
  29143. +}
  29144. +
  29145. +void stop_tty(struct tty_struct *tty)
  29146. +{
  29147. +    if (tty->stopped)
  29148. +        return;
  29149. +    tty->stopped = 1;
  29150. +    if (tty->link && tty->link->packet) {
  29151. +        tty->ctrl_status &= ~TIOCPKT_START;
  29152. +        tty->ctrl_status |= TIOCPKT_STOP;
  29153. +        wake_up_interruptible(&tty->link->read_wait);
  29154. +    }
  29155. +    if (tty->driver.stop)
  29156. +        (tty->driver.stop)(tty);
  29157. +}
  29158. +
  29159. +void start_tty(struct tty_struct *tty)
  29160. +{
  29161. +    if (!tty->stopped)
  29162. +        return;
  29163. +    tty->stopped = 0;
  29164. +    if (tty->link && tty->link->packet) {
  29165. +        tty->ctrl_status &= ~TIOCPKT_STOP;
  29166. +        tty->ctrl_status |= TIOCPKT_START;
  29167. +        wake_up_interruptible(&tty->link->read_wait);
  29168. +    }
  29169. +    if (tty->driver.start)
  29170. +        (tty->driver.start)(tty);
  29171. +    if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  29172. +        tty->ldisc.write_wakeup)
  29173. +        (tty->ldisc.write_wakeup)(tty);
  29174. +    wake_up_interruptible(&tty->write_wait);
  29175. +}
  29176. +
  29177. +static int tty_read(struct inode * inode, struct file * file, char * buf, int count)
  29178. +{
  29179. +    int i;
  29180. +    struct tty_struct * tty;
  29181. +
  29182. +    tty = (struct tty_struct *)file->private_data;
  29183. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_read"))
  29184. +        return -EIO;
  29185. +    if (!tty || (tty->flags & (1 << TTY_IO_ERROR)))
  29186. +        return -EIO;
  29187. +
  29188. +    /* This check not only needs to be done before reading, but also
  29189. +       whenever read_chan() gets woken up after sleeping, so I've
  29190. +       moved it to there.  This should only be done for the N_TTY
  29191. +       line discipline, anyway.  Same goes for write_chan(). -- jlc. */
  29192. +#if 0
  29193. +    if ((inode->i_rdev != CONSOLE_DEV) && /* don't stop on /dev/console */
  29194. +        (tty->pgrp > 0) &&
  29195. +        (current->tty == tty) &&
  29196. +        (tty->pgrp != current->pgrp))
  29197. +        if (is_ignored(SIGTTIN) || is_orphaned_pgrp(current->pgrp))
  29198. +            return -EIO;
  29199. +        else {
  29200. +            (void) kill_pg(current->pgrp, SIGTTIN, 1);
  29201. +            return -ERESTARTSYS;
  29202. +        }
  29203. +#endif
  29204. +    if (tty->ldisc.read)
  29205. +        /* XXX casts are for what kernel-wide prototypes should be. */
  29206. +        i = (tty->ldisc.read)(tty,file,(unsigned char *)buf,(unsigned int)count);
  29207. +    else
  29208. +        i = -EIO;
  29209. +    if (i > 0)
  29210. +        inode->i_atime = CURRENT_TIME;
  29211. +    return i;
  29212. +}
  29213. +
  29214. +static int tty_write(struct inode * inode, struct file * file, char * buf, int count)
  29215. +{
  29216. +    int i, is_console;
  29217. +    struct tty_struct * tty;
  29218. +
  29219. +    is_console = (inode->i_rdev == CONSOLE_DEV);
  29220. +
  29221. +    if (is_console && redirect)
  29222. +        tty = redirect;
  29223. +    else
  29224. +        tty = (struct tty_struct *)file->private_data;
  29225. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_write"))
  29226. +        return -EIO;
  29227. +    if (!tty || !tty->driver.write || (tty->flags & (1 << TTY_IO_ERROR)))
  29228. +        return -EIO;
  29229. +#if 0
  29230. +    if (!is_console && L_TOSTOP(tty) && (tty->pgrp > 0) &&
  29231. +        (current->tty == tty) && (tty->pgrp != current->pgrp)) {
  29232. +        if (is_orphaned_pgrp(current->pgrp))
  29233. +            return -EIO;
  29234. +        if (!is_ignored(SIGTTOU)) {
  29235. +            (void) kill_pg(current->pgrp, SIGTTOU, 1);
  29236. +            return -ERESTARTSYS;
  29237. +        }
  29238. +    }
  29239. +#endif
  29240. +    if (tty->ldisc.write)
  29241. +        /* XXX casts are for what kernel-wide prototypes should be. */
  29242. +        i = (tty->ldisc.write)(tty,file,(unsigned char *)buf,(unsigned int)count);
  29243. +    else
  29244. +        i = -EIO;
  29245. +    if (i > 0)
  29246. +        inode->i_mtime = CURRENT_TIME;
  29247. +    return i;
  29248. +}
  29249. +
  29250. +/*
  29251. + * This is so ripe with races that you should *really* not touch this
  29252. + * unless you know exactly what you are doing. All the changes have to be
  29253. + * made atomically, or there may be incorrect pointers all over the place.
  29254. + */
  29255. +static int init_dev(dev_t device, struct tty_struct **ret_tty)
  29256. +{
  29257. +    struct tty_struct *tty, **tty_loc, *o_tty, **o_tty_loc;
  29258. +    struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
  29259. +    struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
  29260. +    struct tty_driver *driver;
  29261. +    int retval;
  29262. +    int idx;
  29263. +
  29264. +    driver = get_tty_driver(device);
  29265. +    if (!driver)
  29266. +        return -ENODEV;
  29267. +
  29268. +    idx = MINOR(device) - driver->minor_start;
  29269. +    tty = o_tty = NULL;
  29270. +    tp = o_tp = NULL;
  29271. +    ltp = o_ltp = NULL;
  29272. +    o_tty_loc = NULL;
  29273. +    o_tp_loc = o_ltp_loc = NULL;
  29274. +
  29275. +    tty_loc = &driver->table[idx];
  29276. +    tp_loc = &driver->termios[idx];
  29277. +    ltp_loc = &driver->termios_locked[idx];
  29278. +repeat:
  29279. +    retval = -EAGAIN;
  29280. +    if (driver->type == TTY_DRIVER_TYPE_PTY &&
  29281. +        driver->subtype == PTY_TYPE_MASTER &&
  29282. +        *tty_loc && (*tty_loc)->count)
  29283. +        goto end_init;
  29284. +    retval = -ENOMEM;
  29285. +    if (!*tty_loc && !tty) {
  29286. +        if (!(tty = (struct tty_struct*) kmalloc(sizeof(struct tty_struct),
  29287. +                            GFP_KERNEL)))
  29288. +            goto end_init;
  29289. +        initialize_tty_struct(tty);
  29290. +        tty->device = device;
  29291. +        tty->driver = *driver;
  29292. +        goto repeat;
  29293. +    }
  29294. +    if (!*tp_loc && !tp) {
  29295. +        tp = (struct termios *) kmalloc(sizeof(struct termios),
  29296. +                        GFP_KERNEL);
  29297. +        if (!tp)
  29298. +            goto end_init;
  29299. +        *tp = driver->init_termios;
  29300. +        goto repeat;
  29301. +    }
  29302. +    if (!*ltp_loc && !ltp) {
  29303. +        ltp = (struct termios *) kmalloc(sizeof(struct termios),
  29304. +                         GFP_KERNEL);
  29305. +        if (!ltp)
  29306. +            goto end_init;
  29307. +        memset(ltp, 0, sizeof(struct termios));
  29308. +        goto repeat;
  29309. +    }
  29310. +    if (driver->type == TTY_DRIVER_TYPE_PTY) {
  29311. +        o_tty_loc = &driver->other->table[idx];
  29312. +        o_tp_loc = &driver->other->termios[idx];
  29313. +        o_ltp_loc = &driver->other->termios_locked[idx];
  29314. +
  29315. +        if (!*o_tty_loc && !o_tty) {
  29316. +            dev_t     o_device;
  29317. +            o_tty = (struct tty_struct *)
  29318. +                kmalloc(sizeof(struct tty_struct),
  29319. +                    GFP_KERNEL);
  29320. +            if (!o_tty)
  29321. +                goto end_init;
  29322. +            o_device = MKDEV(driver->other->major,
  29323. +                     driver->other->minor_start + idx);
  29324. +            initialize_tty_struct(o_tty);
  29325. +            o_tty->device = o_device;
  29326. +            o_tty->driver = *driver->other;
  29327. +            goto repeat;
  29328. +        }
  29329. +        if (!*o_tp_loc && !o_tp) {
  29330. +            o_tp = (struct termios *)
  29331. +                kmalloc(sizeof(struct termios), GFP_KERNEL);
  29332. +            if (!o_tp)
  29333. +                goto end_init;
  29334. +            *o_tp = driver->other->init_termios;
  29335. +            goto repeat;
  29336. +        }
  29337. +        if (!*o_ltp_loc && !o_ltp) {
  29338. +            o_ltp = (struct termios *)
  29339. +                kmalloc(sizeof(struct termios), GFP_KERNEL);
  29340. +            if (!o_ltp)
  29341. +                goto end_init;
  29342. +            memset(o_ltp, 0, sizeof(struct termios));
  29343. +            goto repeat;
  29344. +        }
  29345. +
  29346. +    }
  29347. +    /* Now we have allocated all the structures: update all the pointers.. */
  29348. +    if (!*tp_loc) {
  29349. +        *tp_loc = tp;
  29350. +        tp = NULL;
  29351. +    }
  29352. +    if (!*ltp_loc) {
  29353. +        *ltp_loc = ltp;
  29354. +        ltp = NULL;
  29355. +    }
  29356. +    if (!*tty_loc) {
  29357. +        tty->termios = *tp_loc;
  29358. +        tty->termios_locked = *ltp_loc;
  29359. +        *tty_loc = tty;
  29360. +        (*driver->refcount)++;
  29361. +        (*tty_loc)->count++;
  29362. +        if (tty->ldisc.open) {
  29363. +            retval = (tty->ldisc.open)(tty);
  29364. +            if (retval < 0) {
  29365. +                (*tty_loc)->count--;
  29366. +                tty = NULL;
  29367. +                goto end_init;
  29368. +            }
  29369. +        }
  29370. +        tty = NULL;
  29371. +    } else
  29372. +        (*tty_loc)->count++;
  29373. +    if (driver->type == TTY_DRIVER_TYPE_PTY) {
  29374. +        if (!*o_tp_loc) {
  29375. +            *o_tp_loc = o_tp;
  29376. +            o_tp = NULL;
  29377. +        }
  29378. +        if (!*o_ltp_loc) {
  29379. +            *o_ltp_loc = o_ltp;
  29380. +            o_ltp = NULL;
  29381. +        }
  29382. +        if (!*o_tty_loc) {
  29383. +            o_tty->termios = *o_tp_loc;
  29384. +            o_tty->termios_locked = *o_ltp_loc;
  29385. +            *o_tty_loc = o_tty;
  29386. +            (*driver->other->refcount)++;
  29387. +            if (o_tty->ldisc.open) {
  29388. +                retval = (o_tty->ldisc.open)(o_tty);
  29389. +                if (retval < 0) {
  29390. +                    (*tty_loc)->count--;
  29391. +                    o_tty = NULL;
  29392. +                    goto end_init;
  29393. +                }
  29394. +            }
  29395. +            o_tty = NULL;
  29396. +        }
  29397. +        (*tty_loc)->link = *o_tty_loc;
  29398. +        (*o_tty_loc)->link = *tty_loc;
  29399. +        if (driver->subtype == PTY_TYPE_MASTER)
  29400. +            (*o_tty_loc)->count++;
  29401. +    }
  29402. +    (*tty_loc)->driver = *driver;
  29403. +    *ret_tty = *tty_loc;
  29404. +    retval = 0;
  29405. +end_init:
  29406. +    if (tty)
  29407. +        kfree_s(tty,sizeof(struct tty_struct));
  29408. +    if (o_tty)
  29409. +        kfree_s(o_tty,sizeof(struct tty_struct));
  29410. +    if (tp)
  29411. +        kfree_s(tp, sizeof(struct termios));
  29412. +    if (o_tp)
  29413. +        kfree_s(o_tp, sizeof(struct termios));
  29414. +    if (ltp)
  29415. +        kfree_s(ltp, sizeof(struct termios));
  29416. +    if (o_ltp)
  29417. +        kfree_s(o_ltp, sizeof(struct termios));
  29418. +    return retval;
  29419. +}
  29420. +
  29421. +/*
  29422. + * Even releasing the tty structures is a tricky business.. We have
  29423. + * to be very careful that the structures are all released at the
  29424. + * same time, as interrupts might otherwise get the wrong pointers.
  29425. + */
  29426. +static void release_dev(struct file * filp)
  29427. +{
  29428. +    struct tty_struct *tty, *o_tty;
  29429. +    struct termios *tp, *o_tp, *ltp, *o_ltp;
  29430. +    struct task_struct **p;
  29431. +    int    idx;
  29432. +
  29433. +
  29434. +    tty = (struct tty_struct *)filp->private_data;
  29435. +    if (tty_paranoia_check(tty, filp->f_inode->i_rdev, "release_dev"))
  29436. +        return;
  29437. +
  29438. +    tty_fasync(filp->f_inode, filp, 0);
  29439. +
  29440. +    tp = tty->termios;
  29441. +    ltp = tty->termios_locked;
  29442. +
  29443. +    idx = MINOR(tty->device) - tty->driver.minor_start;
  29444. +#ifdef TTY_PARANOIA_CHECK
  29445. +    if (idx < 0 || idx >= tty->driver.num) {
  29446. +        printk("release_dev: bad idx when trying to free (%d, %d)\n",
  29447. +               MAJOR(tty->device), MINOR(tty->device));
  29448. +        return;
  29449. +    }
  29450. +    if (tty != tty->driver.table[idx]) {
  29451. +        printk("release_dev: driver.table[%d] not tty for (%d, %d)\n",
  29452. +               idx, MAJOR(tty->device), MINOR(tty->device));
  29453. +        return;
  29454. +    }
  29455. +    if (tp != tty->driver.termios[idx]) {
  29456. +        printk("release_dev: driver.termios[%d] not termios for (%d, %d)\n",
  29457. +               idx, MAJOR(tty->device), MINOR(tty->device));
  29458. +        return;
  29459. +    }
  29460. +    if (ltp != tty->driver.termios_locked[idx]) {
  29461. +        printk("release_dev: driver.termios_locked[%d] not termios_locked for (%d, %d)\n",
  29462. +               idx, MAJOR(tty->device), MINOR(tty->device));
  29463. +        return;
  29464. +    }
  29465. +#endif
  29466. +
  29467. +#ifdef TTY_DEBUG_HANGUP
  29468. +    printk("release_dev of %s (tty count=%d)...", tty_name(tty),
  29469. +           tty->count);
  29470. +#endif
  29471. +
  29472. +    o_tty = tty->link;
  29473. +    o_tp = (o_tty) ? o_tty->termios : NULL;
  29474. +    o_ltp = (o_tty) ? o_tty->termios_locked : NULL;
  29475. +
  29476. +#ifdef TTY_PARANOIA_CHECK
  29477. +    if (tty->driver.other) {
  29478. +        if (o_tty != tty->driver.other->table[idx]) {
  29479. +            printk("release_dev: other->table[%d] not o_tty for (%d, %d)\n",
  29480. +                   idx, MAJOR(tty->device), MINOR(tty->device));
  29481. +            return;
  29482. +        }
  29483. +        if (o_tp != tty->driver.other->termios[idx]) {
  29484. +            printk("release_dev: other->termios[%d] not o_termios for (%d, %d)\n",
  29485. +                   idx, MAJOR(tty->device), MINOR(tty->device));
  29486. +            return;
  29487. +        }
  29488. +        if (o_ltp != tty->driver.other->termios_locked[idx]) {
  29489. +            printk("release_dev: other->termios_locked[%d] not o_termios_locked for (%d, %d)\n",
  29490. +                   idx, MAJOR(tty->device), MINOR(tty->device));
  29491. +            return;
  29492. +        }
  29493. +
  29494. +        if (o_tty->link != tty) {
  29495. +            printk("release_dev: bad pty pointers\n");
  29496. +            return;
  29497. +        }
  29498. +    }
  29499. +#endif
  29500. +
  29501. +    if (tty->driver.close)
  29502. +        tty->driver.close(tty, filp);
  29503. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  29504. +        tty->driver.subtype == PTY_TYPE_MASTER) {
  29505. +        if (--tty->link->count < 0) {
  29506. +            printk("release_dev: bad pty slave count (%d) for %s\n",
  29507. +                   tty->count, tty_name(tty));
  29508. +            tty->link->count = 0;
  29509. +        }
  29510. +    }
  29511. +    if (--tty->count < 0) {
  29512. +        printk("release_dev: bad tty->count (%d) for %s\n",
  29513. +               tty->count, tty_name(tty));
  29514. +        tty->count = 0;
  29515. +    }
  29516. +    if (tty->count)
  29517. +        return;
  29518. +
  29519. +    if (o_tty) {
  29520. +        if (o_tty->count)
  29521. +            return;
  29522. +        tty->driver.other->table[idx] = NULL;
  29523. +        tty->driver.other->termios[idx] = NULL;
  29524. +        kfree_s(o_tp, sizeof(struct termios));
  29525. +    }
  29526. +
  29527. +#ifdef TTY_DEBUG_HANGUP
  29528. +    printk("freeing tty structure...");
  29529. +#endif
  29530. +
  29531. +    /*
  29532. +     * Make sure there aren't any processes that still think this
  29533. +     * tty is their controlling tty.
  29534. +     */
  29535. +    for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
  29536. +        if (*p == 0)
  29537. +            continue;
  29538. +        if ((*p)->tty == tty)
  29539. +            (*p)->tty = NULL;
  29540. +        if (o_tty && (*p)->tty == o_tty)
  29541. +            (*p)->tty = NULL;
  29542. +    }
  29543. +
  29544. +    /*
  29545. +     * Shutdown the current line discipline, and reset it to
  29546. +     * N_TTY.
  29547. +     */
  29548. +    if (tty->ldisc.close)
  29549. +        (tty->ldisc.close)(tty);
  29550. +    tty->ldisc = ldiscs[N_TTY];
  29551. +    tty->termios->c_line = N_TTY;
  29552. +
  29553. +    tty->driver.table[idx] = NULL;
  29554. +    if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS) {
  29555. +        tty->driver.termios[idx] = NULL;
  29556. +        kfree_s(tp, sizeof(struct termios));
  29557. +    }
  29558. +    if (tty == redirect || o_tty == redirect)
  29559. +        redirect = NULL;
  29560. +    /*
  29561. +     * Make sure that the tty's task queue isn't activated.  If it
  29562. +     * is, take it out of the linked list.
  29563. +     */
  29564. +    cli();
  29565. +    if (tty->flip.tqueue.sync) {
  29566. +        struct tq_struct *tq, *prev;
  29567. +
  29568. +        for (tq=tq_timer, prev=0; tq; prev=tq, tq=tq->next) {
  29569. +            if (tq == &tty->flip.tqueue) {
  29570. +                if (prev)
  29571. +                    prev->next = tq->next;
  29572. +                else
  29573. +                    tq_timer = tq->next;
  29574. +                break;
  29575. +            }
  29576. +        }
  29577. +    }
  29578. +    sti();
  29579. +    tty->magic = 0;
  29580. +    (*tty->driver.refcount)--;
  29581. +    kfree_s(tty,sizeof(struct tty_struct));
  29582. +    if (o_tty) {
  29583. +        o_tty->magic = 0;
  29584. +        (*o_tty->driver.refcount)--;
  29585. +        kfree_s(o_tty,sizeof(struct tty_struct));
  29586. +    }
  29587. +}
  29588. +
  29589. +/*
  29590. + * tty_open and tty_release keep up the tty count that contains the
  29591. + * number of opens done on a tty. We cannot use the inode-count, as
  29592. + * different inodes might point to the same tty.
  29593. + *
  29594. + * Open-counting is needed for pty masters, as well as for keeping
  29595. + * track of serial lines: DTR is dropped when the last close happens.
  29596. + * (This is not done solely through tty->count, now.  - Ted 1/27/92)
  29597. + *
  29598. + * The termios state of a pty is reset on first open so that
  29599. + * settings don't persist across reuse.
  29600. + */
  29601. +static int tty_open(struct inode * inode, struct file * filp)
  29602. +{
  29603. +    struct tty_struct *tty;
  29604. +    int minor;
  29605. +    int noctty, retval;
  29606. +    dev_t device;
  29607. +
  29608. +retry_open:
  29609. +    noctty = filp->f_flags & O_NOCTTY;
  29610. +    device = inode->i_rdev;
  29611. +    if (device == TTY_DEV) {
  29612. +        if (!current->tty)
  29613. +            return -ENXIO;
  29614. +        device = current->tty->device;
  29615. +        /* noctty = 1; */
  29616. +    }
  29617. +    if (device == CONSOLE_DEV) {
  29618. +        device = MKDEV(TTY_MAJOR, fg_console+1);
  29619. +        noctty = 1;
  29620. +    }
  29621. +    minor = MINOR(device);
  29622. +
  29623. +    retval = init_dev(device, &tty);
  29624. +    filp->private_data = tty;
  29625. +    if (retval)
  29626. +        return retval;
  29627. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  29628. +        tty->driver.subtype == PTY_TYPE_MASTER)
  29629. +        noctty = 1;
  29630. +#ifdef TTY_DEBUG_HANGUP
  29631. +    printk("opening %s...", tty_name(tty));
  29632. +#endif
  29633. +    if (tty->driver.open)
  29634. +        retval = tty->driver.open(tty, filp);
  29635. +    else
  29636. +        retval = -ENODEV;
  29637. +
  29638. +    if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !suser())
  29639. +        retval = -EBUSY;
  29640. +
  29641. +    if (retval) {
  29642. +#ifdef TTY_DEBUG_HANGUP
  29643. +        printk("error %d in opening %s...", retval, tty_name(tty));
  29644. +#endif
  29645. +
  29646. +        release_dev(filp);
  29647. +        if (retval != -ERESTARTSYS)
  29648. +            return retval;
  29649. +        if (current->signal & ~current->blocked)
  29650. +            return retval;
  29651. +        schedule();
  29652. +        /*
  29653. +         * Need to reset f_op in case a hangup happened.
  29654. +         */
  29655. +        filp->f_op = &tty_fops;
  29656. +        goto retry_open;
  29657. +    }
  29658. +    if (!noctty &&
  29659. +        current->leader &&
  29660. +        !current->tty &&
  29661. +        tty->session == 0) {
  29662. +        current->tty = tty;
  29663. +        tty->session = current->session;
  29664. +        tty->pgrp = current->pgrp;
  29665. +    }
  29666. +    return 0;
  29667. +}
  29668. +
  29669. +/*
  29670. + * Note that releasing a pty master also releases the child, so
  29671. + * we have to make the redirection checks after that and on both
  29672. + * sides of a pty.
  29673. + */
  29674. +static void tty_release(struct inode * inode, struct file * filp)
  29675. +{
  29676. +    release_dev(filp);
  29677. +}
  29678. +
  29679. +static int tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
  29680. +{
  29681. +    struct tty_struct * tty;
  29682. +
  29683. +    tty = (struct tty_struct *)filp->private_data;
  29684. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_select"))
  29685. +        return 0;
  29686. +
  29687. +    if (tty->ldisc.select)
  29688. +        return (tty->ldisc.select)(tty, inode, filp, sel_type, wait);
  29689. +    return 0;
  29690. +}
  29691. +
  29692. +static int tty_fasync(struct inode * inode, struct file * filp, int on)
  29693. +{
  29694. +    struct tty_struct * tty;
  29695. +    struct fasync_struct *fa, *prev;
  29696. +
  29697. +    tty = (struct tty_struct *)filp->private_data;
  29698. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_fasync"))
  29699. +        return 0;
  29700. +
  29701. +    for (fa = tty->fasync, prev = 0; fa; prev= fa, fa = fa->fa_next) {
  29702. +        if (fa->fa_file == filp)
  29703. +            break;
  29704. +    }
  29705. +
  29706. +    if (on) {
  29707. +        if (fa)
  29708. +            return 0;
  29709. +        fa = (struct fasync_struct *)kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
  29710. +        if (!fa)
  29711. +            return -ENOMEM;
  29712. +        fa->magic = FASYNC_MAGIC;
  29713. +        fa->fa_file = filp;
  29714. +        fa->fa_next = tty->fasync;
  29715. +        tty->fasync = fa;
  29716. +        if (!tty->read_wait)
  29717. +            tty->minimum_to_wake = 1;
  29718. +        if (filp->f_owner == 0) {
  29719. +            if (tty->pgrp)
  29720. +                filp->f_owner = -tty->pgrp;
  29721. +            else
  29722. +                filp->f_owner = current->pid;
  29723. +        }
  29724. +    } else {
  29725. +        if (!fa)
  29726. +            return 0;
  29727. +        if (prev)
  29728. +            prev->fa_next = fa->fa_next;
  29729. +        else
  29730. +            tty->fasync = fa->fa_next;
  29731. +        kfree_s(fa, sizeof(struct fasync_struct));
  29732. +        if (!tty->fasync && !tty->read_wait)
  29733. +            tty->minimum_to_wake = N_TTY_BUF_SIZE;
  29734. +    }
  29735. +    return 0;
  29736. +}
  29737. +
  29738. +/*
  29739. + * XXX does anyone use this anymore?!?
  29740. + */
  29741. +static int do_get_ps_info(int arg)
  29742. +{
  29743. +    struct tstruct {
  29744. +        int flag;
  29745. +        int present[NR_TASKS];
  29746. +        struct task_struct tasks[NR_TASKS];
  29747. +    };
  29748. +    struct tstruct *ts = (struct tstruct *)arg;
  29749. +    struct task_struct **p;
  29750. +    char *c, *d;
  29751. +    int i, n = 0;
  29752. +
  29753. +    i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct tstruct));
  29754. +    if (i)
  29755. +        return i;
  29756. +    for (p = &FIRST_TASK ; p <= &LAST_TASK ; p++, n++)
  29757. +        if (*p)
  29758. +        {
  29759. +            c = (char *)(*p);
  29760. +            d = (char *)(ts->tasks+n);
  29761. +            for (i=0 ; i<sizeof(struct task_struct) ; i++)
  29762. +                put_fs_byte(*c++, d++);
  29763. +            put_fs_long(1, (unsigned long *)(ts->present+n));
  29764. +        }
  29765. +        else
  29766. +            put_fs_long(0, (unsigned long *)(ts->present+n));
  29767. +    return(0);
  29768. +}
  29769. +
  29770. +static int tty_ioctl(struct inode * inode, struct file * file,
  29771. +             unsigned int cmd, unsigned long arg)
  29772. +{
  29773. +    int    retval;
  29774. +    struct tty_struct * tty;
  29775. +    struct tty_struct * real_tty;
  29776. +    struct winsize tmp_ws;
  29777. +    pid_t pgrp;
  29778. +    unsigned char    ch;
  29779. +    char    mbz = 0;
  29780. +
  29781. +    tty = (struct tty_struct *)file->private_data;
  29782. +    if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
  29783. +        return -EINVAL;
  29784. +
  29785. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  29786. +        tty->driver.subtype == PTY_TYPE_MASTER)
  29787. +        real_tty = tty->link;
  29788. +    else
  29789. +        real_tty = tty;
  29790. +
  29791. +    switch (cmd) {
  29792. +        case TIOCSTI:
  29793. +            if ((current->tty != tty) && !suser())
  29794. +                return -EPERM;
  29795. +            retval = verify_area(VERIFY_READ, (void *) arg, 1);
  29796. +            if (retval)
  29797. +                return retval;
  29798. +            ch = get_fs_byte((char *) arg);
  29799. +            tty->ldisc.receive_buf(tty, &ch, &mbz, 1);
  29800. +            return 0;
  29801. +        case TIOCGWINSZ:
  29802. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  29803. +                         sizeof (struct winsize));
  29804. +            if (retval)
  29805. +                return retval;
  29806. +            memcpy_tofs((struct winsize *) arg, &tty->winsize,
  29807. +                    sizeof (struct winsize));
  29808. +            return 0;
  29809. +        case TIOCSWINSZ:
  29810. +            retval = verify_area(VERIFY_READ, (void *) arg,
  29811. +                         sizeof (struct winsize));
  29812. +            if (retval)
  29813. +                return retval;
  29814. +            memcpy_fromfs(&tmp_ws, (struct winsize *) arg,
  29815. +                      sizeof (struct winsize));
  29816. +            if (memcmp(&tmp_ws, &tty->winsize,
  29817. +                   sizeof(struct winsize))) {
  29818. +                if (tty->pgrp > 0)
  29819. +                    kill_pg(tty->pgrp, SIGWINCH, 1);
  29820. +                if ((real_tty->pgrp != tty->pgrp) &&
  29821. +                    (real_tty->pgrp > 0))
  29822. +                    kill_pg(real_tty->pgrp, SIGWINCH, 1);
  29823. +            }
  29824. +            tty->winsize = tmp_ws;
  29825. +            real_tty->winsize = tmp_ws;
  29826. +            return 0;
  29827. +        case TIOCCONS:
  29828. +            if (tty->driver.type == TTY_DRIVER_TYPE_CONSOLE) {
  29829. +                if (!suser())
  29830. +                    return -EPERM;
  29831. +                redirect = NULL;
  29832. +                return 0;
  29833. +            }
  29834. +            if (redirect)
  29835. +                return -EBUSY;
  29836. +            redirect = real_tty;
  29837. +            return 0;
  29838. +        case FIONBIO:
  29839. +            retval = verify_area(VERIFY_READ, (void *) arg, sizeof(long));
  29840. +            if (retval)
  29841. +                return retval;
  29842. +            arg = get_fs_long((unsigned long *) arg);
  29843. +            if (arg)
  29844. +                file->f_flags |= O_NONBLOCK;
  29845. +            else
  29846. +                file->f_flags &= ~O_NONBLOCK;
  29847. +            return 0;
  29848. +        case TIOCEXCL:
  29849. +            set_bit(TTY_EXCLUSIVE, &tty->flags);
  29850. +            return 0;
  29851. +        case TIOCNXCL:
  29852. +            clear_bit(TTY_EXCLUSIVE, &tty->flags);
  29853. +            return 0;
  29854. +        case TIOCNOTTY:
  29855. +            if (current->tty != tty)
  29856. +                return -ENOTTY;
  29857. +            if (current->leader)
  29858. +                disassociate_ctty(0);
  29859. +            current->tty = NULL;
  29860. +            return 0;
  29861. +        case TIOCSCTTY:
  29862. +            if (current->leader &&
  29863. +                (current->session == tty->session))
  29864. +                return 0;
  29865. +            /*
  29866. +             * The process must be a session leader and
  29867. +             * not have a controlling tty already.
  29868. +             */
  29869. +            if (!current->leader || current->tty)
  29870. +                return -EPERM;
  29871. +            if (tty->session > 0) {
  29872. +                /*
  29873. +                 * This tty is already the controlling
  29874. +                 * tty for another session group!
  29875. +                 */
  29876. +                if ((arg == 1) && suser()) {
  29877. +                    /*
  29878. +                     * Steal it away
  29879. +                     */
  29880. +                    struct task_struct *p;
  29881. +
  29882. +                    for_each_task(p)
  29883. +                        if (p->tty == tty)
  29884. +                            p->tty = NULL;
  29885. +                } else
  29886. +                    return -EPERM;
  29887. +            }
  29888. +            current->tty = tty;
  29889. +            tty->session = current->session;
  29890. +            tty->pgrp = current->pgrp;
  29891. +            return 0;
  29892. +        case TIOCGPGRP:
  29893. +            /*
  29894. +             * (tty == real_tty) is a cheap way of
  29895. +             * testing if the tty is NOT a master pty.
  29896. +             */
  29897. +            if (tty == real_tty && current->tty != real_tty)
  29898. +                return -ENOTTY;
  29899. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  29900. +                         sizeof (pid_t));
  29901. +            if (retval)
  29902. +                return retval;
  29903. +            put_fs_long(real_tty->pgrp, (pid_t *) arg);
  29904. +            return 0;
  29905. +        case TIOCSPGRP:
  29906. +            retval = tty_check_change(real_tty);
  29907. +            if (retval)
  29908. +                return retval;
  29909. +            if (!current->tty ||
  29910. +                (current->tty != real_tty) ||
  29911. +                (real_tty->session != current->session))
  29912. +                return -ENOTTY;
  29913. +            pgrp = get_fs_long((pid_t *) arg);
  29914. +            if (pgrp < 0)
  29915. +                return -EINVAL;
  29916. +            if (session_of_pgrp(pgrp) != current->session)
  29917. +                return -EPERM;
  29918. +            real_tty->pgrp = pgrp;
  29919. +            return 0;
  29920. +        case TIOCGETD:
  29921. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  29922. +                         sizeof (unsigned long));
  29923. +            if (retval)
  29924. +                return retval;
  29925. +            put_fs_long(tty->ldisc.num, (unsigned long *) arg);
  29926. +            return 0;
  29927. +        case TIOCSETD:
  29928. +            retval = tty_check_change(tty);
  29929. +            if (retval)
  29930. +                return retval;
  29931. +            arg = get_fs_long((unsigned long *) arg);
  29932. +            return tty_set_ldisc(tty, arg);
  29933. +        case TIOCLINUX:
  29934. +            retval = verify_area(VERIFY_READ, (void *) arg, 1);
  29935. +            if (retval)
  29936. +                return retval;
  29937. +            switch (get_fs_byte((char *)arg))
  29938. +            {
  29939. +                case 0:
  29940. +                    return do_screendump(arg);
  29941. +                case 1:
  29942. +                    printk("Deprecated TIOCLINUX (1) ioctl\n");
  29943. +                    return do_get_ps_info(arg);
  29944. +                case 2:
  29945. +                    return set_selection(arg, tty);
  29946. +                case 3:
  29947. +                    return paste_selection(tty);
  29948. +                case 4:
  29949. +                    unblank_screen();
  29950. +                    return 0;
  29951. +                case 5:
  29952. +                    return sel_loadlut(arg);
  29953. +                case 6:
  29954. +            /* Make it possible to react to Shift+Mousebutton */
  29955. +            /* Note that shift_state is an undocumented
  29956. +               kernel-internal variable; programs not closely
  29957. +               related to the kernel should not use this. */
  29958. +                    put_fs_byte(0, arg);
  29959. +/*                     put_fs_byte(shift_state,arg); */
  29960. +                    return 0;
  29961. +                case 7:
  29962. +                    put_fs_byte(mouse_reporting(),arg);
  29963. +                    return 0;
  29964. +                default:
  29965. +                    return -EINVAL;
  29966. +            }
  29967. +        default:
  29968. +            if (tty->driver.ioctl) {
  29969. +                retval = (tty->driver.ioctl)(tty, file,
  29970. +                                 cmd, arg);
  29971. +                if (retval != -ENOIOCTLCMD)
  29972. +                    return retval;
  29973. +            }
  29974. +            if (tty->ldisc.ioctl) {
  29975. +                retval = (tty->ldisc.ioctl)(tty, file,
  29976. +                                cmd, arg);
  29977. +                if (retval != -ENOIOCTLCMD)
  29978. +                    return retval;
  29979. +            }
  29980. +            return -EINVAL;
  29981. +        }
  29982. +}
  29983. +
  29984. +
  29985. +/*
  29986. + * This implements the "Secure Attention Key" ---  the idea is to
  29987. + * prevent trojan horses by killing all processes associated with this
  29988. + * tty when the user hits the "Secure Attention Key".  Required for
  29989. + * super-paranoid applications --- see the Orange Book for more details.
  29990. + *
  29991. + * This code could be nicer; ideally it should send a HUP, wait a few
  29992. + * seconds, then send a INT, and then a KILL signal.  But you then
  29993. + * have to coordinate with the init process, since all processes associated
  29994. + * with the current tty must be dead before the new getty is allowed
  29995. + * to spawn.
  29996. + */
  29997. +void do_SAK( struct tty_struct *tty)
  29998. +{
  29999. +#ifdef TTY_SOFT_SAK
  30000. +    tty_hangup(tty);
  30001. +#else
  30002. +    struct task_struct **p;
  30003. +    int session;
  30004. +    int        i;
  30005. +    struct file    *filp;
  30006. +
  30007. +    if (!tty)
  30008. +        return;
  30009. +    session  = tty->session;
  30010. +    if (tty->ldisc.flush_buffer)
  30011. +        tty->ldisc.flush_buffer(tty);
  30012. +    if (tty->driver.flush_buffer)
  30013. +        tty->driver.flush_buffer(tty);
  30014. +     for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
  30015. +        if (!(*p))
  30016. +            continue;
  30017. +        if (((*p)->tty == tty) ||
  30018. +            ((session > 0) && ((*p)->session == session)))
  30019. +            send_sig(SIGKILL, *p, 1);
  30020. +        else {
  30021. +            for (i=0; i < NR_OPEN; i++) {
  30022. +                filp = (*p)->files->fd[i];
  30023. +                if (filp && (filp->f_op == &tty_fops) &&
  30024. +                    (filp->private_data == tty)) {
  30025. +                    send_sig(SIGKILL, *p, 1);
  30026. +                    break;
  30027. +                }
  30028. +            }
  30029. +        }
  30030. +    }
  30031. +#endif
  30032. +}
  30033. +
  30034. +/*
  30035. + * This routine is called out of the software interrupt to flush data
  30036. + * from the flip buffer to the line discipline.
  30037. + */
  30038. +static void flush_to_ldisc(void *private_)
  30039. +{
  30040. +    struct tty_struct *tty = (struct tty_struct *) private_;
  30041. +    unsigned char    *cp;
  30042. +    char        *fp;
  30043. +    int        count;
  30044. +
  30045. +    if (tty->flip.buf_num) {
  30046. +        cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
  30047. +        fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
  30048. +        tty->flip.buf_num = 0;
  30049. +
  30050. +        cli();
  30051. +        tty->flip.char_buf_ptr = tty->flip.char_buf;
  30052. +        tty->flip.flag_buf_ptr = tty->flip.flag_buf;
  30053. +    } else {
  30054. +        cp = tty->flip.char_buf;
  30055. +        fp = tty->flip.flag_buf;
  30056. +        tty->flip.buf_num = 1;
  30057. +
  30058. +        cli();
  30059. +        tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
  30060. +        tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
  30061. +    }
  30062. +    count = tty->flip.count;
  30063. +    tty->flip.count = 0;
  30064. +    sti();
  30065. +
  30066. +#if 0
  30067. +    if (count > tty->max_flip_cnt)
  30068. +        tty->max_flip_cnt = count;
  30069. +#endif
  30070. +    tty->ldisc.receive_buf(tty, cp, fp, count);
  30071. +}
  30072. +
  30073. +/*
  30074. + * This subroutine initializes a tty structure.
  30075. + */
  30076. +static void initialize_tty_struct(struct tty_struct *tty)
  30077. +{
  30078. +    memset(tty, 0, sizeof(struct tty_struct));
  30079. +    tty->magic = TTY_MAGIC;
  30080. +    tty->ldisc = ldiscs[N_TTY];
  30081. +    tty->pgrp = -1;
  30082. +    tty->flip.char_buf_ptr = tty->flip.char_buf;
  30083. +    tty->flip.flag_buf_ptr = tty->flip.flag_buf;
  30084. +    tty->flip.tqueue.routine = flush_to_ldisc;
  30085. +    tty->flip.tqueue.data = tty;
  30086. +}
  30087. +
  30088. +/*
  30089. + * The default put_char routine if the driver did not define one.
  30090. + */
  30091. +void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
  30092. +{
  30093. +    tty->driver.write(tty, 0, &ch, 1);
  30094. +}
  30095. +
  30096. +/*
  30097. + * Called by a tty driver to register itself.
  30098. + */
  30099. +int tty_register_driver(struct tty_driver *driver)
  30100. +{
  30101. +    int error;
  30102. +
  30103. +    if (driver->flags & TTY_DRIVER_INSTALLED)
  30104. +        return 0;
  30105. +
  30106. +    error = register_chrdev(driver->major, driver->name, &tty_fops);
  30107. +    if (error < 0)
  30108. +        return error;
  30109. +    else if(driver->major == 0)
  30110. +        driver->major = error;
  30111. +
  30112. +    if (!driver->put_char)
  30113. +        driver->put_char = tty_default_put_char;
  30114. +
  30115. +    driver->prev = 0;
  30116. +    driver->next = tty_drivers;
  30117. +    tty_drivers->prev = driver;
  30118. +    tty_drivers = driver;
  30119. +    return error;
  30120. +}
  30121. +
  30122. +/*
  30123. + * Called by a tty driver to unregister itself.
  30124. + */
  30125. +int tty_unregister_driver(struct tty_driver *driver)
  30126. +{
  30127. +    int    retval;
  30128. +    struct tty_driver *p;
  30129. +    int    found = 0;
  30130. +    int    major_inuse = 0;
  30131. +
  30132. +    if (driver->refcount)
  30133. +        return -EBUSY;
  30134. +
  30135. +    for (p = tty_drivers; p; p = p->next) {
  30136. +        if (p == driver)
  30137. +            found++;
  30138. +        else if (p->major == driver->major)
  30139. +            major_inuse++;
  30140. +    }
  30141. +
  30142. +    if (!major_inuse) {
  30143. +        retval = unregister_chrdev(driver->major, driver->name);
  30144. +        if (retval)
  30145. +            return retval;
  30146. +    }
  30147. +
  30148. +    if (driver->prev)
  30149. +        driver->prev->next = driver->next;
  30150. +    else
  30151. +        tty_drivers = driver->next;
  30152. +
  30153. +    if (driver->next)
  30154. +        driver->next = driver->next->prev;
  30155. +
  30156. +    return 0;
  30157. +}
  30158. +
  30159. +
  30160. +/*
  30161. + * Initialize the console device. This is called *early*, so
  30162. + * we can't necessarily depend on lots of kernel help here.
  30163. + * Just do some early initializations, and do the complex setup
  30164. + * later.
  30165. + */
  30166. +long console_init(long kmem_start, long kmem_end)
  30167. +{
  30168. +    /* Setup the default TTY line discipline. */
  30169. +    memset(ldiscs, 0, sizeof(ldiscs));
  30170. +    (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
  30171. +
  30172. +    /*
  30173. +     * Set up the standard termios.  Individual tty drivers may
  30174. +     * deviate from this; this is used as a template.
  30175. +     */
  30176. +
  30177. +    memset(&tty_std_termios, 0, sizeof(struct termios));
  30178. +    memcpy(tty_std_termios.c_cc, INIT_C_CC, NCCS);
  30179. +
  30180. +    tty_std_termios.c_iflag = ICRNL | IXON;
  30181. +    tty_std_termios.c_oflag = OPOST | ONLCR;
  30182. +    tty_std_termios.c_cflag = B38400 | CS8 | CREAD;
  30183. +    tty_std_termios.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
  30184. +        ECHOCTL | ECHOKE | IEXTEN;
  30185. +    /*
  30186. +     * set up the console device so that later boot sequences can
  30187. +     * inform about problems etc..
  30188. +     */
  30189. +    return con_init(kmem_start);
  30190. +}
  30191. +
  30192. +/*
  30193. + * Ok, now we can initialize the rest of the tty devices and can count
  30194. + * on memory allocations, interrupts etc..
  30195. + */
  30196. +long tty_init(long kmem_start)
  30197. +{
  30198. +    if (sizeof(struct tty_struct) > PAGE_SIZE)
  30199. +        panic("size of tty structure > PAGE_SIZE!");
  30200. +    if (register_chrdev(TTY_MAJOR,"tty",&tty_fops))
  30201. +        panic("unable to get major %d for tty device", TTY_MAJOR);
  30202. +    if (register_chrdev(TTYAUX_MAJOR,"cua",&tty_fops))
  30203. +        panic("unable to get major %d for tty device", TTYAUX_MAJOR);
  30204. +
  30205. +    kmem_start = kbd_init(kmem_start);
  30206. +    kmem_start = rs_init(kmem_start);
  30207. +    kmem_start = pty_init(kmem_start);
  30208. +    return kmem_start;
  30209. +}
  30210. diff -r -u -N linux.orig/arch/arm/drivers/char/tty_ioctl.c linux.arm/arch/arm/drivers/char/tty_ioctl.c
  30211. --- linux.orig/arch/arm/drivers/char/tty_ioctl.c    Thu Jan  1 01:00:00 1970
  30212. +++ linux.arm/arch/arm/drivers/char/tty_ioctl.c    Fri Oct 27 23:14:27 1995
  30213. @@ -0,0 +1,374 @@
  30214. +/*
  30215. + *  linux/drivers/char/tty_ioctl.c
  30216. + *
  30217. + *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
  30218. + *
  30219. + * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
  30220. + * which can be dynamically activated and de-activated by the line
  30221. + * discipline handling modules (like SLIP).
  30222. + */
  30223. +
  30224. +#include <linux/types.h>
  30225. +#include <linux/termios.h>
  30226. +#include <linux/errno.h>
  30227. +#include <linux/sched.h>
  30228. +#include <linux/kernel.h>
  30229. +#include <linux/major.h>
  30230. +#include <linux/tty.h>
  30231. +#include <linux/fcntl.h>
  30232. +#include <linux/string.h>
  30233. +#include <linux/mm.h>
  30234. +
  30235. +#include <asm/io.h>
  30236. +#include <asm/bitops.h>
  30237. +#include <asm/segment.h>
  30238. +#include <asm/system.h>
  30239. +
  30240. +#undef TTY_DEBUG_WAIT_UNTIL_SENT
  30241. +
  30242. +#undef    DEBUG
  30243. +#ifdef DEBUG
  30244. +# define    PRINTK(x)    printk (x)
  30245. +#else
  30246. +# define    PRINTK(x)    /**/
  30247. +#endif
  30248. +
  30249. +/*
  30250. + * Internal flag options for termios setting behavior
  30251. + */
  30252. +#define TERMIOS_FLUSH    1
  30253. +#define TERMIOS_WAIT    2
  30254. +#define TERMIOS_TERMIO    4
  30255. +
  30256. +void tty_wait_until_sent(struct tty_struct * tty, int timeout)
  30257. +{
  30258. +    struct wait_queue wait = { current, NULL };
  30259. +
  30260. +#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  30261. +    printk("%s wait until sent...\n", tty_name(tty));
  30262. +#endif
  30263. +    if (!tty->driver.chars_in_buffer ||
  30264. +        !tty->driver.chars_in_buffer(tty))
  30265. +        return;
  30266. +    add_wait_queue(&tty->write_wait, &wait);
  30267. +    current->counter = 0;    /* make us low-priority */
  30268. +    if (timeout)
  30269. +        current->timeout = timeout + jiffies;
  30270. +    else
  30271. +        current->timeout = (unsigned) -1;
  30272. +    do {
  30273. +#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  30274. +        printk("waiting %s...(%d)\n", tty_name(tty), tty->driver.chars_in_buffer(tty));
  30275. +#endif
  30276. +        current->state = TASK_INTERRUPTIBLE;
  30277. +        if (current->signal & ~current->blocked)
  30278. +            break;
  30279. +        if (!tty->driver.chars_in_buffer(tty))
  30280. +            break;
  30281. +        schedule();
  30282. +    } while (current->timeout);
  30283. +    current->state = TASK_RUNNING;
  30284. +    remove_wait_queue(&tty->write_wait, &wait);
  30285. +}
  30286. +
  30287. +static void unset_locked_termios(struct termios *termios,
  30288. +                 struct termios *old,
  30289. +                 struct termios *locked)
  30290. +{
  30291. +    int    i;
  30292. +    
  30293. +#define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
  30294. +
  30295. +    if (!locked) {
  30296. +        printk("Warning?!? termios_locked is NULL.\n");
  30297. +        return;
  30298. +    }
  30299. +
  30300. +    NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
  30301. +    NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
  30302. +    NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
  30303. +    NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
  30304. +    termios->c_line = locked->c_line ? old->c_line : termios->c_line;
  30305. +    for (i=0; i < NCCS; i++)
  30306. +        termios->c_cc[i] = locked->c_cc[i] ?
  30307. +            old->c_cc[i] : termios->c_cc[i];
  30308. +}
  30309. +
  30310. +static int set_termios(struct tty_struct * tty, unsigned long arg, int opt)
  30311. +{
  30312. +    struct termio tmp_termio;
  30313. +    struct termios tmp_termios;
  30314. +    struct termios old_termios = *tty->termios;
  30315. +    int retval, canon_change;
  30316. +
  30317. +    retval = tty_check_change(tty);
  30318. +    if (retval)
  30319. +        return retval;
  30320. +
  30321. +    if (opt & TERMIOS_TERMIO) {
  30322. +        retval = verify_area(VERIFY_READ, (void *) arg, sizeof(struct termio));
  30323. +        if (retval)
  30324. +            return retval;
  30325. +        tmp_termios = *tty->termios;
  30326. +        memcpy_fromfs(&tmp_termio, (struct termio *) arg,
  30327. +                  sizeof (struct termio));
  30328. +
  30329. +#define SET_LOW_BITS(x,y)    ((x) = (0xffff0000 & (x)) | (y))
  30330. +        SET_LOW_BITS(tmp_termios.c_iflag, tmp_termio.c_iflag);
  30331. +        SET_LOW_BITS(tmp_termios.c_oflag, tmp_termio.c_oflag);
  30332. +        SET_LOW_BITS(tmp_termios.c_cflag, tmp_termio.c_cflag);
  30333. +        SET_LOW_BITS(tmp_termios.c_lflag, tmp_termio.c_lflag);
  30334. +        memcpy(&tmp_termios.c_cc, &tmp_termio.c_cc, NCC);
  30335. +#undef SET_LOW_BITS
  30336. +    } else {
  30337. +        retval = verify_area(VERIFY_READ, (void *) arg, sizeof(struct termios));
  30338. +        if (retval)
  30339. +            return retval;
  30340. +        memcpy_fromfs(&tmp_termios, (struct termios *) arg,
  30341. +                  sizeof (struct termios));
  30342. +    }
  30343. +
  30344. +    if ((opt & TERMIOS_FLUSH) && tty->ldisc.flush_buffer)
  30345. +        tty->ldisc.flush_buffer(tty);
  30346. +
  30347. +    if (opt & TERMIOS_WAIT)
  30348. +        tty_wait_until_sent(tty, 0);
  30349. +
  30350. +    cli();
  30351. +    *tty->termios = tmp_termios;
  30352. +    unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
  30353. +    canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
  30354. +    if (canon_change) {
  30355. +        memset(&tty->read_flags, 0, sizeof tty->read_flags);
  30356. +        tty->canon_head = tty->read_tail;
  30357. +        tty->canon_data = 0;
  30358. +        tty->erasing = 0;
  30359. +    }
  30360. +    sti();
  30361. +    if (canon_change && !L_ICANON(tty) && tty->read_cnt)
  30362. +        /* Get characters left over from canonical mode. */
  30363. +        wake_up_interruptible(&tty->read_wait);
  30364. +
  30365. +    /* see if packet mode change of state */
  30366. +
  30367. +    if (tty->link && tty->link->packet) {
  30368. +        int old_flow = ((old_termios.c_iflag & IXON) &&
  30369. +                (old_termios.c_cc[VSTOP] == '\023') &&
  30370. +                (old_termios.c_cc[VSTART] == '\021'));
  30371. +        int new_flow = (I_IXON(tty) &&
  30372. +                STOP_CHAR(tty) == '\023' &&
  30373. +                START_CHAR(tty) == '\021');
  30374. +        if (old_flow != new_flow) {
  30375. +            tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
  30376. +            if (new_flow)
  30377. +                tty->ctrl_status |= TIOCPKT_DOSTOP;
  30378. +            else
  30379. +                tty->ctrl_status |= TIOCPKT_NOSTOP;
  30380. +            wake_up_interruptible(&tty->link->read_wait);
  30381. +        }
  30382. +    }
  30383. +
  30384. +    if (tty->driver.set_termios)
  30385. +        (*tty->driver.set_termios)(tty, &old_termios);
  30386. +
  30387. +    if (tty->ldisc.set_termios)
  30388. +        (*tty->ldisc.set_termios)(tty, &old_termios);
  30389. +        
  30390. +    return 0;
  30391. +}
  30392. +
  30393. +static int get_termio(struct tty_struct * tty, struct termio * termio)
  30394. +{
  30395. +    int i;
  30396. +    struct termio tmp_termio;
  30397. +
  30398. +    i = verify_area(VERIFY_WRITE, termio, sizeof (struct termio));
  30399. +    if (i)
  30400. +        return i;
  30401. +    tmp_termio.c_iflag = tty->termios->c_iflag;
  30402. +    tmp_termio.c_oflag = tty->termios->c_oflag;
  30403. +    tmp_termio.c_cflag = tty->termios->c_cflag;
  30404. +    tmp_termio.c_lflag = tty->termios->c_lflag;
  30405. +    tmp_termio.c_line = tty->termios->c_line;
  30406. +    for(i=0 ; i < NCC ; i++)
  30407. +        tmp_termio.c_cc[i] = tty->termios->c_cc[i];
  30408. +    memcpy_tofs(termio, &tmp_termio, sizeof (struct termio));
  30409. +    return 0;
  30410. +}
  30411. +
  30412. +static unsigned long inq_canon(struct tty_struct * tty)
  30413. +{
  30414. +    int nr, head, tail;
  30415. +
  30416. +    if (!tty->canon_data || !tty->read_buf)
  30417. +        return 0;
  30418. +    head = tty->canon_head;
  30419. +    tail = tty->read_tail;
  30420. +    nr = (head - tail) & (N_TTY_BUF_SIZE-1);
  30421. +    /* Skip EOF-chars.. */
  30422. +    while (head != tail) {
  30423. +        if (test_bit(tail, &tty->read_flags) &&
  30424. +            tty->read_buf[tail] == __DISABLED_CHAR)
  30425. +            nr--;
  30426. +        tail = (tail+1) & (N_TTY_BUF_SIZE-1);
  30427. +    }
  30428. +    return nr;
  30429. +}
  30430. +
  30431. +int n_tty_ioctl(struct tty_struct * tty, struct file * file,
  30432. +               unsigned int cmd, unsigned long arg)
  30433. +{
  30434. +    struct tty_struct * real_tty;
  30435. +    int retval;
  30436. +    int opt = 0;
  30437. +
  30438. +    if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  30439. +        tty->driver.subtype == PTY_TYPE_MASTER)
  30440. +        real_tty = tty->link;
  30441. +    else
  30442. +        real_tty = tty;
  30443. +
  30444. +    switch (cmd) {
  30445. +        case TCGETS:
  30446. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  30447. +                         sizeof (struct termios));
  30448. +            if (retval)
  30449. +                return retval;
  30450. +            memcpy_tofs((struct termios *) arg,
  30451. +                    real_tty->termios,
  30452. +                    sizeof (struct termios));
  30453. +            return 0;
  30454. +        case TCSETSF:
  30455. +            opt |= TERMIOS_FLUSH;
  30456. +        case TCSETSW:
  30457. +            opt |= TERMIOS_WAIT;
  30458. +        case TCSETS:
  30459. +            return set_termios(real_tty, arg, opt);
  30460. +        case TCGETA:
  30461. +            return get_termio(real_tty,(struct termio *) arg);
  30462. +        case TCSETAF:
  30463. +            opt |= TERMIOS_FLUSH;
  30464. +        case TCSETAW:
  30465. +            opt |= TERMIOS_WAIT;
  30466. +        case TCSETA:
  30467. +            return set_termios(real_tty, arg, opt|TERMIOS_TERMIO);
  30468. +        case TCXONC:
  30469. +            retval = tty_check_change(tty);
  30470. +            if (retval)
  30471. +                return retval;
  30472. +            switch (arg) {
  30473. +            case TCOOFF:
  30474. +                stop_tty(tty);
  30475. +                break;
  30476. +            case TCOON:
  30477. +                start_tty(tty);
  30478. +                break;
  30479. +            case TCIOFF:
  30480. +                if (STOP_CHAR(tty) != __DISABLED_CHAR)
  30481. +                    tty->driver.write(tty, 0,
  30482. +                              &STOP_CHAR(tty), 1);
  30483. +                break;
  30484. +            case TCION:
  30485. +                if (START_CHAR(tty) != __DISABLED_CHAR)
  30486. +                    tty->driver.write(tty, 0,
  30487. +                              &START_CHAR(tty), 1);
  30488. +                break;
  30489. +            default:
  30490. +                return -EINVAL;
  30491. +            }
  30492. +            return 0;
  30493. +        case TCFLSH:
  30494. +            retval = tty_check_change(tty);
  30495. +            if (retval)
  30496. +                return retval;
  30497. +            switch (arg) {
  30498. +            case TCIFLUSH:
  30499. +                if (tty->ldisc.flush_buffer)
  30500. +                    tty->ldisc.flush_buffer(tty);
  30501. +                break;
  30502. +            case TCIOFLUSH:
  30503. +                if (tty->ldisc.flush_buffer)
  30504. +                    tty->ldisc.flush_buffer(tty);
  30505. +                /* fall through */
  30506. +            case TCOFLUSH:
  30507. +                if (tty->driver.flush_buffer)
  30508. +                    tty->driver.flush_buffer(tty);
  30509. +                break;
  30510. +            default:
  30511. +                return -EINVAL;
  30512. +            }
  30513. +            return 0;
  30514. +        case TIOCOUTQ:
  30515. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  30516. +                         sizeof (unsigned long));
  30517. +            if (retval)
  30518. +                return retval;
  30519. +            if (tty->driver.chars_in_buffer)
  30520. +                put_fs_long(tty->driver.chars_in_buffer(tty),
  30521. +                        (unsigned long *) arg);
  30522. +            else
  30523. +                put_fs_long(0, (unsigned long *) arg);
  30524. +            return 0;
  30525. +        case TIOCINQ:
  30526. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  30527. +                         sizeof (unsigned long));
  30528. +            if (retval)
  30529. +                return retval;
  30530. +            if (L_ICANON(tty))
  30531. +                put_fs_long(inq_canon(tty),
  30532. +                    (unsigned long *) arg);
  30533. +            else
  30534. +                put_fs_long(tty->read_cnt,
  30535. +                        (unsigned long *) arg);
  30536. +            return 0;
  30537. +        case TIOCGLCKTRMIOS:
  30538. +            retval = verify_area(VERIFY_WRITE, (void *) arg,
  30539. +                         sizeof (struct termios));
  30540. +            if (retval)
  30541. +                return retval;
  30542. +            memcpy_tofs((struct termios *) arg,
  30543. +                    real_tty->termios_locked,
  30544. +                    sizeof (struct termios));
  30545. +            return 0;
  30546. +        case TIOCSLCKTRMIOS:
  30547. +            if (!suser())
  30548. +                return -EPERM;
  30549. +            retval = verify_area(VERIFY_READ, (void *) arg,
  30550. +                         sizeof (struct termios));
  30551. +            if (retval)
  30552. +                return retval;
  30553. +            memcpy_fromfs(real_tty->termios_locked,
  30554. +                      (struct termios *) arg,
  30555. +                      sizeof (struct termios));
  30556. +            return 0;
  30557. +        case TIOCPKT:
  30558. +            if (tty->driver.type != TTY_DRIVER_TYPE_PTY ||
  30559. +                tty->driver.subtype != PTY_TYPE_MASTER)
  30560. +                return -ENOTTY;
  30561. +            retval = verify_area(VERIFY_READ, (void *) arg,
  30562. +                         sizeof (unsigned long));
  30563. +            if (retval)
  30564. +                return retval;
  30565. +            if (get_fs_long(arg)) {
  30566. +                if (!tty->packet) {
  30567. +                    tty->packet = 1;
  30568. +                    tty->link->ctrl_status = 0;
  30569. +                }
  30570. +            } else
  30571. +                tty->packet = 0;
  30572. +            return 0;
  30573. +        /* These two ioctl's always return success; even if */
  30574. +        /* the driver doesn't support them. */
  30575. +        case TCSBRK: case TCSBRKP:
  30576. +            retval = tty_check_change(tty);
  30577. +            if (retval)
  30578. +                return retval;
  30579. +            tty_wait_until_sent(tty, 0);
  30580. +            if (!tty->driver.ioctl)
  30581. +                return 0;
  30582. +            tty->driver.ioctl(tty, file, cmd, arg);
  30583. +            return 0;
  30584. +        default:
  30585. +            return -ENOIOCTLCMD;
  30586. +        }
  30587. +}
  30588. diff -r -u -N linux.orig/arch/arm/drivers/char/vc_screen.c linux.arm/arch/arm/drivers/char/vc_screen.c
  30589. --- linux.orig/arch/arm/drivers/char/vc_screen.c    Thu Jan  1 01:00:00 1970
  30590. +++ linux.arm/arch/arm/drivers/char/vc_screen.c    Fri Oct 27 23:14:41 1995
  30591. @@ -0,0 +1,226 @@
  30592. +/*
  30593. + * linux/drivers/char/vc_screen.c
  30594. + *
  30595. + * Provide access to virtual console memory.
  30596. + * /dev/vcs0: the screen as it is being viewed right now (possibly scrolled)
  30597. + * /dev/vcsN: the screen of /dev/ttyN (1 <= N <= 63)
  30598. + *            [minor: N]
  30599. + *
  30600. + * /dev/vcsaN: idem, but including attributes, and prefixed with
  30601. + *    the 4 bytes lines,columns,x,y (as screendump used to give)
  30602. + *            [minor: N+128]
  30603. + *
  30604. + * This replaces screendump and part of selection, so that the system
  30605. + * administrator can control access using file system permissions.
  30606. + *
  30607. + * aeb@cwi.nl - efter Friedas begravelse - 950211
  30608. + */
  30609. +
  30610. +#include <linux/kernel.h>
  30611. +#include <linux/major.h>
  30612. +#include <linux/errno.h>
  30613. +#include <linux/tty.h>
  30614. +#include <linux/fs.h>
  30615. +#include <asm/segment.h>
  30616. +#include "vt_kern.h"
  30617. +/*#include "selection.h"*/
  30618. +
  30619. +#define HEADER_SIZE    4
  30620. +#define video_num_lines 75
  30621. +#define video_num_columns 100
  30622. +static inline int
  30623. +vcs_size(struct inode *inode)
  30624. +{
  30625. +    int size = video_num_lines * video_num_columns;
  30626. +    if (MINOR(inode->i_rdev) & 128)
  30627. +        size = 4*size + HEADER_SIZE;
  30628. +    return size;
  30629. +}
  30630. +
  30631. +static int
  30632. +vcs_lseek(struct inode *inode, struct file *file, off_t offset, int orig)
  30633. +{
  30634. +    int size = vcs_size(inode);
  30635. +
  30636. +    switch (orig) {
  30637. +        case 0:
  30638. +            file->f_pos = offset;
  30639. +            break;
  30640. +        case 1:
  30641. +            file->f_pos += offset;
  30642. +            break;
  30643. +        case 2:
  30644. +            file->f_pos = size + offset;
  30645. +            break;
  30646. +        default:
  30647. +            return -EINVAL;
  30648. +    }
  30649. +    if (file->f_pos < 0 || file->f_pos > size)
  30650. +        return -EINVAL;
  30651. +    return file->f_pos;
  30652. +}
  30653. +
  30654. +static int
  30655. +vcs_read(struct inode *inode, struct file *file, char *buf, int count)
  30656. +{
  30657. +    unsigned long p = file->f_pos;
  30658. +    unsigned int cons = MINOR(inode->i_rdev);
  30659. +    int attr, size, read;
  30660. +    char *buf0;
  30661. +    unsigned long *org, d;
  30662. +
  30663. +    attr = (cons & 128);
  30664. +    cons = (cons & 127);
  30665. +    if (cons == 0)
  30666. +        cons = fg_console;
  30667. +    else
  30668. +        cons--;
  30669. +    if (!vc_cons_allocated(cons))
  30670. +        return -ENXIO;
  30671. +
  30672. +    size = vcs_size(inode);
  30673. +    if (count < 0 || p > size)
  30674. +        return -EINVAL;
  30675. +    if (count > size - p)
  30676. +        count = size - p;
  30677. +
  30678. +    buf0 = buf;
  30679. +    if (!attr) {
  30680. +        org = screen_pos(cons, p);
  30681. +        while (count-- > 0)
  30682. +            put_fs_byte(*org++ & 0xff, buf++);
  30683. +    } else {
  30684. +        if (p < HEADER_SIZE) {
  30685. +            char header[HEADER_SIZE];
  30686. +            header[0] = (char) video_num_lines;
  30687. +            header[1] = (char) video_num_columns;
  30688. +            getconsxy(cons, header+2);
  30689. +            while (p < HEADER_SIZE && count-- > 0)
  30690. +                put_fs_byte(header[p++], buf++);
  30691. +        }
  30692. +        p -= HEADER_SIZE;
  30693. +        org = screen_pos(cons, p>>2);
  30694. +        if (p & 3)
  30695. +            d = *org++;
  30696. +        if ((p & 3)>0 && count-- > 0)
  30697. +            put_fs_byte(d >> 24, buf++);
  30698. +        if ((p & 3)>1 && count-- > 0)
  30699. +            put_fs_byte((d >> 16) & 0xff, buf++);
  30700. +        if ((p & 3)>2 && count-- > 0)
  30701. +            put_fs_byte((d >> 8) & 0xff, buf++);
  30702. +        while (count > 1) {
  30703. +            put_fs_long(*org++, buf);
  30704. +            buf += 4;
  30705. +            count -= 4;
  30706. +        }
  30707. +        if (count > 0)
  30708. +        {
  30709. +            d = *org;
  30710. +            put_fs_byte(d & 0xff, buf++);
  30711. +            if (count > 1)
  30712. +                put_fs_byte((d >> 8) & 0xff, buf++);
  30713. +            if (count > 2)
  30714. +                put_fs_byte((d >> 16) & 0xff, buf++);
  30715. +        }
  30716. +    }
  30717. +    read = buf - buf0;
  30718. +    file->f_pos += read;
  30719. +    return read;
  30720. +}
  30721. +
  30722. +static int
  30723. +vcs_write(struct inode *inode, struct file *file, char *buf, int count)
  30724. +{
  30725. +    unsigned long p = file->f_pos;
  30726. +    unsigned int cons = MINOR(inode->i_rdev);
  30727. +    int viewed, attr, size, written;
  30728. +    char *buf0;
  30729. +    unsigned long *org, d;
  30730. +
  30731. +    attr = (cons & 128);
  30732. +    cons = (cons & 127);
  30733. +    if (cons == 0) {
  30734. +        cons = fg_console;
  30735. +        viewed = 1;
  30736. +    } else {
  30737. +        cons--;
  30738. +        viewed = 0;
  30739. +    }
  30740. +    if (!vc_cons_allocated(cons))
  30741. +        return -ENXIO;
  30742. +
  30743. +    size = vcs_size(inode);
  30744. +    if (count < 0 || p > size)
  30745. +        return -EINVAL;
  30746. +    if (count > size - p)
  30747. +        count = size - p;
  30748. +
  30749. +    buf0 = buf;
  30750. +    if (!attr) {
  30751. +        org = screen_pos(cons, p);
  30752. +        while (count-- > 0) {
  30753. +            *org = (*org & 0xffffff00) | get_fs_byte(buf++);
  30754. +            ll_char_write (*org);
  30755. +            org++;
  30756. +        }
  30757. +    } else {
  30758. +#if 0
  30759. +        if (p < HEADER_SIZE) {
  30760. +            char header[HEADER_SIZE];
  30761. +            getconsxy(cons, header+2);
  30762. +            while (p < HEADER_SIZE && count-- > 0)
  30763. +                header[p++] = get_fs_byte(buf++);
  30764. +            if (!viewed)
  30765. +                putconsxy(cons, header+2);
  30766. +        }
  30767. +        p -= HEADER_SIZE;
  30768. +        org = screen_pos(cons, p>>2, viewed);
  30769. +        if ((p & 1) && count-- > 0) {
  30770. +            scr_writew((get_fs_byte(buf++) << 8) |
  30771. +                   (scr_readw(org) & 0xff), org);
  30772. +            org++;
  30773. +        }
  30774. +        while (count > 1) {
  30775. +            scr_writew(get_fs_word(buf), org++);
  30776. +            buf += 2;
  30777. +            count -= 2;
  30778. +        }
  30779. +        if (count > 0)
  30780. +            scr_writew((scr_readw(org) & 0xff00) |
  30781. +                   get_fs_byte(buf++), org);
  30782. +#endif
  30783. +    }
  30784. +    written = buf - buf0;
  30785. +    update_scrmem (cons, file->f_pos, written);
  30786. +    file->f_pos += written;
  30787. +    return written;
  30788. +}
  30789. +
  30790. +static int
  30791. +vcs_open(struct inode *inode, struct file *filp)
  30792. +{
  30793. +    unsigned int cons = (MINOR(inode->i_rdev) & 127);
  30794. +    if(cons && !vc_cons_allocated(cons-1))
  30795. +        return -ENXIO;
  30796. +    return 0;
  30797. +}
  30798. +
  30799. +static struct file_operations vcs_fops = {
  30800. +    vcs_lseek,    /* lseek */
  30801. +    vcs_read,    /* read */
  30802. +    vcs_write,    /* write */
  30803. +    NULL,        /* readdir */
  30804. +    NULL,        /* select */
  30805. +    NULL,        /* ioctl */
  30806. +    NULL,        /* mmap */
  30807. +    vcs_open,    /* open */
  30808. +    NULL,        /* release */
  30809. +    NULL        /* fsync */
  30810. +};
  30811. +
  30812. +long vcs_init(long kmem_start)
  30813. +{
  30814. +    if (register_chrdev(VCS_MAJOR, "vcs", &vcs_fops))
  30815. +        printk("unable to get major %d for vcs device", VCS_MAJOR);
  30816. +    return kmem_start;
  30817. +}
  30818. diff -r -u -N linux.orig/arch/arm/drivers/char/vt.c linux.arm/arch/arm/drivers/char/vt.c
  30819. --- linux.orig/arch/arm/drivers/char/vt.c    Thu Jan  1 01:00:00 1970
  30820. +++ linux.arm/arch/arm/drivers/char/vt.c    Fri Oct 27 23:14:21 1995
  30821. @@ -0,0 +1,920 @@
  30822. +/*
  30823. + *  linux/drivers/char/vt.c
  30824. + *
  30825. + *  Copyright (C) 1992 obz under the linux copyright
  30826. + *
  30827. + *  Dynamic diacritical handling - aeb@cwi.nl - Dec 1993
  30828. + *  Dynamic keymap and string allocation - aeb@cwi.nl - May 1994
  30829. + *  Ported to ARM - rmk92@ecs.soton.ac.uk - July 1995
  30830. + */
  30831. +
  30832. +#include <linux/types.h>
  30833. +#include <linux/errno.h>
  30834. +#include <linux/sched.h>
  30835. +#include <linux/tty.h>
  30836. +#include <linux/timer.h>
  30837. +#include <linux/kernel.h>
  30838. +#include <linux/kd.h>
  30839. +#include <linux/vt.h>
  30840. +#include <linux/string.h>
  30841. +#include <linux/malloc.h>
  30842. +
  30843. +/* #include <asm/io.h> */
  30844. +#include <asm/segment.h>
  30845. +
  30846. +#include "kbd_kern.h"
  30847. +#include "vt_kern.h"
  30848. +#include "diacr.h"
  30849. +
  30850. +extern struct tty_driver console_driver;
  30851. +extern int sel_cons;
  30852. +
  30853. +#define VT_IS_IN_USE(i)    (console_driver.table[i] && console_driver.table[i]->count)
  30854. +#define VT_BUSY(i)    (VT_IS_IN_USE(i) || i == fg_console || i == sel_cons)
  30855. +
  30856. +/*
  30857. + * Console (vt and kd) routines, as defined by USL SVR4 manual, and by
  30858. + * experimentation and study of X386 SYSV handling.
  30859. + *
  30860. + * One point of difference: SYSV vt's are /dev/vtX, which X >= 0, and
  30861. + * /dev/console is a separate ttyp. Under Linux, /dev/tty0 is /dev/console,
  30862. + * and the vc start at /dev/ttyX, X >= 1. We maintain that here, so we will
  30863. + * always treat our set of vt as numbered 1..MAX_NR_CONSOLES (corresponding to
  30864. + * ttys 0..MAX_NR_CONSOLES-1). Explicitly naming VT 0 is illegal, but using
  30865. + * /dev/tty0 (fg_console) as a target is legal, since an implicit aliasing
  30866. + * to the current console is done by the main ioctl code.
  30867. + */
  30868. +
  30869. +struct vt_struct *vt_cons[MAX_NR_CONSOLES];
  30870. +
  30871. +asmlinkage int sys_ioperm(unsigned long from, unsigned long num, int on);
  30872. +
  30873. +extern int getkeycode(unsigned int scancode);
  30874. +extern int setkeycode(unsigned int scancode, unsigned int keycode);
  30875. +extern void compute_shiftstate(void);
  30876. +extern void change_console(unsigned int new_console);
  30877. +extern void complete_change_console(unsigned int new_console);
  30878. +extern int vt_waitactive(void);
  30879. +extern void do_blank_screen(int nopowersave);
  30880. +extern void do_unblank_screen(void);
  30881. + 
  30882. +extern unsigned int keymap_count;
  30883. +
  30884. +/*
  30885. + * routines to load custom translation table and EGA/VGA font from console.c
  30886. + */
  30887. +extern int con_set_trans(char * table);
  30888. +extern int con_get_trans(char * table);
  30889. +extern void con_clear_unimap(struct unimapinit *ui);
  30890. +extern int con_set_unimap(ushort ct, struct unipair *list);
  30891. +extern int con_get_unimap(ushort ct, ushort *uct, struct unipair *list);
  30892. +extern int con_set_font(char * fontmap);
  30893. +extern int con_get_font(char * fontmap);
  30894. +
  30895. +/*
  30896. + * these are the valid i/o ports we're allowed to change. they map all the
  30897. + * video ports
  30898. + */
  30899. +#define GPFIRST 0x3b4
  30900. +#define GPLAST 0x3df
  30901. +#define GPNUM (GPLAST - GPFIRST + 1)
  30902. +
  30903. +/*
  30904. + * Generates sound of some count for some number of clock ticks
  30905. + * [count = 1193180 / frequency]
  30906. + *
  30907. + * If freq is 0, will turn off sound, else will turn it on for that time.
  30908. + * If msec is 0, will return immediately, else will sleep for msec time, then
  30909. + * turn sound off.
  30910. + *
  30911. + * We use the BEEP_TIMER vector since we're using the same method to
  30912. + * generate sound, and we'll overwrite any beep in progress. That may
  30913. + * be something to fix later, if we like.
  30914. + *
  30915. + * We also return immediately, which is what was implied within the X
  30916. + * comments - KDMKTONE doesn't put the process to sleep.
  30917. + */
  30918. +void
  30919. +kd_mksound2(unsigned int count, unsigned int vol, unsigned int ticks)
  30920. +{
  30921. +    int freq;
  30922. +    
  30923. +    if(count)
  30924. +        freq = 1193180/count;
  30925. +    else
  30926. +        freq = 0;
  30927. +    mk_beep(freq, vol, ticks);
  30928. +}
  30929. +
  30930. +void
  30931. +kd_mksound(unsigned int count, unsigned int ticks)
  30932. +{
  30933. +    kd_mksound2(count, 64, ticks);
  30934. +}
  30935. +
  30936. +/*
  30937. + * We handle the console-specific ioctl's here.  We allow the
  30938. + * capability to modify any console, not just the fg_console.
  30939. + */
  30940. +int vt_ioctl(struct tty_struct *tty, struct file * file,
  30941. +         unsigned int cmd, unsigned long arg)
  30942. +{
  30943. +    int i, perm;
  30944. +    unsigned int console;
  30945. +    unsigned char ucval;
  30946. +    struct kbd_struct * kbd;
  30947. +    struct vt_struct *vt = (struct vt_struct *)tty->driver_data;
  30948. +
  30949. +    console = vt->vc_num;
  30950. +
  30951. +    if (!vc_cons_allocated(console))     /* impossible? */
  30952. +        return -ENOIOCTLCMD;
  30953. +
  30954. +    /*
  30955. +     * To have permissions to do most of the vt ioctls, we either have
  30956. +     * to be the owner of the tty, or super-user.
  30957. +     */
  30958. +    perm = 0;
  30959. +    if (current->tty == tty || suser())
  30960. +        perm = 1;
  30961. +
  30962. +    kbd = kbd_table + console;
  30963. +    switch (cmd) {
  30964. +    case KIOCSOUND:
  30965. +        if (!perm)
  30966. +            return -EPERM;
  30967. +        kd_mksound((unsigned int)arg, 5);
  30968. +        return 0;
  30969. +
  30970. +    case KDMKTONE:
  30971. +        if (!perm)
  30972. +            return -EPERM;
  30973. +    {
  30974. +        unsigned int freq  = ((unsigned long *)arg)[0];
  30975. +        unsigned int vol   = ((unsigned long *)arg)[1];
  30976. +        unsigned int ticks = HZ * ((((unsigned long *)arg)[2] >> 16) & 0xffff) / 1000;
  30977. +
  30978. +        /*
  30979. +         * Generate the tone for the appropriate number of ticks.
  30980. +         * If the time is zero, turn off sound ourselves.
  30981. +         */
  30982. +        kd_mksound2(freq, vol, ticks);
  30983. +        return 0;
  30984. +    }
  30985. +
  30986. +    case KDGKBTYPE:
  30987. +        /*
  30988. +         * this is naive.
  30989. +         */
  30990. +        i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned char));
  30991. +        if (!i)
  30992. +            put_fs_byte(KB_101, (char *) arg);
  30993. +        return i;
  30994. +
  30995. +    case KDADDIO:
  30996. +    case KDDELIO:
  30997. +        /*
  30998. +         * KDADDIO and KDDELIO may be able to add ports beyond what
  30999. +         * we reject here, but to be safe...
  31000. +         */
  31001. +        if (arg < GPFIRST || arg > GPLAST)
  31002. +            return -EINVAL;
  31003. +        return sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
  31004. +
  31005. +    case KDENABIO:
  31006. +    case KDDISABIO:
  31007. +        return sys_ioperm(GPFIRST, GPNUM,
  31008. +                  (cmd == KDENABIO)) ? -ENXIO : 0;
  31009. +
  31010. +    case KDSETMODE:
  31011. +        /*
  31012. +         * currently, setting the mode from KD_TEXT to KD_GRAPHICS
  31013. +         * doesn't do a whole lot. i'm not sure if it should do any
  31014. +         * restoration of modes or what...
  31015. +         */
  31016. +        if (!perm)
  31017. +            return -EPERM;
  31018. +        switch (arg) {
  31019. +        case KD_GRAPHICS:
  31020. +            break;
  31021. +        case KD_TEXT0:
  31022. +        case KD_TEXT1:
  31023. +            arg = KD_TEXT;
  31024. +        case KD_TEXT:
  31025. +            break;
  31026. +        default:
  31027. +            return -EINVAL;
  31028. +        }
  31029. +        if (vt_cons[console]->vc_mode == (unsigned char) arg)
  31030. +            return 0;
  31031. +        vt_cons[console]->vc_mode = (unsigned char) arg;
  31032. +        if (console != fg_console)
  31033. +            return 0;
  31034. +        /*
  31035. +         * explicitly blank/unblank the screen if switching modes
  31036. +         */
  31037. +        if (arg == KD_TEXT)
  31038. +            do_unblank_screen();
  31039. +        else
  31040. +            do_blank_screen(1);
  31041. +        return 0;
  31042. +
  31043. +    case KDGETMODE:
  31044. +        i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned long));
  31045. +        if (!i)
  31046. +            put_fs_long(vt_cons[console]->vc_mode, (unsigned long *) arg);
  31047. +        return i;
  31048. +
  31049. +    case KDMAPDISP:
  31050. +    case KDUNMAPDISP:
  31051. +        /*
  31052. +         * these work like a combination of mmap and KDENABIO.
  31053. +         * this could be easily finished.
  31054. +         */
  31055. +        return -EINVAL;
  31056. +
  31057. +    case KDSKBMODE:
  31058. +        if (!perm)
  31059. +            return -EPERM;
  31060. +        switch(arg) {
  31061. +          case K_RAW:
  31062. +            kbd->kbdmode = VC_RAW;
  31063. +            break;
  31064. +          case K_MEDIUMRAW:
  31065. +            kbd->kbdmode = VC_MEDIUMRAW;
  31066. +            break;
  31067. +          case K_XLATE:
  31068. +            kbd->kbdmode = VC_XLATE;
  31069. +            compute_shiftstate();
  31070. +            break;
  31071. +          case K_UNICODE:
  31072. +            kbd->kbdmode = VC_UNICODE;
  31073. +            compute_shiftstate();
  31074. +            break;
  31075. +          default:
  31076. +            return -EINVAL;
  31077. +        }
  31078. +        if (tty->ldisc.flush_buffer)
  31079. +            tty->ldisc.flush_buffer(tty);
  31080. +        return 0;
  31081. +
  31082. +    case KDGKBMODE:
  31083. +        i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned long));
  31084. +        if (!i) {
  31085. +            ucval = ((kbd->kbdmode == VC_RAW) ? K_RAW :
  31086. +                 (kbd->kbdmode == VC_MEDIUMRAW) ? K_MEDIUMRAW :
  31087. +                 (kbd->kbdmode == VC_UNICODE) ? K_UNICODE :
  31088. +                 K_XLATE);
  31089. +            put_fs_long(ucval, (unsigned long *) arg);
  31090. +        }
  31091. +        return i;
  31092. +
  31093. +    /* this could be folded into KDSKBMODE, but for compatibility
  31094. +       reasons it is not so easy to fold KDGKBMETA into KDGKBMODE */
  31095. +    case KDSKBMETA:
  31096. +        switch(arg) {
  31097. +          case K_METABIT:
  31098. +            clr_vc_kbd_mode(kbd, VC_META);
  31099. +            break;
  31100. +          case K_ESCPREFIX:
  31101. +            set_vc_kbd_mode(kbd, VC_META);
  31102. +            break;
  31103. +          default:
  31104. +            return -EINVAL;
  31105. +        }
  31106. +        return 0;
  31107. +
  31108. +    case KDGKBMETA:
  31109. +        i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned long));
  31110. +        if (!i) {
  31111. +            ucval = (vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX :
  31112. +                 K_METABIT);
  31113. +            put_fs_long(ucval, (unsigned long *) arg);
  31114. +        }
  31115. +        return i;
  31116. +
  31117. +    case KDGETKEYCODE:
  31118. +    {
  31119. +        struct kbkeycode * const a = (struct kbkeycode *)arg;
  31120. +        unsigned int sc;
  31121. +        int kc;
  31122. +
  31123. +        i = verify_area(VERIFY_WRITE, (void *)a, sizeof(struct kbkeycode));
  31124. +        if (i)
  31125. +            return i;
  31126. +        sc = get_fs_long((int *) &a->scancode);
  31127. +        kc = getkeycode(sc);
  31128. +        if (kc < 0)
  31129. +            return kc;
  31130. +        put_fs_long(kc, (int *) &a->keycode);
  31131. +        return 0;
  31132. +    }
  31133. +
  31134. +    case KDSETKEYCODE:
  31135. +    {
  31136. +        struct kbkeycode * const a = (struct kbkeycode *)arg;
  31137. +        unsigned int sc, kc;
  31138. +
  31139. +        if (!perm)
  31140. +            return -EPERM;
  31141. +        i = verify_area(VERIFY_READ, (void *)a, sizeof(struct kbkeycode));
  31142. +        if (i)
  31143. +            return i;
  31144. +        sc = get_fs_long((int *) &a->scancode);
  31145. +        kc = get_fs_long((int *) &a->keycode);
  31146. +        return setkeycode(sc, kc);
  31147. +    }
  31148. +
  31149. +    case KDGKBENT:
  31150. +    {
  31151. +        struct kbentry * const a = (struct kbentry *)arg;
  31152. +        ushort *key_map, val;
  31153. +        u_char s;
  31154. +
  31155. +        i = verify_area(VERIFY_WRITE, (void *)a, sizeof(struct kbentry));
  31156. +        if (i)
  31157. +            return i;
  31158. +        if ((i = get_fs_byte((char *) &a->kb_index)) >= NR_KEYS)
  31159. +            return -EINVAL;
  31160. +        if ((s = get_fs_byte((char *) &a->kb_table)) >= MAX_NR_KEYMAPS)
  31161. +            return -EINVAL;
  31162. +        key_map = key_maps[s];
  31163. +        if (key_map) {
  31164. +            val = U(key_map[i]);
  31165. +            if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
  31166. +            val = K_HOLE;
  31167. +        } else
  31168. +            val = (i ? K_HOLE : K_NOSUCHMAP);
  31169. +        put_fs_word(val, (short *) &a->kb_value);
  31170. +        return 0;
  31171. +    }
  31172. +
  31173. +    case KDSKBENT:
  31174. +    {
  31175. +        const struct kbentry * a = (struct kbentry *)arg;
  31176. +        ushort *key_map;
  31177. +        u_char s;
  31178. +        u_short v, ov;
  31179. +
  31180. +        if (!perm)
  31181. +            return -EPERM;
  31182. +        i = verify_area(VERIFY_READ, (void *)a, sizeof(struct kbentry));
  31183. +        if (i)
  31184. +            return i;
  31185. +        if ((i = get_fs_byte((char *) &a->kb_index)) >= NR_KEYS)
  31186. +            return -EINVAL;
  31187. +        if ((s = get_fs_byte((char *) &a->kb_table)) >= MAX_NR_KEYMAPS)
  31188. +            return -EINVAL;
  31189. +        v = get_fs_word(&a->kb_value);
  31190. +        if (!i && v == K_NOSUCHMAP) {
  31191. +            /* disallocate map */
  31192. +            key_map = key_maps[s];
  31193. +            if (s && key_map) {
  31194. +                key_maps[s] = 0;
  31195. +                if (key_map[0] == U(K_ALLOCATED)) {
  31196. +                kfree_s(key_map, sizeof(plain_map));
  31197. +                keymap_count--;
  31198. +                }
  31199. +            }
  31200. +            return 0;
  31201. +        }
  31202. +
  31203. +        if (KTYP(v) < NR_TYPES) {
  31204. +            if (KVAL(v) > max_vals[KTYP(v)])
  31205. +            return -EINVAL;
  31206. +        } else
  31207. +            if (kbd->kbdmode != VC_UNICODE)
  31208. +            return -EINVAL;
  31209. +
  31210. +        /* assignment to entry 0 only tests validity of args */
  31211. +        if (!i)
  31212. +            return 0;
  31213. +
  31214. +        if (!(key_map = key_maps[s])) {
  31215. +            int j;
  31216. +            
  31217. +            if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && !suser())
  31218. +                return -EPERM;
  31219. +
  31220. +            key_map = (ushort *) kmalloc(sizeof(plain_map),
  31221. +                             GFP_KERNEL);
  31222. +            if (!key_map)
  31223. +                return -ENOMEM;
  31224. +            key_maps[s] = key_map;
  31225. +            key_map[0] = U(K_ALLOCATED);
  31226. +            for (j = 1; j < NR_KEYS; j++)
  31227. +                key_map[j] = U(K_HOLE);
  31228. +            keymap_count++;
  31229. +        }
  31230. +        ov = U(key_map[i]);
  31231. +        if (v == ov)
  31232. +            return 0;    /* nothing to do */
  31233. +        /*
  31234. +         * Only the Superuser can set or unset the Secure
  31235. +         * Attention Key.
  31236. +         */
  31237. +        if (((ov == K_SAK) || (v == K_SAK)) && !suser())
  31238. +            return -EPERM;
  31239. +        key_map[i] = U(v);
  31240. +        if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
  31241. +            compute_shiftstate();
  31242. +        return 0;
  31243. +    }
  31244. +
  31245. +    case KDGKBSENT:
  31246. +    {
  31247. +        struct kbsentry *a = (struct kbsentry *)arg;
  31248. +        char *p;
  31249. +        u_char *q;
  31250. +        int sz;
  31251. +
  31252. +        i = verify_area(VERIFY_WRITE, (void *)a, sizeof(struct kbsentry));
  31253. +        if (i)
  31254. +            return i;
  31255. +        if ((i = get_fs_byte(&a->kb_func)) >= MAX_NR_FUNC || i < 0)
  31256. +            return -EINVAL;
  31257. +        sz = sizeof(a->kb_string) - 1; /* sz should have been
  31258. +                          a struct member */
  31259. +        q = a->kb_string;
  31260. +        p = func_table[i];
  31261. +        if(p)
  31262. +            for ( ; *p && sz; p++, sz--)
  31263. +                put_fs_byte(*p, q++);
  31264. +        put_fs_byte(0, q);
  31265. +        return ((p && *p) ? -EOVERFLOW : 0);
  31266. +    }
  31267. +
  31268. +    case KDSKBSENT:
  31269. +    {
  31270. +        struct kbsentry * const a = (struct kbsentry *)arg;
  31271. +        int delta;
  31272. +        char *first_free, *fj, *fnw;
  31273. +        int j, k, sz;
  31274. +        u_char *p;
  31275. +        char *q;
  31276. +
  31277. +        if (!perm)
  31278. +            return -EPERM;
  31279. +        i = verify_area(VERIFY_READ, (void *)a, sizeof(struct kbsentry));
  31280. +        if (i)
  31281. +            return i;
  31282. +        if ((i = get_fs_byte(&a->kb_func)) >= MAX_NR_FUNC)
  31283. +            return -EINVAL;
  31284. +        q = func_table[i];
  31285. +
  31286. +        first_free = funcbufptr + (funcbufsize - funcbufleft);
  31287. +        for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++) ;
  31288. +        if (j < MAX_NR_FUNC)
  31289. +            fj = func_table[j];
  31290. +        else
  31291. +            fj = first_free;
  31292. +
  31293. +        delta = (q ? -strlen(q) : 1);
  31294. +        sz = sizeof(a->kb_string);     /* sz should have been
  31295. +                           a struct member */
  31296. +        for (p = a->kb_string; get_fs_byte(p) && sz; p++,sz--)
  31297. +            delta++;
  31298. +        if (!sz)
  31299. +            return -EOVERFLOW;
  31300. +        if (delta <= funcbufleft) {     /* it fits in current buf */
  31301. +            if (j < MAX_NR_FUNC) {
  31302. +            memmove(fj + delta, fj, first_free - fj);
  31303. +            for (k = j; k < MAX_NR_FUNC; k++)
  31304. +                if (func_table[k])
  31305. +                func_table[k] += delta;
  31306. +            }
  31307. +            if (!q)
  31308. +              func_table[i] = fj;
  31309. +            funcbufleft -= delta;
  31310. +        } else {            /* allocate a larger buffer */
  31311. +            sz = 256;
  31312. +            while (sz < funcbufsize - funcbufleft + delta)
  31313. +              sz <<= 1;
  31314. +            fnw = (char *) kmalloc(sz, GFP_KERNEL);
  31315. +            if(!fnw)
  31316. +              return -ENOMEM;
  31317. +
  31318. +            if (!q)
  31319. +              func_table[i] = fj;
  31320. +            if (fj > funcbufptr)
  31321. +            memmove(fnw, funcbufptr, fj - funcbufptr);
  31322. +            for (k = 0; k < j; k++)
  31323. +              if (func_table[k])
  31324. +            func_table[k] = fnw + (func_table[k] - funcbufptr);
  31325. +
  31326. +            if (first_free > fj) {
  31327. +            memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
  31328. +            for (k = j; k < MAX_NR_FUNC; k++)
  31329. +              if (func_table[k])
  31330. +                func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
  31331. +            }
  31332. +            if (funcbufptr != func_buf)
  31333. +              kfree_s(funcbufptr, funcbufsize);
  31334. +            funcbufptr = fnw;
  31335. +            funcbufleft = funcbufleft - delta + sz - funcbufsize;
  31336. +            funcbufsize = sz;
  31337. +        }
  31338. +        for (p = a->kb_string, q = func_table[i]; ; p++, q++)
  31339. +            if (!(*q = get_fs_byte(p)))
  31340. +                break;
  31341. +        return 0;
  31342. +    }
  31343. +
  31344. +    case KDGKBDIACR:
  31345. +    {
  31346. +        struct kbdiacrs *a = (struct kbdiacrs *)arg;
  31347. +
  31348. +        i = verify_area(VERIFY_WRITE, (void *) a, sizeof(struct kbdiacrs));
  31349. +        if (i)
  31350. +            return i;
  31351. +        put_fs_long(accent_table_size, &a->kb_cnt);
  31352. +        memcpy_tofs(a->kbdiacr, accent_table,
  31353. +                accent_table_size*sizeof(struct kbdiacr));
  31354. +        return 0;
  31355. +    }
  31356. +
  31357. +    case KDSKBDIACR:
  31358. +    {
  31359. +        struct kbdiacrs *a = (struct kbdiacrs *)arg;
  31360. +        unsigned int ct;
  31361. +
  31362. +        if (!perm)
  31363. +            return -EPERM;
  31364. +        i = verify_area(VERIFY_READ, (void *) a, sizeof(struct kbdiacrs));
  31365. +        if (i)
  31366. +            return i;
  31367. +        ct = get_fs_long(&a->kb_cnt);
  31368. +        if (ct >= MAX_DIACR)
  31369. +            return -EINVAL;
  31370. +        accent_table_size = ct;
  31371. +        memcpy_fromfs(accent_table, a->kbdiacr, ct*sizeof(struct kbdiacr));
  31372. +        return 0;
  31373. +    }
  31374. +
  31375. +    /* the ioctls below read/set the flags usually shown in the leds */
  31376. +    /* don't use them - they will go away without warning */
  31377. +    case KDGKBLED:
  31378. +        i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned char));
  31379. +        if (i)
  31380. +            return i;
  31381. +        put_fs_byte(kbd->ledflagstate |
  31382. +                (kbd->default_ledflagstate << 4), (char *) arg);
  31383. +        return 0;
  31384. +
  31385. +    case KDSKBLED:
  31386. +        if (!perm)
  31387. +            return -EPERM;
  31388. +        if (arg & ~0x77)
  31389. +            return -EINVAL;
  31390. +        kbd->ledflagstate = (arg & 7);
  31391. +        kbd->default_ledflagstate = ((arg >> 4) & 7);
  31392. +        set_leds();
  31393. +        return 0;
  31394. +
  31395. +    /* the ioctls below only set the lights, not the functions */
  31396. +    /* for those, see KDGKBLED and KDSKBLED above */
  31397. +    case KDGETLED:
  31398. +        i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned char));
  31399. +        if (i)
  31400. +            return i;
  31401. +        put_fs_byte(getledstate(), (char *) arg);
  31402. +        return 0;
  31403. +
  31404. +    case KDSETLED:
  31405. +        if (!perm)
  31406. +            return -EPERM;
  31407. +        setledstate(kbd, arg);
  31408. +        return 0;
  31409. +
  31410. +    /*
  31411. +     * A process can indicate its willingness to accept signals
  31412. +     * generated by pressing an appropriate key combination.
  31413. +     * Thus, one can have a daemon that e.g. spawns a new console
  31414. +     * upon a keypess and then changes to it.
  31415. +     * Probably init should be changed to do this (and have a
  31416. +     * field ks (`keyboard signal') in inittab describing the
  31417. +     * desired acion), so that the number of background daemons
  31418. +     * does not increase.
  31419. +     */
  31420. +    case KDSIGACCEPT:
  31421. +    {
  31422. +        extern int spawnpid, spawnsig;
  31423. +        if (!perm)
  31424. +          return -EPERM;
  31425. +        if (arg < 1 || arg > NSIG || arg == SIGKILL)
  31426. +          return -EINVAL;
  31427. +        spawnpid = current->pid;
  31428. +        spawnsig = arg;
  31429. +        return 0;
  31430. +    }
  31431. +
  31432. +    case VT_SETMODE:
  31433. +    {
  31434. +        struct vt_mode *vtmode = (struct vt_mode *)arg;
  31435. +        char mode;
  31436. +
  31437. +        if (!perm)
  31438. +            return -EPERM;
  31439. +        i = verify_area(VERIFY_WRITE, (void *)vtmode, sizeof(struct vt_mode));
  31440. +        if (i)
  31441. +            return i;
  31442. +        mode = get_fs_byte(&vtmode->mode);
  31443. +        if (mode != VT_AUTO && mode != VT_PROCESS)
  31444. +            return -EINVAL;
  31445. +        vt_cons[console]->vt_mode.mode = mode;
  31446. +        vt_cons[console]->vt_mode.waitv = get_fs_byte(&vtmode->waitv);
  31447. +        vt_cons[console]->vt_mode.relsig = get_fs_word(&vtmode->relsig);
  31448. +        vt_cons[console]->vt_mode.acqsig = get_fs_word(&vtmode->acqsig);
  31449. +        /* the frsig is ignored, so we set it to 0 */
  31450. +        vt_cons[console]->vt_mode.frsig = 0;
  31451. +        vt_cons[console]->vt_pid = current->pid;
  31452. +        vt_cons[console]->vt_newvt = 0;
  31453. +        return 0;
  31454. +    }
  31455. +
  31456. +    case VT_GETMODE:
  31457. +    {
  31458. +        struct vt_mode *vtmode = (struct vt_mode *)arg;
  31459. +
  31460. +        i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct vt_mode));
  31461. +        if (i)
  31462. +            return i;
  31463. +        put_fs_byte(vt_cons[console]->vt_mode.mode, &vtmode->mode);
  31464. +        put_fs_byte(vt_cons[console]->vt_mode.waitv, &vtmode->waitv);
  31465. +        put_fs_word(vt_cons[console]->vt_mode.relsig, &vtmode->relsig);
  31466. +        put_fs_word(vt_cons[console]->vt_mode.acqsig, &vtmode->acqsig);
  31467. +        put_fs_word(vt_cons[console]->vt_mode.frsig, &vtmode->frsig);
  31468. +        return 0;
  31469. +    }
  31470. +
  31471. +    /*
  31472. +     * Returns global vt state. Note that VT 0 is always open, since
  31473. +     * it's an alias for the current VT, and people can't use it here.
  31474. +     * We cannot return state for more than 16 VTs, since v_state is short.
  31475. +     */
  31476. +    case VT_GETSTATE:
  31477. +    {
  31478. +        struct vt_stat *vtstat = (struct vt_stat *)arg;
  31479. +        unsigned short state, mask;
  31480. +
  31481. +        i = verify_area(VERIFY_WRITE,(void *)vtstat, sizeof(struct vt_stat));
  31482. +        if (i)
  31483. +            return i;
  31484. +        put_fs_word(fg_console + 1, &vtstat->v_active);
  31485. +        state = 1;    /* /dev/tty0 is always open */
  31486. +        for (i = 0, mask = 2; i < MAX_NR_CONSOLES && mask; ++i, mask <<= 1)
  31487. +            if (VT_IS_IN_USE(i))
  31488. +                state |= mask;
  31489. +        put_fs_word(state, &vtstat->v_state);
  31490. +        return 0;
  31491. +    }
  31492. +
  31493. +    /*
  31494. +     * Returns the first available (non-opened) console.
  31495. +     */
  31496. +    case VT_OPENQRY:
  31497. +        i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(long));
  31498. +        if (i)
  31499. +            return i;
  31500. +        for (i = 0; i < MAX_NR_CONSOLES; ++i)
  31501. +            if (! VT_IS_IN_USE(i))
  31502. +                break;
  31503. +        put_fs_long(i < MAX_NR_CONSOLES ? (i+1) : -1,
  31504. +                (unsigned long *)arg);
  31505. +        return 0;
  31506. +
  31507. +    /*
  31508. +     * ioctl(fd, VT_ACTIVATE, num) will cause us to switch to vt # num,
  31509. +     * with num >= 1 (switches to vt 0, our console, are not allowed, just
  31510. +     * to preserve sanity).
  31511. +     */
  31512. +    case VT_ACTIVATE:
  31513. +        if (!perm)
  31514. +            return -EPERM;
  31515. +        if (arg == 0 || arg > MAX_NR_CONSOLES)
  31516. +            return -ENXIO;
  31517. +        arg--;
  31518. +        i = vc_allocate(arg);
  31519. +        if (i)
  31520. +            return i;
  31521. +        change_console(arg);
  31522. +        return 0;
  31523. +
  31524. +    /*
  31525. +     * wait until the specified VT has been activated
  31526. +     */
  31527. +    case VT_WAITACTIVE:
  31528. +        if (!perm)
  31529. +            return -EPERM;
  31530. +        if (arg == 0 || arg > MAX_NR_CONSOLES)
  31531. +            return -ENXIO;
  31532. +        arg--;
  31533. +        while (fg_console != arg)
  31534. +        {
  31535. +            if (vt_waitactive() < 0)
  31536. +                return -EINTR;
  31537. +        }
  31538. +        return 0;
  31539. +
  31540. +    /*
  31541. +     * If a vt is under process control, the kernel will not switch to it
  31542. +     * immediately, but postpone the operation until the process calls this
  31543. +     * ioctl, allowing the switch to complete.
  31544. +     *
  31545. +     * According to the X sources this is the behavior:
  31546. +     *    0:    pending switch-from not OK
  31547. +     *    1:    pending switch-from OK
  31548. +     *    2:    completed switch-to OK
  31549. +     */
  31550. +    case VT_RELDISP:
  31551. +        if (!perm)
  31552. +            return -EPERM;
  31553. +        if (vt_cons[console]->vt_mode.mode != VT_PROCESS)
  31554. +            return -EINVAL;
  31555. +
  31556. +        /*
  31557. +         * Switching-from response
  31558. +         */
  31559. +        if (vt_cons[console]->vt_newvt >= 0)
  31560. +        {
  31561. +            if (arg == 0)
  31562. +                /*
  31563. +                 * Switch disallowed, so forget we were trying
  31564. +                 * to do it.
  31565. +                 */
  31566. +                vt_cons[console]->vt_newvt = -1;
  31567. +
  31568. +            else
  31569. +            {
  31570. +                /*
  31571. +                 * The current vt has been released, so
  31572. +                 * complete the switch.
  31573. +                 */
  31574. +                int newvt = vt_cons[console]->vt_newvt;
  31575. +                vt_cons[console]->vt_newvt = -1;
  31576. +                i = vc_allocate(newvt);
  31577. +                if (i)
  31578. +                    return i;
  31579. +                complete_change_console(newvt);
  31580. +            }
  31581. +        }
  31582. +
  31583. +        /*
  31584. +         * Switched-to response
  31585. +         */
  31586. +        else
  31587. +        {
  31588. +            /*
  31589. +             * If it's just an ACK, ignore it
  31590. +             */
  31591. +            if (arg != VT_ACKACQ)
  31592. +                return -EINVAL;
  31593. +        }
  31594. +
  31595. +        return 0;
  31596. +
  31597. +     /*
  31598. +      * Disallocate memory associated to VT (but leave VT1)
  31599. +      */
  31600. +     case VT_DISALLOCATE:
  31601. +        if (arg > MAX_NR_CONSOLES)
  31602. +            return -ENXIO;
  31603. +        if (arg == 0) {
  31604. +            /* disallocate all unused consoles, but leave 0 */
  31605. +            for (i = 1; i<MAX_NR_CONSOLES; i++)
  31606. +              if (! VT_BUSY(i))
  31607. +              vc_disallocate(i);
  31608. +        } else {
  31609. +            /* disallocate a single console, if possible */
  31610. +            arg--;
  31611. +            if (VT_BUSY(arg))
  31612. +              return -EBUSY;
  31613. +            if (arg)                /* leave 0 */
  31614. +            vc_disallocate(arg);
  31615. +        }
  31616. +        return 0;
  31617. +
  31618. +    case VT_RESIZE:
  31619. +    {
  31620. +        struct vt_sizes *vtsizes = (struct vt_sizes *) arg;
  31621. +        ushort ll,cc;
  31622. +        if (!perm)
  31623. +            return -EPERM;
  31624. +        i = verify_area(VERIFY_READ, (void *)vtsizes, sizeof(struct vt_sizes));
  31625. +        if (i)
  31626. +            return i;
  31627. +        ll = get_fs_word(&vtsizes->v_rows);
  31628. +        cc = get_fs_word(&vtsizes->v_cols);
  31629. +        return vc_resize(ll, cc);
  31630. +    }
  31631. +    
  31632. +    case VT_GETPALETTE:
  31633. +    {
  31634. +        unsigned long pix, num, *val;
  31635. +        
  31636. +            i = verify_area(VERIFY_WRITE, (void *)arg, 12);
  31637. +            if (i)
  31638. +                return i;
  31639. +            pix = get_fs_long((unsigned long *)arg);
  31640. +            num = get_fs_long((unsigned long *)(arg + 4));
  31641. +            val = (unsigned long *)get_fs_long((unsigned long *)(arg + 8));
  31642. +        return palette_getentries(console, pix, num, val);
  31643. +    }
  31644. +
  31645. +    case VT_SETPALETTE:
  31646. +    {
  31647. +        unsigned long pix, num, *val;
  31648. +
  31649. +            i = verify_area(VERIFY_READ, (void *)arg, 12);
  31650. +            if (i)
  31651. +                return i;
  31652. +
  31653. +            pix = get_fs_long((unsigned long *)arg);
  31654. +            num = get_fs_long((unsigned long *)(arg + 4));
  31655. +            val = (unsigned long *)get_fs_long((unsigned long *)(arg + 8));
  31656. +        return palette_setentries(console, pix, num, val);
  31657. +    }
  31658. +
  31659. +    case VT_GETSCRINFO:
  31660. +        i = verify_area(VERIFY_WRITE, (void *)arg, 20);
  31661. +            if (i)
  31662. +                return i;
  31663. +        return console_getparams(console, arg);
  31664. +
  31665. +    case PIO_FONT:
  31666. +        if (!perm)
  31667. +            return -EPERM;
  31668. +        if (vt_cons[fg_console]->vc_mode != KD_TEXT)
  31669. +            return -EINVAL;
  31670. +        return con_set_font((char *)arg);
  31671. +        /* con_set_font() defined in console.c */
  31672. +
  31673. +    case GIO_FONT:
  31674. +        if (vt_cons[fg_console]->vc_mode != KD_TEXT)
  31675. +            return -EINVAL;
  31676. +        return con_get_font((char *)arg);
  31677. +        /* con_get_font() defined in console.c */
  31678. +
  31679. +    case PIO_SCRNMAP:
  31680. +        if (!perm)
  31681. +            return -EPERM;
  31682. +        return con_set_trans((char *)arg);
  31683. +
  31684. +    case GIO_SCRNMAP:
  31685. +        return con_get_trans((char *)arg);
  31686. +
  31687. +    case PIO_UNIMAPCLR:
  31688. +          {    struct unimapinit ui;
  31689. +        if (!perm)
  31690. +            return -EPERM;
  31691. +        i = verify_area(VERIFY_READ, (void *)arg, sizeof(struct unimapinit));
  31692. +        if (i)
  31693. +          return i;
  31694. +        memcpy_fromfs(&ui, (void *)arg, sizeof(struct unimapinit));
  31695. +        con_clear_unimap(&ui);
  31696. +        return 0;
  31697. +          }
  31698. +
  31699. +    case PIO_UNIMAP:
  31700. +          {    struct unimapdesc *ud;
  31701. +        u_short ct;
  31702. +        struct unipair *list;
  31703. +
  31704. +        if (!perm)
  31705. +            return -EPERM;
  31706. +        i = verify_area(VERIFY_READ, (void *)arg, sizeof(struct unimapdesc));
  31707. +        if (i == 0) {
  31708. +            ud = (struct unimapdesc *) arg;
  31709. +            ct = get_fs_word(&ud->entry_ct);
  31710. +            list = (struct unipair *) get_fs_long(&ud->entries);
  31711. +            i = verify_area(VERIFY_READ, (void *) list,
  31712. +                        ct*sizeof(struct unipair));
  31713. +        }
  31714. +        if (i)
  31715. +          return i;
  31716. +        return con_set_unimap(ct, list);
  31717. +          }
  31718. +
  31719. +    case GIO_UNIMAP:
  31720. +          {    struct unimapdesc *ud;
  31721. +        u_short ct;
  31722. +        struct unipair *list;
  31723. +
  31724. +        i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct unimapdesc));
  31725. +        if (i == 0) {
  31726. +            ud = (struct unimapdesc *) arg;
  31727. +            ct = get_fs_word(&ud->entry_ct);
  31728. +            list = (struct unipair *) get_fs_long(&ud->entries);
  31729. +            if (ct)
  31730. +              i = verify_area(VERIFY_WRITE, (void *) list,
  31731. +                          ct*sizeof(struct unipair));
  31732. +        }
  31733. +        if (i)
  31734. +          return i;
  31735. +        return con_get_unimap(ct, &(ud->entry_ct), list);
  31736. +          }
  31737. +
  31738. +    default:
  31739. +        return -ENOIOCTLCMD;
  31740. +    }
  31741. +}
  31742. diff -r -u -N linux.orig/arch/arm/drivers/char/vt_kern.h linux.arm/arch/arm/drivers/char/vt_kern.h
  31743. --- linux.orig/arch/arm/drivers/char/vt_kern.h    Thu Jan  1 01:00:00 1970
  31744. +++ linux.arm/arch/arm/drivers/char/vt_kern.h    Fri Oct 27 23:14:27 1995
  31745. @@ -0,0 +1,29 @@
  31746. +#ifndef _VT_KERN_H
  31747. +#define _VT_KERN_H
  31748. +
  31749. +/*
  31750. + * this really is an extension of the vc_cons structure in console.c, but
  31751. + * with information needed by the vt package
  31752. + */
  31753. +
  31754. +#include <linux/vt.h>
  31755. +
  31756. +extern struct vt_struct {
  31757. +    int vc_num;                /* The console number */
  31758. +    unsigned char    vc_mode;        /* KD_TEXT, ... */
  31759. +    unsigned char    vc_kbdraw;
  31760. +    unsigned char    vc_kbde0;
  31761. +    unsigned char   vc_kbdleds;
  31762. +    struct vt_mode    vt_mode;
  31763. +    int        vt_pid;
  31764. +    int        vt_newvt;
  31765. +    struct wait_queue *paste_wait;
  31766. +} *vt_cons[MAX_NR_CONSOLES];
  31767. +
  31768. +void kd_mksound(unsigned int count, unsigned int ticks);
  31769. +int vc_allocate(unsigned int console);
  31770. +int vc_cons_allocated(unsigned int console);
  31771. +int vc_resize(unsigned long lines, unsigned long cols);
  31772. +void vc_disallocate(unsigned int console);
  31773. +
  31774. +#endif /* _VT_KERN_H */
  31775. diff -r -u -N linux.orig/arch/arm/drivers/net/Makefile linux.arm/arch/arm/drivers/net/Makefile
  31776. --- linux.orig/arch/arm/drivers/net/Makefile    Thu Jan  1 01:00:00 1970
  31777. +++ linux.arm/arch/arm/drivers/net/Makefile    Fri Oct 27 23:15:04 1995
  31778. @@ -0,0 +1,105 @@
  31779. +# File: drivers/net/Makefile
  31780. +#
  31781. +# Makefile for the Linux network (ethercard) device drivers.
  31782. +#
  31783. +
  31784. +# This will go away in some future future: hidden configuration files
  31785. +# are difficult for users to deal with.
  31786. +include CONFIG
  31787. +
  31788. +# Build MODULES by appending to this string for every driver below
  31789. +#MODULES :=
  31790. +
  31791. +NETDRV_OBJS := Space.o auto_irq.o net_init.o loopback.o
  31792. +CFLAGS :=$(CFLAGS) -I../../../../net/inet
  31793. +CPP :=$(CPP) -I../../../../net/inet
  31794. +
  31795. +.c.o:
  31796. +    $(CC) $(CFLAGS) -c $<
  31797. +
  31798. +
  31799. +# The point of the makefile...
  31800. +all: net.a
  31801. +
  31802. +Space.o: Space.c ../../../../include/linux/autoconf.h
  31803. +    $(CC) $(CFLAGS) $(OPTS) -c $<
  31804. +
  31805. +net_init.o: ../../../../include/linux/autoconf.h
  31806. +
  31807. +ifdef CONFIG_ETHER3
  31808. +NETDRV_OBJS := $(NETDRV_OBJS) nq8005.o
  31809. +else
  31810. +MODULES := $(MODULES) nq8005.o
  31811. +endif
  31812. +
  31813. +ifdef CONFIG_PLIP
  31814. +NETDRV_OBJS := $(NETDRV_OBJS) plip.o
  31815. +else
  31816. +MODULES := $(MODULES) plip.o
  31817. +endif
  31818. +plip.o:    plip.c CONFIG
  31819. +    $(CC) $(CPPFLAGS) $(CFLAGS) $(PLIP_OPTS) -c $<
  31820. +
  31821. +ifdef CONFIG_PPP
  31822. +NETDRV_OBJS := $(NETDRV_OBJS) ppp.o
  31823. +CONFIG_SLHC = CONFIG_SLHC
  31824. +else
  31825. +MODULES := $(MODULES) ppp.o
  31826. +endif
  31827. +
  31828. +ifdef CONFIG_SLIP
  31829. +NETDRV_OBJS := $(NETDRV_OBJS) slip.o
  31830. +CONFIG_SLHC = CONFIG_SLHC
  31831. +else
  31832. +MODULES := $(MODULES) slip.o
  31833. +endif
  31834. +slip.o:    slip.c CONFIG
  31835. +    $(CC) $(CPPFLAGS) $(CFLAGS) -c $<
  31836. +
  31837. +ifdef CONFIG_DUMMY
  31838. +NETDRV_OBJS := $(NETDRV_OBJS) dummy.o
  31839. +else
  31840. +MODULES := $(MODULES) dummy.o
  31841. +endif
  31842. +dummy.o: dummy.c CONFIG
  31843. +    $(CC) $(CPPFLAGS) $(CFLAGS) -c $<
  31844. +
  31845. +ifdef CONFIG_SLHC
  31846. +NETDRV_OBJS := $(NETDRV_OBJS) slhc.o
  31847. +else
  31848. +MODULES := slhc.o $(MODULES)
  31849. +endif
  31850. +
  31851. +net.a: $(NETDRV_OBJS)
  31852. +    rm -f net.a
  31853. +    $(AR) rcs net.a $(NETDRV_OBJS)
  31854. +
  31855. +clean:
  31856. +    rm -f core *.o *.a *.s
  31857. +
  31858. +dep:
  31859. +    $(CPP) -M $(NETDRV_OBJS:.o=.c) > .depend
  31860. +ifdef MODULES
  31861. +    $(CPP) -M -DMODULE $(MODULES:.o=.c) >> .depend
  31862. +endif
  31863. +
  31864. +tar:
  31865. +
  31866. +ifdef MODULES
  31867. +
  31868. +modules: $(MODULES)
  31869. +    echo $(MODULES) > ../../../../modules/NET_MODULES
  31870. +    cd ../../../../modules; \
  31871. +        for i in $(MODULES); do ln -sf ../arch/arm/drivers/net/$$i .; done
  31872. +
  31873. +else
  31874. +
  31875. +modules:
  31876. +
  31877. +endif
  31878. +
  31879. +# include a dependency file if one exists
  31880. +
  31881. +ifeq (.depend,$(wildcard .depend))
  31882. +include .depend
  31883. +endif
  31884. diff -r -u -N linux.orig/arch/arm/drivers/net/Space.c linux.arm/arch/arm/drivers/net/Space.c
  31885. --- linux.orig/arch/arm/drivers/net/Space.c    Thu Jan  1 01:00:00 1970
  31886. +++ linux.arm/arch/arm/drivers/net/Space.c    Fri Oct 27 23:15:03 1995
  31887. @@ -0,0 +1,202 @@
  31888. +/*
  31889. + * INET        An implementation of the TCP/IP protocol suite for the LINUX
  31890. + *        operating system.  INET is implemented using the  BSD Socket
  31891. + *        interface as the means of communication with the user level.
  31892. + *
  31893. + *        Holds initial configuration information for devices.
  31894. + *
  31895. + * NOTE:    This file is a nice idea, but its current format does not work
  31896. + *        well for drivers that support multiple units, like the SLIP
  31897. + *        driver.  We should actually have only one pointer to a driver
  31898. + *        here, with the driver knowing how many units it supports.
  31899. + *        Currently, the SLIP driver abuses the "base_addr" integer
  31900. + *        field of the 'device' structure to store the unit number...
  31901. + *        -FvK
  31902. + *
  31903. + * Version:    @(#)Space.c    1.0.7    08/12/93
  31904. + *
  31905. + * Authors:    Ross Biro, <bir7@leland.Stanford.Edu>
  31906. + *        Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  31907. + *        Donald J. Becker, <becker@super.org>
  31908. + *
  31909. + *        This program is free software; you can redistribute it and/or
  31910. + *        modify it under the terms of the GNU General Public License
  31911. + *        as published by the Free Software Foundation; either version
  31912. + *        2 of the License, or (at your option) any later version.
  31913. + */
  31914. +#include <linux/config.h>
  31915. +#include <linux/netdevice.h>
  31916. +#include <linux/errno.h>
  31917. +
  31918. +#define    NEXT_DEV    NULL
  31919. +
  31920. +
  31921. +/* A unified ethernet device probe.  This is the easiest way to have every
  31922. +   ethernet adaptor have the name "eth[0123...]".
  31923. +   */
  31924. +extern int ether3_probe(struct device *dev);
  31925. +
  31926. +static int
  31927. +ethif_probe(struct device *dev)
  31928. +{
  31929. +    short base_addr = dev->base_addr;
  31930. +
  31931. +    if (base_addr < 0  ||  base_addr == 1)
  31932. +    return 1;        /* ENXIO */
  31933. +
  31934. +    if (1
  31935. +#ifdef CONFIG_ETHER3
  31936. +        && ether3_probe(dev)
  31937. +#endif
  31938. +    && 1 ) {
  31939. +    return 1;    /* -ENODEV or -EAGAIN would be more accurate. */
  31940. +    }
  31941. +    return 0;
  31942. +}
  31943. +
  31944. +/* The first device defaults to I/O base '0', which means autoprobe. */
  31945. +#ifndef ETH0_ADDR
  31946. +# define ETH0_ADDR 0
  31947. +#endif
  31948. +#ifndef ETH0_IRQ
  31949. +# define ETH0_IRQ 0
  31950. +#endif
  31951. +/* "eth0" defaults to autoprobe (== 0), other use a base of 0xffe0 (== -0x20),
  31952. +   which means "don't probe".  These entries exist to only to provide empty
  31953. +   slots which may be enabled at boot-time. */
  31954. +
  31955. +static struct device eth3_dev = {
  31956. +    "eth3", 0,0,0,0,0xffe0 /* I/O base*/, 0,0,0,0, NEXT_DEV, ethif_probe };
  31957. +static struct device eth2_dev = {
  31958. +    "eth2", 0,0,0,0,0xffe0 /* I/O base*/, 0,0,0,0, ð3_dev, ethif_probe };
  31959. +static struct device eth1_dev = {
  31960. +    "eth1", 0,0,0,0,0xffe0 /* I/O base*/, 0,0,0,0, ð2_dev, ethif_probe };
  31961. +
  31962. +static struct device eth0_dev = {
  31963. +    "eth0", 0, 0, 0, 0, ETH0_ADDR, ETH0_IRQ, 0, 0, 0, ð1_dev, ethif_probe };
  31964. +
  31965. +#   undef NEXT_DEV
  31966. +#   define NEXT_DEV    (ð0_dev)
  31967. +
  31968. +#if defined(PLIP) || defined(CONFIG_PLIP)
  31969. +    extern int plip_init(struct device *);
  31970. +    static struct device plip2_dev = {
  31971. +    "plip2", 0, 0, 0, 0, 0x278, 2, 0, 0, 0, NEXT_DEV, plip_init, };
  31972. +    static struct device plip1_dev = {
  31973. +    "plip1", 0, 0, 0, 0, 0x378, 7, 0, 0, 0, &plip2_dev, plip_init, };
  31974. +    static struct device plip0_dev = {
  31975. +    "plip0", 0, 0, 0, 0, 0x3BC, 5, 0, 0, 0, &plip1_dev, plip_init, };
  31976. +#   undef NEXT_DEV
  31977. +#   define NEXT_DEV    (&plip0_dev)
  31978. +#endif  /* PLIP */
  31979. +
  31980. +#if defined(SLIP) || defined(CONFIG_SLIP)
  31981. +    extern int slip_init(struct device *);
  31982. +    
  31983. +#ifdef SL_SLIP_LOTS
  31984. +
  31985. +    static struct device slip15_dev={"sl15",0,0,0,0,15,0,0,0,0,NEXT_DEV,slip_init};
  31986. +    static struct device slip14_dev={"sl14",0,0,0,0,14,0,0,0,0,&slip15_dev,slip_init};
  31987. +    static struct device slip13_dev={"sl13",0,0,0,0,13,0,0,0,0,&slip14_dev,slip_init};
  31988. +    static struct device slip12_dev={"sl12",0,0,0,0,12,0,0,0,0,&slip13_dev,slip_init};
  31989. +    static struct device slip11_dev={"sl11",0,0,0,0,11,0,0,0,0,&slip12_dev,slip_init};
  31990. +    static struct device slip10_dev={"sl10",0,0,0,0,10,0,0,0,0,&slip11_dev,slip_init};
  31991. +    static struct device slip9_dev={"sl9",0,0,0,0,9,0,0,0,0,&slip10_dev,slip_init};
  31992. +    static struct device slip8_dev={"sl8",0,0,0,0,8,0,0,0,0,&slip9_dev,slip_init};
  31993. +    static struct device slip7_dev={"sl7",0,0,0,0,7,0,0,0,0,&slip8_dev,slip_init};
  31994. +    static struct device slip6_dev={"sl6",0,0,0,0,6,0,0,0,0,&slip7_dev,slip_init};
  31995. +    static struct device slip5_dev={"sl5",0,0,0,0,5,0,0,0,0,&slip6_dev,slip_init};
  31996. +    static struct device slip4_dev={"sl4",0,0,0,0,4,0,0,0,0,&slip5_dev,slip_init};
  31997. +#   undef    NEXT_DEV
  31998. +#   define    NEXT_DEV    (&slip4_dev)
  31999. +#endif    /* SL_SLIP_LOTS */
  32000. +    
  32001. +    static struct device slip3_dev = {
  32002. +    "sl3",            /* Internal SLIP driver, channel 3    */
  32003. +    0x0,            /* recv memory end            */
  32004. +    0x0,            /* recv memory start            */
  32005. +    0x0,            /* memory end                */
  32006. +    0x0,            /* memory start                */
  32007. +    0x3,            /* base I/O address            */
  32008. +    0,            /* IRQ                    */
  32009. +    0, 0, 0,        /* flags                */
  32010. +    NEXT_DEV,        /* next device                */
  32011. +    slip_init        /* slip_init should set up the rest    */
  32012. +    };
  32013. +    static struct device slip2_dev = {
  32014. +    "sl2",            /* Internal SLIP driver, channel 2    */
  32015. +    0x0,            /* recv memory end            */
  32016. +    0x0,            /* recv memory start            */
  32017. +    0x0,            /* memory end                */
  32018. +    0x0,            /* memory start                */
  32019. +    0x2,            /* base I/O address            */
  32020. +    0,            /* IRQ                    */
  32021. +    0, 0, 0,        /* flags                */
  32022. +    &slip3_dev,        /* next device                */
  32023. +    slip_init        /* slip_init should set up the rest    */
  32024. +    };
  32025. +    static struct device slip1_dev = {
  32026. +    "sl1",            /* Internal SLIP driver, channel 1    */
  32027. +    0x0,            /* recv memory end            */
  32028. +    0x0,            /* recv memory start            */
  32029. +    0x0,            /* memory end                */
  32030. +    0x0,            /* memory start                */
  32031. +    0x1,            /* base I/O address            */
  32032. +    0,            /* IRQ                    */
  32033. +    0, 0, 0,        /* flags                */
  32034. +    &slip2_dev,        /* next device                */
  32035. +    slip_init        /* slip_init should set up the rest    */
  32036. +    };
  32037. +    static struct device slip0_dev = {
  32038. +    "sl0",            /* Internal SLIP driver, channel 0    */
  32039. +    0x0,            /* recv memory end            */
  32040. +    0x0,            /* recv memory start            */
  32041. +    0x0,            /* memory end                */
  32042. +    0x0,            /* memory start                */
  32043. +    0x0,            /* base I/O address            */
  32044. +    0,            /* IRQ                    */
  32045. +    0, 0, 0,        /* flags                */
  32046. +    &slip1_dev,        /* next device                */
  32047. +    slip_init        /* slip_init should set up the rest    */
  32048. +    };
  32049. +#   undef    NEXT_DEV
  32050. +#   define    NEXT_DEV    (&slip0_dev)
  32051. +#endif    /* SLIP */
  32052. +  
  32053. +#if defined(CONFIG_PPP)
  32054. +extern int ppp_init(struct device *);
  32055. +static struct device ppp3_dev = {
  32056. +    "ppp3", 0x0, 0x0, 0x0, 0x0, 3, 0, 0, 0, 0, NEXT_DEV,  ppp_init, };
  32057. +static struct device ppp2_dev = {
  32058. +    "ppp2", 0x0, 0x0, 0x0, 0x0, 2, 0, 0, 0, 0, &ppp3_dev, ppp_init, };
  32059. +static struct device ppp1_dev = {
  32060. +    "ppp1", 0x0, 0x0, 0x0, 0x0, 1, 0, 0, 0, 0, &ppp2_dev, ppp_init, };
  32061. +static struct device ppp0_dev = {
  32062. +    "ppp0", 0x0, 0x0, 0x0, 0x0, 0, 0, 0, 0, 0, &ppp1_dev, ppp_init, };
  32063. +#undef NEXT_DEV
  32064. +#define NEXT_DEV (&ppp0_dev)
  32065. +#endif   /* PPP */
  32066. +
  32067. +#ifdef CONFIG_DUMMY
  32068. +    extern int dummy_init(struct device *dev);
  32069. +    static struct device dummy_dev = {
  32070. +    "dummy", 0x0, 0x0, 0x0, 0x0, 0, 0, 0, 0, 0, NEXT_DEV, dummy_init, };
  32071. +#   undef    NEXT_DEV
  32072. +#   define    NEXT_DEV    (&dummy_dev)
  32073. +#endif
  32074. +
  32075. +extern int loopback_init(struct device *dev);
  32076. +struct device loopback_dev = {
  32077. +    "lo",            /* Software Loopback interface        */
  32078. +    0x0,            /* recv memory end            */
  32079. +    0x0,            /* recv memory start            */
  32080. +    0x0,            /* memory end                */
  32081. +    0x0,            /* memory start                */
  32082. +    0,            /* base I/O address            */
  32083. +    0,            /* IRQ                    */
  32084. +    0, 0, 0,        /* flags                */
  32085. +    NEXT_DEV,        /* next device                */
  32086. +    loopback_init        /* loopback_init should set up the rest    */
  32087. +};
  32088. +
  32089. +struct device *dev_base = &loopback_dev;
  32090. diff -r -u -N linux.orig/arch/arm/drivers/net/auto_irq.c linux.arm/arch/arm/drivers/net/auto_irq.c
  32091. --- linux.orig/arch/arm/drivers/net/auto_irq.c    Thu Jan  1 01:00:00 1970
  32092. +++ linux.arm/arch/arm/drivers/net/auto_irq.c    Fri Oct 27 23:14:59 1995
  32093. @@ -0,0 +1,122 @@
  32094. +/* auto_irq.c: Auto-configure IRQ lines for linux. */
  32095. +/*
  32096. +    Written 1994 by Donald Becker.
  32097. +
  32098. +    The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
  32099. +    Center of Excellence in Space Data and Information Sciences
  32100. +      Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  32101. +
  32102. +    This code is a general-purpose IRQ line detector for devices with
  32103. +    jumpered IRQ lines.  If you can make the device raise an IRQ (and
  32104. +    that IRQ line isn't already being used), these routines will tell
  32105. +    you what IRQ line it's using -- perfect for those oh-so-cool boot-time
  32106. +    device probes!
  32107. +
  32108. +    To use this, first call autoirq_setup(timeout). TIMEOUT is how many
  32109. +    'jiffies' (1/100 sec.) to detect other devices that have active IRQ lines,
  32110. +    and can usually be zero at boot.  'autoirq_setup()' returns the bit
  32111. +    vector of nominally-available IRQ lines (lines may be physically in-use,
  32112. +    but not yet registered to a device).
  32113. +    Next, set up your device to trigger an interrupt.
  32114. +    Finally call autoirq_report(TIMEOUT) to find out which IRQ line was
  32115. +    most recently active.  The TIMEOUT should usually be zero, but may
  32116. +    be set to the number of jiffies to wait for a slow device to raise an IRQ.
  32117. +
  32118. +    The idea of using the setup timeout to filter out bogus IRQs came from
  32119. +    the serial driver.
  32120. +*/
  32121. +
  32122. +
  32123. +#ifdef version
  32124. +static char *version=
  32125. +"auto_irq.c:v1.11 Donald Becker (becker@cesdis.gsfc.nasa.gov)";
  32126. +#endif
  32127. +
  32128. +#include <linux/sched.h>
  32129. +#include <linux/delay.h>
  32130. +#include <asm/bitops.h>
  32131. +#include <asm/io.h>
  32132. +#include <asm/irq.h>
  32133. +#include <linux/netdevice.h>
  32134. +
  32135. +struct device *irq2dev_map[32] = {0, 0, /* ... zeroed */};
  32136. +
  32137. +int irqs_busy = 0x2147;        /* The set of fixed IRQs (keyboard, timer, etc) */
  32138. +int irqs_used = 0x0001;        /* The set of fixed IRQs sometimes enabled. */
  32139. +int irqs_reserved = 0x0000;    /* An advisory "reserved" table. */
  32140. +int irqs_shared = 0x0000;    /* IRQ lines "shared" among conforming cards.*/
  32141. +
  32142. +static volatile int irq_number;    /* The latest irq number we actually found. */
  32143. +static volatile int irq_bitmap; /* The irqs we actually found. */
  32144. +static int irq_handled;        /* The irq lines we have a handler on. */
  32145. +
  32146. +static void autoirq_probe(int irq, struct pt_regs * regs)
  32147. +{
  32148. +    irq_number = irq;
  32149. +    set_bit(irq, (void *)&irq_bitmap);    /* irq_bitmap |= 1 << irq; */
  32150. +    disable_irq(irq);
  32151. +    return;
  32152. +}
  32153. +
  32154. +int autoirq_setup(int waittime)
  32155. +{
  32156. +    int i, mask;
  32157. +    int timeout = jiffies + waittime;
  32158. +    int boguscount = (waittime*loops_per_sec) / 100;
  32159. +
  32160. +    irq_handled = 0;
  32161. +    for (i = 0; i < 16; i++) {
  32162. +        if (test_bit(i, &irqs_busy) == 0
  32163. +            && request_irq(i, autoirq_probe, SA_INTERRUPT, "irq probe") == 0)
  32164. +            set_bit(i, (void *)&irq_handled);    /* irq_handled |= 1 << i;*/
  32165. +    }
  32166. +    /* Update our USED lists. */
  32167. +    irqs_used |= ~irq_handled;
  32168. +    irq_number = 0;
  32169. +    irq_bitmap = 0;
  32170. +
  32171. +    /* Hang out at least <waittime> jiffies waiting for bogus IRQ hits. */
  32172. +    while (timeout > jiffies  &&  --boguscount > 0)
  32173. +        ;
  32174. +
  32175. +    for (i = 0, mask = 0x01; i < 16; i++, mask <<= 1) {
  32176. +        if (irq_bitmap & irq_handled & mask) {
  32177. +            irq_handled &= ~mask;
  32178. +#ifdef notdef
  32179. +            printk(" Spurious interrupt on IRQ %d\n", i);
  32180. +#endif
  32181. +            free_irq(i);
  32182. +        }
  32183. +    }
  32184. +    return irq_handled;
  32185. +}
  32186. +
  32187. +int autoirq_report(int waittime)
  32188. +{
  32189. +    int i;
  32190. +    int timeout = jiffies+waittime;
  32191. +    int boguscount = (waittime*loops_per_sec) / 100;
  32192. +
  32193. +    /* Hang out at least <waittime> jiffies waiting for the IRQ. */
  32194. +
  32195. +    while (timeout > jiffies  &&  --boguscount > 0)
  32196. +        if (irq_number)
  32197. +            break;
  32198. +
  32199. +    /* Retract the irq handlers that we installed. */
  32200. +    for (i = 0; i < 16; i++) {
  32201. +        if (test_bit(i, (void *)&irq_handled))
  32202. +            free_irq(i);
  32203. +    }
  32204. +    return irq_number;
  32205. +}
  32206. +
  32207. +/*
  32208. + * Local variables:
  32209. + *  compile-command: "gcc -DKERNEL -Wall -O6 -fomit-frame-pointer -I/usr/src/linux/net/tcp -c auto_irq.c"
  32210. + *  version-control: t
  32211. + *  kept-new-versions: 5
  32212. + *  c-indent-level: 4
  32213. + *  tab-width: 4
  32214. + * End:
  32215. + */
  32216. diff -r -u -N linux.orig/arch/arm/drivers/net/dummy.c linux.arm/arch/arm/drivers/net/dummy.c
  32217. --- linux.orig/arch/arm/drivers/net/dummy.c    Thu Jan  1 01:00:00 1970
  32218. +++ linux.arm/arch/arm/drivers/net/dummy.c    Fri Oct 27 23:14:59 1995
  32219. @@ -0,0 +1,175 @@
  32220. +/* dummy.c: a dummy net driver
  32221. +
  32222. +    The purpose of this driver is to provide a device to point a
  32223. +    route through, but not to actually transmit packets.
  32224. +
  32225. +    Why?  If you have a machine whose only connection is an occasional
  32226. +    PPP/SLIP/PLIP link, you can only connect to your own hostname
  32227. +    when the link is up.  Otherwise you have to use localhost.
  32228. +    This isn't very consistent.
  32229. +
  32230. +    One solution is to set up a dummy link using PPP/SLIP/PLIP,
  32231. +    but this seems (to me) too much overhead for too little gain.
  32232. +    This driver provides a small alternative. Thus you can do
  32233. +    
  32234. +    [when not running slip]
  32235. +        ifconfig dummy slip.addr.ess.here up
  32236. +    [to go to slip]
  32237. +        ifconfig dummy down
  32238. +        dip whatever
  32239. +
  32240. +    This was written by looking at Donald Becker's skeleton driver
  32241. +    and the loopback driver.  I then threw away anything that didn't
  32242. +    apply!    Thanks to Alan Cox for the key clue on what to do with
  32243. +    misguided packets.
  32244. +
  32245. +            Nick Holloway, 27th May 1994
  32246. +    [I tweaked this explanation a little but thats all]
  32247. +            Alan Cox, 30th May 1994
  32248. +*/
  32249. +
  32250. +/* To have statistics (just packets sent) define this */
  32251. +#undef DUMMY_STATS
  32252. +
  32253. +#ifdef MODULE
  32254. +#include <linux/module.h>
  32255. +#include <linux/version.h>
  32256. +#endif
  32257. +
  32258. +#include <linux/kernel.h>
  32259. +#include <linux/sched.h>
  32260. +#include <linux/types.h>
  32261. +#include <linux/fcntl.h>
  32262. +#include <linux/interrupt.h>
  32263. +#include <linux/ptrace.h>
  32264. +#include <linux/ioport.h>
  32265. +#include <linux/in.h>
  32266. +#include <linux/malloc.h>
  32267. +#include <linux/string.h>
  32268. +#include <asm/system.h>
  32269. +#include <asm/bitops.h>
  32270. +#include <asm/io.h>
  32271. +#include <asm/dma.h>
  32272. +#include <linux/errno.h>
  32273. +
  32274. +#include <linux/netdevice.h>
  32275. +#include <linux/etherdevice.h>
  32276. +#include <linux/skbuff.h>
  32277. +
  32278. +static int dummy_xmit(struct sk_buff *skb, struct device *dev);
  32279. +#ifdef DUMMY_STATS
  32280. +static struct enet_statistics *dummy_get_stats(struct device *dev);
  32281. +#endif
  32282. +
  32283. +#ifdef MODULE
  32284. +static int dummy_open(struct device *dev)
  32285. +{
  32286. +    MOD_INC_USE_COUNT;
  32287. +    return 0;
  32288. +}
  32289. +
  32290. +static int dummy_close(struct device *dev)
  32291. +{
  32292. +    MOD_DEC_USE_COUNT;
  32293. +    return 0;
  32294. +}
  32295. +
  32296. +#endif
  32297. +
  32298. +
  32299. +int dummy_init(struct device *dev)
  32300. +{
  32301. +/* I commented this out as bootup is noisy enough anyway and this driver
  32302. +   seems pretty reliable 8) 8) 8) */
  32303. +/*    printk ( KERN_INFO "Dummy net driver (94/05/27 v1.0)\n" ); */
  32304. +
  32305. +    /* Initialize the device structure. */
  32306. +    dev->hard_start_xmit    = dummy_xmit;
  32307. +
  32308. +#if DUMMY_STATS
  32309. +    dev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL);
  32310. +    memset(dev->priv, 0, sizeof(struct enet_statistics));
  32311. +    dev->get_stats        = dummy_get_stats;
  32312. +#endif
  32313. +#ifdef MODULE
  32314. +    dev->open = &dummy_open;
  32315. +    dev->stop = &dummy_close;
  32316. +#endif
  32317. +
  32318. +    /* Fill in the fields of the device structure with ethernet-generic values. */
  32319. +    ether_setup(dev);
  32320. +    dev->flags |= IFF_NOARP;
  32321. +
  32322. +    return 0;
  32323. +}
  32324. +
  32325. +static int
  32326. +dummy_xmit(struct sk_buff *skb, struct device *dev)
  32327. +{
  32328. +#if DUMMY_STATS
  32329. +    struct enet_statistics *stats;
  32330. +#endif
  32331. +
  32332. +    if (skb == NULL || dev == NULL)
  32333. +        return 0;
  32334. +
  32335. +    dev_kfree_skb(skb, FREE_WRITE);
  32336. +
  32337. +#if DUMMY_STATS
  32338. +    stats = (struct enet_statistics *)dev->priv;
  32339. +    stats->tx_packets++;
  32340. +#endif
  32341. +
  32342. +    return 0;
  32343. +}
  32344. +
  32345. +#if DUMMY_STATS
  32346. +static struct enet_statistics *
  32347. +dummy_get_stats(struct device *dev)
  32348. +{
  32349. +    struct enet_statistics *stats = (struct enet_statistics*) dev->priv;
  32350. +    return stats;
  32351. +}
  32352. +#endif
  32353. +
  32354. +#ifdef MODULE
  32355. +char kernel_version[] = UTS_RELEASE;
  32356. +
  32357. +static int dummy_probe(struct device *dev)
  32358. +{
  32359. +    dummy_init(dev);
  32360. +    return 0;
  32361. +}
  32362. +
  32363. +static struct device dev_dummy = {
  32364. +    "dummy0\0   ", 
  32365. +        0, 0, 0, 0,
  32366. +         0x0, 0,
  32367. +         0, 0, 0, NULL, dummy_probe };
  32368. +
  32369. +int init_module(void)
  32370. +{
  32371. +    /* Find a name for this unit */
  32372. +    int ct= 1;
  32373. +    
  32374. +    while(dev_get(dev_dummy.name)!=NULL && ct<100)
  32375. +    {
  32376. +        sprintf(dev_dummy.name,"dummy%d",ct);
  32377. +        ct++;
  32378. +    }
  32379. +    
  32380. +    if (register_netdev(&dev_dummy) != 0)
  32381. +        return -EIO;
  32382. +    return 0;
  32383. +}
  32384. +
  32385. +void cleanup_module(void)
  32386. +{
  32387. +    if (MOD_IN_USE)
  32388. +        printk("dummy: device busy, remove delayed\n");
  32389. +    else
  32390. +    {
  32391. +        unregister_netdev(&dev_dummy);
  32392. +    }
  32393. +}
  32394. +#endif /* MODULE */
  32395. diff -r -u -N linux.orig/arch/arm/drivers/net/ether3.c linux.arm/arch/arm/drivers/net/ether3.c
  32396. --- linux.orig/arch/arm/drivers/net/ether3.c    Thu Jan  1 01:00:00 1970
  32397. +++ linux.arm/arch/arm/drivers/net/ether3.c    Fri Oct 27 23:15:07 1995
  32398. @@ -0,0 +1,860 @@
  32399. +/*
  32400. + * linux/drivers/net/ether3.c
  32401. + *
  32402. + * SEEQ nq8005 ethernet driver
  32403. + *
  32404. + */
  32405. +
  32406. +#ifdef MODULE
  32407. +#include <linux/module.h>
  32408. +#include <linux/version.h>
  32409. +#define CLAIM_IRQ_AT_OPEN
  32410. +#else
  32411. +#define MOD_INC_USE_COUNT
  32412. +#define MOD_DEC_USE_COUNT
  32413. +#endif
  32414. +
  32415. +#include <linux/config.h>
  32416. +#include <linux/kernel.h>
  32417. +#include <linux/sched.h>
  32418. +#include <linux/types.h>
  32419. +#include <linux/fcntl.h>
  32420. +#include <linux/interrupt.h>
  32421. +#include <linux/ptrace.h>
  32422. +#include <linux/ioport.h>
  32423. +#include <linux/in.h>
  32424. +#include <linux/malloc.h>
  32425. +#include <linux/string.h>
  32426. +#include <asm/system.h>
  32427. +#include <asm/bitops.h>
  32428. +#include <asm/io.h>
  32429. +#include <asm/dma.h>
  32430. +#include <linux/errno.h>
  32431. +
  32432. +#include <linux/netdevice.h>
  32433. +#include <linux/etherdevice.h>
  32434. +#include <linux/skbuff.h>
  32435. +
  32436. +#include <asm/ecard.h>
  32437. +
  32438. +#include "ether3.h"
  32439. +
  32440. +#define FUNC_PROLOGUE \
  32441. +    struct arc_net *an = (struct arc_net *)dev->priv
  32442. +
  32443. +static unsigned int net_debug = NET_DEBUG;
  32444. +
  32445. +#define tx_done(dev) 0
  32446. +/* ------------------------------------------------------------------------------- */
  32447. +static char *version = "ether3 ethernet driver (c) 1995 R.M.King V1.00\n";
  32448. +
  32449. +#define BUS_16 16
  32450. +#define BUS_8  8
  32451. +
  32452. +extern int inswb(int reg, void *buffer, int len);
  32453. +extern int outswb(int reg, void *buffer, int len);
  32454. +
  32455. +unsigned char def_eth_addr[6] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};
  32456. +
  32457. +static int ether3_prods[] = { 0x00A4 };
  32458. +static int ether3_manus[] = { 0x0011 };
  32459. +
  32460. +/* --------------------------------------------------------------------------- */
  32461. +
  32462. +static void check_dev(struct device *dev, char *s)
  32463. +{
  32464. +    struct device *dev2;
  32465. +
  32466. +    dev2 = dev->next;
  32467. +    
  32468. +    while (dev2 && dev2 != dev)
  32469. +        dev2 = dev2->next;
  32470. +
  32471. +    if (dev2 == dev)
  32472. +        printk("eek! - %s\n", s);
  32473. +}
  32474. +
  32475. +/*
  32476. + * set one of the receive address registers in the chip
  32477. + */
  32478. +
  32479. +static void
  32480. +ether3_setrxaddr(struct device *dev, int address, unsigned char *addr)
  32481. +{
  32482. +    FUNC_PROLOGUE;
  32483. +    unsigned long flags;
  32484. +    int stat, i;
  32485. +
  32486. +    save_flags(flags);
  32487. +    cli();
  32488. +
  32489. +    stat = inw(REG_STATUS);
  32490. +    if(stat & STAT_RXON)
  32491. +        outw(an->regs.command | CMD_RXOFF, REG_COMMAND);
  32492. +
  32493. +    outw(an->regs.config1 | address, REG_CONFIG1);
  32494. +    for(i=0; i<6; i++)
  32495. +        outb(addr[i], REG_BUFWIN);
  32496. +
  32497. +    if(stat & STAT_RXON)
  32498. +        outw(an->regs.command | CMD_RXON, REG_COMMAND);
  32499. +
  32500. +    restore_flags(flags);
  32501. +}
  32502. +
  32503. +/*
  32504. + * write data to the buffer memory
  32505. + */
  32506. +
  32507. +static void
  32508. +ether3_writebuffer(struct device *dev, void *data, int start, int length)
  32509. +{
  32510. +    FUNC_PROLOGUE;
  32511. +    int timeout = 1000000;
  32512. +    if(start != -1)
  32513. +    {
  32514. +        outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  32515. +        outw(an->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  32516. +        while((inw(REG_STATUS) & STAT_FIFOEMPTY) == 0)
  32517. +            if(!timeout--)
  32518. +            {
  32519. +                printk("settxlim_16 broken\n");
  32520. +                an->broken = 1;
  32521. +                return;
  32522. +            }
  32523. +        outw(an->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  32524. +        outw(start, REG_DMAADDR);
  32525. +    }
  32526. +    if(length != 0)
  32527. +        outswb(REG_BUFWIN, data, length);
  32528. +}
  32529. +
  32530. +/*
  32531. + * read data from the buffer memory
  32532. + */
  32533. +
  32534. +static void
  32535. +ether3_readbuffer(struct device *dev, void *data, int start, int length)
  32536. +{
  32537. +    FUNC_PROLOGUE;
  32538. +    int timeout = 1000000;
  32539. +    if(start != -1)
  32540. +    {
  32541. +        outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  32542. +        outw(an->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  32543. +        while((inw(REG_STATUS) & STAT_FIFOEMPTY) == 0)
  32544. +            if(!timeout--)
  32545. +            {
  32546. +                printk("setrxlim_16 broken\n");
  32547. +                an->broken = 1;
  32548. +                return;
  32549. +            }
  32550. +        outw(start, REG_DMAADDR);
  32551. +        outw(an->regs.command | CMD_FIFOREAD, REG_COMMAND);
  32552. +    }
  32553. +    if(length != 0)
  32554. +        inswb(REG_BUFWIN, data, length);
  32555. +}
  32556. +
  32557. +/* --------------------------------------------------------------------------- */
  32558. +
  32559. +static int
  32560. +ether3_ramtest(struct device *dev, unsigned char byte)
  32561. +{
  32562. +    unsigned char *buffer = kmalloc(RX_END, GFP_KERNEL);
  32563. +    unsigned long flags;
  32564. +    int i,ret=0;
  32565. +    int max_errors = 4;
  32566. +    int bad=-1;
  32567. +
  32568. +    if(!buffer)
  32569. +        return 1;
  32570. +
  32571. +    save_flags(flags);
  32572. +    cli();
  32573. +
  32574. +    memset(buffer, byte, RX_END);
  32575. +    ether3_writebuffer(dev, buffer, 0, TX_END);
  32576. +    ether3_writebuffer(dev, buffer+RX_START, RX_START, RX_LEN);
  32577. +
  32578. +    memset(buffer, byte ^ 0xff, RX_END);
  32579. +    ether3_readbuffer(dev, buffer, 0, TX_END);
  32580. +    ether3_readbuffer(dev, buffer+RX_START, RX_START, RX_LEN);
  32581. +
  32582. +    for(i=0; i<RX_END; i++)
  32583. +    {
  32584. +        if(buffer[i] != byte)
  32585. +        {
  32586. +            if(max_errors>=0 && bad!=buffer[i])
  32587. +            {
  32588. +                printk("%s: RAM failed with (%02X instead of %02X) at 0x%04X",
  32589. +                    dev->name, buffer[i], byte, i);
  32590. +                ret = 2;
  32591. +                max_errors--;
  32592. +                bad=buffer[i];
  32593. +            }
  32594. +        }
  32595. +        else
  32596. +        {
  32597. +            if(bad != -1)
  32598. +            {
  32599. +                printk(" - 0x%04X\n", i);
  32600. +                bad = -1;
  32601. +            }
  32602. +        }
  32603. +    }
  32604. +    if(bad != -1)
  32605. +        printk(" - 0x10000\n");
  32606. +    kfree(buffer);
  32607. +    restore_flags(flags);
  32608. +
  32609. +    return ret;
  32610. +}
  32611. +
  32612. +/* ------------------------------------------------------------------------------- */
  32613. +
  32614. +static int
  32615. +ether3_init_1(struct device *dev)
  32616. +{
  32617. +    outb(0x80, REG_CONFIG2);
  32618. +    outb(0, REG_COMMAND);
  32619. +
  32620. +    outb(1, REG_CONFIG1);
  32621. +    if(inb(REG_CONFIG1+1)==1 && inb(REG_CONFIG1)==0)
  32622. +        return BUS_8;
  32623. +    if(inw(REG_CONFIG1)==0x101)
  32624. +        return BUS_16;
  32625. +    return 0;
  32626. +}
  32627. +
  32628. +static int
  32629. +ether3_init_2(struct device *dev)
  32630. +{
  32631. +    FUNC_PROLOGUE;
  32632. +    unsigned long a=0;
  32633. +    int i;
  32634. +
  32635. +    ether3_setrxaddr(dev, CFG1_BUFSELSTAT0, dev->dev_addr);
  32636. +
  32637. +    an->regs.config1 = CFG1_RECVSPECBROAD|CFG1_RECVCOMPSTAT0|CFG1_DMABURST8;
  32638. +    an->regs.config2 = CFG2_CTRLO|CFG2_RECVCRC|CFG2_ERRENCRC;
  32639. +
  32640. +    outw(an->regs.config1 | CFG1_TRANSEND, REG_CONFIG1);
  32641. +    outw((TX_END>>8) - 1, REG_BUFWIN);
  32642. +    outw(an->regs.recvptr    , REG_RECVPTR);
  32643. +    outw(an->regs.transmitptr    , REG_TRANSMITPTR);
  32644. +    outw(an->regs.recvptr >> 8, REG_RECVEND);
  32645. +    outw(an->regs.config2    , REG_CONFIG2);
  32646. +    outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  32647. +    ether3_writebuffer(dev, &a, an->regs.transmitptr, 4);
  32648. +    outw(an->regs.command    , REG_COMMAND);
  32649. +
  32650. +    i = ether3_ramtest(dev, 0x5A);
  32651. +    if(i)
  32652. +        return i;
  32653. +    return ether3_ramtest(dev, 0x1E);
  32654. +}
  32655. +
  32656. +/* This is the real probe routine. */
  32657. +
  32658. +static int
  32659. +ether3_probe1(struct device *dev)
  32660. +{
  32661. +    static unsigned version_printed = 0;
  32662. +    struct arc_net *an;
  32663. +    int i;
  32664. +
  32665. +    if(!dev->priv)
  32666. +        dev->priv = kmalloc(sizeof(struct arc_net), GFP_KERNEL);
  32667. +
  32668. +    if(!dev->priv)
  32669. +        return 1;
  32670. +
  32671. +    an = (struct arc_net *) dev->priv;
  32672. +    memset(an, 0, sizeof(struct arc_net));
  32673. +    an->bus_type    = BUS_16;
  32674. +    an->broken    = 0;
  32675. +
  32676. +    if((an->bus_type=ether3_init_1(dev))==0)
  32677. +    {
  32678. +        kfree(dev->priv);
  32679. +        return 1;
  32680. +    }
  32681. +
  32682. +    if (net_debug  &&  version_printed++ == 0)
  32683. +        printk(version);
  32684. +
  32685. +    printk("%s: ether3 found (bus width %d), ", dev->name, an->bus_type);
  32686. +
  32687. +    /* Retrive and print the ethernet address. */
  32688. +    for (i = 0; i < 6; i++)
  32689. +        printk(i==0?" %2.2x":i==5?":%2.2x\n":":%2.2x", dev->dev_addr[i]);
  32690. +
  32691. +    if(ether3_init_2(dev))
  32692. +    {
  32693. +        kfree(dev->priv);
  32694. +        return 1;
  32695. +    }
  32696. +
  32697. +    dev->open        = ether3_open;
  32698. +    dev->stop        = ether3_close;
  32699. +    dev->hard_start_xmit    = ether3_send_packet;
  32700. +    dev->get_stats            = ether3_get_stats;
  32701. +    dev->set_multicast_list = set_multicast_list;
  32702. +
  32703. +    /* Fill in the fields of the device structure with ethernet values. */
  32704. +    ether_setup(dev);
  32705. +#ifndef CLAIM_IRQ_AT_OPEN
  32706. +    if (request_irq(dev->irq, ether3_interrupt, 0, "ether3")) {
  32707. +        kfree(dev->priv);
  32708. +        return -EAGAIN;
  32709. +    }
  32710. +
  32711. +    irq2dev_map[dev->irq] = dev;
  32712. +#endif
  32713. +    return 0;
  32714. +}
  32715. +
  32716. +/* --------------------------------------------------------------------------- */
  32717. +
  32718. +static void
  32719. +ether3_addr(char *addr, struct expansion_card *ec)
  32720. +{
  32721. +    struct chunk_dir cd;
  32722. +    char *s;
  32723. +    
  32724. +    if(ecard_readchunk(&cd, ec, 0xf5, 0) && (s = strchr(cd.d.string, '(')))
  32725. +    {
  32726. +        int i;
  32727. +        for (i = 0; i<6; i++)
  32728. +        {
  32729. +            addr[i] = simple_strtoul(s + 1, &s, 0x10);
  32730. +            if(*s != (i==5?')' : ':' ))
  32731. +                break;
  32732. +        }
  32733. +        if(i == 6)
  32734. +            return;
  32735. +    }
  32736. +    memcpy(addr, def_eth_addr, 6);
  32737. +}
  32738. +int
  32739. +ether3_probe(struct device *dev)
  32740. +{
  32741. +#ifndef MODULE
  32742. +    struct expansion_card *ec;
  32743. +    unsigned char *eth_addr;
  32744. +    int base_addr;
  32745. +
  32746. +    if(!dev)
  32747. +        return ENODEV;
  32748. +
  32749. +    if((ec = ecard_find(0, sizeof(ether3_prods), ether3_prods, ether3_manus)) == NULL)
  32750. +        return ENODEV;
  32751. +
  32752. +    dev->base_addr    = ((unsigned long)ec->r_podaddr & ~0x003c0000UL) >> 2;
  32753. +    dev->irq    = ec->irq;
  32754. +
  32755. +    ecard_claim (ec);
  32756. +
  32757. +    ether3_addr(dev->dev_addr, ec);
  32758. +#endif
  32759. +    if(ether3_probe1(dev) == 0)
  32760. +        return 0;
  32761. +    return ENODEV;
  32762. +}
  32763. +
  32764. +/* ------------------------------------------------------------------------ */
  32765. +
  32766. +static void
  32767. +ether3_init_for_open(struct device *dev)
  32768. +{
  32769. +    FUNC_PROLOGUE;
  32770. +    unsigned long a=0;
  32771. +
  32772. +    an->regs.command = 0;
  32773. +    outw(CMD_RXOFF|CMD_TXOFF, REG_COMMAND);
  32774. +    while(inw(REG_STATUS) & (STAT_RXON|STAT_TXON));
  32775. +
  32776. +    ether3_setrxaddr(dev, CFG1_BUFSELSTAT0, dev->dev_addr);
  32777. +    an->regs.transmitptr = 0;    /* address that transmitter has processed to */
  32778. +    an->txinsert = 0;        /* address of next available packet for tx */
  32779. +    an->txed = 0;            /* transmitted length index */
  32780. +    an->txto = 0;            /* to transmit length index */
  32781. +    an->tx_ends[0] = 0;
  32782. +    an->use = 0;
  32783. +
  32784. +    an->regs.config2 |= CFG2_CTRLO;
  32785. +
  32786. +    outw(an->regs.config1 | CFG1_TRANSEND, REG_CONFIG1);
  32787. +    outw((TX_END>>8) - 1, REG_BUFWIN);
  32788. +
  32789. +    an->regs.recvptr    = RX_START;
  32790. +    outw(an->regs.recvptr    , REG_RECVPTR);
  32791. +    outw(an->regs.recvptr>>8, REG_RECVEND);
  32792. +
  32793. +    outw(0, REG_TRANSMITPTR);
  32794. +    outw(an->regs.config2 , REG_CONFIG2);
  32795. +    outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  32796. +
  32797. +    ether3_writebuffer(dev, &a, an->regs.transmitptr, 4);
  32798. +
  32799. +
  32800. +    an->regs.command = CMD_ENINTRX|CMD_ENINTTX;
  32801. +    outw(an->regs.command | CMD_RXON, REG_COMMAND);
  32802. +}
  32803. +
  32804. +/* Open/initialize the board.  This is called (in the current kernel)
  32805. +   sometime after booting when the 'ifconfig' program is run.
  32806. +
  32807. +   This routine should set everything up anew at each open, even
  32808. +   registers that "should" only need to be set once at boot, so that
  32809. +   there is non-reboot way to recover if something goes wrong.
  32810. +   */
  32811. +static int
  32812. +ether3_open(struct device *dev)
  32813. +{
  32814. +    ether3_init_for_open(dev);
  32815. +
  32816. +#ifdef CLAIM_IRQ_AT_OPEN
  32817. +    if (request_irq(dev->irq, ether3_interrupt, 0, "ether3")) {
  32818. +        kfree(dev->priv);
  32819. +        return -EAGAIN;
  32820. +    }
  32821. +
  32822. +    irq2dev_map[dev->irq] = dev;
  32823. +#endif
  32824. +
  32825. +    MOD_INC_USE_COUNT;
  32826. +
  32827. +    dev->tbusy = 0;
  32828. +    dev->interrupt = 0;
  32829. +    dev->start = 1;
  32830. +    return 0;
  32831. +}
  32832. +
  32833. +static int
  32834. +ether3_send_packet(struct sk_buff *skb, struct device *dev)
  32835. +{
  32836. +    FUNC_PROLOGUE;
  32837. +
  32838. +    if (dev->tbusy) {
  32839. +        /* If we get here, some higher level has decided we are broken.
  32840. +           There should really be a "kick me" function call instead. */
  32841. +        int tickssofar = jiffies - dev->trans_start;
  32842. +        if (tickssofar < 5)
  32843. +            return 1;
  32844. +        printk("%s: transmit timed out, %s?\n", dev->name,
  32845. +               tx_done(dev) ? "IRQ conflict" : "network cable problem");
  32846. +        /* Try to restart the adaptor. */
  32847. +        dev->tbusy = 0;
  32848. +        an->use = 0;
  32849. +        an->regs.config2 |= CFG2_CTRLO;
  32850. +        outw(an->regs.config2 , REG_CONFIG2);
  32851. +        dev->trans_start = jiffies;
  32852. +    }
  32853. +
  32854. +    /* If some higher layer thinks we've missed an tx-done interrupt
  32855. +       we are passed NULL. Caution: dev_tint() handles the cli()/sti()
  32856. +       itself. */
  32857. +    if (skb == NULL) {
  32858. +        dev_tint(dev);
  32859. +        return 0;
  32860. +    }
  32861. +
  32862. +    /* Block a timer-based transmit from overlapping.  This could better be
  32863. +       done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
  32864. +    if (set_bit(0, (void*)&dev->tbusy) != 0)
  32865. +        printk("%s: Transmitter access conflict.\n", dev->name);
  32866. +    else {
  32867. +        short length = ETH_ZLEN < (skb->len-2) ? (skb->len-2) : ETH_ZLEN;
  32868. +        unsigned char *buf = skb->data;
  32869. +        unsigned long flags;
  32870. +        unsigned long thisinfo, nextinfo=0;
  32871. +        int thisdata, thisstart, nextpacket;
  32872. +
  32873. +        if(an->broken)
  32874. +        {
  32875. +          dev_kfree_skb(skb, FREE_WRITE);
  32876. +          an->stats.tx_dropped ++;
  32877. +          return 1;
  32878. +        }
  32879. +
  32880. +        thisstart = an->txinsert;
  32881. +        thisdata = thisstart + 4;
  32882. +        if(thisdata >= TX_END)
  32883. +            thisdata -= TX_END;
  32884. +        nextpacket = thisdata + length;
  32885. +        if(nextpacket >= TX_END)
  32886. +            nextpacket -= TX_END;
  32887. +        an->txinsert = nextpacket;
  32888. +        an->tx_ends[an->txto++] = nextpacket;
  32889. +        if(an->txto >= MAX_TXED)
  32890. +          an->txto = 0;
  32891. +
  32892. +        thisinfo = 0x00E80000 | ((nextpacket >> 8) & 0xff) | ((nextpacket << 8) & 0xff00);
  32893. +
  32894. +        save_flags(flags);
  32895. +        cli();
  32896. +        an->use++;
  32897. +        an->regs.config2 &= ~CFG2_CTRLO;
  32898. +        outw(an->regs.config2 , REG_CONFIG2);
  32899. +
  32900. +        ether3_writebuffer(dev, buf + 2, thisdata, length&1?(length+1):length);
  32901. +        ether3_writebuffer(dev, &nextinfo, -1, 4);
  32902. +        ether3_writebuffer(dev, &thisinfo, thisstart, 4);
  32903. +        restore_flags(flags);
  32904. +
  32905. +        if((inw(REG_STATUS) & STAT_TXON)==0) {
  32906. +          outw(thisstart, REG_TRANSMITPTR);
  32907. +          outw(an->regs.command | CMD_TXON, REG_COMMAND);
  32908. +        }
  32909. +        dev->trans_start = jiffies;
  32910. +    }
  32911. +    dev_kfree_skb (skb, FREE_WRITE);
  32912. +
  32913. +    /* You might need to clean up and record Tx statistics here. */
  32914. +
  32915. +    return 0;
  32916. +}
  32917. +
  32918. +/* The typical workload of the driver:
  32919. +   Handle the network interface interrupts. */
  32920. +static void
  32921. +ether3_interrupt(int irq, struct pt_regs *regs)
  32922. +{
  32923. +    struct device *dev = (struct device *)(irq2dev_map[irq]);
  32924. +    struct arc_net *an = (struct arc_net *)dev->priv;
  32925. +    int status, boguscount = 0, done = 0;
  32926. +#if NET_DEBUG > 1
  32927. +    if(net_debug & DEBUG_INT)
  32928. +             printk("ether3_interrupt: irq %d\n", irq);
  32929. +#endif
  32930. +
  32931. +    if (dev == NULL) {
  32932. +        printk ("ether3_interrupt(): irq %d for unknown device.\n", irq);
  32933. +        return;
  32934. +    }
  32935. +    dev->interrupt = 1;
  32936. +
  32937. +    do {
  32938. +        status = inw(REG_STATUS);
  32939. +        if (status & STAT_INTRX) {
  32940. +            /* Got a packet(s). */
  32941. +            ether3_rx(dev);
  32942. +            done = 1;
  32943. +        }
  32944. +        if (status & STAT_INTTX) {
  32945. +            ether3_tx(dev);
  32946. +            done = 1;
  32947. +        }
  32948. +        outw((status & (STAT_INTRX|STAT_INTTX|STAT_INTBUFWIN))
  32949. +          | an->regs.command, REG_COMMAND);
  32950. +    } while (++boguscount < 20 && !done) ;
  32951. +
  32952. +    dev->interrupt = 0;
  32953. +
  32954. +#if NET_DEBUG > 1
  32955. +    if(net_debug & DEBUG_INT)
  32956. +             printk("ether3_interrupt: done\n", irq);
  32957. +#endif
  32958. +}
  32959. +
  32960. +/* We have a good packet(s), get it/them out of the buffers. */
  32961. +static void
  32962. +ether3_rx(struct device *dev)
  32963. +{
  32964. +    FUNC_PROLOGUE;
  32965. +    struct sk_buff *skb=NULL;
  32966. +    unsigned int end;
  32967. +    unsigned int length;
  32968. +
  32969. +    an->use++;
  32970. +    if(an->use == 1)
  32971. +    {
  32972. +        an->regs.config2 &= ~CFG2_CTRLO;
  32973. +        outw(an->regs.config2 , REG_CONFIG2);
  32974. +    }
  32975. +    do {
  32976. +        unsigned char buffer[20];
  32977. +        ether3_readbuffer(dev, buffer, an->regs.recvptr, 20);
  32978. +
  32979. +        if(buffer[0] == 0 || (buffer[3] & 0x80)==0)
  32980. +            goto rx_fin;
  32981. +#if NET_DEBUG > 1
  32982. +        if(net_debug & DEBUG_RX) {
  32983. +        {
  32984. +            int i;
  32985. +            printk("ether3_rx:", an->regs.recvptr);
  32986. +            for(i=3; i<18; i++)
  32987. +                printk("%02X ",(unsigned int)buffer[i]);
  32988. +            printk("\n");
  32989. +        }
  32990. +#endif
  32991. +
  32992. +        end = (buffer[0]<<8) | buffer[1];
  32993. +
  32994. +        if((buffer[2] & 0xC0) != 0x40)
  32995. +          /* no data follows */
  32996. +          goto done;
  32997. +
  32998. +        if(buffer[3] & 15) {
  32999. +            an->stats.rx_errors++;
  33000. +            if(buffer[3] & 1) an->stats.rx_fifo_errors ++;
  33001. +            if(buffer[3] & 2) an->stats.rx_crc_errors ++;
  33002. +            if(buffer[3] & 4) an->stats.rx_fifo_errors ++;
  33003. +            if(buffer[3] & 8) an->stats.rx_length_errors ++;
  33004. +            goto done;
  33005. +        }
  33006. +
  33007. +        if(end > an->regs.recvptr)
  33008. +            length = end - an->regs.recvptr;
  33009. +        else
  33010. +            length = (end - RX_START) + (RX_END - an->regs.recvptr);
  33011. +
  33012. +        skb = alloc_skb(length + 4, GFP_ATOMIC);
  33013. +        if(skb == NULL) {
  33014. +            printk("%s: memory squeeze, dropping packet.\n", dev->name);
  33015. +            an->stats.rx_dropped++;
  33016. +            an->regs.recvptr = end;
  33017. +            outw(an->regs.recvptr >> 8, REG_RECVEND);
  33018. +            goto rx_fin;
  33019. +        }
  33020. +
  33021. +        skb->len = length - 4;
  33022. +        skb->dev = dev;
  33023. +        memcpy(skb->data + 2, buffer + 4, 20-4);
  33024. +        ether3_readbuffer(dev, skb->data+18, -1, length-20);
  33025. +    done:
  33026. +        an->regs.recvptr = end;
  33027. +        outw(an->regs.recvptr >> 8, REG_RECVEND);
  33028. +        if(skb) {
  33029. +            netif_rx(skb);
  33030. +            skb=NULL;
  33031. +            an->stats.rx_packets++;
  33032. +        }
  33033. +    }
  33034. +    while(inw(REG_STATUS) & STAT_RXON);
  33035. +
  33036. +    outw(an->regs.recvptr, REG_RECVPTR);
  33037. +    outw(an->regs.command | CMD_RXON, REG_COMMAND);
  33038. +
  33039. +    /* If any worth-while packets have been received, dev_rint()
  33040. +       has done a mark_bh(NET_BH) for us and will work on them
  33041. +       when we get to the bottom-half routine. */
  33042. +rx_fin:
  33043. +    if(an->use)
  33044. +    {
  33045. +        an->use--;
  33046. +        if(an->use == 0)
  33047. +        {
  33048. +            an->regs.config2 |= CFG2_CTRLO;
  33049. +            outw(an->regs.config2 , REG_CONFIG2);
  33050. +        }
  33051. +    }
  33052. +}
  33053. +
  33054. +/* ----------------------------------------------------------------------------- */
  33055. +
  33056. +static void
  33057. +ether3_tx(struct device *dev)
  33058. +{
  33059. +    FUNC_PROLOGUE;
  33060. +    unsigned char buffer[4];
  33061. +
  33062. +    if(an->regs.transmitptr + 4 > TX_END) {
  33063. +        int len = TX_END - an->regs.transmitptr;
  33064. +        ether3_readbuffer(dev, buffer, an->regs.transmitptr, len);
  33065. +        ether3_readbuffer(dev, buffer+len, 0, 4 - len);
  33066. +    }
  33067. +    else
  33068. +        ether3_readbuffer(dev, buffer, an->regs.transmitptr, 4);
  33069. +
  33070. +    if(!(buffer[3] & 0x80))
  33071. +        return;
  33072. +
  33073. +    if(buffer[3] & 7) {
  33074. +        if(buffer[3] & 5) an->stats.tx_errors ++;
  33075. +        if(buffer[3] & 4) an->stats.collisions += 16;
  33076. +        if(buffer[3] & 2) an->stats.collisions += (buffer[3] & 0x78)>>3;
  33077. +        if(buffer[3] & 1) an->stats.tx_fifo_errors ++;
  33078. +    }
  33079. +    if(!(buffer[3] & 5))
  33080. +        an->stats.tx_packets++;
  33081. +
  33082. +    an->regs.transmitptr = an->tx_ends[an->txed++];
  33083. +    if(an->txed >= MAX_TXED)
  33084. +        an->txed = 0;
  33085. +    if(an->regs.transmitptr >= TX_END)
  33086. +        an->regs.transmitptr -= TX_END;
  33087. +/* if(an->regs.transmitptr != ((buffer[0]<<8)|buffer[1])) */
  33088. +/* printk("%p:%p\n",an->regs.transmitptr, (buffer[2]<<24)|(buffer[3]<<16)|(buffer[0]<<8)|buffer[1]); */
  33089. +    dev->tbusy = 0;
  33090. +    mark_bh(NET_BH);    /* Inform upper layers. */
  33091. +    if(an->use)
  33092. +    {
  33093. +        an->use--;
  33094. +        if(an->use == 0)
  33095. +        {
  33096. +            an->regs.config2 |= CFG2_CTRLO;
  33097. +            outw(an->regs.config2 , REG_CONFIG2);
  33098. +        }
  33099. +    }
  33100. +}
  33101. +
  33102. +/* The inverse routine to net_open(). */
  33103. +static int
  33104. +ether3_close(struct device *dev)
  33105. +{
  33106. +    FUNC_PROLOGUE;
  33107. +    unsigned long flags;
  33108. +
  33109. +    dev->tbusy = 1;
  33110. +    dev->start = 0;
  33111. +
  33112. +    save_flags(flags);
  33113. +    cli();
  33114. +
  33115. +    outw(CMD_RXOFF|CMD_TXOFF, REG_COMMAND);
  33116. +    an->regs.command = 0;
  33117. +    while(inw(REG_STATUS) & (STAT_RXON|STAT_TXON));
  33118. +    ether3_init_1(dev);
  33119. +
  33120. +    restore_flags(flags);
  33121. +
  33122. +    /* Flush the Tx */
  33123. +#ifdef CLAIM_IRQ_AT_OPEN
  33124. +    free_irq(dev->irq);
  33125. +
  33126. +    irq2dev_map[dev->irq] = NULL;
  33127. +#endif
  33128. +
  33129. +    MOD_DEC_USE_COUNT;
  33130. +
  33131. +    return 0;
  33132. +
  33133. +}
  33134. +
  33135. +/* Get the current statistics.    This may be called with the card open or
  33136. +   closed. */
  33137. +static struct enet_statistics *
  33138. +ether3_get_stats(struct device *dev)
  33139. +{
  33140. +    FUNC_PROLOGUE;
  33141. +    return &an->stats;
  33142. +}
  33143. +
  33144. +/* Set or clear the multicast filter for this adaptor.
  33145. +   num_addrs == -1    Promiscuous mode, receive all packets
  33146. +   num_addrs == 0    Normal mode, clear multicast list
  33147. +   num_addrs > 0    Multicast mode, receive normal and MC packets, and do
  33148. +            best-effort filtering.
  33149. + */
  33150. +static void
  33151. +set_multicast_list(struct device *dev, int num_addrs, void *addrs)
  33152. +{
  33153. +    FUNC_PROLOGUE;
  33154. +
  33155. +    if(num_addrs == -1)
  33156. +        an->regs.config1 |= CFG1_RECVPROMISC;
  33157. +    else
  33158. +        an->regs.config1 = (an->regs.config1 & ~CFG1_RECVPROMISC)
  33159. +                    | CFG1_RECVSPECBROAD;
  33160. +
  33161. +    outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  33162. +}
  33163. +
  33164. +#ifdef MODULE
  33165. +char kernel_version[] = UTS_RELEASE;
  33166. +static struct device ether3 = {
  33167. +    "        ",
  33168. +    0, 0, 0, 0,
  33169. +    0, 0,
  33170. +    0, 0, 0, NULL, ether3_probe
  33171. +};
  33172. +
  33173. +char *ethernames[4] = {
  33174. +    "        ",
  33175. +    "        ",
  33176. +    "        ",
  33177. +    "        "
  33178. +};
  33179. +static struct device *my_ethers[4];
  33180. +static struct expansion_card *ec[4];
  33181. +
  33182. +int
  33183. +init_module(void)
  33184. +{
  33185. +    int i;
  33186. +
  33187. +    for(i = 0; i < 4; i++)
  33188. +    {
  33189. +        my_ethers[i] = NULL;
  33190. +        ec[i] = NULL;
  33191. +    }
  33192. +
  33193. +    i = 0;
  33194. +
  33195. +    do
  33196. +    {
  33197. +        if ((ec[i] = ecard_find(0, sizeof(ether3_prods), ether3_prods, ether3_manus)) == NULL)
  33198. +            break;
  33199. +
  33200. +        my_ethers[i] = (struct device *)kmalloc(sizeof(struct device), GFP_KERNEL);
  33201. +        memset(my_ethers[i], 0, sizeof(struct device));
  33202. +
  33203. +        my_ethers[i]->irq = ec[i]->irq;
  33204. +        my_ethers[i]->base_addr= ((unsigned long)ec[i]->r_podaddr & ~0x003c0000UL)>>2;
  33205. +        my_ethers[i]->init = ether3_probe;
  33206. +        my_ethers[i]->name = ethernames[i];
  33207. +
  33208. +        ether3_addr(my_ethers[i]->dev_addr, ec[i]);
  33209. +
  33210. +        ecard_claim(ec[i]);
  33211. +
  33212. +        if(register_netdev(my_ethers[i]) != 0)
  33213. +        {
  33214. +            for (i = 0; i < 4; i++)
  33215. +            {
  33216. +                if(my_ethers[i])
  33217. +                {
  33218. +                    kfree(my_ethers[i]);
  33219. +                    my_ethers[i] = NULL;
  33220. +                }
  33221. +                if(ec[i])
  33222. +                {
  33223. +                    ecard_release(ec[i]);
  33224. +                    ec[i] = NULL;
  33225. +                }
  33226. +            }
  33227. +            return -EIO;
  33228. +        }
  33229. +        i++;
  33230. +    }
  33231. +    while(i < 4);
  33232. +
  33233. +    return i != 0 ? 0 : -ENODEV;
  33234. +}
  33235. +
  33236. +void
  33237. +cleanup_module(void)
  33238. +{
  33239. +    if (MOD_IN_USE) {
  33240. +        printk("%s: device busy, remove delayed\n", ether3.name);
  33241. +    } else {
  33242. +        int i;
  33243. +        for(i = 0; i < 4; i++)
  33244. +        {
  33245. +            if(my_ethers[i])
  33246. +            {
  33247. +                unregister_netdev(my_ethers[i]);
  33248. +                my_ethers[i] = NULL;
  33249. +            }
  33250. +            if(ec[i])
  33251. +            {
  33252. +                ecard_release(ec[i]);
  33253. +                ec[i] = NULL;
  33254. +            }
  33255. +        }
  33256. +    }
  33257. +}
  33258. +#endif /* MODULE */
  33259. diff -r -u -N linux.orig/arch/arm/drivers/net/ether3.h linux.arm/arch/arm/drivers/net/ether3.h
  33260. --- linux.orig/arch/arm/drivers/net/ether3.h    Thu Jan  1 01:00:00 1970
  33261. +++ linux.arm/arch/arm/drivers/net/ether3.h    Fri Oct 27 23:15:07 1995
  33262. @@ -0,0 +1,153 @@
  33263. +/*
  33264. + * linux/drivers/net/ether3.h
  33265. + *
  33266. + * network driver for Acorn Ether3 cards
  33267. + */
  33268. +
  33269. +#ifndef _LINUX_ether3_H
  33270. +#define _LINUX_ether3_H
  33271. +
  33272. +/* use 0 for production, 1 for verification, >2 for debug. debug flags: */
  33273. +#define DEBUG_TX     2
  33274. +#define DEBUG_RX     4
  33275. +#define DEBUG_INT     8
  33276. +#define DEBUG_IC    16
  33277. +#ifndef NET_DEBUG
  33278. +#define NET_DEBUG 1
  33279. +#endif
  33280. +
  33281. +/* Command register definitions & bits */
  33282. +#define REG_COMMAND        (dev->base_addr + 0x00)
  33283. +#define CMD_ENINTDMA        0x0001
  33284. +#define CMD_ENINTRX        0x0002
  33285. +#define CMD_ENINTTX        0x0004
  33286. +#define CMD_ENINTBUFWIN        0x0008
  33287. +#define CMD_ACKINTDMA        0x0010
  33288. +#define CMD_ACKINTRX        0x0020
  33289. +#define CMD_ACKINTTX        0x0040
  33290. +#define CMD_ACKINTBUFWIN    0x0080
  33291. +#define CMD_DMAON        0x0100
  33292. +#define CMD_RXON        0x0200
  33293. +#define CMD_TXON        0x0400
  33294. +#define CMD_DMAOFF        0x0800
  33295. +#define CMD_RXOFF        0x1000
  33296. +#define CMD_TXOFF        0x2000
  33297. +#define CMD_FIFOREAD        0x4000
  33298. +#define CMD_FIFOWRITE        0x8000
  33299. +
  33300. +/* status register */
  33301. +#define REG_STATUS        (dev->base_addr + 0x00)
  33302. +#define STAT_ENINTSTAT        0x0001
  33303. +#define STAT_ENINTRX        0x0002
  33304. +#define STAT_ENINTTX        0x0004
  33305. +#define STAT_ENINTBUFWIN    0x0008
  33306. +#define STAT_INTDMA        0x0010
  33307. +#define STAT_INTRX        0x0020
  33308. +#define STAT_INTTX        0x0040
  33309. +#define STAT_INTBUFWIN        0x0080
  33310. +#define STAT_DMAON        0x0100
  33311. +#define STAT_RXON        0x0200
  33312. +#define STAT_TXON        0x0400
  33313. +#define STAT_FIFOFULL        0x2000
  33314. +#define STAT_FIFOEMPTY        0x4000
  33315. +#define STAT_FIFODIR        0x8000
  33316. +
  33317. +/* configuration register 1 */
  33318. +#define REG_CONFIG1        (dev->base_addr + 0x10)
  33319. +#define CFG1_BUFSELSTAT0    0x0000
  33320. +#define CFG1_BUFSELSTAT1    0x0001
  33321. +#define CFG1_BUFSELSTAT2    0x0002
  33322. +#define CFG1_BUFSELSTAT3    0x0003
  33323. +#define CFG1_BUFSELSTAT4    0x0004
  33324. +#define CFG1_BUFSELSTAT5    0x0005
  33325. +#define CFG1_ADDRPROM        0x0006
  33326. +#define CFG1_TRANSEND        0x0007
  33327. +#define CFG1_LOCBUFMEM        0x0008
  33328. +#define CFG1_INTVECTOR        0x0009
  33329. +#define CFG1_DMABURSTCONT    0x0000
  33330. +#define CFG1_DMABURST800NS    0x0010
  33331. +#define CFG1_DMABURST1600NS    0x0020
  33332. +#define CFG1_DMABURST3200NS    0x0030
  33333. +#define CFG1_DMABURST1        0x0000
  33334. +#define CFG1_DMABURST4        0x0040
  33335. +#define CFG1_DMABURST8        0x0080
  33336. +#define CFG1_DMABURST16        0x00C0
  33337. +#define CFG1_RECVCOMPSTAT0    0x0100
  33338. +#define CFG1_RECVCOMPSTAT1    0x0200
  33339. +#define CFG1_RECVCOMPSTAT2    0x0400
  33340. +#define CFG1_RECVCOMPSTAT3    0x0800
  33341. +#define CFG1_RECVCOMPSTAT4    0x1000
  33342. +#define CFG1_RECVCOMPSTAT5    0x2000
  33343. +#define CFG1_RECVSPECONLY    0x0000
  33344. +#define CFG1_RECVSPECBROAD    0x4000
  33345. +#define CFG1_RECVSPECBRMULTI    0x8000
  33346. +#define CFG1_RECVPROMISC    0xC000
  33347. +
  33348. +/* configuration register 2 */
  33349. +#define REG_CONFIG2        (dev->base_addr + 0x20)
  33350. +#define CFG2_BYTESWAP        0x0001
  33351. +#define CFG2_ERRENCRC        0x0008
  33352. +#define CFG2_ERRENDRIBBLE    0x0010
  33353. +#define CFG2_ERRSHORTFRAME    0x0020
  33354. +#define CFG2_SLOTSELECT        0x0040
  33355. +#define CFG2_PREAMSELECT    0x0080
  33356. +#define CFG2_ADDRLENGTH        0x0100
  33357. +#define CFG2_RECVCRC        0x0200
  33358. +#define CFG2_XMITNOCRC        0x0400
  33359. +#define CFG2_LOOPBACK        0x0800
  33360. +#define CFG2_CTRLO        0x1000
  33361. +#define CFG2_RESET        0x8000
  33362. +
  33363. +#define REG_RECVEND        (dev->base_addr + 0x30)
  33364. +
  33365. +#define REG_BUFWIN        (dev->base_addr + 0x40)
  33366. +
  33367. +#define REG_RECVPTR        (dev->base_addr + 0x50)
  33368. +
  33369. +#define REG_TRANSMITPTR        (dev->base_addr + 0x60)
  33370. +
  33371. +#define REG_DMAADDR        (dev->base_addr + 0x70)
  33372. +
  33373. +
  33374. +#define TX_END          0x6000
  33375. +#define RX_START        0x6000
  33376. +#define RX_LEN          0xA000
  33377. +#define RX_END          0x10000
  33378. +#define MAX_TXED    360
  33379. +
  33380. +struct arc_net
  33381. +{
  33382. +    int bus_type;
  33383. +    struct
  33384. +    {
  33385. +      int command;
  33386. +      int config1;
  33387. +      int config2;
  33388. +      int transmitptr;
  33389. +      int recvptr;
  33390. +    } regs;
  33391. +    int txinsert;
  33392. +    struct enet_statistics stats;
  33393. +    int txed;
  33394. +    int txto;
  33395. +    int tx_ends[MAX_TXED];
  33396. +    int broken;
  33397. +    int use;
  33398. +};
  33399. +
  33400. +extern struct device *init_etherdev(struct device *dev, int sizeof_private,
  33401. +            unsigned long *mem_startp);
  33402. +
  33403. +extern int    ether3_probe(struct device *dev);
  33404. +
  33405. +static int    ether3_probe1(struct device *dev);
  33406. +static int    ether3_open(struct device *dev);
  33407. +static int    ether3_send_packet(struct sk_buff *skb, struct device *dev);
  33408. +static void    ether3_interrupt(int irq, struct pt_regs *regs);
  33409. +static void    ether3_rx(struct device *dev);
  33410. +static void    ether3_tx(struct device *dev);
  33411. +static int    ether3_close(struct device *dev);
  33412. +static struct enet_statistics *ether3_get_stats(struct device *dev);
  33413. +static void    set_multicast_list(struct device *dev, int num_addrs, void *addrs);
  33414. +
  33415. +#endif
  33416. diff -r -u -N linux.orig/arch/arm/drivers/net/loopback.c linux.arm/arch/arm/drivers/net/loopback.c
  33417. --- linux.orig/arch/arm/drivers/net/loopback.c    Thu Jan  1 01:00:00 1970
  33418. +++ linux.arm/arch/arm/drivers/net/loopback.c    Fri Oct 27 23:14:59 1995
  33419. @@ -0,0 +1,140 @@
  33420. +/*
  33421. + * INET        An implementation of the TCP/IP protocol suite for the LINUX
  33422. + *        operating system.  INET is implemented using the  BSD Socket
  33423. + *        interface as the means of communication with the user level.
  33424. + *
  33425. + *        Pseudo-driver for the loopback interface.
  33426. + *
  33427. + * Version:    @(#)loopback.c    1.0.4b    08/16/93
  33428. + *
  33429. + * Authors:    Ross Biro, <bir7@leland.Stanford.Edu>
  33430. + *        Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  33431. + *        Donald Becker, <becker@cesdis.gsfc.nasa.gov>
  33432. + *
  33433. + *        Alan Cox    :    Fixed oddments for NET3.014
  33434. + *
  33435. + *        This program is free software; you can redistribute it and/or
  33436. + *        modify it under the terms of the GNU General Public License
  33437. + *        as published by the Free Software Foundation; either version
  33438. + *        2 of the License, or (at your option) any later version.
  33439. + */
  33440. +#include <linux/config.h>
  33441. +#include <linux/kernel.h>
  33442. +#include <linux/sched.h>
  33443. +#include <linux/interrupt.h>
  33444. +#include <linux/fs.h>
  33445. +#include <linux/types.h>
  33446. +#include <linux/string.h>
  33447. +#include <linux/socket.h>
  33448. +#include <linux/errno.h>
  33449. +#include <linux/fcntl.h>
  33450. +#include <linux/in.h>
  33451. +#include <linux/if_ether.h>    /* For the statistics structure. */
  33452. +
  33453. +#include <asm/system.h>
  33454. +#include <asm/segment.h>
  33455. +#include <asm/io.h>
  33456. +
  33457. +#include <linux/inet.h>
  33458. +#include <linux/netdevice.h>
  33459. +#include <linux/etherdevice.h>
  33460. +#include <linux/skbuff.h>
  33461. +
  33462. +
  33463. +static int
  33464. +loopback_xmit(struct sk_buff *skb, struct device *dev)
  33465. +{
  33466. +  struct enet_statistics *stats = (struct enet_statistics *)dev->priv;
  33467. +  int done;
  33468. +
  33469. +  if (skb == NULL || dev == NULL) return(0);
  33470. +
  33471. +  cli();
  33472. +  if (dev->tbusy != 0) {
  33473. +    sti();
  33474. +    stats->tx_errors++;
  33475. +    return(1);
  33476. +  }
  33477. +  dev->tbusy = 1;
  33478. +  sti();
  33479. +  
  33480. +  /* FIXME: Optimise so buffers with skb->free=1 are not copied but
  33481. +     instead are lobbed from tx queue to rx queue */
  33482. +
  33483. +  done = dev_rint(skb->data, skb->len, 0, dev);
  33484. +  dev_kfree_skb(skb, FREE_WRITE);
  33485. +
  33486. +  while (done != 1) {
  33487. +    done = dev_rint(NULL, 0, 0, dev);
  33488. +  }
  33489. +  stats->tx_packets++;
  33490. +
  33491. +  dev->tbusy = 0;
  33492. +
  33493. +  if (!intr_count && (bh_active & bh_mask)) {
  33494. +    start_bh_atomic();
  33495. +    do_bottom_half();
  33496. +    end_bh_atomic();
  33497. +  }
  33498. +
  33499. +  return(0);
  33500. +}
  33501. +
  33502. +static struct enet_statistics *
  33503. +get_stats(struct device *dev)
  33504. +{
  33505. +    return (struct enet_statistics *)dev->priv;
  33506. +}
  33507. +
  33508. +static int loopback_open(struct device *dev)
  33509. +{
  33510. +    dev->flags|=IFF_LOOPBACK;
  33511. +    return 0;
  33512. +}
  33513. +
  33514. +/* Initialize the rest of the LOOPBACK device. */
  33515. +int
  33516. +loopback_init(struct device *dev)
  33517. +{
  33518. +  int i;
  33519. +
  33520. +  dev->mtu        = 2000;            /* MTU            */
  33521. +  dev->tbusy        = 0;
  33522. +  dev->hard_start_xmit    = loopback_xmit;
  33523. +  dev->open        = NULL;
  33524. +#if 1
  33525. +  dev->hard_header    = eth_header;
  33526. +  dev->hard_header_len    = ETH_HLEN;        /* 14            */
  33527. +  dev->addr_len        = ETH_ALEN;        /* 6            */
  33528. +  dev->type        = ARPHRD_ETHER;        /* 0x0001        */
  33529. +  dev->type_trans    = eth_type_trans;
  33530. +  dev->rebuild_header    = eth_rebuild_header;
  33531. +  dev->open        = loopback_open;
  33532. +#else
  33533. +  dev->hard_header_length = 0;
  33534. +  dev->addr_len        = 0;
  33535. +  dev->type        = 0;            /* loopback_type (0)    */
  33536. +  dev->hard_header    = NULL;
  33537. +  dev->type_trans    = NULL;
  33538. +  dev->rebuild_header    = NULL;
  33539. +#endif
  33540. +
  33541. +  /* New-style flags. */
  33542. +  dev->flags        = IFF_LOOPBACK|IFF_BROADCAST;
  33543. +  dev->family        = AF_INET;
  33544. +#ifdef CONFIG_INET    
  33545. +  dev->pa_addr        = in_aton("127.0.0.1");
  33546. +  dev->pa_brdaddr    = in_aton("127.255.255.255");
  33547. +  dev->pa_mask        = in_aton("255.0.0.0");
  33548. +  dev->pa_alen        = sizeof(unsigned long);
  33549. +#endif  
  33550. +  dev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL);
  33551. +  memset(dev->priv, 0, sizeof(struct enet_statistics));
  33552. +  dev->get_stats = get_stats;
  33553. +
  33554. +  /* Fill in the generic fields of the device structure. */
  33555. +  for (i = 0; i < DEV_NUMBUFFS; i++)
  33556. +    skb_queue_head_init(&dev->buffs[i]);
  33557. +  
  33558. +  return(0);
  33559. +};
  33560. diff -r -u -N linux.orig/arch/arm/drivers/net/net_init.c linux.arm/arch/arm/drivers/net/net_init.c
  33561. --- linux.orig/arch/arm/drivers/net/net_init.c    Thu Jan  1 01:00:00 1970
  33562. +++ linux.arm/arch/arm/drivers/net/net_init.c    Fri Oct 27 23:14:59 1995
  33563. @@ -0,0 +1,320 @@
  33564. +/* netdrv_init.c: Initialization for network devices. */
  33565. +/*
  33566. +    Written 1993,1994,1995 by Donald Becker.
  33567. +
  33568. +    The author may be reached as becker@cesdis.gsfc.nasa.gov or
  33569. +    C/O Center of Excellence in Space Data and Information Sciences
  33570. +        Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  33571. +
  33572. +    This file contains the initialization for the "pl14+" style ethernet
  33573. +    drivers.  It should eventually replace most of drivers/net/Space.c.
  33574. +    It's primary advantage is that it's able to allocate low-memory buffers.
  33575. +    A secondary advantage is that the dangerous NE*000 netcards can reserve
  33576. +    their I/O port region before the SCSI probes start.
  33577. +
  33578. +    Modifications/additions by Bjorn Ekwall <bj0rn@blox.se>:
  33579. +        ethdev_index[MAX_ETH_CARDS]
  33580. +        register_netdev() / unregister_netdev()
  33581. +*/
  33582. +
  33583. +#include <linux/config.h>
  33584. +#include <linux/kernel.h>
  33585. +#include <linux/sched.h>
  33586. +#include <linux/types.h>
  33587. +#include <linux/fs.h>
  33588. +#include <linux/malloc.h>
  33589. +#include <linux/if_ether.h>
  33590. +#include <linux/string.h>
  33591. +#include <linux/netdevice.h>
  33592. +#include <linux/etherdevice.h>
  33593. +
  33594. +/* The network devices currently exist only in the socket namespace, so these
  33595. +   entries are unused.  The only ones that make sense are
  33596. +    open    start the ethercard
  33597. +    close    stop  the ethercard
  33598. +    ioctl    To get statistics, perhaps set the interface port (AUI, BNC, etc.)
  33599. +   One can also imagine getting raw packets using
  33600. +    read & write
  33601. +   but this is probably better handled by a raw packet socket.
  33602. +
  33603. +   Given that almost all of these functions are handled in the current
  33604. +   socket-based scheme, putting ethercard devices in /dev/ seems pointless.
  33605. +   
  33606. +   [Removed all support for /dev network devices. When someone adds
  33607. +    streams then by magic we get them, but otherwise they are un-needed
  33608. +    and a space waste]
  33609. +*/
  33610. +
  33611. +/* The list of used and available "eth" slots (for "eth0", "eth1", etc.) */
  33612. +#define MAX_ETH_CARDS 16 /* same as the number if irq's in irq2dev[] */
  33613. +static struct device *ethdev_index[MAX_ETH_CARDS];
  33614. +
  33615. +unsigned long lance_init(unsigned long mem_start, unsigned long mem_end);
  33616. +unsigned long pi_init(unsigned long mem_start, unsigned long mem_end);
  33617. +unsigned long apricot_init(unsigned long mem_start, unsigned long mem_end);
  33618. +unsigned long dec21040_init(unsigned long mem_start, unsigned long mem_end);
  33619. +
  33620. +/*
  33621. +  net_dev_init() is our network device initialization routine.
  33622. +  It's called from init/main.c with the start and end of free memory,
  33623. +  and returns the new start of free memory.
  33624. +  */
  33625. +
  33626. +unsigned long net_dev_init (unsigned long mem_start, unsigned long mem_end)
  33627. +{
  33628. +
  33629. +    /* Network device initialization for devices that must allocate
  33630. +       low-memory or contiguous DMA buffers.
  33631. +       */
  33632. +#if defined(CONFIG_LANCE)
  33633. +    mem_start = lance_init(mem_start, mem_end);
  33634. +#endif
  33635. +#if defined(CONFIG_PI)
  33636. +    mem_start = pi_init(mem_start, mem_end);
  33637. +#endif    
  33638. +#if defined(CONFIG_DEC_ELCP)
  33639. +    mem_start = dec21040_init(mem_start, mem_end);
  33640. +#endif    
  33641. +    return mem_start;
  33642. +}
  33643. +
  33644. +/* Fill in the fields of the device structure with ethernet-generic values.
  33645. +
  33646. +   If no device structure is passed, a new one is constructed, complete with
  33647. +   a SIZEOF_PRIVATE private data area.
  33648. +
  33649. +   If an empty string area is passed as dev->name, or a new structure is made,
  33650. +   a new name string is constructed.  The passed string area should be 8 bytes
  33651. +   long.
  33652. + */
  33653. +
  33654. +struct device *
  33655. +init_etherdev(struct device *dev, int sizeof_priv, unsigned long *mem_startp)
  33656. +{
  33657. +    int new_device = 0;
  33658. +    int i;
  33659. +
  33660. +    /* Use an existing correctly named device in Space.c:dev_base. */
  33661. +    if (dev == NULL) {
  33662. +        int alloc_size = sizeof(struct device) + sizeof("eth%d  ")
  33663. +            + sizeof_priv + 3;
  33664. +        struct device *cur_dev;
  33665. +        char pname[8];        /* Putative name for the device.  */
  33666. +
  33667. +        for (i = 0; i < MAX_ETH_CARDS; ++i)
  33668. +            if (ethdev_index[i] == NULL) {
  33669. +                sprintf(pname, "eth%d", i);
  33670. +                for (cur_dev = dev_base; cur_dev; cur_dev = cur_dev->next)
  33671. +                    if (strcmp(pname, cur_dev->name) == 0) {
  33672. +                        dev = cur_dev;
  33673. +                        dev->init = NULL;
  33674. +                        sizeof_priv = (sizeof_priv + 3) & ~3;
  33675. +                        if (mem_startp && *mem_startp ) {
  33676. +                            dev->priv = (void*) *mem_startp;
  33677. +                            *mem_startp += sizeof_priv;
  33678. +                        } else
  33679. +                            dev->priv = kmalloc(sizeof_priv, GFP_KERNEL);
  33680. +                        memset(dev->priv, 0, sizeof_priv);
  33681. +                        goto found;
  33682. +                    }
  33683. +            }
  33684. +
  33685. +        alloc_size &= ~3;        /* Round to dword boundary. */
  33686. +
  33687. +        if (mem_startp && *mem_startp ) {
  33688. +            dev = (struct device *)*mem_startp;
  33689. +            *mem_startp += alloc_size;
  33690. +        } else
  33691. +            dev = (struct device *)kmalloc(alloc_size, GFP_KERNEL);
  33692. +        memset(dev, 0, alloc_size);
  33693. +        if (sizeof_priv)
  33694. +            dev->priv = (void *) (dev + 1);
  33695. +        dev->name = sizeof_priv + (char *)(dev + 1);
  33696. +        new_device = 1;
  33697. +    }
  33698. +
  33699. +    found:                        /* From the double loop above. */
  33700. +
  33701. +    if (dev->name &&
  33702. +        ((dev->name[0] == '\0') || (dev->name[0] == ' '))) {
  33703. +        for (i = 0; i < MAX_ETH_CARDS; ++i)
  33704. +            if (ethdev_index[i] == NULL) {
  33705. +                sprintf(dev->name, "eth%d", i);
  33706. +                ethdev_index[i] = dev;
  33707. +                break;
  33708. +            }
  33709. +    }
  33710. +
  33711. +    ether_setup(dev);     /* Hmmm, should this be called here? */
  33712. +    
  33713. +    if (new_device) {
  33714. +        /* Append the device to the device queue. */
  33715. +        struct device **old_devp = &dev_base;
  33716. +        while ((*old_devp)->next)
  33717. +            old_devp = & (*old_devp)->next;
  33718. +        (*old_devp)->next = dev;
  33719. +        dev->next = 0;
  33720. +    }
  33721. +    return dev;
  33722. +}
  33723. +
  33724. +void ether_setup(struct device *dev)
  33725. +{
  33726. +    int i;
  33727. +    /* Fill in the fields of the device structure with ethernet-generic values.
  33728. +       This should be in a common file instead of per-driver.  */
  33729. +    for (i = 0; i < DEV_NUMBUFFS; i++)
  33730. +        skb_queue_head_init(&dev->buffs[i]);
  33731. +
  33732. +    /* register boot-defined "eth" devices */
  33733. +    if (dev->name && (strncmp(dev->name, "eth", 3) == 0)) {
  33734. +        i = simple_strtoul(dev->name + 3, NULL, 0);
  33735. +        if (ethdev_index[i] == NULL) {
  33736. +            ethdev_index[i] = dev;
  33737. +        }
  33738. +        else if (dev != ethdev_index[i]) {
  33739. +            /* Really shouldn't happen! */
  33740. +            printk("ether_setup: Ouch! Someone else took %s\n",
  33741. +                dev->name);
  33742. +        }
  33743. +    }
  33744. +
  33745. +    dev->hard_header    = eth_header;
  33746. +    dev->rebuild_header = eth_rebuild_header;
  33747. +    dev->type_trans = eth_type_trans;
  33748. +
  33749. +    dev->type        = ARPHRD_ETHER;
  33750. +#ifndef __arm__
  33751. +    dev->hard_header_len = ETH_HLEN;
  33752. +#else
  33753. +    dev->hard_header_len = (ETH_HLEN | 3) + 1;
  33754. +#endif
  33755. +    dev->mtu        = 1500; /* eth_mtu */
  33756. +    dev->addr_len    = ETH_ALEN;
  33757. +    for (i = 0; i < ETH_ALEN; i++) {
  33758. +        dev->broadcast[i]=0xff;
  33759. +    }
  33760. +
  33761. +    /* New-style flags. */
  33762. +    dev->flags        = IFF_BROADCAST|IFF_MULTICAST;
  33763. +    dev->family        = AF_INET;
  33764. +    dev->pa_addr    = 0;
  33765. +    dev->pa_brdaddr = 0;
  33766. +    dev->pa_mask    = 0;
  33767. +    dev->pa_alen    = sizeof(unsigned long);
  33768. +}
  33769. +
  33770. +int ether_config(struct device *dev, struct ifmap *map)
  33771. +{
  33772. +    if (map->mem_start != (u_long)(-1))
  33773. +        dev->mem_start = map->mem_start;
  33774. +    if (map->mem_end != (u_long)(-1))
  33775. +        dev->mem_end = map->mem_end;
  33776. +    if (map->base_addr != (u_short)(-1))
  33777. +        dev->base_addr = map->base_addr;
  33778. +    if (map->irq != (u_char)(-1))
  33779. +        dev->irq = map->irq;
  33780. +    if (map->dma != (u_char)(-1))
  33781. +        dev->dma = map->dma;
  33782. +    if (map->port != (u_char)(-1))
  33783. +        dev->if_port = map->port;
  33784. +    return 0;
  33785. +}
  33786. +
  33787. +int register_netdev(struct device *dev)
  33788. +{
  33789. +    struct device *d = dev_base;
  33790. +    unsigned long flags;
  33791. +    int i=MAX_ETH_CARDS;
  33792. +
  33793. +    save_flags(flags);
  33794. +    cli();
  33795. +
  33796. +    if (dev && dev->init) {
  33797. +        if (dev->name &&
  33798. +            ((dev->name[0] == '\0') || (dev->name[0] == ' '))) {
  33799. +            for (i = 0; i < MAX_ETH_CARDS; ++i)
  33800. +                if (ethdev_index[i] == NULL) {
  33801. +                    sprintf(dev->name, "eth%d", i);
  33802. +                    printk("loading device '%s'...\n", dev->name);
  33803. +                    ethdev_index[i] = dev;
  33804. +                    break;
  33805. +                }
  33806. +        }
  33807. +
  33808. +        if (dev->init(dev) != 0) {
  33809. +            if (i < MAX_ETH_CARDS) ethdev_index[i] = NULL;
  33810. +            restore_flags(flags);
  33811. +            return -EIO;
  33812. +        }
  33813. +
  33814. +        /* Add device to end of chain */
  33815. +        if (dev_base) {
  33816. +            while (d->next)
  33817. +                d = d->next;
  33818. +            d->next = dev;
  33819. +        }
  33820. +        else
  33821. +            dev_base = dev;
  33822. +        dev->next = NULL;
  33823. +    }
  33824. +    restore_flags(flags);
  33825. +    return 0;
  33826. +}
  33827. +
  33828. +void unregister_netdev(struct device *dev)
  33829. +{
  33830. +    struct device *d = dev_base;
  33831. +    unsigned long flags;
  33832. +    int i;
  33833. +
  33834. +    save_flags(flags);
  33835. +    cli();
  33836. +
  33837. +    printk("unregister_netdev: device ");
  33838. +
  33839. +    if (dev == NULL) {
  33840. +        printk("was NULL\n");
  33841. +        restore_flags(flags);
  33842. +        return;
  33843. +    }
  33844. +    /* else */
  33845. +    if (dev->start)
  33846. +        printk("'%s' busy\n", dev->name);
  33847. +    else {
  33848. +        if (dev_base == dev)
  33849. +            dev_base = dev->next;
  33850. +        else {
  33851. +            while (d && (d->next != dev))
  33852. +                d = d->next;
  33853. +
  33854. +            if (d && (d->next == dev)) {
  33855. +                d->next = dev->next;
  33856. +                printk("'%s' unlinked\n", dev->name);
  33857. +            }
  33858. +            else {
  33859. +                printk("'%s' not found\n", dev->name);
  33860. +                restore_flags(flags);
  33861. +                return;
  33862. +            }
  33863. +        }
  33864. +        for (i = 0; i < MAX_ETH_CARDS; ++i) {
  33865. +            if (ethdev_index[i] == dev) {
  33866. +                ethdev_index[i] = NULL;
  33867. +                break;
  33868. +            }
  33869. +        }
  33870. +    }
  33871. +    restore_flags(flags);
  33872. +}
  33873. +
  33874. +
  33875. +
  33876. +/*
  33877. + * Local variables:
  33878. + *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c net_init.c"
  33879. + *  version-control: t
  33880. + *  kept-new-versions: 5
  33881. + *  tab-width: 4
  33882. + * End:
  33883. + */
  33884. diff -r -u -N linux.orig/arch/arm/drivers/net/nq8005.c linux.arm/arch/arm/drivers/net/nq8005.c
  33885. --- linux.orig/arch/arm/drivers/net/nq8005.c    Thu Jan  1 01:00:00 1970
  33886. +++ linux.arm/arch/arm/drivers/net/nq8005.c    Fri Oct 27 23:15:00 1995
  33887. @@ -0,0 +1,860 @@
  33888. +/*
  33889. + * linux/drivers/net/ether3.c
  33890. + *
  33891. + * SEEQ nq8005 ethernet driver
  33892. + *
  33893. + */
  33894. +
  33895. +#ifdef MODULE
  33896. +#include <linux/module.h>
  33897. +#include <linux/version.h>
  33898. +#define CLAIM_IRQ_AT_OPEN
  33899. +#else
  33900. +#define MOD_INC_USE_COUNT
  33901. +#define MOD_DEC_USE_COUNT
  33902. +#endif
  33903. +
  33904. +#include <linux/config.h>
  33905. +#include <linux/kernel.h>
  33906. +#include <linux/sched.h>
  33907. +#include <linux/types.h>
  33908. +#include <linux/fcntl.h>
  33909. +#include <linux/interrupt.h>
  33910. +#include <linux/ptrace.h>
  33911. +#include <linux/ioport.h>
  33912. +#include <linux/in.h>
  33913. +#include <linux/malloc.h>
  33914. +#include <linux/string.h>
  33915. +#include <asm/system.h>
  33916. +#include <asm/bitops.h>
  33917. +#include <asm/io.h>
  33918. +#include <asm/dma.h>
  33919. +#include <linux/errno.h>
  33920. +
  33921. +#include <linux/netdevice.h>
  33922. +#include <linux/etherdevice.h>
  33923. +#include <linux/skbuff.h>
  33924. +
  33925. +#include <asm/ecard.h>
  33926. +
  33927. +#include "ether3.h"
  33928. +
  33929. +#define FUNC_PROLOGUE \
  33930. +    struct arc_net *an = (struct arc_net *)dev->priv
  33931. +
  33932. +static unsigned int net_debug = NET_DEBUG;
  33933. +
  33934. +#define tx_done(dev) 0
  33935. +/* ------------------------------------------------------------------------------- */
  33936. +static char *version = "ether3 ethernet driver (c) 1995 R.M.King V1.00\n";
  33937. +
  33938. +#define BUS_16 16
  33939. +#define BUS_8  8
  33940. +
  33941. +extern int inswb(int reg, void *buffer, int len);
  33942. +extern int outswb(int reg, void *buffer, int len);
  33943. +
  33944. +unsigned char def_eth_addr[6] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};
  33945. +
  33946. +static int ether3_prods[] = { 0x00A4 };
  33947. +static int ether3_manus[] = { 0x0011 };
  33948. +
  33949. +/* --------------------------------------------------------------------------- */
  33950. +
  33951. +static void check_dev(struct device *dev, char *s)
  33952. +{
  33953. +    struct device *dev2;
  33954. +
  33955. +    dev2 = dev->next;
  33956. +    
  33957. +    while (dev2 && dev2 != dev)
  33958. +        dev2 = dev2->next;
  33959. +
  33960. +    if (dev2 == dev)
  33961. +        printk("eek! - %s\n", s);
  33962. +}
  33963. +
  33964. +/*
  33965. + * set one of the receive address registers in the chip
  33966. + */
  33967. +
  33968. +static void
  33969. +ether3_setrxaddr(struct device *dev, int address, unsigned char *addr)
  33970. +{
  33971. +    FUNC_PROLOGUE;
  33972. +    unsigned long flags;
  33973. +    int stat, i;
  33974. +
  33975. +    save_flags(flags);
  33976. +    cli();
  33977. +
  33978. +    stat = inw(REG_STATUS);
  33979. +    if(stat & STAT_RXON)
  33980. +        outw(an->regs.command | CMD_RXOFF, REG_COMMAND);
  33981. +
  33982. +    outw(an->regs.config1 | address, REG_CONFIG1);
  33983. +    for(i=0; i<6; i++)
  33984. +        outb(addr[i], REG_BUFWIN);
  33985. +
  33986. +    if(stat & STAT_RXON)
  33987. +        outw(an->regs.command | CMD_RXON, REG_COMMAND);
  33988. +
  33989. +    restore_flags(flags);
  33990. +}
  33991. +
  33992. +/*
  33993. + * write data to the buffer memory
  33994. + */
  33995. +
  33996. +static void
  33997. +ether3_writebuffer(struct device *dev, void *data, int start, int length)
  33998. +{
  33999. +    FUNC_PROLOGUE;
  34000. +    int timeout = 1000000;
  34001. +    if(start != -1)
  34002. +    {
  34003. +        outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34004. +        outw(an->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  34005. +        while((inw(REG_STATUS) & STAT_FIFOEMPTY) == 0)
  34006. +            if(!timeout--)
  34007. +            {
  34008. +                printk("settxlim_16 broken\n");
  34009. +                an->broken = 1;
  34010. +                return;
  34011. +            }
  34012. +        outw(an->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  34013. +        outw(start, REG_DMAADDR);
  34014. +    }
  34015. +    if(length != 0)
  34016. +        outswb(REG_BUFWIN, data, length);
  34017. +}
  34018. +
  34019. +/*
  34020. + * read data from the buffer memory
  34021. + */
  34022. +
  34023. +static void
  34024. +ether3_readbuffer(struct device *dev, void *data, int start, int length)
  34025. +{
  34026. +    FUNC_PROLOGUE;
  34027. +    int timeout = 1000000;
  34028. +    if(start != -1)
  34029. +    {
  34030. +        outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34031. +        outw(an->regs.command | CMD_FIFOWRITE, REG_COMMAND);
  34032. +        while((inw(REG_STATUS) & STAT_FIFOEMPTY) == 0)
  34033. +            if(!timeout--)
  34034. +            {
  34035. +                printk("setrxlim_16 broken\n");
  34036. +                an->broken = 1;
  34037. +                return;
  34038. +            }
  34039. +        outw(start, REG_DMAADDR);
  34040. +        outw(an->regs.command | CMD_FIFOREAD, REG_COMMAND);
  34041. +    }
  34042. +    if(length != 0)
  34043. +        inswb(REG_BUFWIN, data, length);
  34044. +}
  34045. +
  34046. +/* --------------------------------------------------------------------------- */
  34047. +
  34048. +static int
  34049. +ether3_ramtest(struct device *dev, unsigned char byte)
  34050. +{
  34051. +    unsigned char *buffer = kmalloc(RX_END, GFP_KERNEL);
  34052. +    unsigned long flags;
  34053. +    int i,ret=0;
  34054. +    int max_errors = 4;
  34055. +    int bad=-1;
  34056. +
  34057. +    if(!buffer)
  34058. +        return 1;
  34059. +
  34060. +    save_flags(flags);
  34061. +    cli();
  34062. +
  34063. +    memset(buffer, byte, RX_END);
  34064. +    ether3_writebuffer(dev, buffer, 0, TX_END);
  34065. +    ether3_writebuffer(dev, buffer+RX_START, RX_START, RX_LEN);
  34066. +
  34067. +    memset(buffer, byte ^ 0xff, RX_END);
  34068. +    ether3_readbuffer(dev, buffer, 0, TX_END);
  34069. +    ether3_readbuffer(dev, buffer+RX_START, RX_START, RX_LEN);
  34070. +
  34071. +    for(i=0; i<RX_END; i++)
  34072. +    {
  34073. +        if(buffer[i] != byte)
  34074. +        {
  34075. +            if(max_errors>=0 && bad!=buffer[i])
  34076. +            {
  34077. +                printk("%s: RAM failed with (%02X instead of %02X) at 0x%04X",
  34078. +                    dev->name, buffer[i], byte, i);
  34079. +                ret = 2;
  34080. +                max_errors--;
  34081. +                bad=buffer[i];
  34082. +            }
  34083. +        }
  34084. +        else
  34085. +        {
  34086. +            if(bad != -1)
  34087. +            {
  34088. +                printk(" - 0x%04X\n", i);
  34089. +                bad = -1;
  34090. +            }
  34091. +        }
  34092. +    }
  34093. +    if(bad != -1)
  34094. +        printk(" - 0x10000\n");
  34095. +    kfree(buffer);
  34096. +    restore_flags(flags);
  34097. +
  34098. +    return ret;
  34099. +}
  34100. +
  34101. +/* ------------------------------------------------------------------------------- */
  34102. +
  34103. +static int
  34104. +ether3_init_1(struct device *dev)
  34105. +{
  34106. +    outb(0x80, REG_CONFIG2);
  34107. +    outb(0, REG_COMMAND);
  34108. +
  34109. +    outb(1, REG_CONFIG1);
  34110. +    if(inb(REG_CONFIG1+1)==1 && inb(REG_CONFIG1)==0)
  34111. +        return BUS_8;
  34112. +    if(inw(REG_CONFIG1)==0x101)
  34113. +        return BUS_16;
  34114. +    return 0;
  34115. +}
  34116. +
  34117. +static int
  34118. +ether3_init_2(struct device *dev)
  34119. +{
  34120. +    FUNC_PROLOGUE;
  34121. +    unsigned long a=0;
  34122. +    int i;
  34123. +
  34124. +    ether3_setrxaddr(dev, CFG1_BUFSELSTAT0, dev->dev_addr);
  34125. +
  34126. +    an->regs.config1 = CFG1_RECVSPECBROAD|CFG1_RECVCOMPSTAT0|CFG1_DMABURST8;
  34127. +    an->regs.config2 = CFG2_CTRLO|CFG2_RECVCRC|CFG2_ERRENCRC;
  34128. +
  34129. +    outw(an->regs.config1 | CFG1_TRANSEND, REG_CONFIG1);
  34130. +    outw((TX_END>>8) - 1, REG_BUFWIN);
  34131. +    outw(an->regs.recvptr    , REG_RECVPTR);
  34132. +    outw(an->regs.transmitptr    , REG_TRANSMITPTR);
  34133. +    outw(an->regs.recvptr >> 8, REG_RECVEND);
  34134. +    outw(an->regs.config2    , REG_CONFIG2);
  34135. +    outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34136. +    ether3_writebuffer(dev, &a, an->regs.transmitptr, 4);
  34137. +    outw(an->regs.command    , REG_COMMAND);
  34138. +
  34139. +    i = ether3_ramtest(dev, 0x5A);
  34140. +    if(i)
  34141. +        return i;
  34142. +    return ether3_ramtest(dev, 0x1E);
  34143. +}
  34144. +
  34145. +/* This is the real probe routine. */
  34146. +
  34147. +static int
  34148. +ether3_probe1(struct device *dev)
  34149. +{
  34150. +    static unsigned version_printed = 0;
  34151. +    struct arc_net *an;
  34152. +    int i;
  34153. +
  34154. +    if(!dev->priv)
  34155. +        dev->priv = kmalloc(sizeof(struct arc_net), GFP_KERNEL);
  34156. +
  34157. +    if(!dev->priv)
  34158. +        return 1;
  34159. +
  34160. +    an = (struct arc_net *) dev->priv;
  34161. +    memset(an, 0, sizeof(struct arc_net));
  34162. +    an->bus_type    = BUS_16;
  34163. +    an->broken    = 0;
  34164. +
  34165. +    if((an->bus_type=ether3_init_1(dev))==0)
  34166. +    {
  34167. +        kfree(dev->priv);
  34168. +        return 1;
  34169. +    }
  34170. +
  34171. +    if (net_debug  &&  version_printed++ == 0)
  34172. +        printk(version);
  34173. +
  34174. +    printk("%s: ether3 found (bus width %d), ", dev->name, an->bus_type);
  34175. +
  34176. +    /* Retrive and print the ethernet address. */
  34177. +    for (i = 0; i < 6; i++)
  34178. +        printk(i==0?" %2.2x":i==5?":%2.2x\n":":%2.2x", dev->dev_addr[i]);
  34179. +
  34180. +    if(ether3_init_2(dev))
  34181. +    {
  34182. +        kfree(dev->priv);
  34183. +        return 1;
  34184. +    }
  34185. +
  34186. +    dev->open        = ether3_open;
  34187. +    dev->stop        = ether3_close;
  34188. +    dev->hard_start_xmit    = ether3_send_packet;
  34189. +    dev->get_stats            = ether3_get_stats;
  34190. +    dev->set_multicast_list = set_multicast_list;
  34191. +
  34192. +    /* Fill in the fields of the device structure with ethernet values. */
  34193. +    ether_setup(dev);
  34194. +#ifndef CLAIM_IRQ_AT_OPEN
  34195. +    if (request_irq(dev->irq, ether3_interrupt, 0, "ether3")) {
  34196. +        kfree(dev->priv);
  34197. +        return -EAGAIN;
  34198. +    }
  34199. +
  34200. +    irq2dev_map[dev->irq] = dev;
  34201. +#endif
  34202. +    return 0;
  34203. +}
  34204. +
  34205. +/* --------------------------------------------------------------------------- */
  34206. +
  34207. +static void
  34208. +ether3_addr(char *addr, struct expansion_card *ec)
  34209. +{
  34210. +    struct chunk_dir cd;
  34211. +    char *s;
  34212. +    
  34213. +    if(ecard_readchunk(&cd, ec, 0xf5, 0) && (s = strchr(cd.d.string, '(')))
  34214. +    {
  34215. +        int i;
  34216. +        for (i = 0; i<6; i++)
  34217. +        {
  34218. +            addr[i] = simple_strtoul(s + 1, &s, 0x10);
  34219. +            if(*s != (i==5?')' : ':' ))
  34220. +                break;
  34221. +        }
  34222. +        if(i == 6)
  34223. +            return;
  34224. +    }
  34225. +    memcpy(addr, def_eth_addr, 6);
  34226. +}
  34227. +int
  34228. +ether3_probe(struct device *dev)
  34229. +{
  34230. +#ifndef MODULE
  34231. +    struct expansion_card *ec;
  34232. +    unsigned char *eth_addr;
  34233. +    int base_addr;
  34234. +
  34235. +    if(!dev)
  34236. +        return ENODEV;
  34237. +
  34238. +    if((ec = ecard_find(0, sizeof(ether3_prods), ether3_prods, ether3_manus)) == NULL)
  34239. +        return ENODEV;
  34240. +
  34241. +    dev->base_addr    = ((unsigned long)ec->r_podaddr & ~0x003c0000UL) >> 2;
  34242. +    dev->irq    = ec->irq;
  34243. +
  34244. +    ecard_claim (ec);
  34245. +
  34246. +    ether3_addr(dev->dev_addr, ec);
  34247. +#endif
  34248. +    if(ether3_probe1(dev) == 0)
  34249. +        return 0;
  34250. +    return ENODEV;
  34251. +}
  34252. +
  34253. +/* ------------------------------------------------------------------------ */
  34254. +
  34255. +static void
  34256. +ether3_init_for_open(struct device *dev)
  34257. +{
  34258. +    FUNC_PROLOGUE;
  34259. +    unsigned long a=0;
  34260. +
  34261. +    an->regs.command = 0;
  34262. +    outw(CMD_RXOFF|CMD_TXOFF, REG_COMMAND);
  34263. +    while(inw(REG_STATUS) & (STAT_RXON|STAT_TXON));
  34264. +
  34265. +    ether3_setrxaddr(dev, CFG1_BUFSELSTAT0, dev->dev_addr);
  34266. +    an->regs.transmitptr = 0;    /* address that transmitter has processed to */
  34267. +    an->txinsert = 0;        /* address of next available packet for tx */
  34268. +    an->txed = 0;            /* transmitted length index */
  34269. +    an->txto = 0;            /* to transmit length index */
  34270. +    an->tx_ends[0] = 0;
  34271. +    an->use = 0;
  34272. +
  34273. +    an->regs.config2 |= CFG2_CTRLO;
  34274. +
  34275. +    outw(an->regs.config1 | CFG1_TRANSEND, REG_CONFIG1);
  34276. +    outw((TX_END>>8) - 1, REG_BUFWIN);
  34277. +
  34278. +    an->regs.recvptr    = RX_START;
  34279. +    outw(an->regs.recvptr    , REG_RECVPTR);
  34280. +    outw(an->regs.recvptr>>8, REG_RECVEND);
  34281. +
  34282. +    outw(0, REG_TRANSMITPTR);
  34283. +    outw(an->regs.config2 , REG_CONFIG2);
  34284. +    outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34285. +
  34286. +    ether3_writebuffer(dev, &a, an->regs.transmitptr, 4);
  34287. +
  34288. +
  34289. +    an->regs.command = CMD_ENINTRX|CMD_ENINTTX;
  34290. +    outw(an->regs.command | CMD_RXON, REG_COMMAND);
  34291. +}
  34292. +
  34293. +/* Open/initialize the board.  This is called (in the current kernel)
  34294. +   sometime after booting when the 'ifconfig' program is run.
  34295. +
  34296. +   This routine should set everything up anew at each open, even
  34297. +   registers that "should" only need to be set once at boot, so that
  34298. +   there is non-reboot way to recover if something goes wrong.
  34299. +   */
  34300. +static int
  34301. +ether3_open(struct device *dev)
  34302. +{
  34303. +    ether3_init_for_open(dev);
  34304. +
  34305. +#ifdef CLAIM_IRQ_AT_OPEN
  34306. +    if (request_irq(dev->irq, ether3_interrupt, 0, "ether3")) {
  34307. +        kfree(dev->priv);
  34308. +        return -EAGAIN;
  34309. +    }
  34310. +
  34311. +    irq2dev_map[dev->irq] = dev;
  34312. +#endif
  34313. +
  34314. +    MOD_INC_USE_COUNT;
  34315. +
  34316. +    dev->tbusy = 0;
  34317. +    dev->interrupt = 0;
  34318. +    dev->start = 1;
  34319. +    return 0;
  34320. +}
  34321. +
  34322. +static int
  34323. +ether3_send_packet(struct sk_buff *skb, struct device *dev)
  34324. +{
  34325. +    FUNC_PROLOGUE;
  34326. +
  34327. +    if (dev->tbusy) {
  34328. +        /* If we get here, some higher level has decided we are broken.
  34329. +           There should really be a "kick me" function call instead. */
  34330. +        int tickssofar = jiffies - dev->trans_start;
  34331. +        if (tickssofar < 5)
  34332. +            return 1;
  34333. +        printk("%s: transmit timed out, %s?\n", dev->name,
  34334. +               tx_done(dev) ? "IRQ conflict" : "network cable problem");
  34335. +        /* Try to restart the adaptor. */
  34336. +        dev->tbusy = 0;
  34337. +        an->use = 0;
  34338. +        an->regs.config2 |= CFG2_CTRLO;
  34339. +        outw(an->regs.config2 , REG_CONFIG2);
  34340. +        dev->trans_start = jiffies;
  34341. +    }
  34342. +
  34343. +    /* If some higher layer thinks we've missed an tx-done interrupt
  34344. +       we are passed NULL. Caution: dev_tint() handles the cli()/sti()
  34345. +       itself. */
  34346. +    if (skb == NULL) {
  34347. +        dev_tint(dev);
  34348. +        return 0;
  34349. +    }
  34350. +
  34351. +    /* Block a timer-based transmit from overlapping.  This could better be
  34352. +       done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
  34353. +    if (set_bit(0, (void*)&dev->tbusy) != 0)
  34354. +        printk("%s: Transmitter access conflict.\n", dev->name);
  34355. +    else {
  34356. +        short length = ETH_ZLEN < (skb->len-2) ? (skb->len-2) : ETH_ZLEN;
  34357. +        unsigned char *buf = skb->data;
  34358. +        unsigned long flags;
  34359. +        unsigned long thisinfo, nextinfo=0;
  34360. +        int thisdata, thisstart, nextpacket;
  34361. +
  34362. +        if(an->broken)
  34363. +        {
  34364. +          dev_kfree_skb(skb, FREE_WRITE);
  34365. +          an->stats.tx_dropped ++;
  34366. +          return 1;
  34367. +        }
  34368. +
  34369. +        thisstart = an->txinsert;
  34370. +        thisdata = thisstart + 4;
  34371. +        if(thisdata >= TX_END)
  34372. +            thisdata -= TX_END;
  34373. +        nextpacket = thisdata + length;
  34374. +        if(nextpacket >= TX_END)
  34375. +            nextpacket -= TX_END;
  34376. +        an->txinsert = nextpacket;
  34377. +        an->tx_ends[an->txto++] = nextpacket;
  34378. +        if(an->txto >= MAX_TXED)
  34379. +          an->txto = 0;
  34380. +
  34381. +        thisinfo = 0x00E80000 | ((nextpacket >> 8) & 0xff) | ((nextpacket << 8) & 0xff00);
  34382. +
  34383. +        save_flags(flags);
  34384. +        cli();
  34385. +        an->use++;
  34386. +        an->regs.config2 &= ~CFG2_CTRLO;
  34387. +        outw(an->regs.config2 , REG_CONFIG2);
  34388. +
  34389. +        ether3_writebuffer(dev, buf + 2, thisdata, length&1?(length+1):length);
  34390. +        ether3_writebuffer(dev, &nextinfo, -1, 4);
  34391. +        ether3_writebuffer(dev, &thisinfo, thisstart, 4);
  34392. +        restore_flags(flags);
  34393. +
  34394. +        if((inw(REG_STATUS) & STAT_TXON)==0) {
  34395. +          outw(thisstart, REG_TRANSMITPTR);
  34396. +          outw(an->regs.command | CMD_TXON, REG_COMMAND);
  34397. +        }
  34398. +        dev->trans_start = jiffies;
  34399. +    }
  34400. +    dev_kfree_skb (skb, FREE_WRITE);
  34401. +
  34402. +    /* You might need to clean up and record Tx statistics here. */
  34403. +
  34404. +    return 0;
  34405. +}
  34406. +
  34407. +/* The typical workload of the driver:
  34408. +   Handle the network interface interrupts. */
  34409. +static void
  34410. +ether3_interrupt(int irq, struct pt_regs *regs)
  34411. +{
  34412. +    struct device *dev = (struct device *)(irq2dev_map[irq]);
  34413. +    struct arc_net *an = (struct arc_net *)dev->priv;
  34414. +    int status, boguscount = 0, done = 0;
  34415. +#if NET_DEBUG > 1
  34416. +    if(net_debug & DEBUG_INT)
  34417. +             printk("ether3_interrupt: irq %d\n", irq);
  34418. +#endif
  34419. +
  34420. +    if (dev == NULL) {
  34421. +        printk ("ether3_interrupt(): irq %d for unknown device.\n", irq);
  34422. +        return;
  34423. +    }
  34424. +    dev->interrupt = 1;
  34425. +
  34426. +    do {
  34427. +        status = inw(REG_STATUS);
  34428. +        if (status & STAT_INTRX) {
  34429. +            /* Got a packet(s). */
  34430. +            ether3_rx(dev);
  34431. +            done = 1;
  34432. +        }
  34433. +        if (status & STAT_INTTX) {
  34434. +            ether3_tx(dev);
  34435. +            done = 1;
  34436. +        }
  34437. +        outw((status & (STAT_INTRX|STAT_INTTX|STAT_INTBUFWIN))
  34438. +          | an->regs.command, REG_COMMAND);
  34439. +    } while (++boguscount < 20 && !done) ;
  34440. +
  34441. +    dev->interrupt = 0;
  34442. +
  34443. +#if NET_DEBUG > 1
  34444. +    if(net_debug & DEBUG_INT)
  34445. +             printk("ether3_interrupt: done\n", irq);
  34446. +#endif
  34447. +}
  34448. +
  34449. +/* We have a good packet(s), get it/them out of the buffers. */
  34450. +static void
  34451. +ether3_rx(struct device *dev)
  34452. +{
  34453. +    FUNC_PROLOGUE;
  34454. +    struct sk_buff *skb=NULL;
  34455. +    unsigned int end;
  34456. +    unsigned int length;
  34457. +
  34458. +    an->use++;
  34459. +    if(an->use == 1)
  34460. +    {
  34461. +        an->regs.config2 &= ~CFG2_CTRLO;
  34462. +        outw(an->regs.config2 , REG_CONFIG2);
  34463. +    }
  34464. +    do {
  34465. +        unsigned char buffer[20];
  34466. +        ether3_readbuffer(dev, buffer, an->regs.recvptr, 20);
  34467. +
  34468. +        if(buffer[0] == 0 || (buffer[3] & 0x80)==0)
  34469. +            goto rx_fin;
  34470. +#if NET_DEBUG > 1
  34471. +        if(net_debug & DEBUG_RX) {
  34472. +        {
  34473. +            int i;
  34474. +            printk("ether3_rx:", an->regs.recvptr);
  34475. +            for(i=3; i<18; i++)
  34476. +                printk("%02X ",(unsigned int)buffer[i]);
  34477. +            printk("\n");
  34478. +        }
  34479. +#endif
  34480. +
  34481. +        end = (buffer[0]<<8) | buffer[1];
  34482. +
  34483. +        if((buffer[2] & 0xC0) != 0x40)
  34484. +          /* no data follows */
  34485. +          goto done;
  34486. +
  34487. +        if(buffer[3] & 15) {
  34488. +            an->stats.rx_errors++;
  34489. +            if(buffer[3] & 1) an->stats.rx_fifo_errors ++;
  34490. +            if(buffer[3] & 2) an->stats.rx_crc_errors ++;
  34491. +            if(buffer[3] & 4) an->stats.rx_fifo_errors ++;
  34492. +            if(buffer[3] & 8) an->stats.rx_length_errors ++;
  34493. +            goto done;
  34494. +        }
  34495. +
  34496. +        if(end > an->regs.recvptr)
  34497. +            length = end - an->regs.recvptr;
  34498. +        else
  34499. +            length = (end - RX_START) + (RX_END - an->regs.recvptr);
  34500. +
  34501. +        skb = alloc_skb(length + 4, GFP_ATOMIC);
  34502. +        if(skb == NULL) {
  34503. +            printk("%s: memory squeeze, dropping packet.\n", dev->name);
  34504. +            an->stats.rx_dropped++;
  34505. +            an->regs.recvptr = end;
  34506. +            outw(an->regs.recvptr >> 8, REG_RECVEND);
  34507. +            goto rx_fin;
  34508. +        }
  34509. +
  34510. +        skb->len = length - 4;
  34511. +        skb->dev = dev;
  34512. +        memcpy(skb->data + 2, buffer + 4, 20-4);
  34513. +        ether3_readbuffer(dev, skb->data+18, -1, length-20);
  34514. +    done:
  34515. +        an->regs.recvptr = end;
  34516. +        outw(an->regs.recvptr >> 8, REG_RECVEND);
  34517. +        if(skb) {
  34518. +            netif_rx(skb);
  34519. +            skb=NULL;
  34520. +            an->stats.rx_packets++;
  34521. +        }
  34522. +    }
  34523. +    while(inw(REG_STATUS) & STAT_RXON);
  34524. +
  34525. +    outw(an->regs.recvptr, REG_RECVPTR);
  34526. +    outw(an->regs.command | CMD_RXON, REG_COMMAND);
  34527. +
  34528. +    /* If any worth-while packets have been received, dev_rint()
  34529. +       has done a mark_bh(NET_BH) for us and will work on them
  34530. +       when we get to the bottom-half routine. */
  34531. +rx_fin:
  34532. +    if(an->use)
  34533. +    {
  34534. +        an->use--;
  34535. +        if(an->use == 0)
  34536. +        {
  34537. +            an->regs.config2 |= CFG2_CTRLO;
  34538. +            outw(an->regs.config2 , REG_CONFIG2);
  34539. +        }
  34540. +    }
  34541. +}
  34542. +
  34543. +/* ----------------------------------------------------------------------------- */
  34544. +
  34545. +static void
  34546. +ether3_tx(struct device *dev)
  34547. +{
  34548. +    FUNC_PROLOGUE;
  34549. +    unsigned char buffer[4];
  34550. +
  34551. +    if(an->regs.transmitptr + 4 > TX_END) {
  34552. +        int len = TX_END - an->regs.transmitptr;
  34553. +        ether3_readbuffer(dev, buffer, an->regs.transmitptr, len);
  34554. +        ether3_readbuffer(dev, buffer+len, 0, 4 - len);
  34555. +    }
  34556. +    else
  34557. +        ether3_readbuffer(dev, buffer, an->regs.transmitptr, 4);
  34558. +
  34559. +    if(!(buffer[3] & 0x80))
  34560. +        return;
  34561. +
  34562. +    if(buffer[3] & 7) {
  34563. +        if(buffer[3] & 5) an->stats.tx_errors ++;
  34564. +        if(buffer[3] & 4) an->stats.collisions += 16;
  34565. +        if(buffer[3] & 2) an->stats.collisions += (buffer[3] & 0x78)>>3;
  34566. +        if(buffer[3] & 1) an->stats.tx_fifo_errors ++;
  34567. +    }
  34568. +    if(!(buffer[3] & 5))
  34569. +        an->stats.tx_packets++;
  34570. +
  34571. +    an->regs.transmitptr = an->tx_ends[an->txed++];
  34572. +    if(an->txed >= MAX_TXED)
  34573. +        an->txed = 0;
  34574. +    if(an->regs.transmitptr >= TX_END)
  34575. +        an->regs.transmitptr -= TX_END;
  34576. +/* if(an->regs.transmitptr != ((buffer[0]<<8)|buffer[1])) */
  34577. +/* printk("%p:%p\n",an->regs.transmitptr, (buffer[2]<<24)|(buffer[3]<<16)|(buffer[0]<<8)|buffer[1]); */
  34578. +    dev->tbusy = 0;
  34579. +    mark_bh(NET_BH);    /* Inform upper layers. */
  34580. +    if(an->use)
  34581. +    {
  34582. +        an->use--;
  34583. +        if(an->use == 0)
  34584. +        {
  34585. +            an->regs.config2 |= CFG2_CTRLO;
  34586. +            outw(an->regs.config2 , REG_CONFIG2);
  34587. +        }
  34588. +    }
  34589. +}
  34590. +
  34591. +/* The inverse routine to net_open(). */
  34592. +static int
  34593. +ether3_close(struct device *dev)
  34594. +{
  34595. +    FUNC_PROLOGUE;
  34596. +    unsigned long flags;
  34597. +
  34598. +    dev->tbusy = 1;
  34599. +    dev->start = 0;
  34600. +
  34601. +    save_flags(flags);
  34602. +    cli();
  34603. +
  34604. +    outw(CMD_RXOFF|CMD_TXOFF, REG_COMMAND);
  34605. +    an->regs.command = 0;
  34606. +    while(inw(REG_STATUS) & (STAT_RXON|STAT_TXON));
  34607. +    ether3_init_1(dev);
  34608. +
  34609. +    restore_flags(flags);
  34610. +
  34611. +    /* Flush the Tx */
  34612. +#ifdef CLAIM_IRQ_AT_OPEN
  34613. +    free_irq(dev->irq);
  34614. +
  34615. +    irq2dev_map[dev->irq] = NULL;
  34616. +#endif
  34617. +
  34618. +    MOD_DEC_USE_COUNT;
  34619. +
  34620. +    return 0;
  34621. +
  34622. +}
  34623. +
  34624. +/* Get the current statistics.    This may be called with the card open or
  34625. +   closed. */
  34626. +static struct enet_statistics *
  34627. +ether3_get_stats(struct device *dev)
  34628. +{
  34629. +    FUNC_PROLOGUE;
  34630. +    return &an->stats;
  34631. +}
  34632. +
  34633. +/* Set or clear the multicast filter for this adaptor.
  34634. +   num_addrs == -1    Promiscuous mode, receive all packets
  34635. +   num_addrs == 0    Normal mode, clear multicast list
  34636. +   num_addrs > 0    Multicast mode, receive normal and MC packets, and do
  34637. +            best-effort filtering.
  34638. + */
  34639. +static void
  34640. +set_multicast_list(struct device *dev, int num_addrs, void *addrs)
  34641. +{
  34642. +    FUNC_PROLOGUE;
  34643. +
  34644. +    if(num_addrs == -1)
  34645. +        an->regs.config1 |= CFG1_RECVPROMISC;
  34646. +    else
  34647. +        an->regs.config1 = (an->regs.config1 & ~CFG1_RECVPROMISC)
  34648. +                    | CFG1_RECVSPECBROAD;
  34649. +
  34650. +    outw(an->regs.config1 | CFG1_LOCBUFMEM, REG_CONFIG1);
  34651. +}
  34652. +
  34653. +#ifdef MODULE
  34654. +char kernel_version[] = UTS_RELEASE;
  34655. +static struct device ether3 = {
  34656. +    "        ",
  34657. +    0, 0, 0, 0,
  34658. +    0, 0,
  34659. +    0, 0, 0, NULL, ether3_probe
  34660. +};
  34661. +
  34662. +char *ethernames[4] = {
  34663. +    "        ",
  34664. +    "        ",
  34665. +    "        ",
  34666. +    "        "
  34667. +};
  34668. +static struct device *my_ethers[4];
  34669. +static struct expansion_card *ec[4];
  34670. +
  34671. +int
  34672. +init_module(void)
  34673. +{
  34674. +    int i;
  34675. +
  34676. +    for(i = 0; i < 4; i++)
  34677. +    {
  34678. +        my_ethers[i] = NULL;
  34679. +        ec[i] = NULL;
  34680. +    }
  34681. +
  34682. +    i = 0;
  34683. +
  34684. +    do
  34685. +    {
  34686. +        if ((ec[i] = ecard_find(0, sizeof(ether3_prods), ether3_prods, ether3_manus)) == NULL)
  34687. +            break;
  34688. +
  34689. +        my_ethers[i] = (struct device *)kmalloc(sizeof(struct device), GFP_KERNEL);
  34690. +        memset(my_ethers[i], 0, sizeof(struct device));
  34691. +
  34692. +        my_ethers[i]->irq = ec[i]->irq;
  34693. +        my_ethers[i]->base_addr= ((unsigned long)ec[i]->r_podaddr & ~0x003c0000UL)>>2;
  34694. +        my_ethers[i]->init = ether3_probe;
  34695. +        my_ethers[i]->name = ethernames[i];
  34696. +
  34697. +        ether3_addr(my_ethers[i]->dev_addr, ec[i]);
  34698. +
  34699. +        ecard_claim(ec[i]);
  34700. +
  34701. +        if(register_netdev(my_ethers[i]) != 0)
  34702. +        {
  34703. +            for (i = 0; i < 4; i++)
  34704. +            {
  34705. +                if(my_ethers[i])
  34706. +                {
  34707. +                    kfree(my_ethers[i]);
  34708. +                    my_ethers[i] = NULL;
  34709. +                }
  34710. +                if(ec[i])
  34711. +                {
  34712. +                    ecard_release(ec[i]);
  34713. +                    ec[i] = NULL;
  34714. +                }
  34715. +            }
  34716. +            return -EIO;
  34717. +        }
  34718. +        i++;
  34719. +    }
  34720. +    while(i < 4);
  34721. +
  34722. +    return i != 0 ? 0 : -ENODEV;
  34723. +}
  34724. +
  34725. +void
  34726. +cleanup_module(void)
  34727. +{
  34728. +    if (MOD_IN_USE) {
  34729. +        printk("%s: device busy, remove delayed\n", ether3.name);
  34730. +    } else {
  34731. +        int i;
  34732. +        for(i = 0; i < 4; i++)
  34733. +        {
  34734. +            if(my_ethers[i])
  34735. +            {
  34736. +                unregister_netdev(my_ethers[i]);
  34737. +                my_ethers[i] = NULL;
  34738. +            }
  34739. +            if(ec[i])
  34740. +            {
  34741. +                ecard_release(ec[i]);
  34742. +                ec[i] = NULL;
  34743. +            }
  34744. +        }
  34745. +    }
  34746. +}
  34747. +#endif /* MODULE */
  34748. diff -r -u -N linux.orig/arch/arm/drivers/net/plip.c linux.arm/arch/arm/drivers/net/plip.c
  34749. --- linux.orig/arch/arm/drivers/net/plip.c    Thu Jan  1 01:00:00 1970
  34750. +++ linux.arm/arch/arm/drivers/net/plip.c    Fri Oct 27 23:15:01 1995
  34751. @@ -0,0 +1,1104 @@
  34752. +/* $Id: plip.c,v 1.12 1995/02/11 10:26:05 gniibe Exp $ */
  34753. +/* PLIP: A parallel port "network" driver for Linux. */
  34754. +/* This driver is for parallel port with 5-bit cable (LapLink (R) cable). */
  34755. +/*
  34756. + * Authors:    Donald Becker,  <becker@super.org>
  34757. + *        Tommy Thorn, <thorn@daimi.aau.dk>
  34758. + *        Tanabe Hiroyasu, <hiro@sanpo.t.u-tokyo.ac.jp>
  34759. + *        Alan Cox, <gw4pts@gw4pts.ampr.org>
  34760. + *        Peter Bauer, <100136.3530@compuserve.com>
  34761. + *        Niibe Yutaka, <gniibe@mri.co.jp>
  34762. + *
  34763. + *        Modularization and ifreq/ifmap support by Alan Cox.
  34764. + *        Rewritten by Niibe Yutaka.
  34765. + *
  34766. + *        This program is free software; you can redistribute it and/or
  34767. + *        modify it under the terms of the GNU General Public License
  34768. + *        as published by the Free Software Foundation; either version
  34769. + *        2 of the License, or (at your option) any later version.
  34770. + */
  34771. +
  34772. +/*
  34773. + * Original version and the name 'PLIP' from Donald Becker <becker@super.org>
  34774. + * inspired by Russ Nelson's parallel port packet driver.
  34775. + *
  34776. + * NOTE:
  34777. + *     Tanabe Hiroyasu had changed the protocol, and it was in Linux v1.0.
  34778. + *     Because of the necessity to communicate to DOS machines with the
  34779. + *     Crynwr packet driver, Peter Bauer changed the protocol again
  34780. + *     back to original protocol.
  34781. + *
  34782. + *     This version follows original PLIP protocol. 
  34783. + *     So, this PLIP can't communicate the PLIP of Linux v1.0.
  34784. + */
  34785. +
  34786. +static char *version = "NET3 PLIP version 2.0 gniibe@mri.co.jp\n";
  34787. +
  34788. +/*
  34789. +  Sources:
  34790. +    Ideas and protocols came from Russ Nelson's <nelson@crynwr.com>
  34791. +    "parallel.asm" parallel port packet driver.
  34792. +
  34793. +  The "Crynwr" parallel port standard specifies the following protocol:
  34794. +    Trigger by sending '0x08' (this cause interrupt on other end)
  34795. +    count-low octet
  34796. +    count-high octet
  34797. +    ... data octets
  34798. +    checksum octet
  34799. +  Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)>
  34800. +            <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)>
  34801. +
  34802. +  The packet is encapsulated as if it were ethernet.
  34803. +
  34804. +  The cable used is a de facto standard parallel null cable -- sold as
  34805. +  a "LapLink" cable by various places.  You'll need a 12-conductor cable to
  34806. +  make one yourself.  The wiring is:
  34807. +    SLCTIN    17 - 17
  34808. +    GROUND    25 - 25
  34809. +    D0->ERROR    2 - 15        15 - 2
  34810. +    D1->SLCT    3 - 13        13 - 3
  34811. +    D2->PAPOUT    4 - 12        12 - 4
  34812. +    D3->ACK    5 - 10        10 - 5
  34813. +    D4->BUSY    6 - 11        11 - 6
  34814. +  Do not connect the other pins.  They are
  34815. +    D5,D6,D7 are 7,8,9
  34816. +    STROBE is 1, FEED is 14, INIT is 16
  34817. +    extra grounds are 18,19,20,21,22,23,24
  34818. +*/
  34819. +
  34820. +#ifdef MODULE
  34821. +#include <linux/module.h>
  34822. +#include <linux/version.h>
  34823. +#else
  34824. +#define MOD_INC_USE_COUNT
  34825. +#define MOD_DEC_USE_COUNT
  34826. +#endif
  34827. +
  34828. +#include <linux/kernel.h>
  34829. +#include <linux/sched.h>
  34830. +#include <linux/types.h>
  34831. +#include <linux/fcntl.h>
  34832. +#include <linux/interrupt.h>
  34833. +#include <linux/string.h>
  34834. +#include <linux/ptrace.h>
  34835. +#include <linux/if_ether.h>
  34836. +#include <asm/system.h>
  34837. +#include <asm/io.h>
  34838. +#include <linux/in.h>
  34839. +#include <linux/errno.h>
  34840. +#include <linux/delay.h>
  34841. +#include <linux/lp.h>
  34842. +
  34843. +#include <linux/netdevice.h>
  34844. +#include <linux/etherdevice.h>
  34845. +#include <linux/skbuff.h>
  34846. +#include <linux/if_plip.h>
  34847. +
  34848. +#include <linux/tqueue.h>
  34849. +#include <linux/ioport.h>
  34850. +#include <asm/bitops.h>
  34851. +#include <asm/irq.h>
  34852. +#include <asm/byteorder.h>
  34853. +
  34854. +/* Use 0 for production, 1 for verification, >2 for debug */
  34855. +#ifndef NET_DEBUG
  34856. +#define NET_DEBUG 1
  34857. +#endif
  34858. +static unsigned int net_debug = NET_DEBUG;
  34859. +
  34860. +/* In micro second */
  34861. +#define PLIP_DELAY_UNIT           1
  34862. +
  34863. +/* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
  34864. +#define PLIP_TRIGGER_WAIT     500
  34865. +
  34866. +/* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
  34867. +#define PLIP_NIBBLE_WAIT        3000
  34868. +
  34869. +#define PAR_INTR_ON        (LP_PINITP|LP_PSELECP|LP_PINTEN)
  34870. +#define PAR_INTR_OFF        (LP_PINITP|LP_PSELECP)
  34871. +#define PAR_DATA(dev)        ((dev)->base_addr+0)
  34872. +#define PAR_STATUS(dev)        ((dev)->base_addr+1)
  34873. +#define PAR_CONTROL(dev)    ((dev)->base_addr+2)
  34874. +
  34875. +/* Bottom halfs */
  34876. +static void plip_kick_bh(struct device *dev);
  34877. +static void plip_bh(struct device *dev);
  34878. +
  34879. +/* Interrupt handler */
  34880. +static void plip_interrupt(int irq, struct pt_regs *regs);
  34881. +
  34882. +/* Functions for DEV methods */
  34883. +static int plip_rebuild_header(void *buff, struct device *dev,
  34884. +                   unsigned long raddr, struct sk_buff *skb);
  34885. +static int plip_tx_packet(struct sk_buff *skb, struct device *dev);
  34886. +static int plip_open(struct device *dev);
  34887. +static int plip_close(struct device *dev);
  34888. +static struct enet_statistics *plip_get_stats(struct device *dev);
  34889. +static int plip_config(struct device *dev, struct ifmap *map);
  34890. +static int plip_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
  34891. +
  34892. +enum plip_connection_state {
  34893. +    PLIP_CN_NONE=0,
  34894. +    PLIP_CN_RECEIVE,
  34895. +    PLIP_CN_SEND,
  34896. +    PLIP_CN_CLOSING,
  34897. +    PLIP_CN_ERROR
  34898. +};
  34899. +
  34900. +enum plip_packet_state {
  34901. +    PLIP_PK_DONE=0,
  34902. +    PLIP_PK_TRIGGER,
  34903. +    PLIP_PK_LENGTH_LSB,
  34904. +    PLIP_PK_LENGTH_MSB,
  34905. +    PLIP_PK_DATA,
  34906. +    PLIP_PK_CHECKSUM
  34907. +};
  34908. +
  34909. +enum plip_nibble_state {
  34910. +    PLIP_NB_BEGIN,
  34911. +    PLIP_NB_1,
  34912. +    PLIP_NB_2,
  34913. +};
  34914. +
  34915. +struct plip_local {
  34916. +    enum plip_packet_state state;
  34917. +    enum plip_nibble_state nibble;
  34918. +    union {
  34919. +        struct {
  34920. +#if defined(LITTLE_ENDIAN)
  34921. +            unsigned char lsb;
  34922. +            unsigned char msb;
  34923. +#elif defined(BIG_ENDIAN)
  34924. +            unsigned char msb;
  34925. +            unsigned char lsb;
  34926. +#else
  34927. +#error    "Please fix endianness defines in <asm/byteorder.h>"
  34928. +#endif                        
  34929. +        } b;
  34930. +        unsigned short h;
  34931. +    } length;
  34932. +    unsigned short byte;
  34933. +    unsigned char  checksum;
  34934. +    unsigned char  data;
  34935. +    struct sk_buff *skb;
  34936. +};
  34937. +
  34938. +struct net_local {
  34939. +    struct enet_statistics enet_stats;
  34940. +    struct tq_struct immediate;
  34941. +    struct tq_struct deferred;
  34942. +    struct plip_local snd_data;
  34943. +    struct plip_local rcv_data;
  34944. +    unsigned long  trigger;
  34945. +    unsigned long  nibble;
  34946. +    enum plip_connection_state connection;
  34947. +    unsigned short timeout_count;
  34948. +    char is_deferred;
  34949. +    int (*orig_rebuild_header)(void *eth, struct device *dev,
  34950. +                   unsigned long raddr, struct sk_buff *skb);
  34951. +};
  34952. +
  34953. +/* Entry point of PLIP driver.
  34954. +   Probe the hardware, and register/initialize the driver. */
  34955. +int
  34956. +plip_init(struct device *dev)
  34957. +{
  34958. +    struct net_local *nl;
  34959. +
  34960. +    /* Check region before the probe */
  34961. +    if (check_region(PAR_DATA(dev), 3) < 0)
  34962. +        return -ENODEV;
  34963. +
  34964. +    /* Check that there is something at base_addr. */
  34965. +    outb(0, PAR_DATA(dev));
  34966. +    udelay(1000);
  34967. +    if (inb(PAR_DATA(dev)) != 0)
  34968. +        return -ENODEV;
  34969. +
  34970. +    printk(version);
  34971. +    printk("%s: Parallel port at %#3lx, ", dev->name, dev->base_addr);
  34972. +    if (dev->irq) {
  34973. +        printk("using assigned IRQ %d.\n", dev->irq);
  34974. +    } else {
  34975. +        int irq = 0;
  34976. +#ifdef MODULE
  34977. +        /* dev->irq==0 means autoprobe, but we don't try to do so
  34978. +           with module.  We can change it by ifconfig */
  34979. +#else
  34980. +        unsigned int irqs = probe_irq_on();
  34981. +
  34982. +        outb(0x00, PAR_CONTROL(dev));
  34983. +        udelay(1000);
  34984. +        outb(PAR_INTR_OFF, PAR_CONTROL(dev));
  34985. +        outb(PAR_INTR_ON, PAR_CONTROL(dev));
  34986. +        outb(PAR_INTR_OFF, PAR_CONTROL(dev));
  34987. +        udelay(1000);
  34988. +        irq = probe_irq_off(irqs);
  34989. +#endif
  34990. +        if (irq > 0) {
  34991. +            dev->irq = irq;
  34992. +            printk("using probed IRQ %d.\n", dev->irq);
  34993. +        } else
  34994. +            printk("failed to detect IRQ(%d) --"
  34995. +                   " Please set IRQ by ifconfig.\n", irq);
  34996. +    }
  34997. +
  34998. +    request_region(PAR_DATA(dev), 3, dev->name);
  34999. +
  35000. +    /* Fill in the generic fields of the device structure. */
  35001. +    ether_setup(dev);
  35002. +
  35003. +    /* Then, override parts of it */
  35004. +    dev->hard_start_xmit    = plip_tx_packet;
  35005. +    dev->open        = plip_open;
  35006. +    dev->stop        = plip_close;
  35007. +    dev->get_stats         = plip_get_stats;
  35008. +    dev->set_config        = plip_config;
  35009. +    dev->do_ioctl        = plip_ioctl;
  35010. +    dev->flags            = IFF_POINTOPOINT|IFF_NOARP;
  35011. +
  35012. +    /* Set the private structure */
  35013. +    dev->priv = kmalloc(sizeof (struct net_local), GFP_KERNEL);
  35014. +    if (dev->priv == NULL)
  35015. +        return EAGAIN;
  35016. +    memset(dev->priv, 0, sizeof(struct net_local));
  35017. +    nl = (struct net_local *) dev->priv;
  35018. +
  35019. +    nl->orig_rebuild_header = dev->rebuild_header;
  35020. +    dev->rebuild_header     = plip_rebuild_header;
  35021. +
  35022. +    /* Initialize constants */
  35023. +    nl->trigger    = PLIP_TRIGGER_WAIT;
  35024. +    nl->nibble    = PLIP_NIBBLE_WAIT;
  35025. +
  35026. +    /* Initialize task queue structures */
  35027. +    nl->immediate.next = &tq_last;
  35028. +    nl->immediate.sync = 0;
  35029. +    nl->immediate.routine = (void *)(void *)plip_bh;
  35030. +    nl->immediate.data = dev;
  35031. +
  35032. +    nl->deferred.next = &tq_last;
  35033. +    nl->deferred.sync = 0;
  35034. +    nl->deferred.routine = (void *)(void *)plip_kick_bh;
  35035. +    nl->deferred.data = dev;
  35036. +
  35037. +    return 0;
  35038. +}
  35039. +
  35040. +/* Bottom half handler for the delayed request.
  35041. +   This routine is kicked by do_timer().
  35042. +   Request `plip_bh' to be invoked. */
  35043. +static void
  35044. +plip_kick_bh(struct device *dev)
  35045. +{
  35046. +    struct net_local *nl = (struct net_local *)dev->priv;
  35047. +
  35048. +    if (nl->is_deferred) {
  35049. +        queue_task(&nl->immediate, &tq_immediate);
  35050. +        mark_bh(IMMEDIATE_BH);
  35051. +    }
  35052. +}
  35053. +
  35054. +/* Forward declarations of internal routines */
  35055. +static int plip_none(struct device *, struct net_local *,
  35056. +             struct plip_local *, struct plip_local *);
  35057. +static int plip_receive_packet(struct device *, struct net_local *,
  35058. +                   struct plip_local *, struct plip_local *);
  35059. +static int plip_send_packet(struct device *, struct net_local *,
  35060. +                struct plip_local *, struct plip_local *);
  35061. +static int plip_connection_close(struct device *, struct net_local *,
  35062. +                 struct plip_local *, struct plip_local *);
  35063. +static int plip_error(struct device *, struct net_local *,
  35064. +              struct plip_local *, struct plip_local *);
  35065. +static int plip_bh_timeout_error(struct device *dev, struct net_local *nl,
  35066. +                 struct plip_local *snd,
  35067. +                 struct plip_local *rcv,
  35068. +                 int error);
  35069. +
  35070. +#define OK        0
  35071. +#define TIMEOUT   1
  35072. +#define ERROR     2
  35073. +
  35074. +typedef int (*plip_func)(struct device *dev, struct net_local *nl,
  35075. +             struct plip_local *snd, struct plip_local *rcv);
  35076. +
  35077. +static plip_func connection_state_table[] =
  35078. +{
  35079. +    plip_none,
  35080. +    plip_receive_packet,
  35081. +    plip_send_packet,
  35082. +    plip_connection_close,
  35083. +    plip_error
  35084. +};
  35085. +
  35086. +/* Bottom half handler of PLIP. */
  35087. +static void
  35088. +plip_bh(struct device *dev)
  35089. +{
  35090. +    struct net_local *nl = (struct net_local *)dev->priv;
  35091. +    struct plip_local *snd = &nl->snd_data;
  35092. +    struct plip_local *rcv = &nl->rcv_data;
  35093. +    plip_func f;
  35094. +    int r;
  35095. +
  35096. +    nl->is_deferred = 0;
  35097. +    f = connection_state_table[nl->connection];
  35098. +    if ((r = (*f)(dev, nl, snd, rcv)) != OK
  35099. +        && (r = plip_bh_timeout_error(dev, nl, snd, rcv, r)) != OK) {
  35100. +        nl->is_deferred = 1;
  35101. +        queue_task(&nl->deferred, &tq_timer);
  35102. +    }
  35103. +}
  35104. +
  35105. +static int
  35106. +plip_bh_timeout_error(struct device *dev, struct net_local *nl,
  35107. +              struct plip_local *snd, struct plip_local *rcv,
  35108. +              int error)
  35109. +{
  35110. +    unsigned char c0;
  35111. +
  35112. +    cli();
  35113. +    if (nl->connection == PLIP_CN_SEND) {
  35114. +
  35115. +        if (error != ERROR) { /* Timeout */
  35116. +            nl->timeout_count++;
  35117. +            if ((snd->state == PLIP_PK_TRIGGER
  35118. +                 && nl->timeout_count <= 10)
  35119. +                || nl->timeout_count <= 3) {
  35120. +                sti();
  35121. +                /* Try again later */
  35122. +                return TIMEOUT;
  35123. +            }
  35124. +            c0 = inb(PAR_STATUS(dev));
  35125. +            printk("%s: transmit timeout(%d,%02x)\n",
  35126. +                   dev->name, snd->state, c0);
  35127. +        }
  35128. +        nl->enet_stats.tx_errors++;
  35129. +        nl->enet_stats.tx_aborted_errors++;
  35130. +    } else if (nl->connection == PLIP_CN_RECEIVE) {
  35131. +        if (rcv->state == PLIP_PK_TRIGGER) {
  35132. +            /* Transmission was interrupted. */
  35133. +            sti();
  35134. +            return OK;
  35135. +        }
  35136. +        if (error != ERROR) { /* Timeout */
  35137. +            if (++nl->timeout_count <= 3) {
  35138. +                sti();
  35139. +                /* Try again later */
  35140. +                return TIMEOUT;
  35141. +            }
  35142. +            c0 = inb(PAR_STATUS(dev));
  35143. +            printk("%s: receive timeout(%d,%02x)\n",
  35144. +                   dev->name, rcv->state, c0);
  35145. +        }
  35146. +        nl->enet_stats.rx_dropped++;
  35147. +    }
  35148. +    rcv->state = PLIP_PK_DONE;
  35149. +    if (rcv->skb) {
  35150. +        rcv->skb->free = 1;
  35151. +        kfree_skb(rcv->skb, FREE_READ);
  35152. +        rcv->skb = NULL;
  35153. +    }
  35154. +    snd->state = PLIP_PK_DONE;
  35155. +    if (snd->skb) {
  35156. +        dev_kfree_skb(snd->skb, FREE_WRITE);
  35157. +        snd->skb = NULL;
  35158. +    }
  35159. +    disable_irq(dev->irq);
  35160. +    outb(PAR_INTR_OFF, PAR_CONTROL(dev));
  35161. +    dev->tbusy = 1;
  35162. +    nl->connection = PLIP_CN_ERROR;
  35163. +    outb(0x00, PAR_DATA(dev));
  35164. +    sti();
  35165. +
  35166. +    return TIMEOUT;
  35167. +}
  35168. +
  35169. +static int
  35170. +plip_none(struct device *dev, struct net_local *nl,
  35171. +      struct plip_local *snd, struct plip_local *rcv)
  35172. +{
  35173. +    return OK;
  35174. +}
  35175. +
  35176. +/* PLIP_RECEIVE --- receive a byte(two nibbles)
  35177. +   Returns OK on success, TIMEOUT on timeout */
  35178. +inline static int
  35179. +plip_receive(unsigned short nibble_timeout, unsigned short status_addr,
  35180. +         enum plip_nibble_state *ns_p, unsigned char *data_p)
  35181. +{
  35182. +    unsigned char c0, c1;
  35183. +    unsigned int cx;
  35184. +
  35185. +    switch (*ns_p) {
  35186. +    case PLIP_NB_BEGIN:
  35187. +        cx = nibble_timeout;
  35188. +        while (1) {
  35189. +            c0 = inb(status_addr);
  35190. +            udelay(PLIP_DELAY_UNIT);
  35191. +            if ((c0 & 0x80) == 0) {
  35192. +                c1 = inb(status_addr);
  35193. +                if (c0 == c1)
  35194. +                    break;
  35195. +            }
  35196. +            if (--cx == 0)
  35197. +                return TIMEOUT;
  35198. +        }
  35199. +        *data_p = (c0 >> 3) & 0x0f;
  35200. +        outb(0x10, --status_addr); /* send ACK */
  35201. +        status_addr++;
  35202. +        *ns_p = PLIP_NB_1;
  35203. +
  35204. +    case PLIP_NB_1:
  35205. +        cx = nibble_timeout;
  35206. +        while (1) {
  35207. +            c0 = inb(status_addr);
  35208. +            udelay(PLIP_DELAY_UNIT);
  35209. +            if (c0 & 0x80) {
  35210. +                c1 = inb(status_addr);
  35211. +                if (c0 == c1)
  35212. +                    break;
  35213. +            }
  35214. +            if (--cx == 0)
  35215. +                return TIMEOUT;
  35216. +        }
  35217. +        *data_p |= (c0 << 1) & 0xf0;
  35218. +        outb(0x00, --status_addr); /* send ACK */
  35219. +        status_addr++;
  35220. +        *ns_p = PLIP_NB_BEGIN;
  35221. +        return OK;
  35222. +
  35223. +    case PLIP_NB_2:
  35224. +    }
  35225. +}
  35226. +
  35227. +/* PLIP_RECEIVE_PACKET --- receive a packet */
  35228. +static int
  35229. +plip_receive_packet(struct device *dev, struct net_local *nl,
  35230. +            struct plip_local *snd, struct plip_local *rcv)
  35231. +{
  35232. +    unsigned short status_addr = PAR_STATUS(dev);
  35233. +    unsigned short nibble_timeout = nl->nibble;
  35234. +    unsigned char *lbuf;
  35235. +
  35236. +    switch (rcv->state) {
  35237. +    case PLIP_PK_TRIGGER:
  35238. +        disable_irq(dev->irq);
  35239. +        outb(PAR_INTR_OFF, PAR_CONTROL(dev));
  35240. +        dev->interrupt = 0;
  35241. +        outb(0x01, PAR_DATA(dev)); /* send ACK */
  35242. +        if (net_debug > 2)
  35243. +            printk("%s: receive start\n", dev->name);
  35244. +        rcv->state = PLIP_PK_LENGTH_LSB;
  35245. +        rcv->nibble = PLIP_NB_BEGIN;
  35246. +
  35247. +    case PLIP_PK_LENGTH_LSB:
  35248. +        if (snd->state != PLIP_PK_DONE) {
  35249. +            if (plip_receive(nl->trigger, status_addr,
  35250. +                     &rcv->nibble, &rcv->length.b.lsb)) {
  35251. +                /* collision, here dev->tbusy == 1 */
  35252. +                rcv->state = PLIP_PK_DONE;
  35253. +                nl->is_deferred = 1;
  35254. +                nl->connection = PLIP_CN_SEND;
  35255. +                queue_task(&nl->deferred, &tq_timer);
  35256. +                outb(PAR_INTR_ON, PAR_CONTROL(dev));
  35257. +                enable_irq(dev->irq);
  35258. +                return OK;
  35259. +            }
  35260. +        } else {
  35261. +            if (plip_receive(nibble_timeout, status_addr,
  35262. +                     &rcv->nibble, &rcv->length.b.lsb))
  35263. +                return TIMEOUT;
  35264. +        }
  35265. +        rcv->state = PLIP_PK_LENGTH_MSB;
  35266. +
  35267. +    case PLIP_PK_LENGTH_MSB:
  35268. +        if (plip_receive(nibble_timeout, status_addr,
  35269. +                 &rcv->nibble, &rcv->length.b.msb))
  35270. +            return TIMEOUT;
  35271. +        if (rcv->length.h > dev->mtu || rcv->length.h < 8) {
  35272. +            printk("%s: bogus packet size %d.\n", dev->name, rcv->length.h);
  35273. +            return ERROR;
  35274. +        }
  35275. +        /* Malloc up new buffer. */
  35276. +        rcv->skb = alloc_skb(rcv->length.h, GFP_ATOMIC);
  35277. +        if (rcv->skb == NULL) {
  35278. +            printk("%s: Memory squeeze.\n", dev->name);
  35279. +            return ERROR;
  35280. +        }
  35281. +        rcv->skb->len = rcv->length.h;
  35282. +        rcv->skb->dev = dev;
  35283. +        rcv->state = PLIP_PK_DATA;
  35284. +        rcv->byte = 0;
  35285. +        rcv->checksum = 0;
  35286. +
  35287. +    case PLIP_PK_DATA:
  35288. +        lbuf = rcv->skb->data;
  35289. +        do
  35290. +            if (plip_receive(nibble_timeout, status_addr, 
  35291. +                     &rcv->nibble, &lbuf[rcv->byte]))
  35292. +                return TIMEOUT;
  35293. +        while (++rcv->byte < rcv->length.h);
  35294. +        do
  35295. +            rcv->checksum += lbuf[--rcv->byte];
  35296. +        while (rcv->byte);
  35297. +        rcv->state = PLIP_PK_CHECKSUM;
  35298. +
  35299. +    case PLIP_PK_CHECKSUM:
  35300. +        if (plip_receive(nibble_timeout, status_addr,
  35301. +                 &rcv->nibble, &rcv->data))
  35302. +            return TIMEOUT;
  35303. +        if (rcv->data != rcv->checksum) {
  35304. +            nl->enet_stats.rx_crc_errors++;
  35305. +            if (net_debug)
  35306. +                printk("%s: checksum error\n", dev->name);
  35307. +            return ERROR;
  35308. +        }
  35309. +        rcv->state = PLIP_PK_DONE;
  35310. +
  35311. +    case PLIP_PK_DONE:
  35312. +        /* Inform the upper layer for the arrival of a packet. */
  35313. +        netif_rx(rcv->skb);
  35314. +        nl->enet_stats.rx_packets++;
  35315. +        rcv->skb = NULL;
  35316. +        if (net_debug > 2)
  35317. +            printk("%s: receive end\n", dev->name);
  35318. +
  35319. +        /* Close the connection. */
  35320. +        outb (0x00, PAR_DATA(dev));
  35321. +        cli();
  35322. +        if (snd->state != PLIP_PK_DONE) {
  35323. +            nl->connection = PLIP_CN_SEND;
  35324. +            sti();
  35325. +            queue_task(&nl->immediate, &tq_immediate);
  35326. +            outb(PAR_INTR_ON, PAR_CONTROL(dev));
  35327. +            enable_irq(dev->irq);
  35328. +            return OK;
  35329. +        } else {
  35330. +            nl->connection = PLIP_CN_NONE;
  35331. +            sti();
  35332. +            outb(PAR_INTR_ON, PAR_CONTROL(dev));
  35333. +            enable_irq(dev->irq);
  35334. +            return OK;
  35335. +        }
  35336. +    }
  35337. +    return OK;
  35338. +}
  35339. +
  35340. +/* PLIP_SEND --- send a byte (two nibbles) 
  35341. +   Returns OK on success, TIMEOUT when timeout    */
  35342. +inline static int
  35343. +plip_send(unsigned short nibble_timeout, unsigned short data_addr,
  35344. +      enum plip_nibble_state *ns_p, unsigned char data)
  35345. +{
  35346. +    unsigned char c0;
  35347. +    unsigned int cx;
  35348. +
  35349. +    switch (*ns_p) {
  35350. +    case PLIP_NB_BEGIN:
  35351. +        outb((data & 0x0f), data_addr);
  35352. +        *ns_p = PLIP_NB_1;
  35353. +
  35354. +    case PLIP_NB_1:
  35355. +        outb(0x10 | (data & 0x0f), data_addr);
  35356. +        cx = nibble_timeout;
  35357. +        data_addr++;
  35358. +        while (1) {
  35359. +            c0 = inb(data_addr);
  35360. +            if ((c0 & 0x80) == 0) 
  35361. +                break;
  35362. +            if (--cx == 0)
  35363. +                return TIMEOUT;
  35364. +            udelay(PLIP_DELAY_UNIT);
  35365. +        }
  35366. +        outb(0x10 | (data >> 4), --data_addr);
  35367. +        *ns_p = PLIP_NB_2;
  35368. +
  35369. +    case PLIP_NB_2:
  35370. +        outb((data >> 4), data_addr);
  35371. +        data_addr++;
  35372. +        cx = nibble_timeout;
  35373. +        while (1) {
  35374. +            c0 = inb(data_addr);
  35375. +            if (c0 & 0x80)
  35376. +                break;
  35377. +            if (--cx == 0)
  35378. +                return TIMEOUT;
  35379. +            udelay(PLIP_DELAY_UNIT);
  35380. +        }
  35381. +        data_addr--;
  35382. +        *ns_p = PLIP_NB_BEGIN;
  35383. +        return OK;
  35384. +    }
  35385. +}
  35386. +
  35387. +/* PLIP_SEND_PACKET --- send a packet */
  35388. +static int
  35389. +plip_send_packet(struct device *dev, struct net_local *nl,
  35390. +         struct plip_local *snd, struct plip_local *rcv)
  35391. +{
  35392. +    unsigned short data_addr = PAR_DATA(dev);
  35393. +    unsigned short nibble_timeout = nl->nibble;
  35394. +    unsigned char *lbuf;
  35395. +    unsigned char c0;
  35396. +    unsigned int cx;
  35397. +
  35398. +    if (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
  35399. +        printk("%s: send skb lost\n", dev->name);
  35400. +        snd->state = PLIP_PK_DONE;
  35401. +        snd->skb = NULL;
  35402. +        return ERROR;
  35403. +    }
  35404. +
  35405. +    switch (snd->state) {
  35406. +    case PLIP_PK_TRIGGER:
  35407. +        /* Trigger remote rx interrupt. */
  35408. +        outb(0x08, data_addr);
  35409. +        cx = nl->trigger;
  35410. +        while (1) {
  35411. +            udelay(PLIP_DELAY_UNIT);
  35412. +            cli();
  35413. +            if (nl->connection == PLIP_CN_RECEIVE) {
  35414. +                sti();
  35415. +                /* interrupted */
  35416. +                nl->enet_stats.collisions++;
  35417. +                if (net_debug > 1)
  35418. +                    printk("%s: collision.\n", dev->name);
  35419. +                return OK;
  35420. +            }
  35421. +            c0 = inb(PAR_STATUS(dev));
  35422. +            if (c0 & 0x08) {
  35423. +                disable_irq(dev->irq);
  35424. +                outb(PAR_INTR_OFF, PAR_CONTROL(dev));
  35425. +                if (net_debug > 2)
  35426. +                    printk("%s: send start\n", dev->name);
  35427. +                snd->state = PLIP_PK_LENGTH_LSB;
  35428. +                snd->nibble = PLIP_NB_BEGIN;
  35429. +                nl->timeout_count = 0;
  35430. +                sti();
  35431. +                break;
  35432. +            }
  35433. +            sti();
  35434. +            if (--cx == 0) {
  35435. +                outb(0x00, data_addr);
  35436. +                return TIMEOUT;
  35437. +            }
  35438. +        }
  35439. +
  35440. +    case PLIP_PK_LENGTH_LSB:
  35441. +        if (plip_send(nibble_timeout, data_addr,
  35442. +                  &snd->nibble, snd->length.b.lsb))
  35443. +            return TIMEOUT;
  35444. +        snd->state = PLIP_PK_LENGTH_MSB;
  35445. +
  35446. +    case PLIP_PK_LENGTH_MSB:
  35447. +        if (plip_send(nibble_timeout, data_addr,
  35448. +                  &snd->nibble, snd->length.b.msb))
  35449. +            return TIMEOUT;
  35450. +        snd->state = PLIP_PK_DATA;
  35451. +        snd->byte = 0;
  35452. +        snd->checksum = 0;
  35453. +
  35454. +    case PLIP_PK_DATA:
  35455. +        do
  35456. +            if (plip_send(nibble_timeout, data_addr,
  35457. +                      &snd->nibble, lbuf[snd->byte]))
  35458. +                return TIMEOUT;
  35459. +        while (++snd->byte < snd->length.h);
  35460. +        do
  35461. +            snd->checksum += lbuf[--snd->byte];
  35462. +        while (snd->byte);
  35463. +        snd->state = PLIP_PK_CHECKSUM;
  35464. +
  35465. +    case PLIP_PK_CHECKSUM:
  35466. +        if (plip_send(nibble_timeout, data_addr,
  35467. +                  &snd->nibble, snd->checksum))
  35468. +            return TIMEOUT;
  35469. +
  35470. +        dev_kfree_skb(snd->skb, FREE_WRITE);
  35471. +        nl->enet_stats.tx_packets++;
  35472. +        snd->state = PLIP_PK_DONE;
  35473. +
  35474. +    case PLIP_PK_DONE:
  35475. +        /* Close the connection */
  35476. +        outb (0x00, data_addr);
  35477. +        snd->skb = NULL;
  35478. +        if (net_debug > 2)
  35479. +            printk("%s: send end\n", dev->name);
  35480. +        nl->connection = PLIP_CN_CLOSING;
  35481. +        nl->is_deferred = 1;
  35482. +        queue_task(&nl->deferred, &tq_timer);
  35483. +        outb(PAR_INTR_ON, PAR_CONTROL(dev));
  35484. +        enable_irq(dev->irq);
  35485. +        return OK;
  35486. +    }
  35487. +    return OK;
  35488. +}
  35489. +
  35490. +static int
  35491. +plip_connection_close(struct device *dev, struct net_local *nl,
  35492. +              struct plip_local *snd, struct plip_local *rcv)
  35493. +{
  35494. +    cli();
  35495. +    if (nl->connection == PLIP_CN_CLOSING) {
  35496. +        nl->connection = PLIP_CN_NONE;
  35497. +        dev->tbusy = 0;
  35498. +        mark_bh(NET_BH);
  35499. +    }
  35500. +    sti();
  35501. +    return OK;
  35502. +}
  35503. +
  35504. +/* PLIP_ERROR --- wait till other end settled */
  35505. +static int
  35506. +plip_error(struct device *dev, struct net_local *nl,
  35507. +       struct plip_local *snd, struct plip_local *rcv)
  35508. +{
  35509. +    unsigned char status;
  35510. +
  35511. +    status = inb(PAR_STATUS(dev));
  35512. +    if ((status & 0xf8) == 0x80) {
  35513. +        if (net_debug > 2)
  35514. +            printk("%s: reset interface.\n", dev->name);
  35515. +        nl->connection = PLIP_CN_NONE;
  35516. +        dev->tbusy = 0;
  35517. +        dev->interrupt = 0;
  35518. +        outb(PAR_INTR_ON, PAR_CONTROL(dev));
  35519. +        enable_irq(dev->irq);
  35520. +        mark_bh(NET_BH);
  35521. +    } else {
  35522. +        nl->is_deferred = 1;
  35523. +        queue_task(&nl->deferred, &tq_timer);
  35524. +    }
  35525. +
  35526. +    return OK;
  35527. +}
  35528. +
  35529. +/* Handle the parallel port interrupts. */
  35530. +static void
  35531. +plip_interrupt(int irq, struct pt_regs * regs)
  35532. +{
  35533. +    struct device *dev = (struct device *) irq2dev_map[irq];
  35534. +    struct net_local *nl = (struct net_local *)dev->priv;
  35535. +    struct plip_local *rcv = &nl->rcv_data;
  35536. +    unsigned char c0;
  35537. +
  35538. +    if (dev == NULL) {
  35539. +        printk ("plip_interrupt: irq %d for unknown device.\n", irq);
  35540. +        return;
  35541. +    }
  35542. +
  35543. +    if (dev->interrupt)
  35544. +        return;
  35545. +
  35546. +    c0 = inb(PAR_STATUS(dev));
  35547. +    if ((c0 & 0xf8) != 0xc0) {
  35548. +        if (net_debug > 1)
  35549. +            printk("%s: spurious interrupt\n", dev->name);
  35550. +        return;
  35551. +    }
  35552. +    dev->interrupt = 1;
  35553. +    if (net_debug > 3)
  35554. +        printk("%s: interrupt.\n", dev->name);
  35555. +
  35556. +    cli();
  35557. +    switch (nl->connection) {
  35558. +    case PLIP_CN_CLOSING:
  35559. +        dev->tbusy = 0;
  35560. +    case PLIP_CN_NONE:
  35561. +    case PLIP_CN_SEND:
  35562. +        dev->last_rx = jiffies;
  35563. +        rcv->state = PLIP_PK_TRIGGER;
  35564. +        nl->connection = PLIP_CN_RECEIVE;
  35565. +        nl->timeout_count = 0;
  35566. +        queue_task(&nl->immediate, &tq_immediate);
  35567. +        mark_bh(IMMEDIATE_BH);
  35568. +        sti();
  35569. +        break;
  35570. +
  35571. +    case PLIP_CN_RECEIVE:
  35572. +        sti();
  35573. +        printk("%s: receive interrupt when receiving packet\n", dev->name);
  35574. +        break;
  35575. +
  35576. +    case PLIP_CN_ERROR:
  35577. +        sti();
  35578. +        printk("%s: receive interrupt in error state\n", dev->name);
  35579. +        break;
  35580. +    }
  35581. +}
  35582. +
  35583. +/* We don't need to send arp, for plip is point-to-point. */
  35584. +static int
  35585. +plip_rebuild_header(void *buff, struct device *dev, unsigned long dst,
  35586. +            struct sk_buff *skb)
  35587. +{
  35588. +    struct net_local *nl = (struct net_local *)dev->priv;
  35589. +    struct ethhdr *eth = (struct ethhdr *)buff;
  35590. +    int i;
  35591. +
  35592. +    if ((dev->flags & IFF_NOARP)==0)
  35593. +        return nl->orig_rebuild_header(buff, dev, dst, skb);
  35594. +
  35595. +    if (eth->h_proto != htons(ETH_P_IP)) {
  35596. +        printk("plip_rebuild_header: Don't know how to resolve type %d addresses?\n", (int)eth->h_proto);
  35597. +        memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
  35598. +        return 0;
  35599. +    }
  35600. +
  35601. +    for (i=0; i < ETH_ALEN - sizeof(unsigned long); i++)
  35602. +        eth->h_dest[i] = 0xfc;
  35603. +    memcpy(&(eth->h_dest[i]), &dst, sizeof(unsigned long));
  35604. +    return 0;
  35605. +}
  35606. +
  35607. +static int
  35608. +plip_tx_packet(struct sk_buff *skb, struct device *dev)
  35609. +{
  35610. +    struct net_local *nl = (struct net_local *)dev->priv;
  35611. +    struct plip_local *snd = &nl->snd_data;
  35612. +
  35613. +    if (dev->tbusy)
  35614. +        return 1;
  35615. +
  35616. +    /* If some higher layer thinks we've missed an tx-done interrupt
  35617. +       we are passed NULL. Caution: dev_tint() handles the cli()/sti()
  35618. +       itself. */
  35619. +    if (skb == NULL) {
  35620. +        dev_tint(dev);
  35621. +        return 0;
  35622. +    }
  35623. +
  35624. +    if (set_bit(0, (void*)&dev->tbusy) != 0) {
  35625. +        printk("%s: Transmitter access conflict.\n", dev->name);
  35626. +        return 1;
  35627. +    }
  35628. +
  35629. +    if (skb->len > dev->mtu) {
  35630. +        printk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
  35631. +        dev->tbusy = 0;
  35632. +        return 0;
  35633. +    }
  35634. +
  35635. +    if (net_debug > 2)
  35636. +        printk("%s: send request\n", dev->name);
  35637. +
  35638. +    cli();
  35639. +    dev->trans_start = jiffies;
  35640. +    snd->skb = skb;
  35641. +    snd->length.h = skb->len;
  35642. +    snd->state = PLIP_PK_TRIGGER;
  35643. +    if (nl->connection == PLIP_CN_NONE) {
  35644. +        nl->connection = PLIP_CN_SEND;
  35645. +        nl->timeout_count = 0;
  35646. +    }
  35647. +    queue_task(&nl->immediate, &tq_immediate);
  35648. +    mark_bh(IMMEDIATE_BH);
  35649. +    sti();
  35650. +
  35651. +    return 0;
  35652. +}
  35653. +
  35654. +/* Open/initialize the board.  This is called (in the current kernel)
  35655. +   sometime after booting when the 'ifconfig' program is run.
  35656. +
  35657. +   This routine gets exclusive access to the parallel port by allocating
  35658. +   its IRQ line.
  35659. + */
  35660. +static int
  35661. +plip_open(struct device *dev)
  35662. +{
  35663. +    struct net_local *nl = (struct net_local *)dev->priv;
  35664. +    int i;
  35665. +
  35666. +    if (dev->irq == 0) {
  35667. +        printk("%s: IRQ is not set.  Please set it by ifconfig.\n", dev->name);
  35668. +        return -EAGAIN;
  35669. +    }
  35670. +    cli();
  35671. +    if (request_irq(dev->irq , plip_interrupt, 0, dev->name) != 0) {
  35672. +        sti();
  35673. +        printk("%s: couldn't get IRQ %d.\n", dev->name, dev->irq);
  35674. +        return -EAGAIN;
  35675. +    }
  35676. +    irq2dev_map[dev->irq] = dev;
  35677. +    sti();
  35678. +
  35679. +    /* Clear the data port. */
  35680. +    outb (0x00, PAR_DATA(dev));
  35681. +
  35682. +    /* Enable rx interrupt. */
  35683. +    outb(PAR_INTR_ON, PAR_CONTROL(dev));
  35684. +
  35685. +    /* Initialize the state machine. */
  35686. +    nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
  35687. +    nl->rcv_data.skb = nl->snd_data.skb = NULL;
  35688. +    nl->connection = PLIP_CN_NONE;
  35689. +    nl->is_deferred = 0;
  35690. +
  35691. +    /* Fill in the MAC-level header. */
  35692. +    for (i=0; i < ETH_ALEN - sizeof(unsigned long); i++)
  35693. +        dev->dev_addr[i] = 0xfc;
  35694. +    memcpy(&(dev->dev_addr[i]), &dev->pa_addr, sizeof(unsigned long));
  35695. +
  35696. +    dev->interrupt = 0;
  35697. +    dev->start = 1;
  35698. +    dev->tbusy = 0;
  35699. +    MOD_INC_USE_COUNT;
  35700. +    return 0;
  35701. +}
  35702. +
  35703. +/* The inverse routine to plip_open (). */
  35704. +static int
  35705. +plip_close(struct device *dev)
  35706. +{
  35707. +    struct net_local *nl = (struct net_local *)dev->priv;
  35708. +    struct plip_local *snd = &nl->snd_data;
  35709. +    struct plip_local *rcv = &nl->rcv_data;
  35710. +
  35711. +    dev->tbusy = 1;
  35712. +    dev->start = 0;
  35713. +    cli();
  35714. +    free_irq(dev->irq);
  35715. +    irq2dev_map[dev->irq] = NULL;
  35716. +    nl->is_deferred = 0;
  35717. +    nl->connection = PLIP_CN_NONE;
  35718. +    sti();
  35719. +    outb(0x00, PAR_DATA(dev));
  35720. +
  35721. +    snd->state = PLIP_PK_DONE;
  35722. +    if (snd->skb) {
  35723. +        dev_kfree_skb(snd->skb, FREE_WRITE);
  35724. +        snd->skb = NULL;
  35725. +    }
  35726. +    rcv->state = PLIP_PK_DONE;
  35727. +    if (rcv->skb) {
  35728. +        rcv->skb->free = 1;
  35729. +        kfree_skb(rcv->skb, FREE_READ);
  35730. +        rcv->skb = NULL;
  35731. +    }
  35732. +
  35733. +    /* Reset. */
  35734. +    outb(0x00, PAR_CONTROL(dev));
  35735. +    MOD_DEC_USE_COUNT;
  35736. +    return 0;
  35737. +}
  35738. +
  35739. +static struct enet_statistics *
  35740. +plip_get_stats(struct device *dev)
  35741. +{
  35742. +    struct net_local *nl = (struct net_local *)dev->priv;
  35743. +    struct enet_statistics *r = &nl->enet_stats;
  35744. +
  35745. +    return r;
  35746. +}
  35747. +
  35748. +static int
  35749. +plip_config(struct device *dev, struct ifmap *map)
  35750. +{
  35751. +    if (dev->flags & IFF_UP)
  35752. +        return -EBUSY;
  35753. +
  35754. +    if (map->base_addr != (unsigned long)-1
  35755. +        && map->base_addr != dev->base_addr)
  35756. +        printk("%s: You cannot change base_addr of this interface (ignored).\n", dev->name);
  35757. +
  35758. +    if (map->irq != (unsigned char)-1)
  35759. +        dev->irq = map->irq;
  35760. +    return 0;
  35761. +}
  35762. +
  35763. +static int
  35764. +plip_ioctl(struct device *dev, struct ifreq *rq, int cmd)
  35765. +{
  35766. +    struct net_local *nl = (struct net_local *) dev->priv;
  35767. +    struct plipconf *pc = (struct plipconf *) &rq->ifr_data;
  35768. +    
  35769. +    switch(pc->pcmd) {
  35770. +    case PLIP_GET_TIMEOUT:
  35771. +        pc->trigger = nl->trigger;
  35772. +        pc->nibble  = nl->nibble;
  35773. +        break;
  35774. +    case PLIP_SET_TIMEOUT:
  35775. +        nl->trigger = pc->trigger;
  35776. +        nl->nibble  = pc->nibble;
  35777. +        break;
  35778. +    default:
  35779. +        return -EOPNOTSUPP;
  35780. +    }
  35781. +    return 0;
  35782. +}
  35783. +
  35784. +#ifdef MODULE
  35785. +char kernel_version[] = UTS_RELEASE;
  35786. +
  35787. +static struct device dev_plip0 = 
  35788. +{
  35789. +    "plip0" /*"plip"*/,
  35790. +    0, 0, 0, 0,        /* memory */
  35791. +    0x3BC, 5,        /* base, irq */
  35792. +    0, 0, 0, NULL, plip_init 
  35793. +};
  35794. +
  35795. +static struct device dev_plip1 = 
  35796. +{
  35797. +    "plip1" /*"plip"*/,
  35798. +    0, 0, 0, 0,        /* memory */
  35799. +    0x378, 7,        /* base, irq */
  35800. +    0, 0, 0, NULL, plip_init 
  35801. +};
  35802. +
  35803. +static struct device dev_plip2 = 
  35804. +{
  35805. +    "plip2" /*"plip"*/,
  35806. +    0, 0, 0, 0,        /* memory */
  35807. +    0x278, 2,        /* base, irq */
  35808. +    0, 0, 0, NULL, plip_init 
  35809. +};
  35810. +
  35811. +int
  35812. +init_module(void)
  35813. +{
  35814. +    int devices=0;
  35815. +
  35816. +    if (register_netdev(&dev_plip0) != 0)
  35817. +        devices++;
  35818. +    if (register_netdev(&dev_plip1) != 0)
  35819. +        devices++;
  35820. +    if (register_netdev(&dev_plip2) != 0)
  35821. +        devices++;
  35822. +    if (devices == 0)
  35823. +        return -EIO;
  35824. +    return 0;
  35825. +}
  35826. +
  35827. +void
  35828. +cleanup_module(void)
  35829. +{
  35830. +    if (dev_plip0.priv) {
  35831. +        unregister_netdev(&dev_plip0);
  35832. +        release_region(PAR_DATA(&dev_plip0), 3);
  35833. +        kfree_s(dev_plip0.priv, sizeof(struct net_local));
  35834. +        dev_plip0.priv = NULL;
  35835. +    }
  35836. +    if (dev_plip1.priv) {
  35837. +        unregister_netdev(&dev_plip1);
  35838. +        release_region(PAR_DATA(&dev_plip1), 3);
  35839. +        kfree_s(dev_plip1.priv, sizeof(struct net_local));
  35840. +        dev_plip1.priv = NULL;
  35841. +    }
  35842. +    if (dev_plip2.priv) {
  35843. +        unregister_netdev(&dev_plip2);
  35844. +        release_region(PAR_DATA(&dev_plip2), 3);
  35845. +        kfree_s(dev_plip2.priv, sizeof(struct net_local));
  35846. +        dev_plip2.priv = NULL;
  35847. +    }
  35848. +}
  35849. +#endif /* MODULE */
  35850. +
  35851. +/*
  35852. + * Local variables:
  35853. + * compile-command: "gcc -DMODULE -DCONFIG_MODVERSIONS -D__KERNEL__ -Wall -Wstrict-prototypes -O2 -g -fomit-frame-pointer -pipe -m486 -c plip.c"
  35854. + * End:
  35855. + */
  35856. diff -r -u -N linux.orig/arch/arm/drivers/net/ppp.c linux.arm/arch/arm/drivers/net/ppp.c
  35857. --- linux.orig/arch/arm/drivers/net/ppp.c    Thu Jan  1 01:00:00 1970
  35858. +++ linux.arm/arch/arm/drivers/net/ppp.c    Fri Oct 27 23:15:02 1995
  35859. @@ -0,0 +1,2126 @@
  35860. +/*
  35861. +   PPP for Linux
  35862. +*/
  35863. +
  35864. +/*
  35865. +   Sources:
  35866. +
  35867. +   slip.c
  35868. +
  35869. +   RFC1331: The Point-to-Point Protocol (PPP) for the Transmission of
  35870. +   Multi-protocol Datagrams over Point-to-Point Links
  35871. +
  35872. +   RFC1332: IPCP
  35873. +
  35874. +   ppp-2.0
  35875. +
  35876. +   Flags for this module (any combination is acceptable for testing.):
  35877. +
  35878. +   NET02D          -    Define if using Net-2-Debugged in kernels earlier
  35879. +               than v1.1.4.
  35880. +
  35881. +   NEW_TTY_DRIVERS    -    Define if using new Ted Ts'o's alpha TTY drivers
  35882. +               from tsx-11.mit.edu. From Ted Ts'o.
  35883. +
  35884. +   OPTIMIZE_FLAG_TIME -    Number of jiffies to force sending of leading flag
  35885. +            character. This is normally set to ((HZ * 3) / 2).
  35886. +            This is 1.5 seconds. If not defined then the leading
  35887. +            flag is always sent.  
  35888. +*/
  35889. +
  35890. +/* #define NET02D                -* */
  35891. +#define NEW_TTY_DRIVERS                /* */
  35892. +#define OPTIMIZE_FLAG_TIME  ((HZ * 3)/2)    /* */
  35893. +#define CHECK_CHARACTERS
  35894. +
  35895. +#ifdef MODULE
  35896. +#include <linux/module.h>
  35897. +#include <linux/version.h>
  35898. +#endif
  35899. +
  35900. +#include <linux/kernel.h>
  35901. +#include <linux/sched.h>
  35902. +#include <linux/types.h>
  35903. +#include <linux/fcntl.h>
  35904. +#include <linux/interrupt.h>
  35905. +#include <linux/ptrace.h>
  35906. +#include <linux/ioport.h>
  35907. +#include <linux/in.h>
  35908. +#include <linux/malloc.h>
  35909. +#include <linux/tty.h>
  35910. +#include <linux/errno.h>
  35911. +#include <linux/sched.h>   /* to get the struct task_struct */
  35912. +#include <linux/string.h>  /* used in new tty drivers */
  35913. +#include <linux/signal.h>  /* used in new tty drivers */
  35914. +#include <asm/system.h>
  35915. +#include <asm/bitops.h>
  35916. +#include <asm/segment.h>
  35917. +
  35918. +#ifdef NET02D                /* v1.1.4 net code and earlier */
  35919. +#include <dev.h>
  35920. +#include <skbuff.h>
  35921. +#include <inet.h>
  35922. +#define    skb_queue_head_init(buf)    *(buf) = NULL
  35923. +#else                    /* v1.1.5 and later */
  35924. +#include <linux/netdevice.h>
  35925. +#include <linux/skbuff.h>
  35926. +#include <linux/inet.h>
  35927. +#endif
  35928. +
  35929. +#include <linux/ppp.h>
  35930. +
  35931. +#include <linux/ip.h>
  35932. +#include <linux/tcp.h>
  35933. +
  35934. +#include "slhc.h"
  35935. +
  35936. +#include <linux/if_arp.h>
  35937. +#ifndef ARPHRD_PPP
  35938. +#define ARPHRD_PPP 0
  35939. +#endif
  35940. +
  35941. +#define PRINTK(p) printk p ;
  35942. +#define ASSERT(p) if (!p) PRINTK ((KERN_CRIT "assertion failed: " # p))
  35943. +#define PRINTKN(n,p) {if (ppp_debug >= n) PRINTK (p)}
  35944. +#define CHECK_PPP(a)  if (!ppp->inuse) { PRINTK ((ppp_warning, __LINE__)) return a;}
  35945. +#define CHECK_PPP_VOID()  if (!ppp->inuse) { PRINTK ((ppp_warning, __LINE__)) return;}
  35946. +
  35947. +#define in_xmap(ppp,c)    (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
  35948. +#define in_rmap(ppp,c)    ((((unsigned int) (unsigned char) (c)) < 0x20) && \
  35949. +            ppp->recv_async_map & (1 << (c)))
  35950. +
  35951. +#define bset(p,b)    ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
  35952. +
  35953. +int ppp_debug = 2;
  35954. +int ppp_debug_netpackets = 0;
  35955. +
  35956. +/* Define this string only once for all macro invocations */
  35957. +static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
  35958. +
  35959. +int ppp_init(struct device *);
  35960. +static void ppp_init_ctrl_blk(struct ppp *);
  35961. +static int ppp_dev_open(struct device *);
  35962. +static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
  35963. +static int ppp_dev_close(struct device *);
  35964. +static void ppp_kick_tty(struct ppp *);
  35965. +
  35966. +#ifdef NEW_TTY_DRIVERS
  35967. +#define ppp_find(tty) ((struct ppp *) tty->disc_data)
  35968. +#else
  35969. +static void ppp_output_done(void *);
  35970. +static void ppp_unesc(struct ppp *ppp, unsigned char *c, int n);
  35971. +static struct ppp *ppp_find(struct tty_struct *);
  35972. +#endif
  35973. +
  35974. +static void ppp_doframe(struct ppp *);
  35975. +static int ppp_do_ip(struct ppp *, unsigned short, unsigned char *, int);
  35976. +static int ppp_us_queue(struct ppp *, unsigned short, unsigned char *, int);
  35977. +static int ppp_xmit(struct sk_buff *, struct device *);
  35978. +static unsigned short ppp_type_trans(struct sk_buff *, struct device *);
  35979. +
  35980. +#ifdef NET02D
  35981. +static int ppp_header(unsigned char *buff, struct device *dev,
  35982. +              unsigned short type, unsigned long daddr,
  35983. +              unsigned long saddr, unsigned len);
  35984. +static int ppp_rebuild_header(void *buff, struct device *dev);
  35985. +static void ppp_add_arp(unsigned long addr, struct sk_buff *skb,
  35986. +            struct device *dev);
  35987. +#else
  35988. +static int ppp_header(unsigned char *, struct device *, unsigned short,
  35989. +              void *, void *, unsigned, struct sk_buff *);
  35990. +static int ppp_rebuild_header(void *, struct device *, unsigned long,
  35991. +                  struct sk_buff *);
  35992. +#endif
  35993. +
  35994. +static struct enet_statistics *ppp_get_stats (struct device *);
  35995. +static struct ppp *ppp_alloc(void);
  35996. +static int ppp_lock(struct ppp *);
  35997. +static void ppp_unlock(struct ppp *);
  35998. +static void ppp_add_fcs(struct ppp *);
  35999. +static int ppp_check_fcs(struct ppp *);
  36000. +static void ppp_print_buffer(const char *,char *,int,int);
  36001. +
  36002. +static int ppp_read(struct tty_struct *, struct file *, unsigned char *,
  36003. +            unsigned int);
  36004. +static int ppp_write(struct tty_struct *, struct file *, unsigned char *,
  36005. +             unsigned int);
  36006. +static int ppp_ioctl(struct tty_struct *, struct file *, unsigned int,
  36007. +             unsigned long);
  36008. +static int ppp_select(struct tty_struct *tty, struct inode * inode,
  36009. +              struct file * filp, int sel_type, select_table * wait);
  36010. +static int ppp_open(struct tty_struct *);
  36011. +static void ppp_close(struct tty_struct *);
  36012. +
  36013. +#ifdef NEW_TTY_DRIVERS
  36014. +static int ppp_receive_room(struct tty_struct *tty);
  36015. +static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
  36016. +                char *fp, int count);
  36017. +static void ppp_write_wakeup(struct tty_struct *tty);
  36018. +#else
  36019. +static void ppp_tty_input_ready(struct tty_struct *);
  36020. +#endif
  36021. +
  36022. +/* FCS table from RFC1331 */
  36023. +
  36024. +static unsigned short fcstab[256] = {
  36025. +  0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  36026. +  0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  36027. +  0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  36028. +  0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  36029. +  0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  36030. +  0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  36031. +  0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  36032. +  0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  36033. +  0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  36034. +  0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  36035. +  0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  36036. +  0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  36037. +  0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  36038. +  0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  36039. +  0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  36040. +  0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  36041. +  0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  36042. +  0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  36043. +  0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  36044. +  0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  36045. +  0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  36046. +  0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  36047. +  0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  36048. +  0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  36049. +  0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  36050. +  0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  36051. +  0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  36052. +  0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  36053. +  0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  36054. +  0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  36055. +  0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  36056. +  0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  36057. +  };
  36058. +
  36059. +struct tty_ldisc ppp_ldisc;
  36060. +
  36061. +static struct ppp ppp_ctrl[PPP_NRUNIT];
  36062. +
  36063. +/*************************************************************
  36064. + * INITIALIZATION
  36065. + *************************************************************/
  36066. +
  36067. +static int first_time = 1;
  36068. +
  36069. +/* called at boot time for each ppp device */
  36070. +
  36071. +int
  36072. +ppp_init(struct device *dev)
  36073. +{
  36074. +  struct ppp *ppp;
  36075. +  int i;
  36076. +
  36077. +  ppp = &ppp_ctrl[dev->base_addr];
  36078. +
  36079. +  if (first_time) {
  36080. +    first_time = 0;
  36081. +
  36082. +    printk (KERN_INFO "PPP: version %s (%d channels)"
  36083. +#ifdef NET02D
  36084. +       " NET02D"
  36085. +#endif
  36086. +#ifdef NEW_TTY_DRIVERS
  36087. +       " NEW_TTY_DRIVERS"
  36088. +#endif
  36089. +#ifdef OPTIMIZE_FLAG_TIME
  36090. +       " OPTIMIZE_FLAGS"
  36091. +#endif
  36092. +       "\n", PPP_VERSION, PPP_NRUNIT);
  36093. +
  36094. +    printk (KERN_INFO
  36095. +       "TCP compression code copyright 1989 Regents of the "
  36096. +       "University of California\n");
  36097. +
  36098. +    (void) memset(&ppp_ldisc, 0, sizeof(ppp_ldisc));
  36099. +    ppp_ldisc.open    = ppp_open;
  36100. +    ppp_ldisc.close   = ppp_close;
  36101. +    ppp_ldisc.read    = ppp_read;
  36102. +    ppp_ldisc.write   = ppp_write;
  36103. +    ppp_ldisc.ioctl   = ppp_ioctl;
  36104. +    ppp_ldisc.select  = ppp_select;
  36105. +
  36106. +#ifdef NEW_TTY_DRIVERS
  36107. +    ppp_ldisc.magic       = TTY_LDISC_MAGIC;
  36108. +    ppp_ldisc.receive_room = ppp_receive_room;
  36109. +    ppp_ldisc.receive_buf = ppp_receive_buf;
  36110. +    ppp_ldisc.write_wakeup = ppp_write_wakeup;
  36111. +#else
  36112. +    ppp_ldisc.handler     = ppp_tty_input_ready;
  36113. +#endif
  36114. +
  36115. +    if ((i = tty_register_ldisc(N_PPP, &ppp_ldisc)) == 0)
  36116. +      printk(KERN_INFO "PPP line discipline registered.\n");
  36117. +    else
  36118. +      printk(KERN_ERR "error registering line discipline: %d\n", i);
  36119. +  }
  36120. +
  36121. +  /* initialize PPP control block */
  36122. +  ppp_init_ctrl_blk (ppp);
  36123. +  ppp->inuse = 0;
  36124. +  ppp->line  = dev->base_addr;
  36125. +  ppp->tty   = NULL;
  36126. +  ppp->dev   = dev;
  36127. +
  36128. +  /* clear statistics */
  36129. +  memset (&ppp->stats, '\0', sizeof (struct ppp_stats));
  36130. +
  36131. +  /* device INFO */
  36132. +  dev->mtu             = PPP_MTU;
  36133. +  dev->hard_start_xmit = ppp_xmit;
  36134. +  dev->open            = ppp_dev_open;
  36135. +  dev->stop            = ppp_dev_close;
  36136. +  dev->get_stats       = ppp_get_stats;
  36137. +  dev->hard_header     = ppp_header;
  36138. +  dev->type_trans      = ppp_type_trans;
  36139. +  dev->rebuild_header  = ppp_rebuild_header;
  36140. +  dev->hard_header_len = 0;
  36141. +  dev->addr_len        = 0;
  36142. +  dev->type            = ARPHRD_PPP;
  36143. +
  36144. +#ifdef NET02D
  36145. +  dev->add_arp         = ppp_add_arp;
  36146. +  dev->queue_xmit      = dev_queue_xmit;
  36147. +#else
  36148. +  dev->do_ioctl        = ppp_dev_ioctl;
  36149. +#endif
  36150. +
  36151. +  for (i = 0; i < DEV_NUMBUFFS; i++)
  36152. +    skb_queue_head_init(&dev->buffs[i]);  /* = NULL if NET02D */
  36153. +
  36154. +  /* New-style flags */
  36155. +  dev->flags      = IFF_POINTOPOINT;
  36156. +  dev->family     = AF_INET;
  36157. +  dev->pa_addr    = 0;
  36158. +  dev->pa_brdaddr = 0;
  36159. +  dev->pa_mask    = 0;
  36160. +  dev->pa_alen    = sizeof(unsigned long);
  36161. +
  36162. +  return 0;
  36163. +}
  36164. +
  36165. +static void
  36166. +ppp_init_ctrl_blk(struct ppp *ppp)
  36167. +{
  36168. +  ppp->magic        = PPP_MAGIC;
  36169. +  ppp->sending        = 0;
  36170. +  ppp->toss        = 0xFE;
  36171. +  ppp->escape        = 0;
  36172. +
  36173. +  ppp->flags        = 0;
  36174. +  ppp->mtu        = PPP_MTU;
  36175. +  ppp->mru        = PPP_MRU;
  36176. +  ppp->fcs        = 0;
  36177. +
  36178. +  memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
  36179. +  ppp->xmit_async_map[0] = 0xffffffff;
  36180. +  ppp->xmit_async_map[3] = 0x60000000;
  36181. +  ppp->recv_async_map     = 0x00000000;
  36182. +
  36183. +  ppp->slcomp        = NULL;
  36184. +  ppp->rbuff        = NULL;
  36185. +  ppp->xbuff        = NULL;
  36186. +  ppp->cbuff        = NULL;
  36187. +
  36188. +  ppp->rhead        = NULL;
  36189. +  ppp->rend        = NULL;
  36190. +  ppp->rcount        = 0;
  36191. +  ppp->xhead        = NULL;
  36192. +  ppp->xtail        = NULL;
  36193. +
  36194. +  ppp->us_rbuff        = NULL;
  36195. +  ppp->us_rbuff_end    = NULL;
  36196. +  ppp->us_rbuff_head    = NULL;
  36197. +  ppp->us_rbuff_tail    = NULL;
  36198. +  ppp->read_wait    = NULL;
  36199. +  ppp->write_wait    = NULL;
  36200. +  ppp->us_rbuff_lock    = 0;
  36201. +  ppp->inp_sig        = 0;
  36202. +  ppp->inp_sig_pid    = 0;
  36203. +
  36204. +#ifdef OPTIMIZE_FLAG_TIME /* ensure flag will always be sent first time */
  36205. +  ppp->last_xmit    = jiffies - OPTIMIZE_FLAG_TIME;
  36206. +#else
  36207. +  ppp->last_xmit    = 0;
  36208. +#endif
  36209. +
  36210. +  /* clear statistics */
  36211. +  memset (&ppp->stats, '\0', sizeof (struct ppp_stats));
  36212. +
  36213. +  /* Reset the demand dial information */
  36214. +  ppp->ddinfo.ip_sjiffies  =
  36215. +  ppp->ddinfo.ip_rjiffies  =
  36216. +  ppp->ddinfo.nip_sjiffies =
  36217. +  ppp->ddinfo.nip_rjiffies = jiffies;
  36218. +}
  36219. +
  36220. +/*
  36221. + * MTU has been changed by the IP layer. Unfortunately we are not told
  36222. + * about this, but we spot it ourselves and fix things up. We could be
  36223. + * in an upcall from the tty driver, or in an ip packet queue.
  36224. + */
  36225. +   
  36226. +static void
  36227. +ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
  36228. +{
  36229. +  struct device *dev;
  36230. +  unsigned char *new_rbuff, *new_xbuff, *new_cbuff;
  36231. +  unsigned char *old_rbuff, *old_xbuff, *old_cbuff;
  36232. +  int mtu, mru;
  36233. +/*
  36234. + *  Allocate the buffer from the kernel for the data
  36235. + */
  36236. +  dev = ppp->dev;
  36237. +  mru = new_mru;
  36238. +  mtu = new_mtu;
  36239. +
  36240. +  /* RFC 1331, section 7.2 says the minimum value is 1500 bytes */
  36241. +  if (mru < PPP_MRU)
  36242. +    mru = PPP_MRU;
  36243. +
  36244. +  mtu = (mtu * 2) + 20;
  36245. +  mru = (mru * 2) + 20;
  36246. +
  36247. +  PRINTKN (2,(KERN_INFO "ppp: channel %s mtu = %d, mru = %d\n",
  36248. +          dev->name, new_mtu, new_mru));
  36249. +    
  36250. +  new_xbuff = (unsigned char *) kmalloc(mtu + 4, GFP_ATOMIC);
  36251. +  new_rbuff = (unsigned char *) kmalloc(mru + 4, GFP_ATOMIC);
  36252. +  new_cbuff = (unsigned char *) kmalloc(mru + 4, GFP_ATOMIC);
  36253. +/*
  36254. + *  If the buffers failed to allocate then complain.
  36255. + */
  36256. +  if (new_xbuff == NULL || new_rbuff == NULL || new_cbuff == NULL)
  36257. +    {
  36258. +      PRINTKN (2,(KERN_ERR "ppp: failed to allocate new buffers\n"));
  36259. +/*
  36260. + *  Release new buffer pointers if the updates were not performed
  36261. + */
  36262. +      if (new_rbuff != NULL)
  36263. +    kfree (new_rbuff);
  36264. +
  36265. +      if (new_xbuff != NULL)
  36266. +    kfree (new_xbuff);
  36267. +
  36268. +      if (new_cbuff != NULL)
  36269. +    kfree (new_cbuff);
  36270. +    }
  36271. +/*
  36272. + *  Update the pointers to the new buffer structures.
  36273. + */
  36274. +  else
  36275. +    {
  36276. +      cli();
  36277. +      old_xbuff       = ppp->xbuff;
  36278. +      old_rbuff       = ppp->rbuff;
  36279. +      old_cbuff       = ppp->cbuff;
  36280. +
  36281. +      ppp->xbuff      = new_xbuff;
  36282. +      ppp->rbuff      = new_rbuff;
  36283. +      ppp->cbuff      = new_cbuff;
  36284. +
  36285. +      dev->mem_start  = (unsigned long) new_xbuff;
  36286. +      dev->mem_end    = (unsigned long) (dev->mem_start + mtu);
  36287. +
  36288. +      dev->rmem_start = (unsigned long) new_rbuff;
  36289. +      ppp->rend       = (unsigned char *)
  36290. +      dev->rmem_end   = (unsigned long) (dev->rmem_start + mru);
  36291. +
  36292. +      ppp->rhead      = new_rbuff;
  36293. +/*
  36294. + *  Update the parameters for the new buffer sizes
  36295. + */
  36296. +      ppp->toss        = 0xFE;
  36297. +      ppp->escape    = 0;
  36298. +      ppp->sending    = 0;
  36299. +      ppp->rcount    = 0;
  36300. +
  36301. +      ppp->mru        = new_mru;
  36302. +
  36303. +      ppp->mtu        =
  36304. +      dev->mtu        = new_mtu;
  36305. +
  36306. +      sti();
  36307. +/*
  36308. + *  Release old buffer pointers
  36309. + */
  36310. +      if (old_rbuff != NULL)
  36311. +    kfree (old_rbuff);
  36312. +
  36313. +      if (old_xbuff != NULL)
  36314. +    kfree (old_xbuff);
  36315. +
  36316. +      if (old_cbuff != NULL)
  36317. +    kfree (old_cbuff);
  36318. +    }
  36319. +}
  36320. +
  36321. +/* called when we abandon the PPP line discipline */
  36322. +
  36323. +static void
  36324. +ppp_release(struct ppp *ppp)
  36325. +{
  36326. +#ifdef NEW_TTY_DRIVERS
  36327. +  if (ppp->tty != NULL && ppp->tty->disc_data == ppp)
  36328. +    ppp->tty->disc_data = NULL; /* Break the tty->ppp link */
  36329. +#endif
  36330. +
  36331. +  if (ppp->dev) {
  36332. +    dev_close (ppp->dev);
  36333. +    ppp->dev->flags = 0;
  36334. +  }
  36335. +
  36336. +  kfree (ppp->xbuff);
  36337. +  kfree (ppp->cbuff);
  36338. +  kfree (ppp->rbuff);
  36339. +  kfree (ppp->us_rbuff);
  36340. +
  36341. +  ppp->xbuff    =
  36342. +  ppp->cbuff    =
  36343. +  ppp->rbuff    =
  36344. +  ppp->us_rbuff = NULL;
  36345. +
  36346. +  if (ppp->slcomp) {
  36347. +    slhc_free(ppp->slcomp);
  36348. +    ppp->slcomp = NULL;
  36349. +  }
  36350. +
  36351. +  ppp->inuse = 0;
  36352. +  ppp->tty   = NULL;
  36353. +}
  36354. +
  36355. +static void
  36356. +ppp_close(struct tty_struct *tty)
  36357. +{
  36358. +  struct ppp *ppp = ppp_find(tty);
  36359. +
  36360. +  if (ppp == NULL || ppp->magic != PPP_MAGIC) {
  36361. +    PRINTKN (1,(KERN_WARNING "ppp: trying to close unopened tty!\n"));
  36362. +  } else {
  36363. +    CHECK_PPP_VOID();
  36364. +    ppp_release (ppp);
  36365. +
  36366. +    PRINTKN (2,(KERN_INFO "ppp: channel %s closing.\n", ppp->dev->name));
  36367. +  }
  36368. +}
  36369. +
  36370. +/* called when PPP line discipline is selected on a tty */
  36371. +static int
  36372. +ppp_open(struct tty_struct *tty)
  36373. +{
  36374. +  struct ppp *ppp = ppp_find(tty);
  36375. +
  36376. +  if (ppp) {
  36377. +    PRINTKN (1,(KERN_ERR "ppp_open: gack! tty already associated to %s!\n",
  36378. +        ppp->magic == PPP_MAGIC ? ppp->dev->name : "unknown"));
  36379. +    return -EEXIST;
  36380. +  }
  36381. +
  36382. +  ppp = ppp_alloc();
  36383. +  if (ppp == NULL) {
  36384. +    PRINTKN (1,(KERN_ERR "ppp_open: couldn't allocate ppp channel\n"));
  36385. +    return -ENFILE;
  36386. +  }
  36387. +
  36388. +  /* make sure the channel is actually open */
  36389. +  ppp_init_ctrl_blk (ppp);
  36390. +
  36391. +  ppp->tty = tty;
  36392. +
  36393. +#ifdef NEW_TTY_DRIVERS
  36394. +  tty->disc_data = ppp;
  36395. +  if (tty->driver.flush_buffer)
  36396. +    tty->driver.flush_buffer(tty);
  36397. +  if (tty->ldisc.flush_buffer)
  36398. +    tty->ldisc.flush_buffer(tty);
  36399. +#else
  36400. +  tty_read_flush (tty);
  36401. +  tty_write_flush (tty);
  36402. +#endif
  36403. +
  36404. +  if ((ppp->slcomp = slhc_init(16, 16)) == NULL) {
  36405. +    PRINTKN (1,(KERN_ERR "ppp: no space for compression buffers!\n"));
  36406. +    ppp_release (ppp);
  36407. +    return -ENOMEM;
  36408. +  }
  36409. +
  36410. +  /* Define the buffers for operation */
  36411. +  ppp_changedmtu (ppp, ppp->dev->mtu, ppp->mru);
  36412. +  if (ppp->rbuff == NULL) {
  36413. +    ppp_release (ppp);
  36414. +    return -ENOMEM;
  36415. +  }
  36416. +
  36417. +  /* Allocate a user-level receive buffer */
  36418. +  ppp->us_rbuff = (unsigned char *) kmalloc (RBUFSIZE, GFP_KERNEL);
  36419. +  if (ppp->us_rbuff == NULL) {
  36420. +    PRINTKN (1,(KERN_ERR "ppp: no space for user receive buffer\n"));
  36421. +    ppp_release (ppp);
  36422. +    return -ENOMEM;
  36423. +  }
  36424. +
  36425. +  ppp->us_rbuff_head =
  36426. +  ppp->us_rbuff_tail = ppp->us_rbuff;
  36427. +  ppp->us_rbuff_end  = ppp->us_rbuff + RBUFSIZE;
  36428. +
  36429. +  PRINTKN (2,(KERN_INFO "ppp: channel %s open\n", ppp->dev->name));
  36430. +
  36431. +#ifdef MODULE
  36432. +  MOD_INC_USE_COUNT;
  36433. +#endif
  36434. +
  36435. +  return (ppp->line);
  36436. +}
  36437. +
  36438. +/* called when ppp interface goes "up".  here this just means we start
  36439. +   passing IP packets */
  36440. +static int
  36441. +ppp_dev_open(struct device *dev)
  36442. +{
  36443. +  struct ppp *ppp = &ppp_ctrl[dev->base_addr];
  36444. +
  36445. +  /* reset POINTOPOINT every time, since dev_close zaps it! */
  36446. +  dev->flags |= IFF_POINTOPOINT;
  36447. +
  36448. +  if (ppp->tty == NULL) {
  36449. +    PRINTKN (1,(KERN_ERR "ppp: %s not connected to a TTY! can't go open!\n",
  36450. +        dev->name));
  36451. +    return -ENXIO;
  36452. +  }
  36453. +
  36454. +  PRINTKN (2,(KERN_INFO "ppp: channel %s going up for IP packets!\n",
  36455. +          dev->name));
  36456. +
  36457. +  CHECK_PPP(-ENXIO);
  36458. +  return 0;
  36459. +}
  36460. +
  36461. +static int
  36462. +ppp_dev_close(struct device *dev)
  36463. +{
  36464. +  struct ppp *ppp = &ppp_ctrl[dev->base_addr];
  36465. +
  36466. +  if (ppp->tty == NULL) {
  36467. +    PRINTKN (1,(KERN_ERR "ppp: %s not connected to a TTY! can't go down!\n",
  36468. +        dev->name));
  36469. +    return -ENXIO;
  36470. +  }
  36471. +
  36472. +  PRINTKN (2,(KERN_INFO "ppp: channel %s going down for IP packets!\n",
  36473. +          dev->name));
  36474. +  CHECK_PPP(-ENXIO);
  36475. +#ifdef MODULE
  36476. +  MOD_DEC_USE_COUNT;
  36477. +#endif
  36478. +  return 0;
  36479. +}
  36480. +
  36481. +#ifndef NET02D
  36482. +static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
  36483. +{
  36484. +  struct ppp *ppp = &ppp_ctrl[dev->base_addr];
  36485. +  int    error;
  36486. +
  36487. +  struct stats
  36488. +  {
  36489. +    struct ppp_stats  ppp_stats;
  36490. +    struct slcompress slhc;
  36491. +  } *result;
  36492. +
  36493. +  error = verify_area (VERIFY_READ,
  36494. +               ifr->ifr_ifru.ifru_data,
  36495. +               sizeof (struct stats));
  36496. +
  36497. +  if (error == 0) {
  36498. +    result = (struct stats *) ifr->ifr_ifru.ifru_data;
  36499. +
  36500. +    memcpy_tofs (&result->ppp_stats, &ppp->stats, sizeof (struct ppp_stats));
  36501. +    if (ppp->slcomp)
  36502. +      memcpy_tofs (&result->slhc,    ppp->slcomp, sizeof (struct slcompress));
  36503. +  }
  36504. +
  36505. +  return error;
  36506. +}
  36507. +#endif
  36508. +
  36509. +/*************************************************************
  36510. + * TTY OUTPUT
  36511. + *    The following function delivers a fully-formed PPP
  36512. + *    frame in ppp->xbuff to the TTY for output.
  36513. + *************************************************************/
  36514. +
  36515. +#ifdef NEW_TTY_DRIVERS
  36516. +static inline void
  36517. +#else
  36518. +static void
  36519. +#endif
  36520. +ppp_output_done (void *ppp)
  36521. +{
  36522. +  /* unlock the transmitter queue */
  36523. +  ppp_unlock ((struct ppp *) ppp);
  36524. +
  36525. +  /* If the device is still up then enable the transmitter of the
  36526. +     next frame. */
  36527. +  if (((struct ppp *) ppp)->dev->flags & IFF_UP)
  36528. +#ifndef NET02D
  36529. +    mark_bh (NET_BH);
  36530. +#else
  36531. +    dev_tint (((struct ppp *) ppp)->dev);
  36532. +#endif
  36533. +
  36534. +  /* enable any blocked process pending transmission */
  36535. +  wake_up_interruptible (&((struct ppp *) ppp)->write_wait);
  36536. +}
  36537. +
  36538. +#ifndef NEW_TTY_DRIVERS
  36539. +static void
  36540. +ppp_kick_tty (struct ppp *ppp)
  36541. +{
  36542. +  register int count = ppp->xhead - ppp->xbuff;
  36543. +  register int answer;
  36544. +
  36545. +  ppp->stats.sbytes += count;
  36546. +
  36547. +  answer = tty_write_data (ppp->tty,
  36548. +               ppp->xbuff,
  36549. +               count,
  36550. +               ppp_output_done,
  36551. +               (void *) ppp);
  36552. +
  36553. +  if (answer == 0)
  36554. +    ppp_output_done (ppp);   /* Should not happen */
  36555. +  else
  36556. +    if (answer < 0) {
  36557. +      ppp->stats.serrors++;
  36558. +      ppp_output_done (ppp); /* unlock the transmitter */
  36559. +    }
  36560. +}
  36561. +
  36562. +#else
  36563. +
  36564. +static void
  36565. +ppp_kick_tty (struct ppp *ppp)
  36566. +{
  36567. +    register int count, actual;
  36568. +    
  36569. +    count = ppp->xhead - ppp->xbuff;
  36570. +    
  36571. +    actual = ppp->tty->driver.write(ppp->tty, 0, ppp->xbuff, count);
  36572. +    ppp->stats.sbytes += actual;
  36573. +    if (actual == count) {
  36574. +        ppp_output_done(ppp);
  36575. +    } else {
  36576. +        ppp->xtail = ppp->xbuff + actual;
  36577. +        ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
  36578. +    }
  36579. +}
  36580. +
  36581. +static void ppp_write_wakeup(struct tty_struct *tty)
  36582. +{
  36583. +    register int count, actual;
  36584. +    struct ppp *ppp = ppp_find(tty);
  36585. +
  36586. +    if (!ppp || ppp->magic != PPP_MAGIC) {
  36587. +        PRINTKN (1,
  36588. +             (KERN_ERR "PPP: write_wakeup called but couldn't "
  36589. +              "find PPP struct.\n"));
  36590. +        return;
  36591. +    }
  36592. +
  36593. +    if (!ppp->xtail)
  36594. +        return;
  36595. +
  36596. +    cli();
  36597. +    if (ppp->flags & SC_XMIT_BUSY) {
  36598. +        sti();
  36599. +        return;
  36600. +    }
  36601. +    ppp->flags |= SC_XMIT_BUSY;
  36602. +    sti();
  36603. +    
  36604. +    count = ppp->xhead - ppp->xtail;
  36605. +    
  36606. +    actual = tty->driver.write(tty, 0, ppp->xtail, count);
  36607. +    ppp->stats.sbytes += actual;
  36608. +    if (actual == count) {
  36609. +        ppp->xtail = 0;
  36610. +        tty->flags &= ~TTY_DO_WRITE_WAKEUP;
  36611. +
  36612. +        ppp_output_done(ppp);
  36613. +    } else {
  36614. +        ppp->xtail += actual;
  36615. +    }
  36616. +    ppp->flags &= ~SC_XMIT_BUSY;
  36617. +}
  36618. +#endif
  36619. +
  36620. +/*************************************************************
  36621. + * TTY INPUT
  36622. + *    The following functions handle input that arrives from
  36623. + *    the TTY.  It recognizes PPP frames and either hands them
  36624. + *    to the network layer or queues them for delivery to a
  36625. + *    user process reading this TTY.
  36626. + *************************************************************/
  36627. +
  36628. +/* stuff a single character into the receive buffer */
  36629. +
  36630. +static inline void
  36631. +ppp_enqueue(struct ppp *ppp, unsigned char c)
  36632. +{
  36633. +  unsigned long flags;
  36634. +
  36635. +  save_flags(flags);
  36636. +  cli();
  36637. +  if (ppp->rhead < ppp->rend) {
  36638. +    *ppp->rhead = c;
  36639. +    ppp->rhead++;
  36640. +    ppp->rcount++;
  36641. +  } else
  36642. +    ppp->stats.roverrun++;
  36643. +  restore_flags(flags);
  36644. +}
  36645. +
  36646. +#ifdef CHECK_CHARACTERS
  36647. +static unsigned paritytab[8] = {
  36648. +    0x96696996, 0x69969669, 0x69969669, 0x96696996,
  36649. +    0x69969669, 0x96696996, 0x96696996, 0x69969669
  36650. +};
  36651. +#endif
  36652. +
  36653. +#ifndef NEW_TTY_DRIVERS
  36654. +static void
  36655. +ppp_dump_inqueue(struct tty_struct *tty)
  36656. +{
  36657. +  int  head = tty->read_q.head,
  36658. +       tail = tty->read_q.tail,
  36659. +       i, count;
  36660. +  char buffer[8];
  36661. +
  36662. +  PRINTK ((KERN_DEBUG "INQUEUE: head %d tail %d imode %x:\n", head, tail, 
  36663. +       (unsigned int) tty->termios->c_iflag))
  36664. +
  36665. +  i     = tail;
  36666. +  count = 0;
  36667. +
  36668. +  while (i != head) {
  36669. +    buffer [count] = tty->read_q.buf[i];
  36670. +    if (++count == 8) {
  36671. +      ppp_print_buffer (NULL, buffer, 8, KERNEL_DS);
  36672. +      count = 0;
  36673. +    }
  36674. +    i = (i + 1) & (TTY_BUF_SIZE - 1);
  36675. +  }
  36676. +  ppp_print_buffer (NULL, buffer, count, KERNEL_DS);
  36677. +}
  36678. +
  36679. +/* called by lower levels of TTY driver when data becomes available.
  36680. +   all incoming data comes through this function. */
  36681. +
  36682. +void ppp_tty_input_ready(struct tty_struct *tty)
  36683. +{
  36684. +  struct ppp *ppp = ppp_find(tty);
  36685. +  int n, error;
  36686. +  unsigned char buff[128];
  36687. +
  36688. +/*  PRINTK( (KERN_DEBUG "PPP: handler called.\n") ) */
  36689. +  if (!ppp || ppp->magic != PPP_MAGIC) {
  36690. +    PRINTKN (1,
  36691. +         (KERN_ERR "PPP: handler called but couldn't find PPP struct.\n"));
  36692. +    return;
  36693. +  }
  36694. +
  36695. +  CHECK_PPP_VOID();
  36696. +
  36697. +  /* ZZZ */
  36698. +  if (ppp_debug >= 5)
  36699. +    ppp_dump_inqueue(ppp->tty);
  36700. +
  36701. +  do {
  36702. +    n = tty_read_raw_data(tty, buff, 128);
  36703. +    if ( n == 0 )        /* nothing there */
  36704. +      break;
  36705. +
  36706. +    if (ppp_debug >= 5)
  36707. +      ppp_print_buffer ("receive buffer", buff, n > 0 ? n : -n, KERNEL_DS);
  36708. +
  36709. +    if ( n < 0 ) {
  36710. +      /* Last character is error flag.
  36711. +     Process the previous characters, then set toss flag. */
  36712. +      n = (-n) - 1;
  36713. +      error = buff[n];
  36714. +    } else error = 0;
  36715. +    ppp->stats.rbytes += n;
  36716. +    ppp_unesc(ppp,buff,n);
  36717. +    if (error)
  36718. +      ppp->toss = error;
  36719. +  } while (1);
  36720. +}
  36721. +
  36722. +/* recover frame by undoing PPP escape mechanism;
  36723. +   copies N chars of input data from C into PPP->rbuff
  36724. +   calls ppp_doframe to dispose of any frames it finds
  36725. +*/
  36726. +
  36727. +static void
  36728. +ppp_unesc(struct ppp *ppp, unsigned char *c, int n)
  36729. +{
  36730. +  int i;
  36731. +
  36732. +  for (i = 0; i < n; i++, c++) {
  36733. +    PRINTKN (6,(KERN_DEBUG "(%x)", (unsigned int) *c));
  36734. +
  36735. +#ifdef CHECK_CHARACTERS
  36736. +    if (*c & 0x80)
  36737. +    sc->sc_flags |= SC_RCV_B7_1;
  36738. +    else
  36739. +    sc->sc_flags |= SC_RCV_B7_0;
  36740. +
  36741. +    if (paritytab[*c >> 5] & (1 << (*c & 0x1F)))
  36742. +    sc->sc_flags |= SC_RCV_ODDP;
  36743. +    else
  36744. +    sc->sc_flags |= SC_RCV_EVNP;
  36745. +#endif
  36746. +
  36747. +    switch (*c) {
  36748. +    case PPP_ESC:        /* PPP_ESC: invert 0x20 in next character */
  36749. +      ppp->escape = PPP_TRANS;
  36750. +      break;
  36751. +
  36752. +    case PPP_FLAG:        /* PPP_FLAG: end of frame */
  36753. +      if (ppp->escape)        /* PPP_ESC just before PPP_FLAG is illegal */
  36754. +    ppp->toss = 0xFF;
  36755. +
  36756. +      if ((ppp->toss & 0x80) == 0)
  36757. +    ppp_doframe(ppp);    /* pass frame on to next layers */
  36758. +
  36759. +      ppp->rcount = 0;
  36760. +      ppp->rhead  = ppp->rbuff;
  36761. +      ppp->escape = 0;
  36762. +      ppp->toss   = 0;
  36763. +      break;
  36764. +
  36765. +    default:            /* regular character */
  36766. +      if (!in_rmap (ppp, *c)) {
  36767. +    if (ppp->toss == 0)
  36768. +      ppp_enqueue (ppp, *c ^ ppp->escape);
  36769. +    ppp->escape = 0;
  36770. +      }
  36771. +      break;
  36772. +    }
  36773. +  }
  36774. +}
  36775. +
  36776. +#else
  36777. +static int ppp_receive_room(struct tty_struct *tty)
  36778. +{
  36779. +    return 65536;  /* We can handle an infinite amount of data. :-) */
  36780. +}
  36781. +
  36782. +
  36783. +static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
  36784. +                char *fp, int count)
  36785. +{
  36786. +  register struct ppp *ppp = ppp_find (tty);
  36787. +  unsigned char c;
  36788. + 
  36789. +/*  PRINTK( ("PPP: handler called.\n") ); */
  36790. +
  36791. +  if (!ppp || ppp->magic != PPP_MAGIC) {
  36792. +    PRINTKN (1,("PPP: handler called but couldn't find "
  36793. +        "PPP struct.\n"));
  36794. +    return;
  36795. +  }
  36796. +
  36797. +  CHECK_PPP_VOID();
  36798. + 
  36799. +  if (ppp_debug >= 5) {
  36800. +    ppp_print_buffer ("receive buffer", cp, count, KERNEL_DS);
  36801. +  }
  36802. +
  36803. +  ppp->stats.rbytes += count;
  36804. + 
  36805. +  while (count-- > 0) {
  36806. +    c = *cp++;
  36807. +
  36808. +    if (fp) {
  36809. +      if (*fp && ppp->toss == 0)
  36810. +    ppp->toss = *fp;
  36811. +      fp++;
  36812. +    }
  36813. +
  36814. +#ifdef CHECK_CHARACTERS
  36815. +    if (c & 0x80)
  36816. +    ppp->flags |= SC_RCV_B7_1;
  36817. +    else
  36818. +    ppp->flags |= SC_RCV_B7_0;
  36819. +
  36820. +    if (paritytab[c >> 5] & (1 << (c & 0x1F)))
  36821. +    ppp->flags |= SC_RCV_ODDP;
  36822. +    else
  36823. +    ppp->flags |= SC_RCV_EVNP;
  36824. +#endif
  36825. +
  36826. +    switch (c) {
  36827. +    case PPP_ESC:        /* PPP_ESC: invert 0x20 in next character */
  36828. +      ppp->escape = PPP_TRANS;
  36829. +      break;
  36830. +
  36831. +    case PPP_FLAG:        /* PPP_FLAG: end of frame */
  36832. +      if (ppp->escape)        /* PPP_ESC just before PPP_FLAG is "cancel"*/
  36833. +    ppp->toss = 0xFF;
  36834. +
  36835. +      if ((ppp->toss & 0x80) == 0)
  36836. +    ppp_doframe(ppp);    /* pass frame on to next layers */
  36837. +
  36838. +      ppp->rcount = 0;
  36839. +      ppp->rhead  = ppp->rbuff;
  36840. +      ppp->escape = 0;
  36841. +      ppp->toss   = 0;
  36842. +      break;
  36843. +
  36844. +    default:            /* regular character */
  36845. +      if (!in_rmap (ppp, c)) {
  36846. +    if (ppp->toss == 0)
  36847. +      ppp_enqueue (ppp, c ^ ppp->escape);
  36848. +    ppp->escape = 0;
  36849. +      }
  36850. +    }
  36851. +  }
  36852. +}
  36853. +#endif
  36854. +
  36855. +/* on entry, a received frame is in ppp->rbuff
  36856. +   check it and dispose as appropriate */
  36857. +static void
  36858. +ppp_doframe(struct ppp *ppp)
  36859. +{
  36860. +  u_char *c = ppp->rbuff;
  36861. +  u_short proto;
  36862. +  int count = ppp->rcount;
  36863. +
  36864. +  /* forget it if we've already noticed an error */
  36865. +  if (ppp->toss) {
  36866. +    PRINTKN (1, (KERN_WARNING "ppp_toss: tossing frame, reason = %d\n",
  36867. +         ppp->toss));
  36868. +    slhc_toss (ppp->slcomp);
  36869. +    ppp->stats.rerrors++;
  36870. +    return;
  36871. +  }
  36872. +
  36873. +  /* do this before printing buffer to avoid generating copious output */
  36874. +  if (count == 0)
  36875. +    return;
  36876. +
  36877. +  if (ppp_debug >= 3)
  36878. +    ppp_print_buffer ("receive frame", c, count, KERNEL_DS);
  36879. +
  36880. +  if (count < 4) {
  36881. +    PRINTKN (1,(KERN_WARNING "ppp: got runt ppp frame, %d chars\n", count));
  36882. +    slhc_toss (ppp->slcomp);
  36883. +    ppp->stats.runts++;
  36884. +    return;
  36885. +  }
  36886. +
  36887. +  /* check PPP error detection field */
  36888. +  if (!ppp_check_fcs(ppp)) {
  36889. +    PRINTKN (1,(KERN_WARNING "ppp: frame with bad fcs\n"));
  36890. +    slhc_toss (ppp->slcomp);
  36891. +    ppp->stats.rerrors++;
  36892. +    return;
  36893. +  }
  36894. +
  36895. +  count -= 2;            /* ignore last two characters */
  36896. +
  36897. +  /* now we have a good frame */
  36898. +  /* figure out the protocol field */
  36899. +  if ((c[0] == PPP_ADDRESS) && (c[1] == PPP_CONTROL)) {
  36900. +    c = c + 2;            /* ADDR/CTRL not compressed, so skip */
  36901. +    count -= 2;
  36902. +  }
  36903. +
  36904. +  proto = (u_short) *c++;        /* PROTO compressed */
  36905. +  if (proto & 1) {
  36906. +    count--;
  36907. +  } else {
  36908. +    proto = (proto << 8) | (u_short) *c++; /* PROTO uncompressed */
  36909. +    count -= 2;
  36910. +  }
  36911. +
  36912. +  /* Send the frame to the network if the ppp device is up */
  36913. +  if ((ppp->dev->flags & IFF_UP) && ppp_do_ip(ppp, proto, c, count)) {
  36914. +    ppp->ddinfo.ip_rjiffies = jiffies;
  36915. +    return;
  36916. +  }
  36917. +
  36918. +  /* If we got here, it has to go to a user process doing a read,
  36919. +     so queue it.
  36920. +
  36921. +     User process expects to get whole frame (for some reason), so
  36922. +     use count+2 so as to include FCS field. */
  36923. +
  36924. +  if (ppp_us_queue (ppp, proto, c, count+2)) {
  36925. +    ppp->ddinfo.nip_rjiffies = jiffies;
  36926. +    ppp->stats.rothers++;
  36927. +    return;
  36928. +  }
  36929. +
  36930. +  /* couldn't cope. */
  36931. +  PRINTKN (1,(KERN_WARNING
  36932. +          "ppp: dropping packet on the floor: nobody could take it.\n"));
  36933. +  slhc_toss (ppp->slcomp);
  36934. +  ppp->stats.tossed++;
  36935. +}
  36936. +
  36937. +/* Examine packet at C, attempt to pass up to net layer. 
  36938. +   PROTO is the protocol field from the PPP frame.
  36939. +   Return 1 if could handle it, 0 otherwise.  */
  36940. +
  36941. +static int
  36942. +ppp_do_ip (struct ppp *ppp, unsigned short proto, unsigned char *c,
  36943. +      int count)
  36944. +{
  36945. +  int flags, done;
  36946. +
  36947. +  PRINTKN (4,(KERN_DEBUG "ppp_do_ip: proto %x len %d first byte %x\n",
  36948. +          (int) proto, count, c[0]));
  36949. +
  36950. +  if (ppp_debug_netpackets) {
  36951. +    PRINTK (("KERN_DEBUG %s <-- proto %x len %d\n", ppp->dev->name,
  36952. +         (int) proto, count));
  36953. +  }
  36954. +    
  36955. +  if (proto == PROTO_IP) {
  36956. +    ppp->stats.runcomp++;
  36957. +    goto sendit;
  36958. +  }
  36959. +
  36960. +  if ((proto == PROTO_VJCOMP) && !(ppp->flags & SC_REJ_COMP_TCP)) {
  36961. +    /* get space for uncompressing the header */
  36962. +    done = 0;
  36963. +    save_flags (flags);
  36964. +    cli();
  36965. +    if ((ppp->rhead + 80) < ppp->rend) {
  36966. +      ppp->rhead += 80;
  36967. +      ppp->rcount += 80;
  36968. +      done = 1;
  36969. +    }
  36970. +    restore_flags(flags);
  36971. +
  36972. +    if (! done)    {
  36973. +      PRINTKN (1,(KERN_NOTICE
  36974. +          "ppp: no space to decompress VJ compressed TCP header.\n"));
  36975. +      ppp->stats.roverrun++;
  36976. +      slhc_toss (ppp->slcomp);
  36977. +      return 1;
  36978. +    }
  36979. +
  36980. +    count = slhc_uncompress(ppp->slcomp, c, count);
  36981. +    if (count <= 0) {
  36982. +      ppp->stats.rerrors++;
  36983. +      PRINTKN (1,(KERN_NOTICE "ppp: error in VJ decompression\n"));
  36984. +      slhc_toss (ppp->slcomp);
  36985. +      return 1;
  36986. +    }
  36987. +    ppp->stats.rcomp++;
  36988. +    goto sendit;
  36989. +  }
  36990. +  
  36991. +  if ((proto == PROTO_VJUNCOMP) && !(ppp->flags & SC_REJ_COMP_TCP)) {
  36992. +    if (slhc_remember(ppp->slcomp, c, count) <= 0) {
  36993. +      ppp->stats.rerrors++;
  36994. +      PRINTKN (1,(KERN_NOTICE "ppp: error in VJ memorizing\n"));
  36995. +      slhc_toss (ppp->slcomp);
  36996. +      return 1;
  36997. +    }
  36998. +    ppp->stats.runcomp++;
  36999. +    goto sendit;
  37000. +  }
  37001. +
  37002. +  /* not ours */
  37003. +  return 0;
  37004. +
  37005. + sendit:
  37006. +  if (ppp_debug_netpackets) {
  37007. +    struct iphdr *iph = (struct iphdr *) c;
  37008. +    PRINTK ((KERN_INFO "%s <--    src %lx dst %lx len %d\n", ppp->dev->name, 
  37009. +         iph->saddr, iph->daddr, count))
  37010. +  }
  37011. +
  37012. +  /* receive the frame through the network software */
  37013. +  (void) dev_rint (c, count, 0, ppp->dev);
  37014. +  return 1;
  37015. +}
  37016. +
  37017. +/* stuff packet at BUF, length LEN, into the us_rbuff buffer
  37018. +   prepend PROTO information */
  37019. +
  37020. +#define PUTC(c,label) *ppp->us_rbuff_head++ = c; \
  37021. +                if (ppp->us_rbuff_head == ppp->us_rbuff_end) \
  37022. +                     ppp->us_rbuff_head = ppp->us_rbuff; \
  37023. +                if (ppp->us_rbuff_head == ppp->us_rbuff_tail) \
  37024. +                     goto label;
  37025. +#define GETC(c) c = *ppp->us_rbuff_tail++; \
  37026. +                if (ppp->us_rbuff_tail == ppp->us_rbuff_end) \
  37027. +                     ppp->us_rbuff_tail = ppp->us_rbuff;
  37028. +
  37029. +static int
  37030. +ppp_us_queue(struct ppp *ppp, unsigned short proto, 
  37031. +         unsigned char *buf, int len)
  37032. +{
  37033. +  int totlen;
  37034. +  unsigned char *saved_head;
  37035. +
  37036. +  totlen = len+2;        /* including protocol */
  37037. +
  37038. +  if (set_bit(1, &ppp->us_rbuff_lock)) {
  37039. +    PRINTKN (1, (KERN_NOTICE "ppp_us_queue: can't get lock\n"));
  37040. +    return 0;
  37041. +  }
  37042. +  saved_head = ppp->us_rbuff_head;
  37043. +
  37044. +  PUTC((totlen & 0xff00) >> 8, failure);
  37045. +  PUTC(totlen & 0x00ff, failure);
  37046. +  PUTC((proto & 0xff00) >> 8, failure);
  37047. +  PUTC(proto & 0x00ff, failure);
  37048. +
  37049. +  while (len-- > 0) {
  37050. +    PUTC(*buf++, failure);
  37051. +  }
  37052. +
  37053. +  PRINTKN (3, (KERN_INFO "ppp: successfully queued %d bytes\n", totlen));
  37054. +  clear_bit(1, &ppp->us_rbuff_lock);
  37055. +  wake_up_interruptible (&ppp->read_wait);
  37056. +
  37057. +#ifdef NEW_TTY_DRIVERS
  37058. +  kill_fasync(ppp->tty->fasync, SIGIO);
  37059. +#endif
  37060. +
  37061. +  if (ppp->inp_sig && ppp->inp_sig_pid)
  37062. +    if (kill_proc (ppp->inp_sig_pid, ppp->inp_sig, 1) != 0) {
  37063. +      /* process is gone */
  37064. +      PRINTKN (2,(KERN_NOTICE
  37065. +          "ppp: process that requested notification is gone\n"));
  37066. +      ppp->inp_sig = 0;
  37067. +      ppp->inp_sig_pid = 0;
  37068. +    }
  37069. +  return 1;
  37070. +
  37071. + failure:
  37072. +  ppp->us_rbuff_head = saved_head;
  37073. +  clear_bit(1, &ppp->us_rbuff_lock);
  37074. +
  37075. +  PRINTKN (1, (KERN_NOTICE "ppp_us_queue: ran out of buffer space.\n"));
  37076. +
  37077. +  return 0;
  37078. +}
  37079. +
  37080. +/*************************************************************
  37081. + * LINE DISCIPLINE SUPPORT
  37082. + *    The following functions form support user programs
  37083. + *    which read and write data on a TTY with the PPP line
  37084. + *    discipline.  Reading is done from a circular queue,
  37085. + *    filled by the lower TTY levels.
  37086. + *************************************************************/
  37087. +
  37088. +/* read a PPP frame from the us_rbuff circular buffer, 
  37089. +   waiting if necessary
  37090. +*/
  37091. +
  37092. +static int
  37093. +ppp_read(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
  37094. +{
  37095. +  struct ppp *ppp = ppp_find(tty);
  37096. +  unsigned char c;
  37097. +  int len, i;
  37098. +
  37099. +  if (!ppp || ppp->magic != PPP_MAGIC) {
  37100. +    PRINTKN (1,(KERN_ERR "ppp_read: cannot find ppp channel\n"));
  37101. +    return -EIO;
  37102. +  }
  37103. +
  37104. +  CHECK_PPP(-ENXIO);
  37105. +
  37106. +  PRINTKN (4,(KERN_DEBUG "ppp_read: called %x num %u\n",
  37107. +          (unsigned int) buf,
  37108. +          nr));
  37109. +
  37110. +  do {
  37111. +    /* try to acquire read lock */
  37112. +    if (set_bit(0, &ppp->us_rbuff_lock) == 0) {
  37113. +      /* got lock */
  37114. +      if (ppp->us_rbuff_head == ppp->us_rbuff_tail) {
  37115. +    /* no data */
  37116. +    PRINTKN (4,(KERN_DEBUG "ppp_read: no data\n"));
  37117. +    clear_bit(0, &ppp->us_rbuff_lock);
  37118. +        if (ppp->inp_sig) {
  37119. +      PRINTKN (4,(KERN_DEBUG "ppp_read: EWOULDBLOCK\n"));
  37120. +      return -EWOULDBLOCK;
  37121. +        } else goto wait;
  37122. +      }
  37123. +
  37124. +      /* reset the time of the last read operation */
  37125. +      ppp->ddinfo.nip_rjiffies = jiffies;
  37126. +
  37127. +      GETC (c); len = c << 8; GETC (c); len += c;
  37128. +
  37129. +      PRINTKN (4,(KERN_DEBUG "ppp_read: len = %d\n", len));
  37130. +
  37131. +      if (len + 2 > nr) {
  37132. +    /* frame too big; can't copy it, but do update us_rbuff_head */
  37133. +    PRINTKN (1,(KERN_DEBUG
  37134. +            "ppp: read of %u bytes too small for %d frame\n",
  37135. +            nr, len+2));
  37136. +    ppp->us_rbuff_head += len;
  37137. +    if (ppp->us_rbuff_head > ppp->us_rbuff_end)
  37138. +      ppp->us_rbuff_head += - (ppp->us_rbuff_end - ppp->us_rbuff);
  37139. +    clear_bit(0, &ppp->us_rbuff_lock);
  37140. +    wake_up_interruptible (&ppp->read_wait);
  37141. +    ppp->stats.rgiants++;
  37142. +    return -EOVERFLOW;        /* ZZZ; HACK! */
  37143. +      } else {
  37144. +    /* have the space: copy the packet, faking the first two bytes */
  37145. +    put_fs_byte (PPP_ADDRESS, buf++);
  37146. +    put_fs_byte (PPP_CONTROL, buf++);
  37147. +    i = len;
  37148. +    while (i-- > 0) {
  37149. +      GETC (c);
  37150. +      put_fs_byte (c, buf++);
  37151. +    }
  37152. +      }
  37153. +
  37154. +      clear_bit(0, &ppp->us_rbuff_lock);
  37155. +      PRINTKN (3,(KERN_DEBUG "ppp_read: passing %d bytes up\n", len + 2));
  37156. +      ppp->stats.rothers++;
  37157. +      return len + 2;
  37158. +    }
  37159. +
  37160. +    /* need to wait */
  37161. +  wait:
  37162. +    current->timeout = 0;
  37163. +    PRINTKN (3,(KERN_DEBUG "ppp_read: sleeping\n"));
  37164. +    interruptible_sleep_on (&ppp->read_wait);
  37165. +    if (current->signal & ~current->blocked)
  37166. +      return -EINTR;
  37167. +  } while (1);
  37168. +}
  37169. +
  37170. +/* stuff a character into the transmit buffer, using PPP's way of escaping
  37171. +   special characters.
  37172. +   also, update ppp->fcs to take account of new character */
  37173. +static inline void
  37174. +ppp_stuff_char(struct ppp *ppp, unsigned char c)
  37175. +{
  37176. +  int curpt = ppp->xhead - ppp->xbuff;
  37177. +  if ((curpt < 0) || (curpt > 3000)) {
  37178. +    PRINTK ((KERN_DEBUG "ppp_stuff_char: %x %x %d\n",
  37179. +         (unsigned int) ppp->xbuff, (unsigned int) ppp->xhead, curpt))
  37180. +  }
  37181. +  if (in_xmap (ppp, c)) {
  37182. +    *ppp->xhead++ = PPP_ESC;
  37183. +    *ppp->xhead++ = c ^ PPP_TRANS;
  37184. +  } else
  37185. +    *ppp->xhead++ = c;
  37186. +  ppp->fcs = (ppp->fcs >> 8) ^ fcstab[(ppp->fcs ^ c) & 0xff];
  37187. +}
  37188. +
  37189. +/* write a frame with NR chars from BUF to TTY
  37190. +   we have to put the FCS field on ourselves
  37191. +*/
  37192. +
  37193. +static int
  37194. +ppp_write(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
  37195. +{
  37196. +  struct ppp *ppp = ppp_find(tty);
  37197. +  int i;
  37198. +
  37199. +  if (!ppp || ppp->magic != PPP_MAGIC) {
  37200. +    PRINTKN (1,(KERN_ERR "ppp_write: cannot find ppp unit\n"));
  37201. +    return -EIO;
  37202. +  }
  37203. +
  37204. +  CHECK_PPP(-ENXIO);
  37205. +  
  37206. +  if (ppp->mtu != ppp->dev->mtu)    /* Someone has been ifconfigging */
  37207. +    ppp_changedmtu (ppp, ppp->dev->mtu, ppp->mru);
  37208. +
  37209. +  if (nr > ppp->mtu) {
  37210. +    PRINTKN (1,(KERN_WARNING
  37211. +        "ppp_write: truncating user packet from %u to mtu %d\n",
  37212. +        nr, ppp->mtu));
  37213. +    nr = ppp->mtu;
  37214. +  }
  37215. +
  37216. +  if (ppp_debug >= 3)
  37217. +    ppp_print_buffer ("write frame", buf, nr, USER_DS);
  37218. +
  37219. +  /* lock this PPP unit so we will be the only writer;
  37220. +     sleep if necessary */
  37221. +  while ((ppp->sending == 1) || !ppp_lock(ppp)) {
  37222. +    current->timeout = 0;
  37223. +    PRINTKN (3,(KERN_DEBUG "ppp_write: sleeping\n"));
  37224. +    interruptible_sleep_on(&ppp->write_wait);
  37225. +    if (current->signal & ~current->blocked)
  37226. +      return -EINTR;
  37227. +  }
  37228. +
  37229. +  /* OK, locked.  Stuff the given bytes into the buffer. */
  37230. +
  37231. +  PRINTKN(4,(KERN_DEBUG "ppp_write: acquired write lock\n"));
  37232. +  ppp->xhead = ppp->xbuff;
  37233. +
  37234. +#ifdef OPTIMIZE_FLAG_TIME
  37235. +  if (jiffies - ppp->last_xmit > OPTIMIZE_FLAG_TIME)
  37236. +    *ppp->xhead++ = PPP_FLAG;
  37237. +  ppp->last_xmit = jiffies;
  37238. +#else      
  37239. +  *ppp->xhead++ = PPP_FLAG;
  37240. +#endif
  37241. +
  37242. +  ppp->fcs = PPP_FCS_INIT;
  37243. +  i = nr;
  37244. +  while (i-- > 0)
  37245. +    ppp_stuff_char(ppp,get_fs_byte(buf++));
  37246. +
  37247. +  ppp_add_fcs(ppp);        /* concatenate FCS at end */
  37248. +
  37249. +  *ppp->xhead++ = PPP_FLAG;
  37250. +  
  37251. +  /* reset the time of the last write operation */
  37252. +  ppp->ddinfo.nip_sjiffies = jiffies;
  37253. +
  37254. +  if (ppp_debug >= 6)
  37255. +    ppp_print_buffer ("xmit buffer", ppp->xbuff, ppp->xhead - ppp->xbuff, KERNEL_DS);
  37256. +  else {
  37257. +    PRINTKN (4,(KERN_DEBUG
  37258. +        "ppp_write: writing %d chars\n", ppp->xhead - ppp->xbuff));
  37259. +  }
  37260. +
  37261. +  /* packet is ready-to-go */
  37262. +  ++ppp->stats.sothers;
  37263. +  ppp_kick_tty(ppp);
  37264. +
  37265. +  return((int)nr);
  37266. +}
  37267. + 
  37268. +static int
  37269. +ppp_ioctl(struct tty_struct *tty, struct file *file, unsigned int i,
  37270. +      unsigned long l)
  37271. +{
  37272. +  struct ppp *ppp = ppp_find(tty);
  37273. +  register int temp_i = 0;
  37274. +  int error;
  37275. +
  37276. +  if (!ppp || ppp->magic != PPP_MAGIC) {
  37277. +    PRINTK ((KERN_ERR "ppp_ioctl: can't find PPP block from tty!\n"))
  37278. +    return -EBADF;
  37279. +  }
  37280. +
  37281. +  CHECK_PPP(-ENXIO);
  37282. +
  37283. +  /* This must be root user */
  37284. +  if (!suser())
  37285. +    return -EPERM;
  37286. +
  37287. +  switch (i) {
  37288. +  case PPPIOCSMRU:
  37289. +    error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  37290. +    if (error == 0) {
  37291. +      temp_i = (int) get_fs_long (l);
  37292. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: set mru to %d\n", temp_i));
  37293. +      if (ppp->mru != temp_i)
  37294. +    ppp_changedmtu (ppp, ppp->dev->mtu, temp_i);
  37295. +    }
  37296. +    break;
  37297. +
  37298. +  case PPPIOCGFLAGS:
  37299. +    error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
  37300. +    if (error == 0) {
  37301. +      temp_i = (ppp->flags & SC_MASK);
  37302. +#ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
  37303. +      temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP;
  37304. +#endif
  37305. +      put_fs_long ((long) temp_i, l);
  37306. +      PRINTKN (3,(KERN_DEBUG "ppp_ioctl: get flags: addr %lx flags %x\n",
  37307. +          l,
  37308. +          temp_i));
  37309. +    }
  37310. +    break;
  37311. +
  37312. +  case PPPIOCSFLAGS:
  37313. +    error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  37314. +    if (error == 0) {
  37315. +      temp_i      = (int) get_fs_long (l);
  37316. +      ppp->flags ^= ((ppp->flags ^ temp_i) & SC_MASK);
  37317. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: set flags to %x\n", temp_i));
  37318. +    }
  37319. +    break;
  37320. +
  37321. +  case PPPIOCGASYNCMAP:
  37322. +    error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
  37323. +    if (error == 0) {
  37324. +      put_fs_long (ppp->xmit_async_map[0], l);
  37325. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: get asyncmap: addr %lx asyncmap %lx\n",
  37326. +          l, ppp->xmit_async_map[0]));
  37327. +    }
  37328. +    break;
  37329. +
  37330. +  case PPPIOCSASYNCMAP:
  37331. +    error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  37332. +    if (error == 0) {
  37333. +      ppp->xmit_async_map[0] = get_fs_long (l);
  37334. +      bset (ppp->xmit_async_map, PPP_FLAG);
  37335. +      bset (ppp->xmit_async_map, PPP_ESC);
  37336. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: set xmit asyncmap %lx\n",
  37337. +          ppp->xmit_async_map[0]));
  37338. +    }
  37339. +    break;
  37340. +
  37341. +  case PPPIOCRASYNCMAP:
  37342. +    error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  37343. +    if (error == 0) {
  37344. +      ppp->recv_async_map = get_fs_long (l);
  37345. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: set recv asyncmap %lx\n",
  37346. +          ppp->recv_async_map));
  37347. +    }
  37348. +    break;
  37349. +
  37350. +  case PPPIOCGUNIT:
  37351. +    error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
  37352. +    if (error == 0) {
  37353. +      put_fs_long (ppp->dev->base_addr, l);
  37354. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: get unit: %ld", ppp->dev->base_addr));
  37355. +    }
  37356. +    break;
  37357. +
  37358. +  case PPPIOCSINPSIG:
  37359. +    error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  37360. +    if (error == 0) {
  37361. +      ppp->inp_sig     = (int) get_fs_long (l);
  37362. +      ppp->inp_sig_pid = current->pid;
  37363. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: set input signal %d\n", ppp->inp_sig));
  37364. +    }
  37365. +    break;
  37366. +
  37367. +  case PPPIOCSDEBUG:
  37368. +    error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  37369. +    if (error == 0) {
  37370. +      ppp_debug = (int) get_fs_long (l);
  37371. +      ppp_debug_netpackets = (ppp_debug & 0xff00) >> 8;
  37372. +      ppp_debug &= 0xff;
  37373. +      PRINTKN (1, (KERN_INFO "ppp_ioctl: set debug level %d, netpacket %d\n", 
  37374. +           ppp_debug, ppp_debug_netpackets));
  37375. +    }
  37376. +    break;
  37377. +
  37378. +  case PPPIOCGDEBUG:
  37379. +    error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
  37380. +    if (error == 0) {
  37381. +      put_fs_long ((long) (ppp_debug | (ppp_debug_netpackets << 8)), l);
  37382. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: get debug level %d\n", 
  37383. +          ppp_debug | (ppp_debug_netpackets << 8)));
  37384. +    }
  37385. +    break;
  37386. +
  37387. +  case PPPIOCGSTAT:
  37388. +    error = verify_area (VERIFY_WRITE, (void *) l, sizeof (struct ppp_stats));
  37389. +    if (error == 0) {
  37390. +      memcpy_tofs ((void *) l, &ppp->stats, sizeof (struct ppp_stats));
  37391. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: read statistics\n"));
  37392. +    }
  37393. +    break;
  37394. +
  37395. +  case PPPIOCGTIME:
  37396. +    error = verify_area (VERIFY_WRITE, (void *) l, sizeof (struct ppp_ddinfo));
  37397. +    if (error == 0) {
  37398. +      struct ppp_ddinfo cur_ddinfo;
  37399. +      unsigned long cur_jiffies = jiffies;
  37400. +
  37401. +      /* change absolute times to relative times. */
  37402. +      cur_ddinfo.ip_sjiffies  = cur_jiffies - ppp->ddinfo.ip_sjiffies;
  37403. +      cur_ddinfo.ip_rjiffies  = cur_jiffies - ppp->ddinfo.ip_rjiffies;
  37404. +      cur_ddinfo.nip_sjiffies = cur_jiffies - ppp->ddinfo.nip_sjiffies;
  37405. +      cur_ddinfo.nip_rjiffies = cur_jiffies - ppp->ddinfo.nip_rjiffies;
  37406. +      
  37407. +      memcpy_tofs ((void *) l, &cur_ddinfo, sizeof (struct ppp_ddinfo));
  37408. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: read demand dial info\n"));
  37409. +    }
  37410. +    break;
  37411. +
  37412. +  case PPPIOCGXASYNCMAP:
  37413. +    error = verify_area (VERIFY_WRITE,
  37414. +             (void *) l,
  37415. +             sizeof (ppp->xmit_async_map));
  37416. +    if (error == 0) {
  37417. +      memcpy_tofs ((void *) l,
  37418. +           ppp->xmit_async_map,
  37419. +           sizeof (ppp->xmit_async_map));
  37420. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: get xasyncmap: addr %lx\n", l));
  37421. +    }
  37422. +    break;
  37423. +
  37424. +  case PPPIOCSXASYNCMAP:
  37425. +    error = verify_area (VERIFY_READ, (void *) l,
  37426. +             sizeof (ppp->xmit_async_map));
  37427. +    if (error == 0) {
  37428. +      unsigned long temp_tbl [8];
  37429. +
  37430. +      memcpy_fromfs (temp_tbl, (void *) l, sizeof (ppp->xmit_async_map));
  37431. +      temp_tbl[1]  =  0x00000000; /* must not escape 0x20 - 0x3f */
  37432. +      temp_tbl[2] &= ~0x40000000; /* must not escape 0x5e        */
  37433. +      temp_tbl[3] |=  0x60000000; /* must escape 0x7d and 0x7e   */
  37434. +
  37435. +      if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
  37436. +      (temp_tbl[4] & temp_tbl[5]) != 0 ||
  37437. +      (temp_tbl[6] & temp_tbl[7]) != 0)
  37438. +    error = -EINVAL;
  37439. +      else {
  37440. +    memcpy (ppp->xmit_async_map, temp_tbl, sizeof (ppp->xmit_async_map));
  37441. +    PRINTKN (3,(KERN_INFO "ppp_ioctl: set xasyncmap\n"));
  37442. +      }
  37443. +    }
  37444. +    break;
  37445. +
  37446. +  case PPPIOCSMAXCID:
  37447. +    error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  37448. +    if (error == 0) {
  37449. +      temp_i = (int) get_fs_long (l) + 1;
  37450. +      PRINTKN (3,(KERN_INFO "ppp_ioctl: set maxcid to %d\n", temp_i));
  37451. +      if (ppp->slcomp != NULL)
  37452. +    slhc_free (ppp->slcomp);
  37453. +
  37454. +      ppp->slcomp = slhc_init (temp_i, temp_i);
  37455. +
  37456. +      if (ppp->slcomp == NULL) {
  37457. +    PRINTKN (1,(KERN_ERR "ppp: no space for compression buffers!\n"));
  37458. +    ppp_release (ppp);
  37459. +    error = -ENOMEM;
  37460. +      }
  37461. +    }
  37462. +    break;
  37463. +
  37464. +#ifdef NEW_TTY_DRIVERS
  37465. +    /* Allow stty to read, but not set, the serial port */
  37466. +  case TCGETS:
  37467. +  case TCGETA:
  37468. +    error = n_tty_ioctl(tty, file, i, l);
  37469. +    break;
  37470. +#endif
  37471. +
  37472. +/*
  37473. + *  All other ioctl() events will come here.
  37474. + */
  37475. +
  37476. +  default:
  37477. +    PRINTKN (1,(KERN_ERR "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
  37478. +        i,
  37479. +        l));
  37480. +#ifdef NEW_TTY_DRIVERS
  37481. +    error = -ENOIOCTLCMD;
  37482. +#else
  37483. +    error = -EINVAL;
  37484. +#endif
  37485. +    break;
  37486. +  }
  37487. +  return error;
  37488. +}
  37489. +
  37490. +static int
  37491. +ppp_select (struct tty_struct *tty, struct inode * inode,
  37492. +        struct file * filp, int sel_type, select_table * wait)
  37493. +{
  37494. +  struct ppp *ppp = ppp_find (tty);
  37495. +  
  37496. +  if (!ppp || ppp->magic != PPP_MAGIC) {
  37497. +    PRINTK ((KERN_ERR "ppp_select: can't find PPP block from tty!\n"))
  37498. +    return -EBADF;
  37499. +  }
  37500. +  
  37501. +  /* If the PPP protocol is no longer active, return false */
  37502. +  CHECK_PPP (0);
  37503. +  
  37504. +  /* Process the request based upon the type desired */
  37505. +  switch (sel_type) {
  37506. +  case SEL_IN:
  37507. +    if (set_bit(0, &ppp->us_rbuff_lock) == 0) {
  37508. +      /* Test for the presence of data in the queue */
  37509. +      if (ppp->us_rbuff_head != ppp->us_rbuff_tail) {
  37510. +    clear_bit (0, &ppp->us_rbuff_lock);
  37511. +    return 1;
  37512. +      }
  37513. +      clear_bit (0, &ppp->us_rbuff_lock);
  37514. +    } /* fall through */
  37515. +
  37516. +  case SEL_EX:
  37517. +    /* Is there a pending error condition? */
  37518. +    if (tty->packet && tty->link->ctrl_status)
  37519. +      return 1;
  37520. +    
  37521. +    /* closed? */
  37522. +    if (tty->flags & (1 << TTY_SLAVE_CLOSED))
  37523. +      return 1;
  37524. +    
  37525. +    /* If the tty is disconnected, then this is an exception too */
  37526. +    if (tty_hung_up_p(filp))
  37527. +      return 1;
  37528. +
  37529. +    select_wait (&ppp->read_wait, wait);
  37530. +    break;
  37531. +    
  37532. +  case SEL_OUT:
  37533. +    if (ppp_lock (ppp)) {
  37534. +      if (ppp->sending == 0) {
  37535. +    ppp_unlock (ppp);
  37536. +    return 1;
  37537. +      }
  37538. +      ppp_unlock (ppp);
  37539. +    }
  37540. +    select_wait (&ppp->write_wait, wait);
  37541. +    break;
  37542. +  }
  37543. +  return 0;
  37544. +}
  37545. +
  37546. +/*************************************************************
  37547. + * NETWORK OUTPUT
  37548. + *    This routine accepts requests from the network layer
  37549. + *    and attempts to deliver the packets.
  37550. + *    It also includes various routines we are compelled to
  37551. + *    have to make the network layer work (arp, etc...).
  37552. + *************************************************************/
  37553. +
  37554. +int
  37555. +ppp_xmit(struct sk_buff *skb, struct device *dev)
  37556. +{
  37557. +  struct tty_struct *tty;
  37558. +  struct ppp *ppp;
  37559. +  unsigned char *p;
  37560. +  unsigned short proto;
  37561. +  int len;
  37562. +
  37563. +  /* just a little sanity check. */
  37564. +  if (skb == NULL) {
  37565. +    PRINTKN(3,(KERN_WARNING "ppp_xmit: null packet!\n"));
  37566. +    return 0;
  37567. +  }
  37568. +
  37569. +  /* Get pointers to the various components */
  37570. +  ppp   = &ppp_ctrl[dev->base_addr];
  37571. +  tty   = ppp->tty;
  37572. +  p     = (unsigned char *) (skb + 1);
  37573. +  len   = skb->len;
  37574. +  proto = PROTO_IP;
  37575. +
  37576. +  PRINTKN(4,(KERN_DEBUG "ppp_xmit [%s]: skb %lX busy %d\n", dev->name, 
  37577. +         (unsigned long int) skb, ppp->sending));
  37578. +
  37579. +  /* avoid race conditions when the link fails */
  37580. +  if (!ppp->inuse) {
  37581. +    dev_kfree_skb(skb, FREE_WRITE);
  37582. +    dev_close (dev);
  37583. +    return 0;
  37584. +  }
  37585. +
  37586. +  if (tty == NULL) {
  37587. +    PRINTKN(1,(KERN_ERR "ppp_xmit: %s not connected to a TTY!\n", dev->name));
  37588. +    goto done;
  37589. +  }
  37590. +
  37591. +  if (!(dev->flags & IFF_UP)) {
  37592. +    PRINTKN(1,(KERN_WARNING
  37593. +           "ppp_xmit: packet sent on interface %s, which is down for IP\n",
  37594. +           dev->name));
  37595. +    goto done;
  37596. +  }
  37597. +
  37598. +  /* get length from IP header as per Alan Cox bugfix for slip.c */
  37599. +  if (len < sizeof(struct iphdr)) {
  37600. +    PRINTKN(0,(KERN_ERR "ppp_xmit: given runt packet, ignoring\n"));
  37601. +    goto done;
  37602. +  }
  37603. +  len = ntohs( ((struct iphdr *)(skb->data)) -> tot_len );
  37604. +
  37605. +  /* If doing demand dial then divert the first frame to pppd. */
  37606. +  if (ppp->flags & SC_IP_DOWN) {
  37607. +    if (ppp->flags & SC_IP_FLUSH == 0) {
  37608. +      if (ppp_us_queue (ppp, proto, p, len))
  37609. +    ppp->flags |= SC_IP_FLUSH;
  37610. +    }
  37611. +    goto done;
  37612. +  }
  37613. +
  37614. +  /* Attempt to acquire send lock */
  37615. +  if (ppp->sending || !ppp_lock(ppp)) {
  37616. +    PRINTKN(3,(KERN_WARNING "ppp_xmit: busy\n"));
  37617. +    ppp->stats.sbusy++;
  37618. +    return 1;
  37619. +  }
  37620. +
  37621. +  ppp->xhead = ppp->xbuff;
  37622. +
  37623. +  /* try to compress, if VJ compression mode is on */
  37624. +  if (ppp->flags & SC_COMP_TCP) {
  37625. +    len = slhc_compress(ppp->slcomp, p, len, ppp->cbuff, &p, 
  37626. +            !(ppp->flags & SC_NO_TCP_CCID));
  37627. +    if (p[0] & SL_TYPE_COMPRESSED_TCP)
  37628. +      proto = PROTO_VJCOMP;
  37629. +    else {
  37630. +      if (p[0] >= SL_TYPE_UNCOMPRESSED_TCP) {
  37631. +    proto = PROTO_VJUNCOMP;
  37632. +    p[0] = (p[0] & 0x0f) | 0x40; 
  37633. +      }
  37634. +    }
  37635. +  }
  37636. +
  37637. +  /* increment appropriate counter */
  37638. +  if (proto == PROTO_VJCOMP)
  37639. +    ++ppp->stats.scomp;
  37640. +  else
  37641. +    ++ppp->stats.suncomp;
  37642. +      
  37643. +  if (ppp_debug_netpackets) {
  37644. +    struct iphdr *iph = (struct iphdr *) (skb + 1);
  37645. +    PRINTK ((KERN_DEBUG "%s ==> proto %x len %d src %x dst %x proto %d\n",
  37646. +        dev->name, (int) proto, (int) len, (int) iph->saddr,
  37647. +        (int) iph->daddr, (int) iph->protocol))
  37648. +  }
  37649. +
  37650. +  /* start of frame:   FLAG  ALL_STATIONS  CONTROL  <protohi> <protolo> */
  37651. +#ifdef OPTIMIZE_FLAG_TIME
  37652. +  if (jiffies - ppp->last_xmit > OPTIMIZE_FLAG_TIME)
  37653. +    *ppp->xhead++ = PPP_FLAG;
  37654. +  ppp->last_xmit = jiffies;
  37655. +#else      
  37656. +  *ppp->xhead++ = PPP_FLAG;
  37657. +#endif
  37658. +
  37659. +  ppp->fcs = PPP_FCS_INIT;
  37660. +  if (!(ppp->flags & SC_COMP_AC)) { 
  37661. +    ppp_stuff_char(ppp, PPP_ADDRESS);
  37662. +    ppp_stuff_char(ppp, PPP_CONTROL);
  37663. +  }
  37664. +
  37665. +  if (!(ppp->flags & SC_COMP_PROT) || (proto & 0xff00))
  37666. +    ppp_stuff_char(ppp, proto>>8);
  37667. +  ppp_stuff_char(ppp, proto&0xff);
  37668. +
  37669. +  /* data part */
  37670. +  while (len-- > 0)
  37671. +    ppp_stuff_char(ppp, *p++);
  37672. +
  37673. +  /* fcs and flag */
  37674. +  ppp_add_fcs(ppp);
  37675. +  *ppp->xhead++ = PPP_FLAG;
  37676. +
  37677. +  /* update the time for demand dial function */
  37678. +  ppp->ddinfo.ip_sjiffies = jiffies;
  37679. +
  37680. +  /* send it! */
  37681. +  if (ppp_debug >= 6)
  37682. +    ppp_print_buffer ("xmit buffer", ppp->xbuff, ppp->xhead - ppp->xbuff, KERNEL_DS);
  37683. +  else {
  37684. +    PRINTKN (4,(KERN_DEBUG
  37685. +        "ppp_write: writing %d chars\n", ppp->xhead - ppp->xbuff));
  37686. +  }
  37687. +
  37688. +  ppp_kick_tty(ppp);
  37689. +
  37690. + done:
  37691. +  dev_kfree_skb(skb, FREE_WRITE);
  37692. +  return 0;
  37693. +}
  37694. +  
  37695. +static unsigned short
  37696. +ppp_type_trans (struct sk_buff *skb, struct device *dev)
  37697. +{
  37698. +  return(htons(ETH_P_IP));
  37699. +}
  37700. +
  37701. +#ifdef NET02D
  37702. +static int
  37703. +ppp_header(unsigned char *buff, struct device *dev, unsigned short type,
  37704. +       unsigned long daddr, unsigned long saddr, unsigned len)
  37705. +{
  37706. +  return(0);
  37707. +}
  37708. +
  37709. +static int
  37710. +ppp_rebuild_header(void *buff, struct device *dev)
  37711. +{
  37712. +  return(0);
  37713. +}
  37714. +
  37715. +static void
  37716. +ppp_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
  37717. +{
  37718. +}
  37719. +
  37720. +#else
  37721. +
  37722. +static int
  37723. +ppp_header(unsigned char *buff, struct device *dev, unsigned short type,
  37724. +       void *daddr, void *saddr, unsigned len, struct sk_buff *skb)
  37725. +{
  37726. +  return(0);
  37727. +}
  37728. +
  37729. +static int
  37730. +ppp_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
  37731. +           struct sk_buff *skb)
  37732. +{
  37733. +  return(0);
  37734. +}
  37735. +#endif
  37736. +
  37737. +static struct enet_statistics *
  37738. +ppp_get_stats (struct device *dev)
  37739. +{
  37740. +  struct ppp *ppp = &ppp_ctrl[dev->base_addr];
  37741. +  static struct enet_statistics ppp_stats;
  37742. +
  37743. +  ppp_stats.rx_packets = ppp->stats.rcomp + ppp->stats.runcomp;
  37744. +  ppp_stats.rx_errors = ppp->stats.rerrors;
  37745. +  ppp_stats.rx_dropped = ppp->stats.tossed;
  37746. +  ppp_stats.rx_fifo_errors = 0;
  37747. +  ppp_stats.rx_length_errors = ppp->stats.runts;
  37748. +  ppp_stats.rx_over_errors = ppp->stats.roverrun;
  37749. +  ppp_stats.rx_crc_errors = 0;
  37750. +  ppp_stats.rx_frame_errors = 0;
  37751. +  ppp_stats.tx_packets = ppp->stats.scomp + ppp->stats.suncomp;
  37752. +  ppp_stats.tx_errors = ppp->stats.serrors;
  37753. +  ppp_stats.tx_dropped = 0;
  37754. +  ppp_stats.tx_fifo_errors = 0;
  37755. +  ppp_stats.collisions = ppp->stats.sbusy;
  37756. +  ppp_stats.tx_carrier_errors = 0;
  37757. +  ppp_stats.tx_aborted_errors = 0;
  37758. +  ppp_stats.tx_window_errors = 0;
  37759. +  ppp_stats.tx_heartbeat_errors = 0;
  37760. +
  37761. +  PRINTKN (3, (KERN_INFO "ppp_get_stats called"));
  37762. +  return &ppp_stats;
  37763. +}
  37764. +
  37765. +/*************************************************************
  37766. + * UTILITIES
  37767. + *    Miscellany called by various functions above.
  37768. + *************************************************************/
  37769. +
  37770. +#ifndef NEW_TTY_DRIVERS
  37771. +/* find a PPP channel given a TTY */
  37772. +struct ppp *
  37773. +ppp_find(struct tty_struct *tty)
  37774. +{
  37775. +  int i;
  37776. +  for (i = 0; i < PPP_NRUNIT; i++)
  37777. +    if (ppp_ctrl[i].inuse && (ppp_ctrl[i].tty == tty)) return &ppp_ctrl[i];
  37778. +
  37779. +  return NULL;
  37780. +}
  37781. +#endif
  37782. +
  37783. +/* allocate a PPP channel */
  37784. +static struct ppp *
  37785. +ppp_alloc(void)
  37786. +{
  37787. +  int i;
  37788. +  for (i = 0; i < PPP_NRUNIT; i++)
  37789. +    if (!set_bit(0, &ppp_ctrl[i].inuse)) return &ppp_ctrl[i];
  37790. +
  37791. +  return NULL;
  37792. +}
  37793. +
  37794. +/* marks a PPP interface 'busy'.  user processes will wait, if
  37795. +   they try to write, and the network code will refrain from sending
  37796. +   return nonzero if succeeded in acquiring lock
  37797. +*/
  37798. +
  37799. +static int
  37800. +ppp_lock(struct ppp *ppp)
  37801. +{
  37802. +  int flags, locked;
  37803. +  save_flags(flags);
  37804. +  cli();
  37805. +  locked = ppp->sending;
  37806. +  ppp->sending = 1;
  37807. +  if (ppp->dev->flags & IFF_UP)
  37808. +    ppp->dev->tbusy = 1;
  37809. +  restore_flags(flags);
  37810. +  return locked == 0;
  37811. +}
  37812. +
  37813. +static void
  37814. +ppp_unlock(struct ppp *ppp)
  37815. +{
  37816. +  int flags;
  37817. +  save_flags(flags);
  37818. +  cli();
  37819. +  ppp->sending = 0;
  37820. +  if (ppp->dev->flags & IFF_UP)
  37821. +    ppp->dev->tbusy = 0;
  37822. +  restore_flags(flags);
  37823. +}
  37824. +
  37825. +/* FCS support functions */
  37826. +
  37827. +static void
  37828. +ppp_add_fcs(struct ppp *ppp)
  37829. +{
  37830. +  unsigned short fcs = ppp->fcs;
  37831. +
  37832. +  fcs ^= 0xffff;
  37833. +  ppp_stuff_char(ppp, fcs & 0x00ff);
  37834. +  ppp_stuff_char(ppp, (fcs & 0xff00) >> 8);
  37835. +  ASSERT (ppp->fcs == PPP_FCS_GOOD);
  37836. +  PRINTKN (4,(KERN_DEBUG "ppp_add_fcs: fcs is %lx\n",
  37837. +          (long) (unsigned long) fcs));
  37838. +}
  37839. +
  37840. +static int
  37841. +ppp_check_fcs(struct ppp *ppp)
  37842. +{
  37843. +  unsigned short fcs = PPP_FCS_INIT, msgfcs;
  37844. +  unsigned char *c = ppp->rbuff;
  37845. +  int i;
  37846. +
  37847. +  for (i = 0; i < ppp->rcount - 2; i++, c++)
  37848. +    fcs = (fcs >> 8) ^ fcstab[(fcs ^ *c) & 0xff];
  37849. +
  37850. +  fcs ^= 0xffff;
  37851. +  msgfcs = (c[1] << 8) + c[0];
  37852. +  PRINTKN (4,(KERN_INFO "ppp_check_fcs: got %lx want %lx\n",
  37853. +          (unsigned long) msgfcs, (unsigned long) fcs));
  37854. +  return fcs == msgfcs;
  37855. +}
  37856. +
  37857. +static char hex[] = "0123456789ABCDEF";
  37858. +
  37859. +static inline void ppp_print_hex (register char *out, char *in, int count)
  37860. +{
  37861. +  register unsigned char next_ch;
  37862. +
  37863. +  while (count-- > 0) {
  37864. +    next_ch = (unsigned char) get_fs_byte (in);
  37865. +
  37866. +    *out++  = hex[(next_ch >> 4) & 0x0F];
  37867. +    *out++  = hex[next_ch        & 0x0F];
  37868. +    ++out;
  37869. +    ++in;
  37870. +  }
  37871. +}
  37872. +
  37873. +static inline void ppp_print_char (register char *out, char *in, int count)
  37874. +{
  37875. +  register unsigned char next_ch;
  37876. +
  37877. +  while (count-- > 0) {
  37878. +    next_ch = (unsigned char) get_fs_byte (in);
  37879. +
  37880. +    if (next_ch < 0x20 || next_ch > 0x7e)
  37881. +      *out++ = '.';
  37882. +    else {
  37883. +      *out++ = next_ch;
  37884. +      if (next_ch == '%')    /* printk/syslogd has a bug !! */
  37885. +    *out++ = '%';
  37886. +    }
  37887. +    ++in;
  37888. +  }
  37889. +  *out = '\0';
  37890. +}
  37891. +
  37892. +static void ppp_print_buffer(const char *name, char *buf, int count, int seg)
  37893. +{
  37894. +  char line [44];
  37895. +  int  old_fs = get_fs();
  37896. +
  37897. +  set_fs (seg);
  37898. +
  37899. +  if (name != NULL)
  37900. +    PRINTK ((KERN_DEBUG "ppp: %s, count = %d\n", name, count));
  37901. +
  37902. +  while (count > 8) {
  37903. +    memset         (line, ' ', sizeof (line));
  37904. +    ppp_print_hex  (line, buf, 8);
  37905. +    ppp_print_char (&line[8 * 3], buf, 8);
  37906. +    PRINTK ((KERN_DEBUG "%s\n", line));
  37907. +    count -= 8;
  37908. +    buf   += 8;
  37909. +  }
  37910. +
  37911. +  if (count > 0) {
  37912. +    memset         (line, ' ', sizeof (line));
  37913. +    ppp_print_hex  (line, buf, count);
  37914. +    ppp_print_char (&line[8 * 3], buf, count);
  37915. +    PRINTK ((KERN_DEBUG "%s\n", line));
  37916. +  }
  37917. +
  37918. +  set_fs (old_fs);
  37919. +}
  37920. +
  37921. +#ifdef MODULE
  37922. +char kernel_version[] = UTS_RELEASE;
  37923. +
  37924. +static struct device dev_ppp[PPP_NRUNIT] = {
  37925. +    {
  37926. +        "ppp0",        /* ppp */
  37927. +        0, 0, 0, 0,    /* memory */
  37928. +        0, 0,        /* base, irq */
  37929. +        0, 0, 0, NULL, ppp_init,
  37930. +    }
  37931. +    , { "ppp1" , 0, 0, 0, 0,  1, 0, 0, 0, 0, NULL, ppp_init }
  37932. +    , { "ppp2" , 0, 0, 0, 0,  2, 0, 0, 0, 0, NULL, ppp_init }
  37933. +    , { "ppp3" , 0, 0, 0, 0,  3, 0, 0, 0, 0, NULL, ppp_init }
  37934. +
  37935. +#ifdef PPP_PPP_LOTS
  37936. +    , { "ppp4" , 0, 0, 0, 0,  4, 0, 0, 0, 0, NULL, ppp_init }
  37937. +    , { "ppp5" , 0, 0, 0, 0,  5, 0, 0, 0, 0, NULL, ppp_init }
  37938. +    , { "ppp6" , 0, 0, 0, 0,  6, 0, 0, 0, 0, NULL, ppp_init }
  37939. +    , { "ppp7" , 0, 0, 0, 0,  7, 0, 0, 0, 0, NULL, ppp_init }
  37940. +    , { "ppp8" , 0, 0, 0, 0,  8, 0, 0, 0, 0, NULL, ppp_init }
  37941. +    , { "ppp9" , 0, 0, 0, 0,  9, 0, 0, 0, 0, NULL, ppp_init }
  37942. +    , { "ppp10" , 0, 0, 0, 0, 10, 0, 0, 0, 0, NULL, ppp_init }
  37943. +    , { "ppp11" , 0, 0, 0, 0, 11, 0, 0, 0, 0, NULL, ppp_init }
  37944. +    , { "ppp12" , 0, 0, 0, 0, 12, 0, 0, 0, 0, NULL, ppp_init }
  37945. +    , { "ppp13" , 0, 0, 0, 0, 13, 0, 0, 0, 0, NULL, ppp_init }
  37946. +    , { "ppp14" , 0, 0, 0, 0, 14, 0, 0, 0, 0, NULL, ppp_init }
  37947. +    , { "ppp15" , 0, 0, 0, 0, 15, 0, 0, 0, 0, NULL, ppp_init }
  37948. +#endif
  37949. +};
  37950. +
  37951. +int
  37952. +init_module(void)
  37953. +{
  37954. +    int err;
  37955. +    int i;
  37956. +
  37957. +    for (i = 0; i < PPP_NRUNIT; i++)  {
  37958. +        if ((err = register_netdev(&dev_ppp[i])))  {
  37959. +            if (err == -EEXIST)  {
  37960. +                printk("PPP: devices already present. Module not loaded.\n");
  37961. +            }
  37962. +            return err;
  37963. +        }
  37964. +    }
  37965. +    return 0;
  37966. +}
  37967. +
  37968. +void
  37969. +cleanup_module(void)
  37970. +{
  37971. +    int i;
  37972. +
  37973. +    if (MOD_IN_USE)  {
  37974. +        printk("PPP: device busy, remove delayed\n");
  37975. +        return;
  37976. +    }
  37977. +    for (i = 0; i < PPP_NRUNIT; i++)  {
  37978. +        unregister_netdev(&dev_ppp[i]);
  37979. +    }
  37980. +    if ((i = tty_register_ldisc(N_PPP, NULL)))  {
  37981. +        printk("PPP: can't unregister line discipline (err = %d)\n", i);
  37982. +    }
  37983. +}
  37984. +
  37985. +#endif
  37986. diff -r -u -N linux.orig/arch/arm/drivers/net/slhc.c linux.arm/arch/arm/drivers/net/slhc.c
  37987. --- linux.orig/arch/arm/drivers/net/slhc.c    Thu Jan  1 01:00:00 1970
  37988. +++ linux.arm/arch/arm/drivers/net/slhc.c    Fri Oct 27 23:15:05 1995
  37989. @@ -0,0 +1,747 @@
  37990. +/*
  37991. + * Routines to compress and uncompress tcp packets (for transmission
  37992. + * over low speed serial lines).
  37993. + *
  37994. + * Copyright (c) 1989 Regents of the University of California.
  37995. + * All rights reserved.
  37996. + *
  37997. + * Redistribution and use in source and binary forms are permitted
  37998. + * provided that the above copyright notice and this paragraph are
  37999. + * duplicated in all such forms and that any documentation,
  38000. + * advertising materials, and other materials related to such
  38001. + * distribution and use acknowledge that the software was developed
  38002. + * by the University of California, Berkeley.  The name of the
  38003. + * University may not be used to endorse or promote products derived
  38004. + * from this software without specific prior written permission.
  38005. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  38006. + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  38007. + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  38008. + *
  38009. + *    Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
  38010. + *    - Initial distribution.
  38011. + *
  38012. + *
  38013. + * modified for KA9Q Internet Software Package by
  38014. + * Katie Stevens (dkstevens@ucdavis.edu)
  38015. + * University of California, Davis
  38016. + * Computing Services
  38017. + *    - 01-31-90    initial adaptation (from 1.19)
  38018. + *    PPP.05    02-15-90 [ks]
  38019. + *    PPP.08    05-02-90 [ks]    use PPP protocol field to signal compression
  38020. + *    PPP.15    09-90     [ks]    improve mbuf handling
  38021. + *    PPP.16    11-02     [karn]    substantially rewritten to use NOS facilities
  38022. + *
  38023. + *    - Feb 1991    Bill_Simpson@um.cc.umich.edu
  38024. + *            variable number of conversation slots
  38025. + *            allow zero or one slots
  38026. + *            separate routines
  38027. + *            status display
  38028. + *    - Jul 1994    Dmitry Gorodchanin
  38029. + *            Fixes for memory leaks.
  38030. + *      - Oct 1994      Dmitry Gorodchanin
  38031. + *                      Modularization.
  38032. + *    - Jan 1995    Bjorn Ekwall
  38033. + *            Use ip_fast_csum from ip.h
  38034. + *
  38035. + *
  38036. + *    This module is a difficult issue. It's clearly inet code but it's also clearly
  38037. + *    driver code belonging close to PPP and SLIP
  38038. + */
  38039. +
  38040. +#include <linux/config.h>
  38041. +#ifdef CONFIG_INET
  38042. +/* Entire module is for IP only */
  38043. +#ifdef MODULE
  38044. +#include <linux/module.h>
  38045. +#include <linux/version.h>
  38046. +#endif
  38047. +
  38048. +#include <linux/types.h>
  38049. +#include <linux/sched.h>
  38050. +#include <linux/mm.h>
  38051. +#include <linux/string.h>
  38052. +#include <linux/socket.h>
  38053. +#include <linux/sockios.h>
  38054. +#include <linux/termios.h>
  38055. +#include <linux/in.h>
  38056. +#include <linux/fcntl.h>
  38057. +#include <linux/inet.h>
  38058. +#include <linux/netdevice.h>
  38059. +#include "ip.h"
  38060. +#include "protocol.h"
  38061. +#include "icmp.h"
  38062. +#include "tcp.h"
  38063. +#include <linux/skbuff.h>
  38064. +#include "sock.h"
  38065. +#include <linux/errno.h>
  38066. +#include <linux/timer.h>
  38067. +#include <asm/system.h>
  38068. +#include <asm/segment.h>
  38069. +#include <linux/mm.h>
  38070. +#include "slhc.h"
  38071. +
  38072. +int last_retran;
  38073. +
  38074. +static unsigned char *encode(unsigned char *cp, unsigned short n);
  38075. +static long decode(unsigned char **cpp);
  38076. +static unsigned char * put16(unsigned char *cp, unsigned short x);
  38077. +static unsigned short pull16(unsigned char **cpp);
  38078. +
  38079. +/* Initialize compression data structure
  38080. + *    slots must be in range 0 to 255 (zero meaning no compression)
  38081. + */
  38082. +struct slcompress *
  38083. +slhc_init(int rslots, int tslots)
  38084. +{
  38085. +    register short i;
  38086. +    register struct cstate *ts;
  38087. +    struct slcompress *comp;
  38088. +
  38089. +    comp = (struct slcompress *)kmalloc(sizeof(struct slcompress),
  38090. +                        GFP_KERNEL);
  38091. +    if (! comp)
  38092. +        return NULL;
  38093. +
  38094. +    memset(comp, 0, sizeof(struct slcompress));
  38095. +
  38096. +    if ( rslots > 0  &&  rslots < 256 ) {
  38097. +        comp->rstate =
  38098. +          (struct cstate *)kmalloc(rslots * sizeof(struct cstate),
  38099. +                       GFP_KERNEL);
  38100. +        if (! comp->rstate)
  38101. +        {
  38102. +            kfree((unsigned char *)comp);
  38103. +            return NULL;
  38104. +        }
  38105. +        memset(comp->rstate, 0, rslots * sizeof(struct cstate));
  38106. +        comp->rslot_limit = rslots - 1;
  38107. +    }
  38108. +
  38109. +    if ( tslots > 0  &&  tslots < 256 ) {
  38110. +        comp->tstate =
  38111. +          (struct cstate *)kmalloc(tslots * sizeof(struct cstate),
  38112. +                       GFP_KERNEL);
  38113. +        if (! comp->tstate)
  38114. +        {
  38115. +            kfree((unsigned char *)comp->rstate);
  38116. +            kfree((unsigned char *)comp);
  38117. +            return NULL;
  38118. +        }
  38119. +        memset(comp->tstate, 0, rslots * sizeof(struct cstate));
  38120. +        comp->tslot_limit = tslots - 1;
  38121. +    }
  38122. +
  38123. +    comp->xmit_oldest = 0;
  38124. +    comp->xmit_current = 255;
  38125. +    comp->recv_current = 255;
  38126. +    /*
  38127. +     * don't accept any packets with implicit index until we get
  38128. +     * one with an explicit index.  Otherwise the uncompress code
  38129. +     * will try to use connection 255, which is almost certainly
  38130. +     * out of range
  38131. +     */
  38132. +    comp->flags |= SLF_TOSS;
  38133. +
  38134. +    if ( tslots > 0 ) {
  38135. +        ts = comp->tstate;
  38136. +        for(i = comp->tslot_limit; i > 0; --i){
  38137. +            ts[i].cs_this = i;
  38138. +            ts[i].next = &(ts[i - 1]);
  38139. +        }
  38140. +        ts[0].next = &(ts[comp->tslot_limit]);
  38141. +        ts[0].cs_this = 0;
  38142. +    }
  38143. +#ifdef MODULE
  38144. +    MOD_INC_USE_COUNT;
  38145. +#endif
  38146. +    return comp;
  38147. +}
  38148. +
  38149. +
  38150. +/* Free a compression data structure */
  38151. +void
  38152. +slhc_free(struct slcompress *comp)
  38153. +{
  38154. +    if ( comp == NULLSLCOMPR )
  38155. +        return;
  38156. +
  38157. +    if ( comp->rstate != NULLSLSTATE )
  38158. +        kfree( comp->rstate );
  38159. +
  38160. +    if ( comp->tstate != NULLSLSTATE )
  38161. +        kfree( comp->tstate );
  38162. +
  38163. +#ifdef MODULE
  38164. +    MOD_DEC_USE_COUNT;
  38165. +#endif
  38166. +    kfree( comp );
  38167. +}
  38168. +
  38169. +
  38170. +/* Put a short in host order into a char array in network order */
  38171. +static inline unsigned char *
  38172. +put16(unsigned char *cp, unsigned short x)
  38173. +{
  38174. +    *cp++ = x >> 8;
  38175. +    *cp++ = x;
  38176. +
  38177. +    return cp;
  38178. +}
  38179. +
  38180. +
  38181. +/* Encode a number */
  38182. +unsigned char *
  38183. +encode(unsigned char *cp, unsigned short n)
  38184. +{
  38185. +    if(n >= 256 || n == 0){
  38186. +        *cp++ = 0;
  38187. +        cp = put16(cp,n);
  38188. +    } else {
  38189. +        *cp++ = n;
  38190. +    }
  38191. +    return cp;
  38192. +}
  38193. +
  38194. +/* Pull a 16-bit integer in host order from buffer in network byte order */
  38195. +static unsigned short
  38196. +pull16(unsigned char **cpp)
  38197. +{
  38198. +    short rval;
  38199. +
  38200. +    rval = *(*cpp)++;
  38201. +    rval <<= 8;
  38202. +    rval |= *(*cpp)++;
  38203. +    return rval;
  38204. +}
  38205. +
  38206. +/* Decode a number */
  38207. +long
  38208. +decode(unsigned char **cpp)
  38209. +{
  38210. +    register int x;
  38211. +
  38212. +    x = *(*cpp)++;
  38213. +    if(x == 0){
  38214. +        return pull16(cpp) & 0xffff;    /* pull16 returns -1 on error */
  38215. +    } else {
  38216. +        return x & 0xff;        /* -1 if PULLCHAR returned error */
  38217. +    }
  38218. +}
  38219. +
  38220. +/*
  38221. + * icp and isize are the original packet.
  38222. + * ocp is a place to put a copy if necessary.
  38223. + * cpp is initially a pointer to icp.  If the copy is used,
  38224. + *    change it to ocp.
  38225. + */
  38226. +
  38227. +int
  38228. +slhc_compress(struct slcompress *comp, unsigned char *icp, int isize,
  38229. +    unsigned char *ocp, unsigned char **cpp, int compress_cid)
  38230. +{
  38231. +    register struct cstate *ocs = &(comp->tstate[comp->xmit_oldest]);
  38232. +    register struct cstate *lcs = ocs;
  38233. +    register struct cstate *cs = lcs->next;
  38234. +    register unsigned long deltaS, deltaA;
  38235. +    register short changes = 0;
  38236. +    int hlen;
  38237. +    unsigned char new_seq[16];
  38238. +    register unsigned char *cp = new_seq;
  38239. +    struct iphdr *ip;
  38240. +    struct tcphdr *th, *oth;
  38241. +
  38242. +    ip = (struct iphdr *) icp;
  38243. +
  38244. +    /* Bail if this packet isn't TCP, or is an IP fragment */
  38245. +    if(ip->protocol != IPPROTO_TCP || (ntohs(ip->frag_off) & 0x1fff) ||
  38246. +                       (ip->frag_off & 32)){
  38247. +        /* Send as regular IP */
  38248. +        if(ip->protocol != IPPROTO_TCP)
  38249. +            comp->sls_o_nontcp++;
  38250. +        else
  38251. +            comp->sls_o_tcp++;
  38252. +        return isize;
  38253. +    }
  38254. +    /* Extract TCP header */
  38255. +
  38256. +    th = (struct tcphdr *)(((unsigned char *)ip) + ip->ihl*4);
  38257. +    hlen = ip->ihl*4 + th->doff*4;
  38258. +
  38259. +    /*  Bail if the TCP packet isn't `compressible' (i.e., ACK isn't set or
  38260. +     *  some other control bit is set).
  38261. +     */
  38262. +    if(th->syn || th->fin || th->rst ||
  38263. +        ! (th->ack)){
  38264. +        /* TCP connection stuff; send as regular IP */
  38265. +        comp->sls_o_tcp++;
  38266. +        return isize;
  38267. +    }
  38268. +    /*
  38269. +     * Packet is compressible -- we're going to send either a
  38270. +     * COMPRESSED_TCP or UNCOMPRESSED_TCP packet.  Either way,
  38271. +     * we need to locate (or create) the connection state.
  38272. +     *
  38273. +     * States are kept in a circularly linked list with
  38274. +     * xmit_oldest pointing to the end of the list.  The
  38275. +     * list is kept in lru order by moving a state to the
  38276. +     * head of the list whenever it is referenced.  Since
  38277. +     * the list is short and, empirically, the connection
  38278. +     * we want is almost always near the front, we locate
  38279. +     * states via linear search.  If we don't find a state
  38280. +     * for the datagram, the oldest state is (re-)used.
  38281. +     */
  38282. +    for ( ; ; ) {
  38283. +        if( ip->saddr == cs->cs_ip.saddr
  38284. +         && ip->daddr == cs->cs_ip.daddr
  38285. +         && th->source == cs->cs_tcp.source
  38286. +         && th->dest == cs->cs_tcp.dest)
  38287. +            goto found;
  38288. +
  38289. +        /* if current equal oldest, at end of list */
  38290. +        if ( cs == ocs )
  38291. +            break;
  38292. +        lcs = cs;
  38293. +        cs = cs->next;
  38294. +        comp->sls_o_searches++;
  38295. +    };
  38296. +    /*
  38297. +     * Didn't find it -- re-use oldest cstate.  Send an
  38298. +     * uncompressed packet that tells the other side what
  38299. +     * connection number we're using for this conversation.
  38300. +     *
  38301. +     * Note that since the state list is circular, the oldest
  38302. +     * state points to the newest and we only need to set
  38303. +     * xmit_oldest to update the lru linkage.
  38304. +     */
  38305. +    comp->sls_o_misses++;
  38306. +    comp->xmit_oldest = lcs->cs_this;
  38307. +    goto uncompressed;
  38308. +
  38309. +found:
  38310. +    /*
  38311. +     * Found it -- move to the front on the connection list.
  38312. +     */
  38313. +    if(lcs == ocs) {
  38314. +         /* found at most recently used */
  38315. +    } else if (cs == ocs) {
  38316. +        /* found at least recently used */
  38317. +        comp->xmit_oldest = lcs->cs_this;
  38318. +    } else {
  38319. +        /* more than 2 elements */
  38320. +        lcs->next = cs->next;
  38321. +        cs->next = ocs->next;
  38322. +        ocs->next = cs;
  38323. +    }
  38324. +
  38325. +    /*
  38326. +     * Make sure that only what we expect to change changed.
  38327. +     * Check the following:
  38328. +     * IP protocol version, header length & type of service.
  38329. +     * The "Don't fragment" bit.
  38330. +     * The time-to-live field.
  38331. +     * The TCP header length.
  38332. +     * IP options, if any.
  38333. +     * TCP options, if any.
  38334. +     * If any of these things are different between the previous &
  38335. +     * current datagram, we send the current datagram `uncompressed'.
  38336. +     */
  38337. +    oth = &cs->cs_tcp;
  38338. +
  38339. +    if(last_retran
  38340. +     || ip->version != cs->cs_ip.version || ip->ihl != cs->cs_ip.ihl
  38341. +     || ip->tos != cs->cs_ip.tos
  38342. +     || (ip->frag_off & 64) != (cs->cs_ip.frag_off & 64)
  38343. +     || ip->ttl != cs->cs_ip.ttl
  38344. +     || th->doff != cs->cs_tcp.doff
  38345. +     || (ip->ihl > 5 && memcmp(ip+1,cs->cs_ipopt,((ip->ihl)-5)*4) != 0)
  38346. +     || (th->doff > 5 && memcmp(th+1,cs->cs_tcpopt,((th->doff)-5)*4 != 0))){
  38347. +        goto uncompressed;
  38348. +    }
  38349. +
  38350. +    /*
  38351. +     * Figure out which of the changing fields changed.  The
  38352. +     * receiver expects changes in the order: urgent, window,
  38353. +     * ack, seq (the order minimizes the number of temporaries
  38354. +     * needed in this section of code).
  38355. +     */
  38356. +    if(th->urg){
  38357. +        deltaS = ntohs(th->urg_ptr);
  38358. +        cp = encode(cp,deltaS);
  38359. +        changes |= NEW_U;
  38360. +    } else if(th->urg_ptr != oth->urg_ptr){
  38361. +        /* argh! URG not set but urp changed -- a sensible
  38362. +         * implementation should never do this but RFC793
  38363. +         * doesn't prohibit the change so we have to deal
  38364. +         * with it. */
  38365. +        goto uncompressed;
  38366. +    }
  38367. +    if((deltaS = ntohs(th->window) - ntohs(oth->window)) != 0){
  38368. +        cp = encode(cp,deltaS);
  38369. +        changes |= NEW_W;
  38370. +    }
  38371. +    if((deltaA = ntohl(th->ack_seq) - ntohl(oth->ack_seq)) != 0L){
  38372. +        if(deltaA > 0x0000ffff)
  38373. +            goto uncompressed;
  38374. +        cp = encode(cp,deltaA);
  38375. +        changes |= NEW_A;
  38376. +    }
  38377. +    if((deltaS = ntohl(th->seq) - ntohl(oth->seq)) != 0L){
  38378. +        if(deltaS > 0x0000ffff)
  38379. +            goto uncompressed;
  38380. +        cp = encode(cp,deltaS);
  38381. +        changes |= NEW_S;
  38382. +    }
  38383. +
  38384. +    switch(changes){
  38385. +    case 0:    /* Nothing changed. If this packet contains data and the
  38386. +         * last one didn't, this is probably a data packet following
  38387. +         * an ack (normal on an interactive connection) and we send
  38388. +         * it compressed.  Otherwise it's probably a retransmit,
  38389. +         * retransmitted ack or window probe.  Send it uncompressed
  38390. +         * in case the other side missed the compressed version.
  38391. +         */
  38392. +        if(ip->tot_len != cs->cs_ip.tot_len &&
  38393. +           ntohs(cs->cs_ip.tot_len) == hlen)
  38394. +            break;
  38395. +        goto uncompressed;
  38396. +        break;
  38397. +    case SPECIAL_I:
  38398. +    case SPECIAL_D:
  38399. +        /* actual changes match one of our special case encodings --
  38400. +         * send packet uncompressed.
  38401. +         */
  38402. +        goto uncompressed;
  38403. +    case NEW_S|NEW_A:
  38404. +        if(deltaS == deltaA &&
  38405. +            deltaS == ntohs(cs->cs_ip.tot_len) - hlen){
  38406. +            /* special case for echoed terminal traffic */
  38407. +            changes = SPECIAL_I;
  38408. +            cp = new_seq;
  38409. +        }
  38410. +        break;
  38411. +    case NEW_S:
  38412. +        if(deltaS == ntohs(cs->cs_ip.tot_len) - hlen){
  38413. +            /* special case for data xfer */
  38414. +            changes = SPECIAL_D;
  38415. +            cp = new_seq;
  38416. +        }
  38417. +        break;
  38418. +    }
  38419. +    deltaS = ntohs(ip->id) - ntohs(cs->cs_ip.id);
  38420. +    if(deltaS != 1){
  38421. +        cp = encode(cp,deltaS);
  38422. +        changes |= NEW_I;
  38423. +    }
  38424. +    if(th->psh)
  38425. +        changes |= TCP_PUSH_BIT;
  38426. +    /* Grab the cksum before we overwrite it below.  Then update our
  38427. +     * state with this packet's header.
  38428. +     */
  38429. +    deltaA = ntohs(th->check);
  38430. +    memcpy(&cs->cs_ip,ip,20);
  38431. +    memcpy(&cs->cs_tcp,th,20);
  38432. +    /* We want to use the original packet as our compressed packet.
  38433. +     * (cp - new_seq) is the number of bytes we need for compressed
  38434. +     * sequence numbers.  In addition we need one byte for the change
  38435. +     * mask, one for the connection id and two for the tcp checksum.
  38436. +     * So, (cp - new_seq) + 4 bytes of header are needed.
  38437. +     */
  38438. +    deltaS = cp - new_seq;
  38439. +    if(compress_cid == 0 || comp->xmit_current != cs->cs_this){
  38440. +        cp = ocp;
  38441. +        *cpp = ocp;
  38442. +        *cp++ = changes | NEW_C;
  38443. +        *cp++ = cs->cs_this;
  38444. +        comp->xmit_current = cs->cs_this;
  38445. +    } else {
  38446. +        cp = ocp;
  38447. +        *cpp = ocp;
  38448. +        *cp++ = changes;
  38449. +    }
  38450. +    cp = put16(cp,(short)deltaA);    /* Write TCP checksum */
  38451. +/* deltaS is now the size of the change section of the compressed header */
  38452. +    memcpy(cp,new_seq,deltaS);    /* Write list of deltas */
  38453. +    memcpy(cp+deltaS,icp+hlen,isize-hlen);
  38454. +    comp->sls_o_compressed++;
  38455. +    ocp[0] |= SL_TYPE_COMPRESSED_TCP;
  38456. +    return isize - hlen + deltaS + (cp - ocp);
  38457. +
  38458. +    /* Update connection state cs & send uncompressed packet (i.e.,
  38459. +     * a regular ip/tcp packet but with the 'conversation id' we hope
  38460. +     * to use on future compressed packets in the protocol field).
  38461. +     */
  38462. +uncompressed:
  38463. +    memcpy(&cs->cs_ip,ip,20);
  38464. +    memcpy(&cs->cs_tcp,th,20);
  38465. +    if (ip->ihl > 5)
  38466. +      memcpy(cs->cs_ipopt, ip+1, ((ip->ihl) - 5) * 4);
  38467. +    if (th->doff > 5)
  38468. +      memcpy(cs->cs_tcpopt, th+1, ((th->doff) - 5) * 4);
  38469. +    comp->xmit_current = cs->cs_this;
  38470. +    comp->sls_o_uncompressed++;
  38471. +    memcpy(ocp, icp, isize);
  38472. +    *cpp = ocp;
  38473. +    ocp[9] = cs->cs_this;
  38474. +    ocp[0] |= SL_TYPE_UNCOMPRESSED_TCP;
  38475. +    return isize;
  38476. +}
  38477. +
  38478. +
  38479. +int
  38480. +slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize)
  38481. +{
  38482. +    register int changes;
  38483. +    long x;
  38484. +    register struct tcphdr *thp;
  38485. +    register struct iphdr *ip;
  38486. +    register struct cstate *cs;
  38487. +    int len, hdrlen;
  38488. +    unsigned char *cp = icp;
  38489. +
  38490. +    /* We've got a compressed packet; read the change byte */
  38491. +    comp->sls_i_compressed++;
  38492. +    if(isize < 3){
  38493. +        comp->sls_i_error++;
  38494. +        return 0;
  38495. +    }
  38496. +    changes = *cp++;
  38497. +    if(changes & NEW_C){
  38498. +        /* Make sure the state index is in range, then grab the state.
  38499. +         * If we have a good state index, clear the 'discard' flag.
  38500. +         */
  38501. +        x = *cp++;    /* Read conn index */
  38502. +        if(x < 0 || x > comp->rslot_limit)
  38503. +            goto bad;
  38504. +
  38505. +        comp->flags &=~ SLF_TOSS;
  38506. +        comp->recv_current = x;
  38507. +    } else {
  38508. +        /* this packet has an implicit state index.  If we've
  38509. +         * had a line error since the last time we got an
  38510. +         * explicit state index, we have to toss the packet. */
  38511. +        if(comp->flags & SLF_TOSS){
  38512. +            comp->sls_i_tossed++;
  38513. +            return 0;
  38514. +        }
  38515. +    }
  38516. +    cs = &comp->rstate[comp->recv_current];
  38517. +    thp = &cs->cs_tcp;
  38518. +    ip = &cs->cs_ip;
  38519. +
  38520. +    if((x = pull16(&cp)) == -1) {    /* Read the TCP checksum */
  38521. +        goto bad;
  38522. +        }
  38523. +    thp->check = htons(x);
  38524. +
  38525. +    thp->psh = (changes & TCP_PUSH_BIT) ? 1 : 0;
  38526. +/*
  38527. + * we can use the same number for the length of the saved header and
  38528. + * the current one, because the packet wouldn't have been sent
  38529. + * as compressed unless the options were the same as the previous one
  38530. + */
  38531. +
  38532. +    hdrlen = ip->ihl * 4 + thp->doff * 4;
  38533. +
  38534. +    switch(changes & SPECIALS_MASK){
  38535. +    case SPECIAL_I:        /* Echoed terminal traffic */
  38536. +        {
  38537. +        register short i;
  38538. +        i = ntohs(ip->tot_len) - hdrlen;
  38539. +        thp->ack_seq = htonl( ntohl(thp->ack_seq) + i);
  38540. +        thp->seq = htonl( ntohl(thp->seq) + i);
  38541. +        }
  38542. +        break;
  38543. +
  38544. +    case SPECIAL_D:            /* Unidirectional data */
  38545. +        thp->seq = htonl( ntohl(thp->seq) +
  38546. +                  ntohs(ip->tot_len) - hdrlen);
  38547. +        break;
  38548. +
  38549. +    default:
  38550. +        if(changes & NEW_U){
  38551. +            thp->urg = 1;
  38552. +            if((x = decode(&cp)) == -1) {
  38553. +                goto bad;
  38554. +            }
  38555. +            thp->urg_ptr = htons(x);
  38556. +        } else
  38557. +            thp->urg = 0;
  38558. +        if(changes & NEW_W){
  38559. +            if((x = decode(&cp)) == -1) {
  38560. +                goto bad;
  38561. +            }
  38562. +            thp->window = htons( ntohs(thp->window) + x);
  38563. +        }
  38564. +        if(changes & NEW_A){
  38565. +            if((x = decode(&cp)) == -1) {
  38566. +                goto bad;
  38567. +            }
  38568. +            thp->ack_seq = htonl( ntohl(thp->ack_seq) + x);
  38569. +        }
  38570. +        if(changes & NEW_S){
  38571. +            if((x = decode(&cp)) == -1) {
  38572. +                goto bad;
  38573. +            }
  38574. +            thp->seq = htonl( ntohl(thp->seq) + x);
  38575. +        }
  38576. +        break;
  38577. +    }
  38578. +    if(changes & NEW_I){
  38579. +        if((x = decode(&cp)) == -1) {
  38580. +            goto bad;
  38581. +        }
  38582. +        ip->id = htons (ntohs (ip->id) + x);
  38583. +    } else
  38584. +        ip->id = htons (ntohs (ip->id) + 1);
  38585. +
  38586. +    /*
  38587. +     * At this point, cp points to the first byte of data in the
  38588. +     * packet.  Put the reconstructed TCP and IP headers back on the
  38589. +     * packet.  Recalculate IP checksum (but not TCP checksum).
  38590. +     */
  38591. +
  38592. +    len = isize - (cp - icp);
  38593. +    if (len < 0)
  38594. +        goto bad;
  38595. +    len += hdrlen;
  38596. +    ip->tot_len = htons(len);
  38597. +    ip->check = 0;
  38598. +
  38599. +    memmove(icp + hdrlen, cp, len - hdrlen);
  38600. +
  38601. +    cp = icp;
  38602. +    memcpy(cp, ip, 20);
  38603. +    cp += 20;
  38604. +
  38605. +    if (ip->ihl > 5) {
  38606. +      memcpy(cp, cs->cs_ipopt, ((ip->ihl) - 5) * 4);
  38607. +      cp += ((ip->ihl) - 5) * 4;
  38608. +    }
  38609. +
  38610. +    ((struct iphdr *)icp)->check = ip_fast_csum(icp, ((struct iphdr*)icp)->ihl);
  38611. +
  38612. +    memcpy(cp, thp, 20);
  38613. +    cp += 20;
  38614. +
  38615. +    if (thp->doff > 5) {
  38616. +      memcpy(cp, cs->cs_tcpopt, ((thp->doff) - 5) * 4);
  38617. +      cp += ((thp->doff) - 5) * 4;
  38618. +    }
  38619. +
  38620. +    return len;
  38621. +bad:
  38622. +    comp->sls_i_error++;
  38623. +    return slhc_toss( comp );
  38624. +}
  38625. +
  38626. +
  38627. +int
  38628. +slhc_remember(struct slcompress *comp, unsigned char *icp, int isize)
  38629. +{
  38630. +    register struct cstate *cs;
  38631. +    short ip_len;
  38632. +    struct iphdr *ip;
  38633. +    struct tcphdr *thp;
  38634. +
  38635. +    unsigned char index;
  38636. +
  38637. +    if(isize < 20) {
  38638. +        /* The packet is shorter than a legal IP header */
  38639. +        comp->sls_i_runt++;
  38640. +        return slhc_toss( comp );
  38641. +    }
  38642. +    /* Sneak a peek at the IP header's IHL field to find its length */
  38643. +    ip_len = (icp[0] & 0xf) << 2;
  38644. +    if(ip_len < 20){
  38645. +        /* The IP header length field is too small */
  38646. +        comp->sls_i_runt++;
  38647. +        return slhc_toss( comp );
  38648. +    }
  38649. +    index = icp[9];
  38650. +    icp[9] = IPPROTO_TCP;
  38651. +    ip = (struct iphdr *) icp;
  38652. +
  38653. +    if (ip_fast_csum(icp, ip->ihl)) {
  38654. +        /* Bad IP header checksum; discard */
  38655. +        comp->sls_i_badcheck++;
  38656. +        return slhc_toss( comp );
  38657. +    }
  38658. +    thp = (struct tcphdr *)(((unsigned char *)ip) + ip->ihl*4);
  38659. +    if(index > comp->rslot_limit) {
  38660. +        comp->sls_i_error++;
  38661. +        return slhc_toss(comp);
  38662. +    }
  38663. +
  38664. +    /* Update local state */
  38665. +    cs = &comp->rstate[comp->recv_current = index];
  38666. +    comp->flags &=~ SLF_TOSS;
  38667. +    memcpy(&cs->cs_ip,ip,20);
  38668. +    memcpy(&cs->cs_tcp,thp,20);
  38669. +    if (ip->ihl > 5)
  38670. +      memcpy(cs->cs_ipopt, ip+1, ((ip->ihl) - 5) * 4);
  38671. +    if (thp->doff > 5)
  38672. +      memcpy(cs->cs_tcpopt, thp+1, ((thp->doff) - 5) * 4);
  38673. +    cs->cs_hsize = ip->ihl*2 + thp->doff*2;
  38674. +    /* Put headers back on packet
  38675. +     * Neither header checksum is recalculated
  38676. +     */
  38677. +    comp->sls_i_uncompressed++;
  38678. +    return isize;
  38679. +}
  38680. +
  38681. +
  38682. +int
  38683. +slhc_toss(struct slcompress *comp)
  38684. +{
  38685. +    if ( comp == NULLSLCOMPR )
  38686. +        return 0;
  38687. +
  38688. +    comp->flags |= SLF_TOSS;
  38689. +    return 0;
  38690. +}
  38691. +
  38692. +
  38693. +void slhc_i_status(struct slcompress *comp)
  38694. +{
  38695. +    if (comp != NULLSLCOMPR) {
  38696. +        printk("\t%ld Cmp, %ld Uncmp, %ld Bad, %ld Tossed\n",
  38697. +            comp->sls_i_compressed,
  38698. +            comp->sls_i_uncompressed,
  38699. +            comp->sls_i_error,
  38700. +            comp->sls_i_tossed);
  38701. +    }
  38702. +}
  38703. +
  38704. +
  38705. +void slhc_o_status(struct slcompress *comp)
  38706. +{
  38707. +    if (comp != NULLSLCOMPR) {
  38708. +        printk("\t%ld Cmp, %ld Uncmp, %ld AsIs, %ld NotTCP\n",
  38709. +            comp->sls_o_compressed,
  38710. +            comp->sls_o_uncompressed,
  38711. +            comp->sls_o_tcp,
  38712. +            comp->sls_o_nontcp);
  38713. +        printk("\t%10ld Searches, %10ld Misses\n",
  38714. +            comp->sls_o_searches,
  38715. +            comp->sls_o_misses);
  38716. +    }
  38717. +}
  38718. +
  38719. +#ifdef MODULE
  38720. +char kernel_version[] = UTS_RELEASE;
  38721. +
  38722. +int init_module(void)
  38723. +{
  38724. +    printk("CSLIP: code copyright 1989 Regents of the University of California\n");
  38725. +    return 0;
  38726. +}
  38727. +
  38728. +void cleanup_module(void)
  38729. +{
  38730. +    if (MOD_IN_USE)  {
  38731. +        printk("CSLIP: module in use, remove delayed");
  38732. +    }
  38733. +    return;
  38734. +}
  38735. +#endif /* MODULE */
  38736. +#endif /* CONFIG_INET */
  38737. diff -r -u -N linux.orig/arch/arm/drivers/net/slhc.h linux.arm/arch/arm/drivers/net/slhc.h
  38738. --- linux.orig/arch/arm/drivers/net/slhc.h    Thu Jan  1 01:00:00 1970
  38739. +++ linux.arm/arch/arm/drivers/net/slhc.h    Fri Oct 27 23:15:03 1995
  38740. @@ -0,0 +1,187 @@
  38741. +#ifndef _SLHC_H
  38742. +#define _SLHC_H
  38743. +/*
  38744. + * Definitions for tcp compression routines.
  38745. + *
  38746. + * $Header: slcompress.h,v 1.10 89/12/31 08:53:02 van Exp $
  38747. + *
  38748. + * Copyright (c) 1989 Regents of the University of California.
  38749. + * All rights reserved.
  38750. + *
  38751. + * Redistribution and use in source and binary forms are permitted
  38752. + * provided that the above copyright notice and this paragraph are
  38753. + * duplicated in all such forms and that any documentation,
  38754. + * advertising materials, and other materials related to such
  38755. + * distribution and use acknowledge that the software was developed
  38756. + * by the University of California, Berkeley.  The name of the
  38757. + * University may not be used to endorse or promote products derived
  38758. + * from this software without specific prior written permission.
  38759. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  38760. + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  38761. + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  38762. + *
  38763. + *    Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
  38764. + *    - Initial distribution.
  38765. + *
  38766. + *
  38767. + * modified for KA9Q Internet Software Package by
  38768. + * Katie Stevens (dkstevens@ucdavis.edu)
  38769. + * University of California, Davis
  38770. + * Computing Services
  38771. + *    - 01-31-90    initial adaptation
  38772. + *
  38773. + *    - Feb 1991    Bill_Simpson@um.cc.umich.edu
  38774. + *            variable number of conversation slots
  38775. + *            allow zero or one slots
  38776. + *            separate routines
  38777. + *            status display
  38778. + */
  38779. +
  38780. +/*
  38781. + * Compressed packet format:
  38782. + *
  38783. + * The first octet contains the packet type (top 3 bits), TCP
  38784. + * 'push' bit, and flags that indicate which of the 4 TCP sequence
  38785. + * numbers have changed (bottom 5 bits).  The next octet is a
  38786. + * conversation number that associates a saved IP/TCP header with
  38787. + * the compressed packet.  The next two octets are the TCP checksum
  38788. + * from the original datagram.  The next 0 to 15 octets are
  38789. + * sequence number changes, one change per bit set in the header
  38790. + * (there may be no changes and there are two special cases where
  38791. + * the receiver implicitly knows what changed -- see below).
  38792. + *
  38793. + * There are 5 numbers which can change (they are always inserted
  38794. + * in the following order): TCP urgent pointer, window,
  38795. + * acknowledgment, sequence number and IP ID.  (The urgent pointer
  38796. + * is different from the others in that its value is sent, not the
  38797. + * change in value.)  Since typical use of SLIP links is biased
  38798. + * toward small packets (see comments on MTU/MSS below), changes
  38799. + * use a variable length coding with one octet for numbers in the
  38800. + * range 1 - 255 and 3 octets (0, MSB, LSB) for numbers in the
  38801. + * range 256 - 65535 or 0.  (If the change in sequence number or
  38802. + * ack is more than 65535, an uncompressed packet is sent.)
  38803. + */
  38804. +
  38805. +/*
  38806. + * Packet types (must not conflict with IP protocol version)
  38807. + *
  38808. + * The top nibble of the first octet is the packet type.  There are
  38809. + * three possible types: IP (not proto TCP or tcp with one of the
  38810. + * control flags set); uncompressed TCP (a normal IP/TCP packet but
  38811. + * with the 8-bit protocol field replaced by an 8-bit connection id --
  38812. + * this type of packet syncs the sender & receiver); and compressed
  38813. + * TCP (described above).
  38814. + *
  38815. + * LSB of 4-bit field is TCP "PUSH" bit (a worthless anachronism) and
  38816. + * is logically part of the 4-bit "changes" field that follows.  Top
  38817. + * three bits are actual packet type.  For backward compatibility
  38818. + * and in the interest of conserving bits, numbers are chosen so the
  38819. + * IP protocol version number (4) which normally appears in this nibble
  38820. + * means "IP packet".
  38821. + */
  38822. +
  38823. +/* SLIP compression masks for len/vers byte */
  38824. +#define SL_TYPE_IP 0x40
  38825. +#define SL_TYPE_UNCOMPRESSED_TCP 0x70
  38826. +#define SL_TYPE_COMPRESSED_TCP 0x80
  38827. +#define SL_TYPE_ERROR 0x00
  38828. +
  38829. +/* Bits in first octet of compressed packet */
  38830. +#define NEW_C    0x40    /* flag bits for what changed in a packet */
  38831. +#define NEW_I    0x20
  38832. +#define NEW_S    0x08
  38833. +#define NEW_A    0x04
  38834. +#define NEW_W    0x02
  38835. +#define NEW_U    0x01
  38836. +
  38837. +/* reserved, special-case values of above */
  38838. +#define SPECIAL_I (NEW_S|NEW_W|NEW_U)        /* echoed interactive traffic */
  38839. +#define SPECIAL_D (NEW_S|NEW_A|NEW_W|NEW_U)    /* unidirectional data */
  38840. +#define SPECIALS_MASK (NEW_S|NEW_A|NEW_W|NEW_U)
  38841. +
  38842. +#define TCP_PUSH_BIT 0x10
  38843. +
  38844. +/*
  38845. + * data type and sizes conversion assumptions:
  38846. + *
  38847. + *    VJ code        KA9Q style    generic
  38848. + *    u_char        byte_t        unsigned char     8 bits
  38849. + *    u_short        int16        unsigned short    16 bits
  38850. + *    u_int        int16        unsigned short    16 bits
  38851. + *    u_long        unsigned long    unsigned long    32 bits
  38852. + *    int        int32        long        32 bits
  38853. + */
  38854. +
  38855. +typedef unsigned char byte_t;
  38856. +typedef unsigned long int32;
  38857. +
  38858. +/*
  38859. + * "state" data for each active tcp conversation on the wire.  This is
  38860. + * basically a copy of the entire IP/TCP header from the last packet
  38861. + * we saw from the conversation together with a small identifier
  38862. + * the transmit & receive ends of the line use to locate saved header.
  38863. + */
  38864. +struct cstate {
  38865. +    byte_t    cs_this;    /* connection id number (xmit) */
  38866. +    struct cstate *next;    /* next in ring (xmit) */
  38867. +    struct iphdr cs_ip;    /* ip/tcp hdr from most recent packet */
  38868. +    struct tcphdr cs_tcp;
  38869. +    unsigned char cs_ipopt[64];
  38870. +    unsigned char cs_tcpopt[64];
  38871. +    int cs_hsize;
  38872. +};
  38873. +#define NULLSLSTATE    (struct cstate *)0
  38874. +
  38875. +/*
  38876. + * all the state data for one serial line (we need one of these per line).
  38877. + */
  38878. +struct slcompress {
  38879. +    struct cstate *tstate;    /* transmit connection states (array)*/
  38880. +    struct cstate *rstate;    /* receive connection states (array)*/
  38881. +
  38882. +    byte_t tslot_limit;    /* highest transmit slot id (0-l)*/
  38883. +    byte_t rslot_limit;    /* highest receive slot id (0-l)*/
  38884. +
  38885. +    byte_t xmit_oldest;    /* oldest xmit in ring */
  38886. +    byte_t xmit_current;    /* most recent xmit id */
  38887. +    byte_t recv_current;    /* most recent rcvd id */
  38888. +
  38889. +    byte_t flags;
  38890. +#define SLF_TOSS    0x01    /* tossing rcvd frames until id received */
  38891. +
  38892. +    int32 sls_o_nontcp;    /* outbound non-TCP packets */
  38893. +    int32 sls_o_tcp;    /* outbound TCP packets */
  38894. +    int32 sls_o_uncompressed;    /* outbound uncompressed packets */
  38895. +    int32 sls_o_compressed;    /* outbound compressed packets */
  38896. +    int32 sls_o_searches;    /* searches for connection state */
  38897. +    int32 sls_o_misses;    /* times couldn't find conn. state */
  38898. +
  38899. +    int32 sls_i_uncompressed;    /* inbound uncompressed packets */
  38900. +    int32 sls_i_compressed;    /* inbound compressed packets */
  38901. +    int32 sls_i_error;    /* inbound error packets */
  38902. +    int32 sls_i_tossed;    /* inbound packets tossed because of error */
  38903. +
  38904. +    int32 sls_i_runt;
  38905. +    int32 sls_i_badcheck;
  38906. +};
  38907. +#define NULLSLCOMPR    (struct slcompress *)0
  38908. +
  38909. +#define __ARGS(x) x
  38910. +
  38911. +/* In slhc.c: */
  38912. +struct slcompress *slhc_init __ARGS((int rslots, int tslots));
  38913. +void slhc_free __ARGS((struct slcompress *comp));
  38914. +
  38915. +int slhc_compress __ARGS((struct slcompress *comp, unsigned char *icp,
  38916. +              int isize, unsigned char *ocp, unsigned char **cpp,
  38917. +              int compress_cid));
  38918. +int slhc_uncompress __ARGS((struct slcompress *comp, unsigned char *icp,
  38919. +                int isize));
  38920. +int slhc_remember __ARGS((struct slcompress *comp, unsigned char *icp,
  38921. +              int isize));
  38922. +int slhc_toss __ARGS((struct slcompress *comp));
  38923. +
  38924. +void slhc_i_status __ARGS((struct slcompress *comp));
  38925. +void slhc_o_status __ARGS((struct slcompress *comp));
  38926. +
  38927. +#endif    /* _SLHC_H */
  38928. diff -r -u -N linux.orig/arch/arm/drivers/net/slip.c linux.arm/arch/arm/drivers/net/slip.c
  38929. --- linux.orig/arch/arm/drivers/net/slip.c    Thu Jan  1 01:00:00 1970
  38930. +++ linux.arm/arch/arm/drivers/net/slip.c    Fri Oct 27 23:15:03 1995
  38931. @@ -0,0 +1,1212 @@
  38932. +/*
  38933. + * slip.c    This module implements the SLIP protocol for kernel-based
  38934. + *        devices like TTY.  It interfaces between a raw TTY, and the
  38935. + *        kernel's INET protocol layers (via DDI).
  38936. + *
  38937. + * Version:    @(#)slip.c    0.8.3    12/24/94
  38938. + *
  38939. + * Authors:    Laurence Culhane, <loz@holmes.demon.co.uk>
  38940. + *        Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
  38941. + *
  38942. + * Fixes:
  38943. + *        Alan Cox    :     Sanity checks and avoid tx overruns.
  38944. + *                    Has a new sl->mtu field.
  38945. + *        Alan Cox    :     Found cause of overrun. ifconfig sl0 mtu upwards.
  38946. + *                    Driver now spots this and grows/shrinks its buffers(hack!).
  38947. + *                    Memory leak if you run out of memory setting up a slip driver fixed.
  38948. + *        Matt Dillon    :    Printable slip (borrowed from NET2E)
  38949. + *    Pauline Middelink    :    Slip driver fixes.
  38950. + *        Alan Cox    :    Honours the old SL_COMPRESSED flag
  38951. + *        Alan Cox    :    KISS AX.25 and AXUI IP support
  38952. + *        Michael Riepe    :    Automatic CSLIP recognition added
  38953. + *        Charles Hedrick :    CSLIP header length problem fix.
  38954. + *        Alan Cox    :    Corrected non-IP cases of the above.
  38955. + *        Alan Cox    :    Now uses hardware type as per FvK.
  38956. + *        Alan Cox    :    Default to 192.168.0.0 (RFC 1597)
  38957. + *        A.N.Kuznetsov    :    dev_tint() recursion fix.
  38958. + *    Dmitry Gorodchanin    :    SLIP memory leaks
  38959. + *      Dmitry Gorodchanin      :       Code cleanup. Reduce tty driver
  38960. + *                                      buffering from 4096 to 256 bytes.
  38961. + *                                      Improving SLIP response time.
  38962. + *                                      CONFIG_SLIP_MODE_SLIP6.
  38963. + *                                      ifconfig sl? up & down now works correctly.
  38964. + *                    Modularization.
  38965. + *              Alan Cox        :       Oops - fix AX.25 buffer lengths
  38966. + *      Dmitry Gorodchanin      :       Even more cleanups. Preserve CSLIP
  38967. + *                                      statistics. Include CSLIP code only
  38968. + *                                      if it really needed.
  38969. + *        Alan Cox    :    Free slhc buffers in the right place.
  38970. + *
  38971. + *
  38972. + *
  38973. + *    FIXME:    This driver still makes some IP'ish assumptions. It should build cleanly KISS TNC only without
  38974. + *    CONFIG_INET defined.
  38975. + *      I hope now it is fixed ;)
  38976. + */
  38977. +
  38978. +#define SL_CHECK_TRANSMIT
  38979. +#include <linux/config.h>
  38980. +#ifdef MODULE
  38981. +#include <linux/module.h>
  38982. +#include <linux/version.h>
  38983. +#endif
  38984. +
  38985. +/* Undef this, if you don't need 6bit encapsulation code in the driver */
  38986. +#define CONFIG_SLIP_MODE_SLIP6
  38987. +
  38988. +#include <asm/system.h>
  38989. +#include <asm/segment.h>
  38990. +#include <asm/bitops.h>
  38991. +#include <linux/string.h>
  38992. +#include <linux/mm.h>
  38993. +#include <linux/interrupt.h>
  38994. +#include <linux/in.h>
  38995. +#include <linux/tty.h>
  38996. +#include <linux/errno.h>
  38997. +#include <linux/netdevice.h>
  38998. +#ifdef CONFIG_AX25
  38999. +#include "ax25.h"
  39000. +#endif
  39001. +#include <linux/etherdevice.h>
  39002. +#include <linux/skbuff.h>
  39003. +#include <linux/if_arp.h>
  39004. +#include "slip.h"
  39005. +#ifdef CONFIG_INET
  39006. +#include <linux/ip.h>
  39007. +#include <linux/tcp.h>
  39008. +#include "slhc.h"
  39009. +#endif
  39010. +
  39011. +#ifdef MODULE
  39012. +#define SLIP_VERSION    "0.8.3-NET3.019-NEWTTY-MODULAR"
  39013. +#else
  39014. +#define    SLIP_VERSION    "0.8.3-NET3.019-NEWTTY"
  39015. +#endif
  39016. +
  39017. +
  39018. +static struct slip    sl_ctrl[SL_NRUNIT];
  39019. +static struct tty_ldisc    sl_ldisc;
  39020. +static int        already = 0;
  39021. +
  39022. +static int slip_esc(unsigned char *p, unsigned char *d, int len);
  39023. +static void slip_unesc(struct slip *sl, unsigned char c);
  39024. +#ifdef CONFIG_SLIP_MODE_SLIP6
  39025. +static int slip_esc6(unsigned char *p, unsigned char *d, int len);
  39026. +static void slip_unesc6(struct slip *sl, unsigned char c);
  39027. +#endif
  39028. +
  39029. +
  39030. +/* Find a free SLIP channel, and link in this `tty' line. */
  39031. +static inline struct slip *
  39032. +sl_alloc(void)
  39033. +{
  39034. +    struct slip *sl;
  39035. +    int i;
  39036. +
  39037. +    for (i = 0; i < SL_NRUNIT; i++) {
  39038. +        sl = &sl_ctrl[i];
  39039. +        if (!set_bit(SLF_INUSE, &sl->flags)) {
  39040. +            return sl;
  39041. +        }
  39042. +    }
  39043. +    return NULL;
  39044. +}
  39045. +
  39046. +
  39047. +/* Free a SLIP channel. */
  39048. +static inline void
  39049. +sl_free(struct slip *sl)
  39050. +{
  39051. +    /* Free all SLIP frame buffers. */
  39052. +    if (sl->rbuff)  {
  39053. +        kfree(sl->rbuff);
  39054. +    }
  39055. +    sl->rbuff = NULL;
  39056. +    if (sl->xbuff)  {
  39057. +        kfree(sl->xbuff);
  39058. +    }
  39059. +    sl->xbuff = NULL;
  39060. +#ifdef SL_INCLUDE_CSLIP
  39061. +    /* Save CSLIP statistics */
  39062. +    if (sl->slcomp)  {
  39063. +        sl->rx_compressed += sl->slcomp->sls_i_compressed;
  39064. +        sl->rx_dropped    += sl->slcomp->sls_i_tossed;
  39065. +        sl->tx_compressed += sl->slcomp->sls_o_compressed;
  39066. +        sl->tx_misses     += sl->slcomp->sls_o_misses;
  39067. +    }
  39068. +    if (sl->cbuff)  {
  39069. +        kfree(sl->cbuff);
  39070. +    }
  39071. +    sl->cbuff = NULL;
  39072. +    if(sl->slcomp)
  39073. +        slhc_free(sl->slcomp);
  39074. +    sl->slcomp = NULL;
  39075. +#endif
  39076. +
  39077. +    if (!clear_bit(SLF_INUSE, &sl->flags)) {
  39078. +        printk("%s: sl_free for already free unit.\n", sl->dev->name);
  39079. +    }
  39080. +}
  39081. +
  39082. +/* MTU has been changed by the IP layer. Unfortunately we are not told about this, but
  39083. +   we spot it ourselves and fix things up. We could be in an upcall from the tty
  39084. +   driver, or in an ip packet queue. */
  39085. +
  39086. +static void sl_changedmtu(struct slip *sl)
  39087. +{
  39088. +    struct device *dev = sl->dev;
  39089. +    unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
  39090. +#ifdef SL_INCLUDE_CSLIP
  39091. +    unsigned char *cbuff, *ocbuff;
  39092. +#endif
  39093. +    int len;
  39094. +    unsigned long flags;
  39095. +
  39096. +    len = dev->mtu * 2;
  39097. +/*
  39098. + * allow for arrival of larger UDP packets, even if we say not to
  39099. + * also fixes a bug in which SunOS sends 512-byte packets even with
  39100. + * an MSS of 128
  39101. + */
  39102. +    if (len < 576 * 2)  {
  39103. +        len = 576 * 2;
  39104. +    }
  39105. +
  39106. +    xbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
  39107. +    rbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
  39108. +#ifdef SL_INCLUDE_CSLIP
  39109. +    cbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
  39110. +#endif
  39111. +
  39112. +#ifdef SL_INCLUDE_CSLIP
  39113. +    if (xbuff == NULL || rbuff == NULL || cbuff == NULL)  {
  39114. +#else
  39115. +    if (xbuff == NULL || rbuff == NULL)  {
  39116. +#endif
  39117. +        printk("%s: unable to grow slip buffers, MTU change cancelled.\n",
  39118. +               sl->dev->name);
  39119. +        dev->mtu = sl->mtu;
  39120. +        if (xbuff != NULL)  {
  39121. +            kfree(xbuff);
  39122. +        }
  39123. +        if (rbuff != NULL)  {
  39124. +            kfree(rbuff);
  39125. +        }
  39126. +#ifdef SL_INCLUDE_CSLIP
  39127. +        if (cbuff != NULL)  {
  39128. +            kfree(cbuff);
  39129. +        }
  39130. +#endif
  39131. +        return;
  39132. +    }
  39133. +
  39134. +    save_flags(flags); cli();
  39135. +
  39136. +    oxbuff    = sl->xbuff;
  39137. +    sl->xbuff = xbuff;
  39138. +    orbuff    = sl->rbuff;
  39139. +    sl->rbuff = rbuff;
  39140. +#ifdef SL_INCLUDE_CSLIP
  39141. +    ocbuff    = sl->cbuff;
  39142. +    sl->cbuff = cbuff;
  39143. +#endif
  39144. +    if (sl->xleft)  {
  39145. +        if (sl->xleft <= len)  {
  39146. +            memcpy(sl->xbuff, sl->xhead, sl->xleft);
  39147. +        } else  {
  39148. +            sl->xleft = 0;
  39149. +            sl->tx_dropped++;
  39150. +        }
  39151. +    }
  39152. +    sl->xhead = sl->xbuff;
  39153. +
  39154. +    if (sl->rcount)  {
  39155. +        if (sl->rcount <= len) {
  39156. +            memcpy(sl->rbuff, orbuff, sl->rcount);
  39157. +        } else  {
  39158. +            sl->rcount = 0;
  39159. +            sl->rx_over_errors++;
  39160. +            set_bit(SLF_ERROR, &sl->flags);
  39161. +        }
  39162. +    }
  39163. +#ifdef CONFIG_AX25
  39164. +    sl->mtu      = dev->mtu + 73;
  39165. +#else
  39166. +    sl->mtu      = dev->mtu;
  39167. +#endif
  39168. +    sl->buffsize = len;
  39169. +
  39170. +    restore_flags(flags);
  39171. +
  39172. +    if (oxbuff != NULL)   {
  39173. +        kfree(oxbuff);
  39174. +    }
  39175. +    if (orbuff != NULL)    {
  39176. +        kfree(orbuff);
  39177. +    }
  39178. +#ifdef SL_INCLUDE_CSLIP
  39179. +    if (ocbuff != NULL)  {
  39180. +        kfree(ocbuff);
  39181. +    }
  39182. +#endif
  39183. +}
  39184. +
  39185. +
  39186. +/* Set the "sending" flag.  This must be atomic, hence the ASM. */
  39187. +static inline void
  39188. +sl_lock(struct slip *sl)
  39189. +{
  39190. +    if (set_bit(0, (void *) &sl->dev->tbusy))  {
  39191. +        printk("%s: trying to lock already locked device!\n", sl->dev->name);
  39192. +        }
  39193. +}
  39194. +
  39195. +
  39196. +/* Clear the "sending" flag.  This must be atomic, hence the ASM. */
  39197. +static inline void
  39198. +sl_unlock(struct slip *sl)
  39199. +{
  39200. +    if (!clear_bit(0, (void *)&sl->dev->tbusy))  {
  39201. +        printk("%s: trying to unlock already unlocked device!\n", sl->dev->name);
  39202. +        }
  39203. +}
  39204. +
  39205. +/* Send one completely decapsulated IP datagram to the IP layer. */
  39206. +static void
  39207. +sl_bump(struct slip *sl)
  39208. +{
  39209. +    struct sk_buff *skb;
  39210. +    int count;
  39211. +
  39212. +    count = sl->rcount;
  39213. +#ifdef SL_INCLUDE_CSLIP
  39214. +    if (sl->mode & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
  39215. +        unsigned char c;
  39216. +        if ((c = sl->rbuff[0]) & SL_TYPE_COMPRESSED_TCP) {
  39217. +            /* ignore compressed packets when CSLIP is off */
  39218. +            if (!(sl->mode & SL_MODE_CSLIP)) {
  39219. +                printk("%s: compressed packet ignored\n", sl->dev->name);
  39220. +                return;
  39221. +            }
  39222. +            /* make sure we've reserved enough space for uncompress to use */
  39223. +            if (count + 80 > sl->buffsize) {
  39224. +                sl->rx_over_errors++;
  39225. +                return;
  39226. +            }
  39227. +            count = slhc_uncompress(sl->slcomp, sl->rbuff, count);
  39228. +            if (count <= 0) {
  39229. +                return;
  39230. +            }
  39231. +        } else if (c >= SL_TYPE_UNCOMPRESSED_TCP) {
  39232. +            if (!(sl->mode & SL_MODE_CSLIP)) {
  39233. +                /* turn on header compression */
  39234. +                sl->mode |= SL_MODE_CSLIP;
  39235. +                sl->mode &= ~SL_MODE_ADAPTIVE;
  39236. +                printk("%s: header compression turned on\n", sl->dev->name);
  39237. +            }
  39238. +            sl->rbuff[0] &= 0x4f;
  39239. +            if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0) {
  39240. +                return;
  39241. +            }
  39242. +        }
  39243. +    }
  39244. +#endif  /* SL_INCLUDE_CSLIP */
  39245. +
  39246. +    skb = alloc_skb(count, GFP_ATOMIC);
  39247. +    if (skb == NULL)  {
  39248. +        printk("%s: memory squeeze, dropping packet.\n", sl->dev->name);
  39249. +        sl->rx_dropped++;
  39250. +        return;
  39251. +    }
  39252. +    skb->len = count;
  39253. +    skb->dev = sl->dev;
  39254. +    memcpy(skb->data, sl->rbuff, count);
  39255. +    netif_rx(skb);
  39256. +    sl->rx_packets++;
  39257. +}
  39258. +
  39259. +/* Encapsulate one IP datagram and stuff into a TTY queue. */
  39260. +static void
  39261. +sl_encaps(struct slip *sl, unsigned char *icp, int len)
  39262. +{
  39263. +    unsigned char *p;
  39264. +    int actual, count;
  39265. +
  39266. +
  39267. +#ifdef CONFIG_AX25
  39268. +    if (sl->mtu != sl->dev->mtu + 73) {    /* Someone has been ifconfigging */
  39269. +#else
  39270. +    if (sl->mtu != sl->dev->mtu) {    /* Someone has been ifconfigging */
  39271. +#endif
  39272. +        sl_changedmtu(sl);
  39273. +    }
  39274. +
  39275. +    if (len > sl->mtu) {        /* Sigh, shouldn't occur BUT ... */
  39276. +        len = sl->mtu;
  39277. +        printk ("%s: truncating oversized transmit packet!\n", sl->dev->name);
  39278. +        sl->tx_dropped++;
  39279. +        sl_unlock(sl);
  39280. +        return;
  39281. +    }
  39282. +
  39283. +    p = icp;
  39284. +#ifdef SL_INCLUDE_CSLIP
  39285. +    if (sl->mode & SL_MODE_CSLIP)  {
  39286. +        len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
  39287. +    }
  39288. +#endif
  39289. +#ifdef CONFIG_SLIP_MODE_SLIP6
  39290. +    if(sl->mode & SL_MODE_SLIP6)
  39291. +        count = slip_esc6(p, (unsigned char *) sl->xbuff, len);
  39292. +    else
  39293. +#endif
  39294. +        count = slip_esc(p, (unsigned char *) sl->xbuff, len);
  39295. +
  39296. +    /* Order of next two lines is *very* important.
  39297. +     * When we are sending a little amount of data,
  39298. +     * the transfer may be completed inside driver.write()
  39299. +     * routine, because it's running with interrupts enabled.
  39300. +     * In this case we *never* got WRITE_WAKEUP event,
  39301. +     * if we did not request it before write operation.
  39302. +     *       14 Oct 1994  Dmitry Gorodchanin.
  39303. +     */
  39304. +    sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
  39305. +    actual = sl->tty->driver.write(sl->tty, 0, sl->xbuff, count);
  39306. +#ifdef SL_CHECK_TRANSMIT
  39307. +    sl->dev->trans_start = jiffies;
  39308. +#endif
  39309. +    sl->xleft = count - actual;
  39310. +    sl->xhead = sl->xbuff + actual;
  39311. +}
  39312. +
  39313. +/*
  39314. + * Called by the driver when there's room for more data.  If we have
  39315. + * more packets to send, we send them here.
  39316. + */
  39317. +static void slip_write_wakeup(struct tty_struct *tty)
  39318. +{
  39319. +    int actual;
  39320. +    struct slip *sl = (struct slip *) tty->disc_data;
  39321. +
  39322. +    /* First make sure we're connected. */
  39323. +    if (!sl || sl->magic != SLIP_MAGIC || !sl->dev->start) {
  39324. +        return;
  39325. +    }
  39326. +
  39327. +    if (sl->xleft <= 0)  {
  39328. +        /* Now serial buffer is almost free & we can start
  39329. +         * transmission of another packet */
  39330. +        sl->tx_packets++;
  39331. +        tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  39332. +        sl_unlock(sl);
  39333. +        mark_bh(NET_BH);
  39334. +        return;
  39335. +    }
  39336. +
  39337. +    actual = tty->driver.write(tty, 0, sl->xhead, sl->xleft);
  39338. +    sl->xleft -= actual;
  39339. +    sl->xhead += actual;
  39340. +}
  39341. +
  39342. +/* Encapsulate an IP datagram and kick it into a TTY queue. */
  39343. +static int
  39344. +sl_xmit(struct sk_buff *skb, struct device *dev)
  39345. +{
  39346. +    struct slip *sl = &sl_ctrl[dev->base_addr];
  39347. +
  39348. +    if (!dev->start)  {
  39349. +        printk("%s: xmit call when iface is down\n", dev->name);
  39350. +        return 1;
  39351. +    }
  39352. +    /*
  39353. +     * If we are busy already- too bad.  We ought to be able
  39354. +     * to queue things at this point, to allow for a little
  39355. +     * frame buffer.  Oh well...
  39356. +     * -----------------------------------------------------
  39357. +     * I hate queues in SLIP driver. May be it's efficient,
  39358. +     * but for me latency is more important. ;)
  39359. +     * So, no queues !
  39360. +     *        14 Oct 1994  Dmitry Gorodchanin.
  39361. +     */
  39362. +    if (dev->tbusy) {
  39363. +        /* May be we must check transmitter timeout here ?
  39364. +         *      14 Oct 1994 Dmitry Gorodchanin.
  39365. +         */
  39366. +#ifdef SL_CHECK_TRANSMIT
  39367. +        if (jiffies - dev->trans_start  < 20 * HZ)  {
  39368. +            /* 20 sec timeout not reached */
  39369. +            return 1;
  39370. +        }
  39371. +        printk("%s: transmit timed out, %s?\n", dev->name,
  39372. +               (sl->tty->driver.chars_in_buffer(sl->tty) || sl->xleft) ?
  39373. +               "bad line quality" : "driver error");
  39374. +        sl->xleft = 0;
  39375. +        sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  39376. +        sl_unlock(sl);
  39377. +#else
  39378. +        return 1;
  39379. +#endif
  39380. +    }
  39381. +
  39382. +    /* We were not busy, so we are now... :-) */
  39383. +    if (skb != NULL) {
  39384. +        sl_lock(sl);
  39385. +        sl_encaps(sl, skb->data, skb->len);
  39386. +        dev_kfree_skb(skb, FREE_WRITE);
  39387. +    }
  39388. +    return 0;
  39389. +}
  39390. +
  39391. +
  39392. +/* Return the frame type ID.  This is normally IP but maybe be AX.25. */
  39393. +static unsigned short
  39394. +sl_type_trans (struct sk_buff *skb, struct device *dev)
  39395. +{
  39396. +#ifdef CONFIG_AX25
  39397. +    struct slip *sl = &sl_ctrl[dev->base_addr];
  39398. +
  39399. +    if (sl->mode & SL_MODE_AX25)  {
  39400. +        return htons(ETH_P_AX25);
  39401. +    }
  39402. +#endif
  39403. +    return htons(ETH_P_IP);
  39404. +}
  39405. +
  39406. +
  39407. +/* Fill in the MAC-level header. Not used by SLIP. */
  39408. +static int
  39409. +sl_header(unsigned char *buff, struct device *dev, unsigned short type,
  39410. +      void *daddr, void *saddr, unsigned len, struct sk_buff *skb)
  39411. +{
  39412. +#ifdef CONFIG_AX25
  39413. +#ifdef CONFIG_INET
  39414. +    struct slip *sl = &sl_ctrl[dev->base_addr];
  39415. +
  39416. +    if ((sl->mode & SL_MODE_AX25) && type != htons(ETH_P_AX25))  {
  39417. +        return ax25_encapsulate(buff, dev, type, daddr, saddr, len, skb);
  39418. +    }
  39419. +#endif
  39420. +#endif
  39421. +    return 0;
  39422. +}
  39423. +
  39424. +
  39425. +/* Rebuild the MAC-level header.  Not used by SLIP. */
  39426. +static int
  39427. +sl_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
  39428. +          struct sk_buff *skb)
  39429. +{
  39430. +#ifdef CONFIG_AX25
  39431. +#ifdef CONFIG_INET
  39432. +    struct slip *sl = &sl_ctrl[dev->base_addr];
  39433. +
  39434. +    if (sl->mode & SL_MODE_AX25)  {
  39435. +        return ax25_rebuild_header(buff, dev, raddr, skb);
  39436. +    }
  39437. +#endif
  39438. +#endif
  39439. +    return 0;
  39440. +}
  39441. +
  39442. +
  39443. +/* Open the low-level part of the SLIP channel. Easy! */
  39444. +static int
  39445. +sl_open(struct device *dev)
  39446. +{
  39447. +    struct slip *sl = &sl_ctrl[dev->base_addr];
  39448. +    unsigned long len;
  39449. +
  39450. +    if (sl->tty == NULL) {
  39451. +        return -ENODEV;
  39452. +    }
  39453. +
  39454. +    /*
  39455. +     * Allocate the SLIP frame buffers:
  39456. +     *
  39457. +     * rbuff    Receive buffer.
  39458. +     * xbuff    Transmit buffer.
  39459. +     * cbuff        Temporary compression buffer.
  39460. +     */
  39461. +    len = dev->mtu * 2;
  39462. +    /*
  39463. +     * allow for arrival of larger UDP packets, even if we say not to
  39464. +     * also fixes a bug in which SunOS sends 512-byte packets even with
  39465. +     * an MSS of 128
  39466. +     */
  39467. +    if (len < 576 * 2)  {
  39468. +        len = 576 * 2;
  39469. +    }
  39470. +    sl->rbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
  39471. +    if (sl->rbuff == NULL)   {
  39472. +        goto norbuff;
  39473. +    }
  39474. +    sl->xbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
  39475. +    if (sl->xbuff == NULL)   {
  39476. +        goto noxbuff;
  39477. +    }
  39478. +#ifdef SL_INCLUDE_CSLIP
  39479. +    sl->cbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
  39480. +    if (sl->cbuff == NULL)   {
  39481. +        goto nocbuff;
  39482. +    }
  39483. +    sl->slcomp = slhc_init(16, 16);
  39484. +    if (sl->slcomp == NULL)  {
  39485. +        goto noslcomp;
  39486. +    }
  39487. +#endif
  39488. +
  39489. +#ifdef CONFIG_AX25
  39490. +    sl->mtu         = dev->mtu + 73;
  39491. +#else
  39492. +    sl->mtu         = dev->mtu;
  39493. +#endif
  39494. +    sl->buffsize = len;
  39495. +    sl->rcount   = 0;
  39496. +    sl->xleft    = 0;
  39497. +#ifdef CONFIG_SLIP_MODE_SLIP6
  39498. +    sl->xdata    = 0;
  39499. +    sl->xbits    = 0;
  39500. +#endif
  39501. +    sl->flags   &= (1 << SLF_INUSE);      /* Clear ESCAPE & ERROR flags */
  39502. +
  39503. +    /* Needed because address '0' is special */
  39504. +    if (dev->pa_addr == 0)  {
  39505. +        dev->pa_addr=ntohl(0xC0A80001);
  39506. +    }
  39507. +    dev->tbusy  = 0;
  39508. +/*    dev->flags |= IFF_UP; */
  39509. +    dev->start  = 1;
  39510. +
  39511. +    return 0;
  39512. +
  39513. +    /* Cleanup */
  39514. +#ifdef SL_INCLUDE_CSLIP
  39515. +noslcomp:
  39516. +    kfree(sl->cbuff);
  39517. +nocbuff:
  39518. +#endif
  39519. +    kfree(sl->xbuff);
  39520. +noxbuff:
  39521. +    kfree(sl->rbuff);
  39522. +norbuff:
  39523. +    return -ENOMEM;
  39524. +}
  39525. +
  39526. +
  39527. +/* Close the low-level part of the SLIP channel. Easy! */
  39528. +static int
  39529. +sl_close(struct device *dev)
  39530. +{
  39531. +    struct slip *sl = &sl_ctrl[dev->base_addr];
  39532. +
  39533. +    if (sl->tty == NULL) {
  39534. +        return -EBUSY;
  39535. +    }
  39536. +    sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  39537. +    dev->tbusy = 1;
  39538. +    dev->start = 0;
  39539. +    
  39540. +/*    dev->flags &= ~IFF_UP; */
  39541. +
  39542. +    return 0;
  39543. +}
  39544. +
  39545. +static int
  39546. +slip_receive_room(struct tty_struct *tty)
  39547. +{
  39548. +    return 65536;  /* We can handle an infinite amount of data. :-) */
  39549. +}
  39550. +
  39551. +/*
  39552. + * Handle the 'receiver data ready' interrupt.
  39553. + * This function is called by the 'tty_io' module in the kernel when
  39554. + * a block of SLIP data has been received, which can now be decapsulated
  39555. + * and sent on to some IP layer for further processing.
  39556. + */
  39557. +static void
  39558. +slip_receive_buf(struct tty_struct *tty, unsigned char *cp, char *fp, int count)
  39559. +{
  39560. +    struct slip *sl = (struct slip *) tty->disc_data;
  39561. +
  39562. +    if (!sl || sl->magic != SLIP_MAGIC || !sl->dev->start)
  39563. +        return;
  39564. +
  39565. +    /*
  39566. +     * Argh! mtu change time! - costs us the packet part received
  39567. +     * at the change
  39568. +     */
  39569. +#ifdef CONFIG_AX25
  39570. +    if (sl->mtu != sl->dev->mtu + 73)  {
  39571. +#else
  39572. +    if (sl->mtu != sl->dev->mtu)  {
  39573. +#endif
  39574. +        sl_changedmtu(sl);
  39575. +    }
  39576. +
  39577. +    /* Read the characters out of the buffer */
  39578. +    while (count--) {
  39579. +        if (fp && *fp++) {
  39580. +            if (!set_bit(SLF_ERROR, &sl->flags))  {
  39581. +                sl->rx_errors++;
  39582. +            }
  39583. +            cp++;
  39584. +            continue;
  39585. +        }
  39586. +#ifdef CONFIG_SLIP_MODE_SLIP6
  39587. +        if (sl->mode & SL_MODE_SLIP6)
  39588. +            slip_unesc6(sl, *cp++);
  39589. +        else
  39590. +#endif
  39591. +            slip_unesc(sl, *cp++);
  39592. +    }
  39593. +}
  39594. +
  39595. +/*
  39596. + * Open the high-level part of the SLIP channel.
  39597. + * This function is called by the TTY module when the
  39598. + * SLIP line discipline is called for.  Because we are
  39599. + * sure the tty line exists, we only have to link it to
  39600. + * a free SLIP channel...
  39601. + */
  39602. +static int
  39603. +slip_open(struct tty_struct *tty)
  39604. +{
  39605. +    struct slip *sl = (struct slip *) tty->disc_data;
  39606. +    int err;
  39607. +
  39608. +    /* First make sure we're not already connected. */
  39609. +    if (sl && sl->magic == SLIP_MAGIC) {
  39610. +        return -EEXIST;
  39611. +    }
  39612. +
  39613. +    /* OK.  Find a free SLIP channel to use. */
  39614. +    if ((sl = sl_alloc()) == NULL) {
  39615. +        return -ENFILE;
  39616. +    }
  39617. +
  39618. +    sl->tty = tty;
  39619. +    tty->disc_data = sl;
  39620. +    if (tty->driver.flush_buffer)  {
  39621. +        tty->driver.flush_buffer(tty);
  39622. +    }
  39623. +    if (tty->ldisc.flush_buffer)  {
  39624. +        tty->ldisc.flush_buffer(tty);
  39625. +    }
  39626. +
  39627. +    /* Restore default settings */
  39628. +    sl->mode      = SL_MODE_DEFAULT;
  39629. +    sl->dev->type = ARPHRD_SLIP + sl->mode;
  39630. +#ifdef CONFIG_AX25    
  39631. +    if (sl->dev->type == 260) {    /* KISS */
  39632. +        sl->dev->type = ARPHRD_AX25;
  39633. +    }
  39634. +#endif    
  39635. +    /* Perform the low-level SLIP initialization. */
  39636. +    if ((err = sl_open(sl->dev)))  {
  39637. +        return err;
  39638. +    }
  39639. +    
  39640. +#ifdef MODULE
  39641. +    MOD_INC_USE_COUNT;
  39642. +#endif
  39643. +
  39644. +    /* Done.  We have linked the TTY line to a channel. */
  39645. +    return sl->dev->base_addr;
  39646. +}
  39647. +
  39648. +
  39649. +/*
  39650. + * Close down a SLIP channel.
  39651. + * This means flushing out any pending queues, and then restoring the
  39652. + * TTY line discipline to what it was before it got hooked to SLIP
  39653. + * (which usually is TTY again).
  39654. + */
  39655. +static void
  39656. +slip_close(struct tty_struct *tty)
  39657. +{
  39658. +    struct slip *sl = (struct slip *) tty->disc_data;
  39659. +
  39660. +    /* First make sure we're connected. */
  39661. +    if (!sl || sl->magic != SLIP_MAGIC) {
  39662. +        return;
  39663. +    }
  39664. +
  39665. +    (void) dev_close(sl->dev);
  39666. +    
  39667. +    tty->disc_data = 0;
  39668. +    sl->tty = NULL;
  39669. +    sl_free(sl);
  39670. +#ifdef MODULE
  39671. +    MOD_DEC_USE_COUNT;
  39672. +#endif
  39673. +}
  39674. +
  39675. +
  39676. +static struct enet_statistics *
  39677. +sl_get_stats(struct device *dev)
  39678. +{
  39679. +    static struct enet_statistics stats;
  39680. +    struct slip *sl = &sl_ctrl[dev->base_addr];
  39681. +#ifdef SL_INCLUDE_CSLIP
  39682. +    struct slcompress *comp;
  39683. +#endif
  39684. +
  39685. +    memset(&stats, 0, sizeof(struct enet_statistics));
  39686. +
  39687. +    stats.rx_packets     = sl->rx_packets;
  39688. +    stats.tx_packets     = sl->tx_packets;
  39689. +    stats.rx_dropped     = sl->rx_dropped;
  39690. +    stats.tx_dropped     = sl->tx_dropped;
  39691. +    stats.tx_errors      = sl->tx_errors;
  39692. +    stats.rx_errors      = sl->rx_errors;
  39693. +    stats.rx_over_errors = sl->rx_over_errors;
  39694. +#ifdef SL_INCLUDE_CSLIP
  39695. +    stats.rx_fifo_errors = sl->rx_compressed;
  39696. +    stats.tx_fifo_errors = sl->tx_compressed;
  39697. +    stats.collisions     = sl->tx_misses;
  39698. +    comp = sl->slcomp;
  39699. +    if (comp) {
  39700. +        stats.rx_fifo_errors += comp->sls_i_compressed;
  39701. +        stats.rx_dropped     += comp->sls_i_tossed;
  39702. +        stats.tx_fifo_errors += comp->sls_o_compressed;
  39703. +        stats.collisions     += comp->sls_o_misses;
  39704. +    }
  39705. +#endif /* CONFIG_INET */
  39706. +    return (&stats);
  39707. +}
  39708. +
  39709. +
  39710. + /************************************************************************
  39711. +  *            STANDARD SLIP ENCAPSULATION               *
  39712. +  ************************************************************************/
  39713. +
  39714. +int
  39715. +slip_esc(unsigned char *s, unsigned char *d, int len)
  39716. +{
  39717. +    unsigned char *ptr = d;
  39718. +    unsigned char