floppy.c 117 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635
  1. /*
  2. * linux/drivers/block/floppy.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. * Copyright (C) 1993, 1994 Alain Knaff
  6. * Copyright (C) 1998 Alan Cox
  7. */
  8. /*
  9. * 02.12.91 - Changed to static variables to indicate need for reset
  10. * and recalibrate. This makes some things easier (output_byte reset
  11. * checking etc), and means less interrupt jumping in case of errors,
  12. * so the code is hopefully easier to understand.
  13. */
  14. /*
  15. * This file is certainly a mess. I've tried my best to get it working,
  16. * but I don't like programming floppies, and I have only one anyway.
  17. * Urgel. I should check for more errors, and do more graceful error
  18. * recovery. Seems there are problems with several drives. I've tried to
  19. * correct them. No promises.
  20. */
  21. /*
  22. * As with hd.c, all routines within this file can (and will) be called
  23. * by interrupts, so extreme caution is needed. A hardware interrupt
  24. * handler may not sleep, or a kernel panic will happen. Thus I cannot
  25. * call "floppy-on" directly, but have to set a special timer interrupt
  26. * etc.
  27. */
  28. /*
  29. * 28.02.92 - made track-buffering routines, based on the routines written
  30. * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
  31. */
  32. /*
  33. * Automatic floppy-detection and formatting written by Werner Almesberger
  34. * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
  35. * the floppy-change signal detection.
  36. */
  37. /*
  38. * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
  39. * FDC data overrun bug, added some preliminary stuff for vertical
  40. * recording support.
  41. *
  42. * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
  43. *
  44. * TODO: Errors are still not counted properly.
  45. */
  46. /* 1992/9/20
  47. * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
  48. * modeled after the freeware MS-DOS program fdformat/88 V1.8 by
  49. * Christoph H. Hochst\"atter.
  50. * I have fixed the shift values to the ones I always use. Maybe a new
  51. * ioctl() should be created to be able to modify them.
  52. * There is a bug in the driver that makes it impossible to format a
  53. * floppy as the first thing after bootup.
  54. */
  55. /*
  56. * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
  57. * this helped the floppy driver as well. Much cleaner, and still seems to
  58. * work.
  59. */
  60. /* 1994/6/24 --bbroad-- added the floppy table entries and made
  61. * minor modifications to allow 2.88 floppies to be run.
  62. */
  63. /* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
  64. * disk types.
  65. */
  66. /*
  67. * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
  68. * format bug fixes, but unfortunately some new bugs too...
  69. */
  70. /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
  71. * errors to allow safe writing by specialized programs.
  72. */
  73. /* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
  74. * by defining bit 1 of the "stretch" parameter to mean put sectors on the
  75. * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
  76. * drives are "upside-down").
  77. */
  78. /*
  79. * 1995/8/26 -- Andreas Busse -- added Mips support.
  80. */
  81. /*
  82. * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
  83. * features to asm/floppy.h.
  84. */
  85. /*
  86. * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
  87. */
  88. /*
  89. * 1998/05/07 -- Russell King -- More portability cleanups; moved definition of
  90. * interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
  91. * use of '0' for NULL.
  92. */
  93. /*
  94. * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
  95. * failures.
  96. */
  97. /*
  98. * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
  99. */
  100. /*
  101. * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
  102. * days, 6 hours, 32 minutes and 32 seconds (i.e. MAXINT jiffies; ints were
  103. * being used to store jiffies, which are unsigned longs).
  104. */
  105. /*
  106. * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  107. * - get rid of check_region
  108. * - s/suser/capable/
  109. */
  110. /*
  111. * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
  112. * floppy controller (lingering task on list after module is gone... boom.)
  113. */
  114. /*
  115. * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
  116. * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
  117. * requires many non-obvious changes in arch dependent code.
  118. */
  119. /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
  120. * Better audit of register_blkdev.
  121. */
  122. #undef FLOPPY_SILENT_DCL_CLEAR
  123. #define REALLY_SLOW_IO
  124. #define DEBUGT 2
  125. #define DPRINT(format, args...) \
  126. pr_info("floppy%d: " format, current_drive, ##args)
  127. #define DCL_DEBUG /* debug disk change line */
  128. #ifdef DCL_DEBUG
  129. #define debug_dcl(test, fmt, args...) \
  130. do { if ((test) & FD_DEBUG) DPRINT(fmt, ##args); } while (0)
  131. #else
  132. #define debug_dcl(test, fmt, args...) \
  133. do { if (0) DPRINT(fmt, ##args); } while (0)
  134. #endif
  135. /* do print messages for unexpected interrupts */
  136. static int print_unex = 1;
  137. #include <linux/module.h>
  138. #include <linux/sched.h>
  139. #include <linux/fs.h>
  140. #include <linux/kernel.h>
  141. #include <linux/timer.h>
  142. #include <linux/workqueue.h>
  143. #define FDPATCHES
  144. #include <linux/fdreg.h>
  145. #include <linux/fd.h>
  146. #include <linux/hdreg.h>
  147. #include <linux/errno.h>
  148. #include <linux/slab.h>
  149. #include <linux/mm.h>
  150. #include <linux/bio.h>
  151. #include <linux/string.h>
  152. #include <linux/jiffies.h>
  153. #include <linux/fcntl.h>
  154. #include <linux/delay.h>
  155. #include <linux/mc146818rtc.h> /* CMOS defines */
  156. #include <linux/ioport.h>
  157. #include <linux/interrupt.h>
  158. #include <linux/init.h>
  159. #include <linux/platform_device.h>
  160. #include <linux/mod_devicetable.h>
  161. #include <linux/buffer_head.h> /* for invalidate_buffers() */
  162. #include <linux/mutex.h>
  163. #include <linux/io.h>
  164. #include <linux/uaccess.h>
  165. /*
  166. * PS/2 floppies have much slower step rates than regular floppies.
  167. * It's been recommended that take about 1/4 of the default speed
  168. * in some more extreme cases.
  169. */
  170. static int slow_floppy;
  171. #include <asm/dma.h>
  172. #include <asm/irq.h>
  173. #include <asm/system.h>
  174. static int FLOPPY_IRQ = 6;
  175. static int FLOPPY_DMA = 2;
  176. static int can_use_virtual_dma = 2;
  177. /* =======
  178. * can use virtual DMA:
  179. * 0 = use of virtual DMA disallowed by config
  180. * 1 = use of virtual DMA prescribed by config
  181. * 2 = no virtual DMA preference configured. By default try hard DMA,
  182. * but fall back on virtual DMA when not enough memory available
  183. */
  184. static int use_virtual_dma;
  185. /* =======
  186. * use virtual DMA
  187. * 0 using hard DMA
  188. * 1 using virtual DMA
  189. * This variable is set to virtual when a DMA mem problem arises, and
  190. * reset back in floppy_grab_irq_and_dma.
  191. * It is not safe to reset it in other circumstances, because the floppy
  192. * driver may have several buffers in use at once, and we do currently not
  193. * record each buffers capabilities
  194. */
  195. static DEFINE_SPINLOCK(floppy_lock);
  196. static unsigned short virtual_dma_port = 0x3f0;
  197. irqreturn_t floppy_interrupt(int irq, void *dev_id);
  198. static int set_dor(int fdc, char mask, char data);
  199. #define K_64 0x10000 /* 64KB */
  200. /* the following is the mask of allowed drives. By default units 2 and
  201. * 3 of both floppy controllers are disabled, because switching on the
  202. * motor of these drives causes system hangs on some PCI computers. drive
  203. * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
  204. * a drive is allowed.
  205. *
  206. * NOTE: This must come before we include the arch floppy header because
  207. * some ports reference this variable from there. -DaveM
  208. */
  209. static int allowed_drive_mask = 0x33;
  210. #include <asm/floppy.h>
  211. static int irqdma_allocated;
  212. #include <linux/blkdev.h>
  213. #include <linux/blkpg.h>
  214. #include <linux/cdrom.h> /* for the compatibility eject ioctl */
  215. #include <linux/completion.h>
  216. static struct request *current_req;
  217. static struct request_queue *floppy_queue;
  218. static void do_fd_request(struct request_queue *q);
  219. #ifndef fd_get_dma_residue
  220. #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
  221. #endif
  222. /* Dma Memory related stuff */
  223. #ifndef fd_dma_mem_free
  224. #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
  225. #endif
  226. #ifndef fd_dma_mem_alloc
  227. #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL, get_order(size))
  228. #endif
  229. static inline void fallback_on_nodma_alloc(char **addr, size_t l)
  230. {
  231. #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
  232. if (*addr)
  233. return; /* we have the memory */
  234. if (can_use_virtual_dma != 2)
  235. return; /* no fallback allowed */
  236. pr_info("DMA memory shortage. Temporarily falling back on virtual DMA\n");
  237. *addr = (char *)nodma_mem_alloc(l);
  238. #else
  239. return;
  240. #endif
  241. }
  242. /* End dma memory related stuff */
  243. static unsigned long fake_change;
  244. static bool initialized;
  245. #define ITYPE(x) (((x) >> 2) & 0x1f)
  246. #define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
  247. #define UNIT(x) ((x) & 0x03) /* drive on fdc */
  248. #define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
  249. /* reverse mapping from unit and fdc to drive */
  250. #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
  251. #define DP (&drive_params[current_drive])
  252. #define DRS (&drive_state[current_drive])
  253. #define DRWE (&write_errors[current_drive])
  254. #define FDCS (&fdc_state[fdc])
  255. #define UDP (&drive_params[drive])
  256. #define UDRS (&drive_state[drive])
  257. #define UDRWE (&write_errors[drive])
  258. #define UFDCS (&fdc_state[FDC(drive)])
  259. #define PH_HEAD(floppy, head) (((((floppy)->stretch & 2) >> 1) ^ head) << 2)
  260. #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
  261. /* read/write */
  262. #define COMMAND (raw_cmd->cmd[0])
  263. #define DR_SELECT (raw_cmd->cmd[1])
  264. #define TRACK (raw_cmd->cmd[2])
  265. #define HEAD (raw_cmd->cmd[3])
  266. #define SECTOR (raw_cmd->cmd[4])
  267. #define SIZECODE (raw_cmd->cmd[5])
  268. #define SECT_PER_TRACK (raw_cmd->cmd[6])
  269. #define GAP (raw_cmd->cmd[7])
  270. #define SIZECODE2 (raw_cmd->cmd[8])
  271. #define NR_RW 9
  272. /* format */
  273. #define F_SIZECODE (raw_cmd->cmd[2])
  274. #define F_SECT_PER_TRACK (raw_cmd->cmd[3])
  275. #define F_GAP (raw_cmd->cmd[4])
  276. #define F_FILL (raw_cmd->cmd[5])
  277. #define NR_F 6
  278. /*
  279. * Maximum disk size (in kilobytes).
  280. * This default is used whenever the current disk size is unknown.
  281. * [Now it is rather a minimum]
  282. */
  283. #define MAX_DISK_SIZE 4 /* 3984 */
  284. /*
  285. * globals used by 'result()'
  286. */
  287. #define MAX_REPLIES 16
  288. static unsigned char reply_buffer[MAX_REPLIES];
  289. static int inr; /* size of reply buffer, when called from interrupt */
  290. #define ST0 (reply_buffer[0])
  291. #define ST1 (reply_buffer[1])
  292. #define ST2 (reply_buffer[2])
  293. #define ST3 (reply_buffer[0]) /* result of GETSTATUS */
  294. #define R_TRACK (reply_buffer[3])
  295. #define R_HEAD (reply_buffer[4])
  296. #define R_SECTOR (reply_buffer[5])
  297. #define R_SIZECODE (reply_buffer[6])
  298. #define SEL_DLY (2 * HZ / 100)
  299. /*
  300. * this struct defines the different floppy drive types.
  301. */
  302. static struct {
  303. struct floppy_drive_params params;
  304. const char *name; /* name printed while booting */
  305. } default_drive_params[] = {
  306. /* NOTE: the time values in jiffies should be in msec!
  307. CMOS drive type
  308. | Maximum data rate supported by drive type
  309. | | Head load time, msec
  310. | | | Head unload time, msec (not used)
  311. | | | | Step rate interval, usec
  312. | | | | | Time needed for spinup time (jiffies)
  313. | | | | | | Timeout for spinning down (jiffies)
  314. | | | | | | | Spindown offset (where disk stops)
  315. | | | | | | | | Select delay
  316. | | | | | | | | | RPS
  317. | | | | | | | | | | Max number of tracks
  318. | | | | | | | | | | | Interrupt timeout
  319. | | | | | | | | | | | | Max nonintlv. sectors
  320. | | | | | | | | | | | | | -Max Errors- flags */
  321. {{0, 500, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 80, 3*HZ, 20, {3,1,2,0,2}, 0,
  322. 0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
  323. {{1, 300, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 40, 3*HZ, 17, {3,1,2,0,2}, 0,
  324. 0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
  325. {{2, 500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6, 83, 3*HZ, 17, {3,1,2,0,2}, 0,
  326. 0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
  327. {{3, 250, 16, 16, 3000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
  328. 0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
  329. {{4, 500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
  330. 0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
  331. {{5, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
  332. 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
  333. {{6, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
  334. 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
  335. /* | --autodetected formats--- | | |
  336. * read_track | | Name printed when booting
  337. * | Native format
  338. * Frequency of disk change checks */
  339. };
  340. static struct floppy_drive_params drive_params[N_DRIVE];
  341. static struct floppy_drive_struct drive_state[N_DRIVE];
  342. static struct floppy_write_errors write_errors[N_DRIVE];
  343. static struct timer_list motor_off_timer[N_DRIVE];
  344. static struct gendisk *disks[N_DRIVE];
  345. static struct block_device *opened_bdev[N_DRIVE];
  346. static DEFINE_MUTEX(open_lock);
  347. static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
  348. /*
  349. * This struct defines the different floppy types.
  350. *
  351. * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
  352. * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
  353. * tells if the disk is in Commodore 1581 format, which means side 0 sectors
  354. * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
  355. * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
  356. * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
  357. * side 0 is on physical side 0 (but with the misnamed sector IDs).
  358. * 'stretch' should probably be renamed to something more general, like
  359. * 'options'.
  360. *
  361. * Bits 2 through 9 of 'stretch' tell the number of the first sector.
  362. * The LSB (bit 2) is flipped. For most disks, the first sector
  363. * is 1 (represented by 0x00<<2). For some CP/M and music sampler
  364. * disks (such as Ensoniq EPS 16plus) it is 0 (represented as 0x01<<2).
  365. * For Amstrad CPC disks it is 0xC1 (represented as 0xC0<<2).
  366. *
  367. * Other parameters should be self-explanatory (see also setfdprm(8)).
  368. */
  369. /*
  370. Size
  371. | Sectors per track
  372. | | Head
  373. | | | Tracks
  374. | | | | Stretch
  375. | | | | | Gap 1 size
  376. | | | | | | Data rate, | 0x40 for perp
  377. | | | | | | | Spec1 (stepping rate, head unload
  378. | | | | | | | | /fmt gap (gap2) */
  379. static struct floppy_struct floppy_type[32] = {
  380. { 0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL }, /* 0 no testing */
  381. { 720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360" }, /* 1 360KB PC */
  382. { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /* 2 1.2MB AT */
  383. { 720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360" }, /* 3 360KB SS 3.5" */
  384. { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720" }, /* 4 720KB 3.5" */
  385. { 720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" }, /* 5 360KB AT */
  386. { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" }, /* 6 720KB AT */
  387. { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /* 7 1.44MB 3.5" */
  388. { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /* 8 2.88MB 3.5" */
  389. { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /* 9 3.12MB 3.5" */
  390. { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25" */
  391. { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5" */
  392. { 820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410" }, /* 12 410KB 5.25" */
  393. { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820" }, /* 13 820KB 3.5" */
  394. { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25" */
  395. { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5" */
  396. { 840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420" }, /* 16 420KB 5.25" */
  397. { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830" }, /* 17 830KB 3.5" */
  398. { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25" */
  399. { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5" */
  400. { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880" }, /* 20 880KB 5.25" */
  401. { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5" */
  402. { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5" */
  403. { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25" */
  404. { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5" */
  405. { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5" */
  406. { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5" */
  407. { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5" */
  408. { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5" */
  409. { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5" */
  410. { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800" }, /* 30 800KB 3.5" */
  411. { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5" */
  412. };
  413. #define SECTSIZE (_FD_SECTSIZE(*floppy))
  414. /* Auto-detection: Disk type used until the next media change occurs. */
  415. static struct floppy_struct *current_type[N_DRIVE];
  416. /*
  417. * User-provided type information. current_type points to
  418. * the respective entry of this array.
  419. */
  420. static struct floppy_struct user_params[N_DRIVE];
  421. static sector_t floppy_sizes[256];
  422. static char floppy_device_name[] = "floppy";
  423. /*
  424. * The driver is trying to determine the correct media format
  425. * while probing is set. rw_interrupt() clears it after a
  426. * successful access.
  427. */
  428. static int probing;
  429. /* Synchronization of FDC access. */
  430. #define FD_COMMAND_NONE -1
  431. #define FD_COMMAND_ERROR 2
  432. #define FD_COMMAND_OKAY 3
  433. static volatile int command_status = FD_COMMAND_NONE;
  434. static unsigned long fdc_busy;
  435. static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
  436. static DECLARE_WAIT_QUEUE_HEAD(command_done);
  437. #define NO_SIGNAL (!interruptible || !signal_pending(current))
  438. /* Errors during formatting are counted here. */
  439. static int format_errors;
  440. /* Format request descriptor. */
  441. static struct format_descr format_req;
  442. /*
  443. * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
  444. * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
  445. * H is head unload time (1=16ms, 2=32ms, etc)
  446. */
  447. /*
  448. * Track buffer
  449. * Because these are written to by the DMA controller, they must
  450. * not contain a 64k byte boundary crossing, or data will be
  451. * corrupted/lost.
  452. */
  453. static char *floppy_track_buffer;
  454. static int max_buffer_sectors;
  455. static int *errors;
  456. typedef void (*done_f)(int);
  457. static struct cont_t {
  458. void (*interrupt)(void);
  459. /* this is called after the interrupt of the
  460. * main command */
  461. void (*redo)(void); /* this is called to retry the operation */
  462. void (*error)(void); /* this is called to tally an error */
  463. done_f done; /* this is called to say if the operation has
  464. * succeeded/failed */
  465. } *cont;
  466. static void floppy_ready(void);
  467. static void floppy_start(void);
  468. static void process_fd_request(void);
  469. static void recalibrate_floppy(void);
  470. static void floppy_shutdown(unsigned long);
  471. static int floppy_request_regions(int);
  472. static void floppy_release_regions(int);
  473. static int floppy_grab_irq_and_dma(void);
  474. static void floppy_release_irq_and_dma(void);
  475. /*
  476. * The "reset" variable should be tested whenever an interrupt is scheduled,
  477. * after the commands have been sent. This is to ensure that the driver doesn't
  478. * get wedged when the interrupt doesn't come because of a failed command.
  479. * reset doesn't need to be tested before sending commands, because
  480. * output_byte is automatically disabled when reset is set.
  481. */
  482. static void reset_fdc(void);
  483. /*
  484. * These are global variables, as that's the easiest way to give
  485. * information to interrupts. They are the data used for the current
  486. * request.
  487. */
  488. #define NO_TRACK -1
  489. #define NEED_1_RECAL -2
  490. #define NEED_2_RECAL -3
  491. static int usage_count;
  492. /* buffer related variables */
  493. static int buffer_track = -1;
  494. static int buffer_drive = -1;
  495. static int buffer_min = -1;
  496. static int buffer_max = -1;
  497. /* fdc related variables, should end up in a struct */
  498. static struct floppy_fdc_state fdc_state[N_FDC];
  499. static int fdc; /* current fdc */
  500. static struct floppy_struct *_floppy = floppy_type;
  501. static unsigned char current_drive;
  502. static long current_count_sectors;
  503. static unsigned char fsector_t; /* sector in track */
  504. static unsigned char in_sector_offset; /* offset within physical sector,
  505. * expressed in units of 512 bytes */
  506. #ifndef fd_eject
  507. static inline int fd_eject(int drive)
  508. {
  509. return -EINVAL;
  510. }
  511. #endif
  512. /*
  513. * Debugging
  514. * =========
  515. */
  516. #ifdef DEBUGT
  517. static long unsigned debugtimer;
  518. static inline void set_debugt(void)
  519. {
  520. debugtimer = jiffies;
  521. }
  522. static inline void debugt(const char *message)
  523. {
  524. if (DP->flags & DEBUGT)
  525. pr_info("%s dtime=%lu\n", message, jiffies - debugtimer);
  526. }
  527. #else
  528. static inline void set_debugt(void) { }
  529. static inline void debugt(const char *message) { }
  530. #endif /* DEBUGT */
  531. typedef void (*timeout_fn)(unsigned long);
  532. static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
  533. static const char *timeout_message;
  534. static void is_alive(const char *func, const char *message)
  535. {
  536. /* this routine checks whether the floppy driver is "alive" */
  537. if (test_bit(0, &fdc_busy) && command_status < 2 &&
  538. !timer_pending(&fd_timeout)) {
  539. DPRINT("%s: timeout handler died. %s\n", func, message);
  540. }
  541. }
  542. static void (*do_floppy)(void) = NULL;
  543. #define OLOGSIZE 20
  544. static void (*lasthandler)(void);
  545. static unsigned long interruptjiffies;
  546. static unsigned long resultjiffies;
  547. static int resultsize;
  548. static unsigned long lastredo;
  549. static struct output_log {
  550. unsigned char data;
  551. unsigned char status;
  552. unsigned long jiffies;
  553. } output_log[OLOGSIZE];
  554. static int output_log_pos;
  555. #define current_reqD -1
  556. #define MAXTIMEOUT -2
  557. static void __reschedule_timeout(int drive, const char *message)
  558. {
  559. if (drive == current_reqD)
  560. drive = current_drive;
  561. del_timer(&fd_timeout);
  562. if (drive < 0 || drive >= N_DRIVE) {
  563. fd_timeout.expires = jiffies + 20UL * HZ;
  564. drive = 0;
  565. } else
  566. fd_timeout.expires = jiffies + UDP->timeout;
  567. add_timer(&fd_timeout);
  568. if (UDP->flags & FD_DEBUG)
  569. DPRINT("reschedule timeout %s\n", message);
  570. timeout_message = message;
  571. }
  572. static void reschedule_timeout(int drive, const char *message)
  573. {
  574. unsigned long flags;
  575. spin_lock_irqsave(&floppy_lock, flags);
  576. __reschedule_timeout(drive, message);
  577. spin_unlock_irqrestore(&floppy_lock, flags);
  578. }
  579. #define INFBOUND(a, b) (a) = max_t(int, a, b)
  580. #define SUPBOUND(a, b) (a) = min_t(int, a, b)
  581. /*
  582. * Bottom half floppy driver.
  583. * ==========================
  584. *
  585. * This part of the file contains the code talking directly to the hardware,
  586. * and also the main service loop (seek-configure-spinup-command)
  587. */
  588. /*
  589. * disk change.
  590. * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
  591. * and the last_checked date.
  592. *
  593. * last_checked is the date of the last check which showed 'no disk change'
  594. * FD_DISK_CHANGE is set under two conditions:
  595. * 1. The floppy has been changed after some i/o to that floppy already
  596. * took place.
  597. * 2. No floppy disk is in the drive. This is done in order to ensure that
  598. * requests are quickly flushed in case there is no disk in the drive. It
  599. * follows that FD_DISK_CHANGE can only be cleared if there is a disk in
  600. * the drive.
  601. *
  602. * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
  603. * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
  604. * each seek. If a disk is present, the disk change line should also be
  605. * cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
  606. * change line is set, this means either that no disk is in the drive, or
  607. * that it has been removed since the last seek.
  608. *
  609. * This means that we really have a third possibility too:
  610. * The floppy has been changed after the last seek.
  611. */
  612. static int disk_change(int drive)
  613. {
  614. int fdc = FDC(drive);
  615. if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
  616. DPRINT("WARNING disk change called early\n");
  617. if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
  618. (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
  619. DPRINT("probing disk change on unselected drive\n");
  620. DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
  621. (unsigned int)FDCS->dor);
  622. }
  623. debug_dcl(UDP->flags,
  624. "checking disk change line for drive %d\n", drive);
  625. debug_dcl(UDP->flags, "jiffies=%lu\n", jiffies);
  626. debug_dcl(UDP->flags, "disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
  627. debug_dcl(UDP->flags, "flags=%lx\n", UDRS->flags);
  628. if (UDP->flags & FD_BROKEN_DCL)
  629. return test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
  630. if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
  631. set_bit(FD_VERIFY_BIT, &UDRS->flags);
  632. /* verify write protection */
  633. if (UDRS->maxblock) /* mark it changed */
  634. set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
  635. /* invalidate its geometry */
  636. if (UDRS->keep_data >= 0) {
  637. if ((UDP->flags & FTD_MSG) &&
  638. current_type[drive] != NULL)
  639. DPRINT("Disk type is undefined after disk change\n");
  640. current_type[drive] = NULL;
  641. floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
  642. }
  643. return 1;
  644. } else {
  645. UDRS->last_checked = jiffies;
  646. clear_bit(FD_DISK_NEWCHANGE_BIT, &UDRS->flags);
  647. }
  648. return 0;
  649. }
  650. static inline int is_selected(int dor, int unit)
  651. {
  652. return ((dor & (0x10 << unit)) && (dor & 3) == unit);
  653. }
  654. static bool is_ready_state(int status)
  655. {
  656. int state = status & (STATUS_READY | STATUS_DIR | STATUS_DMA);
  657. return state == STATUS_READY;
  658. }
  659. static int set_dor(int fdc, char mask, char data)
  660. {
  661. unsigned char unit;
  662. unsigned char drive;
  663. unsigned char newdor;
  664. unsigned char olddor;
  665. if (FDCS->address == -1)
  666. return -1;
  667. olddor = FDCS->dor;
  668. newdor = (olddor & mask) | data;
  669. if (newdor != olddor) {
  670. unit = olddor & 0x3;
  671. if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
  672. drive = REVDRIVE(fdc, unit);
  673. debug_dcl(UDP->flags,
  674. "calling disk change from set_dor\n");
  675. disk_change(drive);
  676. }
  677. FDCS->dor = newdor;
  678. fd_outb(newdor, FD_DOR);
  679. unit = newdor & 0x3;
  680. if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
  681. drive = REVDRIVE(fdc, unit);
  682. UDRS->select_date = jiffies;
  683. }
  684. }
  685. return olddor;
  686. }
  687. static void twaddle(void)
  688. {
  689. if (DP->select_delay)
  690. return;
  691. fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
  692. fd_outb(FDCS->dor, FD_DOR);
  693. DRS->select_date = jiffies;
  694. }
  695. /*
  696. * Reset all driver information about the current fdc.
  697. * This is needed after a reset, and after a raw command.
  698. */
  699. static void reset_fdc_info(int mode)
  700. {
  701. int drive;
  702. FDCS->spec1 = FDCS->spec2 = -1;
  703. FDCS->need_configure = 1;
  704. FDCS->perp_mode = 1;
  705. FDCS->rawcmd = 0;
  706. for (drive = 0; drive < N_DRIVE; drive++)
  707. if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
  708. UDRS->track = NEED_2_RECAL;
  709. }
  710. /* selects the fdc and drive, and enables the fdc's input/dma. */
  711. static void set_fdc(int drive)
  712. {
  713. if (drive >= 0 && drive < N_DRIVE) {
  714. fdc = FDC(drive);
  715. current_drive = drive;
  716. }
  717. if (fdc != 1 && fdc != 0) {
  718. pr_info("bad fdc value\n");
  719. return;
  720. }
  721. set_dor(fdc, ~0, 8);
  722. #if N_FDC > 1
  723. set_dor(1 - fdc, ~8, 0);
  724. #endif
  725. if (FDCS->rawcmd == 2)
  726. reset_fdc_info(1);
  727. if (fd_inb(FD_STATUS) != STATUS_READY)
  728. FDCS->reset = 1;
  729. }
  730. /* locks the driver */
  731. static int _lock_fdc(int drive, bool interruptible, int line)
  732. {
  733. if (!usage_count) {
  734. pr_err("Trying to lock fdc while usage count=0 at line %d\n",
  735. line);
  736. return -1;
  737. }
  738. if (test_and_set_bit(0, &fdc_busy)) {
  739. DECLARE_WAITQUEUE(wait, current);
  740. add_wait_queue(&fdc_wait, &wait);
  741. for (;;) {
  742. set_current_state(TASK_INTERRUPTIBLE);
  743. if (!test_and_set_bit(0, &fdc_busy))
  744. break;
  745. schedule();
  746. if (!NO_SIGNAL) {
  747. remove_wait_queue(&fdc_wait, &wait);
  748. return -EINTR;
  749. }
  750. }
  751. set_current_state(TASK_RUNNING);
  752. remove_wait_queue(&fdc_wait, &wait);
  753. flush_scheduled_work();
  754. }
  755. command_status = FD_COMMAND_NONE;
  756. __reschedule_timeout(drive, "lock fdc");
  757. set_fdc(drive);
  758. return 0;
  759. }
  760. #define lock_fdc(drive, interruptible) \
  761. _lock_fdc(drive, interruptible, __LINE__)
  762. /* unlocks the driver */
  763. static inline void unlock_fdc(void)
  764. {
  765. unsigned long flags;
  766. raw_cmd = NULL;
  767. if (!test_bit(0, &fdc_busy))
  768. DPRINT("FDC access conflict!\n");
  769. if (do_floppy)
  770. DPRINT("device interrupt still active at FDC release: %pf!\n",
  771. do_floppy);
  772. command_status = FD_COMMAND_NONE;
  773. spin_lock_irqsave(&floppy_lock, flags);
  774. del_timer(&fd_timeout);
  775. cont = NULL;
  776. clear_bit(0, &fdc_busy);
  777. if (current_req || blk_peek_request(floppy_queue))
  778. do_fd_request(floppy_queue);
  779. spin_unlock_irqrestore(&floppy_lock, flags);
  780. wake_up(&fdc_wait);
  781. }
  782. /* switches the motor off after a given timeout */
  783. static void motor_off_callback(unsigned long nr)
  784. {
  785. unsigned char mask = ~(0x10 << UNIT(nr));
  786. set_dor(FDC(nr), mask, 0);
  787. }
  788. /* schedules motor off */
  789. static void floppy_off(unsigned int drive)
  790. {
  791. unsigned long volatile delta;
  792. int fdc = FDC(drive);
  793. if (!(FDCS->dor & (0x10 << UNIT(drive))))
  794. return;
  795. del_timer(motor_off_timer + drive);
  796. /* make spindle stop in a position which minimizes spinup time
  797. * next time */
  798. if (UDP->rps) {
  799. delta = jiffies - UDRS->first_read_date + HZ -
  800. UDP->spindown_offset;
  801. delta = ((delta * UDP->rps) % HZ) / UDP->rps;
  802. motor_off_timer[drive].expires =
  803. jiffies + UDP->spindown - delta;
  804. }
  805. add_timer(motor_off_timer + drive);
  806. }
  807. /*
  808. * cycle through all N_DRIVE floppy drives, for disk change testing.
  809. * stopping at current drive. This is done before any long operation, to
  810. * be sure to have up to date disk change information.
  811. */
  812. static void scandrives(void)
  813. {
  814. int i;
  815. int drive;
  816. int saved_drive;
  817. if (DP->select_delay)
  818. return;
  819. saved_drive = current_drive;
  820. for (i = 0; i < N_DRIVE; i++) {
  821. drive = (saved_drive + i + 1) % N_DRIVE;
  822. if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
  823. continue; /* skip closed drives */
  824. set_fdc(drive);
  825. if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
  826. (0x10 << UNIT(drive))))
  827. /* switch the motor off again, if it was off to
  828. * begin with */
  829. set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
  830. }
  831. set_fdc(saved_drive);
  832. }
  833. static void empty(void)
  834. {
  835. }
  836. static DECLARE_WORK(floppy_work, NULL);
  837. static void schedule_bh(void (*handler)(void))
  838. {
  839. PREPARE_WORK(&floppy_work, (work_func_t)handler);
  840. schedule_work(&floppy_work);
  841. }
  842. static DEFINE_TIMER(fd_timer, NULL, 0, 0);
  843. static void cancel_activity(void)
  844. {
  845. unsigned long flags;
  846. spin_lock_irqsave(&floppy_lock, flags);
  847. do_floppy = NULL;
  848. PREPARE_WORK(&floppy_work, (work_func_t)empty);
  849. del_timer(&fd_timer);
  850. spin_unlock_irqrestore(&floppy_lock, flags);
  851. }
  852. /* this function makes sure that the disk stays in the drive during the
  853. * transfer */
  854. static void fd_watchdog(void)
  855. {
  856. debug_dcl(DP->flags, "calling disk change from watchdog\n");
  857. if (disk_change(current_drive)) {
  858. DPRINT("disk removed during i/o\n");
  859. cancel_activity();
  860. cont->done(0);
  861. reset_fdc();
  862. } else {
  863. del_timer(&fd_timer);
  864. fd_timer.function = (timeout_fn)fd_watchdog;
  865. fd_timer.expires = jiffies + HZ / 10;
  866. add_timer(&fd_timer);
  867. }
  868. }
  869. static void main_command_interrupt(void)
  870. {
  871. del_timer(&fd_timer);
  872. cont->interrupt();
  873. }
  874. /* waits for a delay (spinup or select) to pass */
  875. static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
  876. {
  877. if (FDCS->reset) {
  878. reset_fdc(); /* do the reset during sleep to win time
  879. * if we don't need to sleep, it's a good
  880. * occasion anyways */
  881. return 1;
  882. }
  883. if (time_before(jiffies, delay)) {
  884. del_timer(&fd_timer);
  885. fd_timer.function = function;
  886. fd_timer.expires = delay;
  887. add_timer(&fd_timer);
  888. return 1;
  889. }
  890. return 0;
  891. }
  892. static DEFINE_SPINLOCK(floppy_hlt_lock);
  893. static int hlt_disabled;
  894. static void floppy_disable_hlt(void)
  895. {
  896. unsigned long flags;
  897. spin_lock_irqsave(&floppy_hlt_lock, flags);
  898. if (!hlt_disabled) {
  899. hlt_disabled = 1;
  900. #ifdef HAVE_DISABLE_HLT
  901. disable_hlt();
  902. #endif
  903. }
  904. spin_unlock_irqrestore(&floppy_hlt_lock, flags);
  905. }
  906. static void floppy_enable_hlt(void)
  907. {
  908. unsigned long flags;
  909. spin_lock_irqsave(&floppy_hlt_lock, flags);
  910. if (hlt_disabled) {
  911. hlt_disabled = 0;
  912. #ifdef HAVE_DISABLE_HLT
  913. enable_hlt();
  914. #endif
  915. }
  916. spin_unlock_irqrestore(&floppy_hlt_lock, flags);
  917. }
  918. static void setup_DMA(void)
  919. {
  920. unsigned long f;
  921. if (raw_cmd->length == 0) {
  922. int i;
  923. pr_info("zero dma transfer size:");
  924. for (i = 0; i < raw_cmd->cmd_count; i++)
  925. pr_cont("%x,", raw_cmd->cmd[i]);
  926. pr_cont("\n");
  927. cont->done(0);
  928. FDCS->reset = 1;
  929. return;
  930. }
  931. if (((unsigned long)raw_cmd->kernel_data) % 512) {
  932. pr_info("non aligned address: %p\n", raw_cmd->kernel_data);
  933. cont->done(0);
  934. FDCS->reset = 1;
  935. return;
  936. }
  937. f = claim_dma_lock();
  938. fd_disable_dma();
  939. #ifdef fd_dma_setup
  940. if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
  941. (raw_cmd->flags & FD_RAW_READ) ?
  942. DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
  943. release_dma_lock(f);
  944. cont->done(0);
  945. FDCS->reset = 1;
  946. return;
  947. }
  948. release_dma_lock(f);
  949. #else
  950. fd_clear_dma_ff();
  951. fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
  952. fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
  953. DMA_MODE_READ : DMA_MODE_WRITE);
  954. fd_set_dma_addr(raw_cmd->kernel_data);
  955. fd_set_dma_count(raw_cmd->length);
  956. virtual_dma_port = FDCS->address;
  957. fd_enable_dma();
  958. release_dma_lock(f);
  959. #endif
  960. floppy_disable_hlt();
  961. }
  962. static void show_floppy(void);
  963. /* waits until the fdc becomes ready */
  964. static int wait_til_ready(void)
  965. {
  966. int status;
  967. int counter;
  968. if (FDCS->reset)
  969. return -1;
  970. for (counter = 0; counter < 10000; counter++) {
  971. status = fd_inb(FD_STATUS);
  972. if (status & STATUS_READY)
  973. return status;
  974. }
  975. if (initialized) {
  976. DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
  977. show_floppy();
  978. }
  979. FDCS->reset = 1;
  980. return -1;
  981. }
  982. /* sends a command byte to the fdc */
  983. static int output_byte(char byte)
  984. {
  985. int status = wait_til_ready();
  986. if (status < 0)
  987. return -1;
  988. if (is_ready_state(status)) {
  989. fd_outb(byte, FD_DATA);
  990. output_log[output_log_pos].data = byte;
  991. output_log[output_log_pos].status = status;
  992. output_log[output_log_pos].jiffies = jiffies;
  993. output_log_pos = (output_log_pos + 1) % OLOGSIZE;
  994. return 0;
  995. }
  996. FDCS->reset = 1;
  997. if (initialized) {
  998. DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
  999. byte, fdc, status);
  1000. show_floppy();
  1001. }
  1002. return -1;
  1003. }
  1004. /* gets the response from the fdc */
  1005. static int result(void)
  1006. {
  1007. int i;
  1008. int status = 0;
  1009. for (i = 0; i < MAX_REPLIES; i++) {
  1010. status = wait_til_ready();
  1011. if (status < 0)
  1012. break;
  1013. status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
  1014. if ((status & ~STATUS_BUSY) == STATUS_READY) {
  1015. resultjiffies = jiffies;
  1016. resultsize = i;
  1017. return i;
  1018. }
  1019. if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
  1020. reply_buffer[i] = fd_inb(FD_DATA);
  1021. else
  1022. break;
  1023. }
  1024. if (initialized) {
  1025. DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
  1026. fdc, status, i);
  1027. show_floppy();
  1028. }
  1029. FDCS->reset = 1;
  1030. return -1;
  1031. }
  1032. #define MORE_OUTPUT -2
  1033. /* does the fdc need more output? */
  1034. static int need_more_output(void)
  1035. {
  1036. int status = wait_til_ready();
  1037. if (status < 0)
  1038. return -1;
  1039. if (is_ready_state(status))
  1040. return MORE_OUTPUT;
  1041. return result();
  1042. }
  1043. /* Set perpendicular mode as required, based on data rate, if supported.
  1044. * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
  1045. */
  1046. static inline void perpendicular_mode(void)
  1047. {
  1048. unsigned char perp_mode;
  1049. if (raw_cmd->rate & 0x40) {
  1050. switch (raw_cmd->rate & 3) {
  1051. case 0:
  1052. perp_mode = 2;
  1053. break;
  1054. case 3:
  1055. perp_mode = 3;
  1056. break;
  1057. default:
  1058. DPRINT("Invalid data rate for perpendicular mode!\n");
  1059. cont->done(0);
  1060. FDCS->reset = 1;
  1061. /*
  1062. * convenient way to return to
  1063. * redo without too much hassle
  1064. * (deep stack et al.)
  1065. */
  1066. return;
  1067. }
  1068. } else
  1069. perp_mode = 0;
  1070. if (FDCS->perp_mode == perp_mode)
  1071. return;
  1072. if (FDCS->version >= FDC_82077_ORIG) {
  1073. output_byte(FD_PERPENDICULAR);
  1074. output_byte(perp_mode);
  1075. FDCS->perp_mode = perp_mode;
  1076. } else if (perp_mode) {
  1077. DPRINT("perpendicular mode not supported by this FDC.\n");
  1078. }
  1079. } /* perpendicular_mode */
  1080. static int fifo_depth = 0xa;
  1081. static int no_fifo;
  1082. static int fdc_configure(void)
  1083. {
  1084. /* Turn on FIFO */
  1085. output_byte(FD_CONFIGURE);
  1086. if (need_more_output() != MORE_OUTPUT)
  1087. return 0;
  1088. output_byte(0);
  1089. output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
  1090. output_byte(0); /* pre-compensation from track
  1091. 0 upwards */
  1092. return 1;
  1093. }
  1094. #define NOMINAL_DTR 500
  1095. /* Issue a "SPECIFY" command to set the step rate time, head unload time,
  1096. * head load time, and DMA disable flag to values needed by floppy.
  1097. *
  1098. * The value "dtr" is the data transfer rate in Kbps. It is needed
  1099. * to account for the data rate-based scaling done by the 82072 and 82077
  1100. * FDC types. This parameter is ignored for other types of FDCs (i.e.
  1101. * 8272a).
  1102. *
  1103. * Note that changing the data transfer rate has a (probably deleterious)
  1104. * effect on the parameters subject to scaling for 82072/82077 FDCs, so
  1105. * fdc_specify is called again after each data transfer rate
  1106. * change.
  1107. *
  1108. * srt: 1000 to 16000 in microseconds
  1109. * hut: 16 to 240 milliseconds
  1110. * hlt: 2 to 254 milliseconds
  1111. *
  1112. * These values are rounded up to the next highest available delay time.
  1113. */
  1114. static void fdc_specify(void)
  1115. {
  1116. unsigned char spec1;
  1117. unsigned char spec2;
  1118. unsigned long srt;
  1119. unsigned long hlt;
  1120. unsigned long hut;
  1121. unsigned long dtr = NOMINAL_DTR;
  1122. unsigned long scale_dtr = NOMINAL_DTR;
  1123. int hlt_max_code = 0x7f;
  1124. int hut_max_code = 0xf;
  1125. if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
  1126. fdc_configure();
  1127. FDCS->need_configure = 0;
  1128. }
  1129. switch (raw_cmd->rate & 0x03) {
  1130. case 3:
  1131. dtr = 1000;
  1132. break;
  1133. case 1:
  1134. dtr = 300;
  1135. if (FDCS->version >= FDC_82078) {
  1136. /* chose the default rate table, not the one
  1137. * where 1 = 2 Mbps */
  1138. output_byte(FD_DRIVESPEC);
  1139. if (need_more_output() == MORE_OUTPUT) {
  1140. output_byte(UNIT(current_drive));
  1141. output_byte(0xc0);
  1142. }
  1143. }
  1144. break;
  1145. case 2:
  1146. dtr = 250;
  1147. break;
  1148. }
  1149. if (FDCS->version >= FDC_82072) {
  1150. scale_dtr = dtr;
  1151. hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
  1152. hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
  1153. }
  1154. /* Convert step rate from microseconds to milliseconds and 4 bits */
  1155. srt = 16 - DIV_ROUND_UP(DP->srt * scale_dtr / 1000, NOMINAL_DTR);
  1156. if (slow_floppy)
  1157. srt = srt / 4;
  1158. SUPBOUND(srt, 0xf);
  1159. INFBOUND(srt, 0);
  1160. hlt = DIV_ROUND_UP(DP->hlt * scale_dtr / 2, NOMINAL_DTR);
  1161. if (hlt < 0x01)
  1162. hlt = 0x01;
  1163. else if (hlt > 0x7f)
  1164. hlt = hlt_max_code;
  1165. hut = DIV_ROUND_UP(DP->hut * scale_dtr / 16, NOMINAL_DTR);
  1166. if (hut < 0x1)
  1167. hut = 0x1;
  1168. else if (hut > 0xf)
  1169. hut = hut_max_code;
  1170. spec1 = (srt << 4) | hut;
  1171. spec2 = (hlt << 1) | (use_virtual_dma & 1);
  1172. /* If these parameters did not change, just return with success */
  1173. if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
  1174. /* Go ahead and set spec1 and spec2 */
  1175. output_byte(FD_SPECIFY);
  1176. output_byte(FDCS->spec1 = spec1);
  1177. output_byte(FDCS->spec2 = spec2);
  1178. }
  1179. } /* fdc_specify */
  1180. /* Set the FDC's data transfer rate on behalf of the specified drive.
  1181. * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
  1182. * of the specify command (i.e. using the fdc_specify function).
  1183. */
  1184. static int fdc_dtr(void)
  1185. {
  1186. /* If data rate not already set to desired value, set it. */
  1187. if ((raw_cmd->rate & 3) == FDCS->dtr)
  1188. return 0;
  1189. /* Set dtr */
  1190. fd_outb(raw_cmd->rate & 3, FD_DCR);
  1191. /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
  1192. * need a stabilization period of several milliseconds to be
  1193. * enforced after data rate changes before R/W operations.
  1194. * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
  1195. */
  1196. FDCS->dtr = raw_cmd->rate & 3;
  1197. return fd_wait_for_completion(jiffies + 2UL * HZ / 100,
  1198. (timeout_fn)floppy_ready);
  1199. } /* fdc_dtr */
  1200. static void tell_sector(void)
  1201. {
  1202. pr_cont(": track %d, head %d, sector %d, size %d",
  1203. R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
  1204. } /* tell_sector */
  1205. static void print_errors(void)
  1206. {
  1207. DPRINT("");
  1208. if (ST0 & ST0_ECE) {
  1209. pr_cont("Recalibrate failed!");
  1210. } else if (ST2 & ST2_CRC) {
  1211. pr_cont("data CRC error");
  1212. tell_sector();
  1213. } else if (ST1 & ST1_CRC) {
  1214. pr_cont("CRC error");
  1215. tell_sector();
  1216. } else if ((ST1 & (ST1_MAM | ST1_ND)) ||
  1217. (ST2 & ST2_MAM)) {
  1218. if (!probing) {
  1219. pr_cont("sector not found");
  1220. tell_sector();
  1221. } else
  1222. pr_cont("probe failed...");
  1223. } else if (ST2 & ST2_WC) { /* seek error */
  1224. pr_cont("wrong cylinder");
  1225. } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
  1226. pr_cont("bad cylinder");
  1227. } else {
  1228. pr_cont("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
  1229. ST0, ST1, ST2);
  1230. tell_sector();
  1231. }
  1232. pr_cont("\n");
  1233. }
  1234. /*
  1235. * OK, this error interpreting routine is called after a
  1236. * DMA read/write has succeeded
  1237. * or failed, so we check the results, and copy any buffers.
  1238. * hhb: Added better error reporting.
  1239. * ak: Made this into a separate routine.
  1240. */
  1241. static int interpret_errors(void)
  1242. {
  1243. char bad;
  1244. if (inr != 7) {
  1245. DPRINT("-- FDC reply error\n");
  1246. FDCS->reset = 1;
  1247. return 1;
  1248. }
  1249. /* check IC to find cause of interrupt */
  1250. switch (ST0 & ST0_INTR) {
  1251. case 0x40: /* error occurred during command execution */
  1252. if (ST1 & ST1_EOC)
  1253. return 0; /* occurs with pseudo-DMA */
  1254. bad = 1;
  1255. if (ST1 & ST1_WP) {
  1256. DPRINT("Drive is write protected\n");
  1257. clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
  1258. cont->done(0);
  1259. bad = 2;
  1260. } else if (ST1 & ST1_ND) {
  1261. set_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
  1262. } else if (ST1 & ST1_OR) {
  1263. if (DP->flags & FTD_MSG)
  1264. DPRINT("Over/Underrun - retrying\n");
  1265. bad = 0;
  1266. } else if (*errors >= DP->max_errors.reporting) {
  1267. print_errors();
  1268. }
  1269. if (ST2 & ST2_WC || ST2 & ST2_BC)
  1270. /* wrong cylinder => recal */
  1271. DRS->track = NEED_2_RECAL;
  1272. return bad;
  1273. case 0x80: /* invalid command given */
  1274. DPRINT("Invalid FDC command given!\n");
  1275. cont->done(0);
  1276. return 2;
  1277. case 0xc0:
  1278. DPRINT("Abnormal termination caused by polling\n");
  1279. cont->error();
  1280. return 2;
  1281. default: /* (0) Normal command termination */
  1282. return 0;
  1283. }
  1284. }
  1285. /*
  1286. * This routine is called when everything should be correctly set up
  1287. * for the transfer (i.e. floppy motor is on, the correct floppy is
  1288. * selected, and the head is sitting on the right track).
  1289. */
  1290. static void setup_rw_floppy(void)
  1291. {
  1292. int i;
  1293. int r;
  1294. int flags;
  1295. int dflags;
  1296. unsigned long ready_date;
  1297. timeout_fn function;
  1298. flags = raw_cmd->flags;
  1299. if (flags & (FD_RAW_READ | FD_RAW_WRITE))
  1300. flags |= FD_RAW_INTR;
  1301. if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
  1302. ready_date = DRS->spinup_date + DP->spinup;
  1303. /* If spinup will take a long time, rerun scandrives
  1304. * again just before spinup completion. Beware that
  1305. * after scandrives, we must again wait for selection.
  1306. */
  1307. if (time_after(ready_date, jiffies + DP->select_delay)) {
  1308. ready_date -= DP->select_delay;
  1309. function = (timeout_fn)floppy_start;
  1310. } else
  1311. function = (timeout_fn)setup_rw_floppy;
  1312. /* wait until the floppy is spinning fast enough */
  1313. if (fd_wait_for_completion(ready_date, function))
  1314. return;
  1315. }
  1316. dflags = DRS->flags;
  1317. if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
  1318. setup_DMA();
  1319. if (flags & FD_RAW_INTR)
  1320. do_floppy = main_command_interrupt;
  1321. r = 0;
  1322. for (i = 0; i < raw_cmd->cmd_count; i++)
  1323. r |= output_byte(raw_cmd->cmd[i]);
  1324. debugt("rw_command: ");
  1325. if (r) {
  1326. cont->error();
  1327. reset_fdc();
  1328. return;
  1329. }
  1330. if (!(flags & FD_RAW_INTR)) {
  1331. inr = result();
  1332. cont->interrupt();
  1333. } else if (flags & FD_RAW_NEED_DISK)
  1334. fd_watchdog();
  1335. }
  1336. static int blind_seek;
  1337. /*
  1338. * This is the routine called after every seek (or recalibrate) interrupt
  1339. * from the floppy controller.
  1340. */
  1341. static void seek_interrupt(void)
  1342. {
  1343. debugt("seek interrupt:");
  1344. if (inr != 2 || (ST0 & 0xF8) != 0x20) {
  1345. DPRINT("seek failed\n");
  1346. DRS->track = NEED_2_RECAL;
  1347. cont->error();
  1348. cont->redo();
  1349. return;
  1350. }
  1351. if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
  1352. debug_dcl(DP->flags,
  1353. "clearing NEWCHANGE flag because of effective seek\n");
  1354. debug_dcl(DP->flags, "jiffies=%lu\n", jiffies);
  1355. clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
  1356. /* effective seek */
  1357. DRS->select_date = jiffies;
  1358. }
  1359. DRS->track = ST1;
  1360. floppy_ready();
  1361. }
  1362. static void check_wp(void)
  1363. {
  1364. if (test_bit(FD_VERIFY_BIT, &DRS->flags)) {
  1365. /* check write protection */
  1366. output_byte(FD_GETSTATUS);
  1367. output_byte(UNIT(current_drive));
  1368. if (result() != 1) {
  1369. FDCS->reset = 1;
  1370. return;
  1371. }
  1372. clear_bit(FD_VERIFY_BIT, &DRS->flags);
  1373. clear_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
  1374. debug_dcl(DP->flags,
  1375. "checking whether disk is write protected\n");
  1376. debug_dcl(DP->flags, "wp=%x\n", ST3 & 0x40);
  1377. if (!(ST3 & 0x40))
  1378. set_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
  1379. else
  1380. clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
  1381. }
  1382. }
  1383. static void seek_floppy(void)
  1384. {
  1385. int track;
  1386. blind_seek = 0;
  1387. debug_dcl(DP->flags, "calling disk change from seek\n");
  1388. if (!test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
  1389. disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
  1390. /* the media changed flag should be cleared after the seek.
  1391. * If it isn't, this means that there is really no disk in
  1392. * the drive.
  1393. */
  1394. set_bit(FD_DISK_CHANGED_BIT, &DRS->flags);
  1395. cont->done(0);
  1396. cont->redo();
  1397. return;
  1398. }
  1399. if (DRS->track <= NEED_1_RECAL) {
  1400. recalibrate_floppy();
  1401. return;
  1402. } else if (test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
  1403. (raw_cmd->flags & FD_RAW_NEED_DISK) &&
  1404. (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
  1405. /* we seek to clear the media-changed condition. Does anybody
  1406. * know a more elegant way, which works on all drives? */
  1407. if (raw_cmd->track)
  1408. track = raw_cmd->track - 1;
  1409. else {
  1410. if (DP->flags & FD_SILENT_DCL_CLEAR) {
  1411. set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
  1412. blind_seek = 1;
  1413. raw_cmd->flags |= FD_RAW_NEED_SEEK;
  1414. }
  1415. track = 1;
  1416. }
  1417. } else {
  1418. check_wp();
  1419. if (raw_cmd->track != DRS->track &&
  1420. (raw_cmd->flags & FD_RAW_NEED_SEEK))
  1421. track = raw_cmd->track;
  1422. else {
  1423. setup_rw_floppy();
  1424. return;
  1425. }
  1426. }
  1427. do_floppy = seek_interrupt;
  1428. output_byte(FD_SEEK);
  1429. output_byte(UNIT(current_drive));
  1430. if (output_byte(track) < 0) {
  1431. reset_fdc();
  1432. return;
  1433. }
  1434. debugt("seek command:");
  1435. }
  1436. static void recal_interrupt(void)
  1437. {
  1438. debugt("recal interrupt:");
  1439. if (inr != 2)
  1440. FDCS->reset = 1;
  1441. else if (ST0 & ST0_ECE) {
  1442. switch (DRS->track) {
  1443. case NEED_1_RECAL:
  1444. debugt("recal interrupt need 1 recal:");
  1445. /* after a second recalibrate, we still haven't
  1446. * reached track 0. Probably no drive. Raise an
  1447. * error, as failing immediately might upset
  1448. * computers possessed by the Devil :-) */
  1449. cont->error();
  1450. cont->redo();
  1451. return;
  1452. case NEED_2_RECAL:
  1453. debugt("recal interrupt need 2 recal:");
  1454. /* If we already did a recalibrate,
  1455. * and we are not at track 0, this
  1456. * means we have moved. (The only way
  1457. * not to move at recalibration is to
  1458. * be already at track 0.) Clear the
  1459. * new change flag */
  1460. debug_dcl(DP->flags,
  1461. "clearing NEWCHANGE flag because of second recalibrate\n");
  1462. clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
  1463. DRS->select_date = jiffies;
  1464. /* fall through */
  1465. default:
  1466. debugt("recal interrupt default:");
  1467. /* Recalibrate moves the head by at
  1468. * most 80 steps. If after one
  1469. * recalibrate we don't have reached
  1470. * track 0, this might mean that we
  1471. * started beyond track 80. Try
  1472. * again. */
  1473. DRS->track = NEED_1_RECAL;
  1474. break;
  1475. }
  1476. } else
  1477. DRS->track = ST1;
  1478. floppy_ready();
  1479. }
  1480. static void print_result(char *message, int inr)
  1481. {
  1482. int i;
  1483. DPRINT("%s ", message);
  1484. if (inr >= 0)
  1485. for (i = 0; i < inr; i++)
  1486. pr_cont("repl[%d]=%x ", i, reply_buffer[i]);
  1487. pr_cont("\n");
  1488. }
  1489. /* interrupt handler. Note that this can be called externally on the Sparc */
  1490. irqreturn_t floppy_interrupt(int irq, void *dev_id)
  1491. {
  1492. int do_print;
  1493. unsigned long f;
  1494. void (*handler)(void) = do_floppy;
  1495. lasthandler = handler;
  1496. interruptjiffies = jiffies;
  1497. f = claim_dma_lock();
  1498. fd_disable_dma();
  1499. release_dma_lock(f);
  1500. floppy_enable_hlt();
  1501. do_floppy = NULL;
  1502. if (fdc >= N_FDC || FDCS->address == -1) {
  1503. /* we don't even know which FDC is the culprit */
  1504. pr_info("DOR0=%x\n", fdc_state[0].dor);
  1505. pr_info("floppy interrupt on bizarre fdc %d\n", fdc);
  1506. pr_info("handler=%pf\n", handler);
  1507. is_alive(__func__, "bizarre fdc");
  1508. return IRQ_NONE;
  1509. }
  1510. FDCS->reset = 0;
  1511. /* We have to clear the reset flag here, because apparently on boxes
  1512. * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
  1513. * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
  1514. * emission of the SENSEI's.
  1515. * It is OK to emit floppy commands because we are in an interrupt
  1516. * handler here, and thus we have to fear no interference of other
  1517. * activity.
  1518. */
  1519. do_print = !handler && print_unex && initialized;
  1520. inr = result();
  1521. if (do_print)
  1522. print_result("unexpected interrupt", inr);
  1523. if (inr == 0) {
  1524. int max_sensei = 4;
  1525. do {
  1526. output_byte(FD_SENSEI);
  1527. inr = result();
  1528. if (do_print)
  1529. print_result("sensei", inr);
  1530. max_sensei--;
  1531. } while ((ST0 & 0x83) != UNIT(current_drive) &&
  1532. inr == 2 && max_sensei);
  1533. }
  1534. if (!handler) {
  1535. FDCS->reset = 1;
  1536. return IRQ_NONE;
  1537. }
  1538. schedule_bh(handler);
  1539. is_alive(__func__, "normal interrupt end");
  1540. /* FIXME! Was it really for us? */
  1541. return IRQ_HANDLED;
  1542. }
  1543. static void recalibrate_floppy(void)
  1544. {
  1545. debugt("recalibrate floppy:");
  1546. do_floppy = recal_interrupt;
  1547. output_byte(FD_RECALIBRATE);
  1548. if (output_byte(UNIT(current_drive)) < 0)
  1549. reset_fdc();
  1550. }
  1551. /*
  1552. * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
  1553. */
  1554. static void reset_interrupt(void)
  1555. {
  1556. debugt("reset interrupt:");
  1557. result(); /* get the status ready for set_fdc */
  1558. if (FDCS->reset) {
  1559. pr_info("reset set in interrupt, calling %pf\n", cont->error);
  1560. cont->error(); /* a reset just after a reset. BAD! */
  1561. }
  1562. cont->redo();
  1563. }
  1564. /*
  1565. * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
  1566. * or by setting the self clearing bit 7 of STATUS (newer FDCs)
  1567. */
  1568. static void reset_fdc(void)
  1569. {
  1570. unsigned long flags;
  1571. do_floppy = reset_interrupt;
  1572. FDCS->reset = 0;
  1573. reset_fdc_info(0);
  1574. /* Pseudo-DMA may intercept 'reset finished' interrupt. */
  1575. /* Irrelevant for systems with true DMA (i386). */
  1576. flags = claim_dma_lock();
  1577. fd_disable_dma();
  1578. release_dma_lock(flags);
  1579. if (FDCS->version >= FDC_82072A)
  1580. fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
  1581. else {
  1582. fd_outb(FDCS->dor & ~0x04, FD_DOR);
  1583. udelay(FD_RESET_DELAY);
  1584. fd_outb(FDCS->dor, FD_DOR);
  1585. }
  1586. }
  1587. static void show_floppy(void)
  1588. {
  1589. int i;
  1590. pr_info("\n");
  1591. pr_info("floppy driver state\n");
  1592. pr_info("-------------------\n");
  1593. pr_info("now=%lu last interrupt=%lu diff=%lu last called handler=%pf\n",
  1594. jiffies, interruptjiffies, jiffies - interruptjiffies,
  1595. lasthandler);
  1596. pr_info("timeout_message=%s\n", timeout_message);
  1597. pr_info("last output bytes:\n");
  1598. for (i = 0; i < OLOGSIZE; i++)
  1599. pr_info("%2x %2x %lu\n",
  1600. output_log[(i + output_log_pos) % OLOGSIZE].data,
  1601. output_log[(i + output_log_pos) % OLOGSIZE].status,
  1602. output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
  1603. pr_info("last result at %lu\n", resultjiffies);
  1604. pr_info("last redo_fd_request at %lu\n", lastredo);
  1605. print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1,
  1606. reply_buffer, resultsize, true);
  1607. pr_info("status=%x\n", fd_inb(FD_STATUS));
  1608. pr_info("fdc_busy=%lu\n", fdc_busy);
  1609. if (do_floppy)
  1610. pr_info("do_floppy=%pf\n", do_floppy);
  1611. if (work_pending(&floppy_work))
  1612. pr_info("floppy_work.func=%pf\n", floppy_work.func);
  1613. if (timer_pending(&fd_timer))
  1614. pr_info("fd_timer.function=%pf\n", fd_timer.function);
  1615. if (timer_pending(&fd_timeout)) {
  1616. pr_info("timer_function=%pf\n", fd_timeout.function);
  1617. pr_info("expires=%lu\n", fd_timeout.expires - jiffies);
  1618. pr_info("now=%lu\n", jiffies);
  1619. }
  1620. pr_info("cont=%p\n", cont);
  1621. pr_info("current_req=%p\n", current_req);
  1622. pr_info("command_status=%d\n", command_status);
  1623. pr_info("\n");
  1624. }
  1625. static void floppy_shutdown(unsigned long data)
  1626. {
  1627. unsigned long flags;
  1628. if (initialized)
  1629. show_floppy();
  1630. cancel_activity();
  1631. floppy_enable_hlt();
  1632. flags = claim_dma_lock();
  1633. fd_disable_dma();
  1634. release_dma_lock(flags);
  1635. /* avoid dma going to a random drive after shutdown */
  1636. if (initialized)
  1637. DPRINT("floppy timeout called\n");
  1638. FDCS->reset = 1;
  1639. if (cont) {
  1640. cont->done(0);
  1641. cont->redo(); /* this will recall reset when needed */
  1642. } else {
  1643. pr_info("no cont in shutdown!\n");
  1644. process_fd_request();
  1645. }
  1646. is_alive(__func__, "");
  1647. }
  1648. /* start motor, check media-changed condition and write protection */
  1649. static int start_motor(void (*function)(void))
  1650. {
  1651. int mask;
  1652. int data;
  1653. mask = 0xfc;
  1654. data = UNIT(current_drive);
  1655. if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
  1656. if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
  1657. set_debugt();
  1658. /* no read since this drive is running */
  1659. DRS->first_read_date = 0;
  1660. /* note motor start time if motor is not yet running */
  1661. DRS->spinup_date = jiffies;
  1662. data |= (0x10 << UNIT(current_drive));
  1663. }
  1664. } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
  1665. mask &= ~(0x10 << UNIT(current_drive));
  1666. /* starts motor and selects floppy */
  1667. del_timer(motor_off_timer + current_drive);
  1668. set_dor(fdc, mask, data);
  1669. /* wait_for_completion also schedules reset if needed. */
  1670. return fd_wait_for_completion(DRS->select_date + DP->select_delay,
  1671. (timeout_fn)function);
  1672. }
  1673. static void floppy_ready(void)
  1674. {
  1675. if (FDCS->reset) {
  1676. reset_fdc();
  1677. return;
  1678. }
  1679. if (start_motor(floppy_ready))
  1680. return;
  1681. if (fdc_dtr())
  1682. return;
  1683. debug_dcl(DP->flags, "calling disk change from floppy_ready\n");
  1684. if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
  1685. disk_change(current_drive) && !DP->select_delay)
  1686. twaddle(); /* this clears the dcl on certain
  1687. * drive/controller combinations */
  1688. #ifdef fd_chose_dma_mode
  1689. if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
  1690. unsigned long flags = claim_dma_lock();
  1691. fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
  1692. release_dma_lock(flags);
  1693. }
  1694. #endif
  1695. if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
  1696. perpendicular_mode();
  1697. fdc_specify(); /* must be done here because of hut, hlt ... */
  1698. seek_floppy();
  1699. } else {
  1700. if ((raw_cmd->flags & FD_RAW_READ) ||
  1701. (raw_cmd->flags & FD_RAW_WRITE))
  1702. fdc_specify();
  1703. setup_rw_floppy();
  1704. }
  1705. }
  1706. static void floppy_start(void)
  1707. {
  1708. reschedule_timeout(current_reqD, "floppy start");
  1709. scandrives();
  1710. debug_dcl(DP->flags, "setting NEWCHANGE in floppy_start\n");
  1711. set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
  1712. floppy_ready();
  1713. }
  1714. /*
  1715. * ========================================================================
  1716. * here ends the bottom half. Exported routines are:
  1717. * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
  1718. * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
  1719. * Initialization also uses output_byte, result, set_dor, floppy_interrupt
  1720. * and set_dor.
  1721. * ========================================================================
  1722. */
  1723. /*
  1724. * General purpose continuations.
  1725. * ==============================
  1726. */
  1727. static void do_wakeup(void)
  1728. {
  1729. reschedule_timeout(MAXTIMEOUT, "do wakeup");
  1730. cont = NULL;
  1731. command_status += 2;
  1732. wake_up(&command_done);
  1733. }
  1734. static struct cont_t wakeup_cont = {
  1735. .interrupt = empty,
  1736. .redo = do_wakeup,
  1737. .error = empty,
  1738. .done = (done_f)empty
  1739. };
  1740. static struct cont_t intr_cont = {
  1741. .interrupt = empty,
  1742. .redo = process_fd_request,
  1743. .error = empty,
  1744. .done = (done_f)empty
  1745. };
  1746. static int wait_til_done(void (*handler)(void), bool interruptible)
  1747. {
  1748. int ret;
  1749. schedule_bh(handler);
  1750. if (command_status < 2 && NO_SIGNAL) {
  1751. DECLARE_WAITQUEUE(wait, current);
  1752. add_wait_queue(&command_done, &wait);
  1753. for (;;) {
  1754. set_current_state(interruptible ?
  1755. TASK_INTERRUPTIBLE :
  1756. TASK_UNINTERRUPTIBLE);
  1757. if (command_status >= 2 || !NO_SIGNAL)
  1758. break;
  1759. is_alive(__func__, "");
  1760. schedule();
  1761. }
  1762. set_current_state(TASK_RUNNING);
  1763. remove_wait_queue(&command_done, &wait);
  1764. }
  1765. if (command_status < 2) {
  1766. cancel_activity();
  1767. cont = &intr_cont;
  1768. reset_fdc();
  1769. return -EINTR;
  1770. }
  1771. if (FDCS->reset)
  1772. command_status = FD_COMMAND_ERROR;
  1773. if (command_status == FD_COMMAND_OKAY)
  1774. ret = 0;
  1775. else
  1776. ret = -EIO;
  1777. command_status = FD_COMMAND_NONE;
  1778. return ret;
  1779. }
  1780. static void generic_done(int result)
  1781. {
  1782. command_status = result;
  1783. cont = &wakeup_cont;
  1784. }
  1785. static void generic_success(void)
  1786. {
  1787. cont->done(1);
  1788. }
  1789. static void generic_failure(void)
  1790. {
  1791. cont->done(0);
  1792. }
  1793. static void success_and_wakeup(void)
  1794. {
  1795. generic_success();
  1796. cont->redo();
  1797. }
  1798. /*
  1799. * formatting and rw support.
  1800. * ==========================
  1801. */
  1802. static int next_valid_format(void)
  1803. {
  1804. int probed_format;
  1805. probed_format = DRS->probed_format;
  1806. while (1) {
  1807. if (probed_format >= 8 || !DP->autodetect[probed_format]) {
  1808. DRS->probed_format = 0;
  1809. return 1;
  1810. }
  1811. if (floppy_type[DP->autodetect[probed_format]].sect) {
  1812. DRS->probed_format = probed_format;
  1813. return 0;
  1814. }
  1815. probed_format++;
  1816. }
  1817. }
  1818. static void bad_flp_intr(void)
  1819. {
  1820. int err_count;
  1821. if (probing) {
  1822. DRS->probed_format++;
  1823. if (!next_valid_format())
  1824. return;
  1825. }
  1826. err_count = ++(*errors);
  1827. INFBOUND(DRWE->badness, err_count);
  1828. if (err_count > DP->max_errors.abort)
  1829. cont->done(0);
  1830. if (err_count > DP->max_errors.reset)
  1831. FDCS->reset = 1;
  1832. else if (err_count > DP->max_errors.recal)
  1833. DRS->track = NEED_2_RECAL;
  1834. }
  1835. static void set_floppy(int drive)
  1836. {
  1837. int type = ITYPE(UDRS->fd_device);
  1838. if (type)
  1839. _floppy = floppy_type + type;
  1840. else
  1841. _floppy = current_type[drive];
  1842. }
  1843. /*
  1844. * formatting support.
  1845. * ===================
  1846. */
  1847. static void format_interrupt(void)
  1848. {
  1849. switch (interpret_errors()) {
  1850. case 1:
  1851. cont->error();
  1852. case 2:
  1853. break;
  1854. case 0:
  1855. cont->done(1);
  1856. }
  1857. cont->redo();
  1858. }
  1859. #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
  1860. #define FM_MODE(x, y) ((y) & ~(((x)->rate & 0x80) >> 1))
  1861. #define CT(x) ((x) | 0xc0)
  1862. static void setup_format_params(int track)
  1863. {
  1864. int n;
  1865. int il;
  1866. int count;
  1867. int head_shift;
  1868. int track_shift;
  1869. struct fparm {
  1870. unsigned char track, head, sect, size;
  1871. } *here = (struct fparm *)floppy_track_buffer;
  1872. raw_cmd = &default_raw_cmd;
  1873. raw_cmd->track = track;
  1874. raw_cmd->flags = (FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
  1875. FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK);
  1876. raw_cmd->rate = _floppy->rate & 0x43;
  1877. raw_cmd->cmd_count = NR_F;
  1878. COMMAND = FM_MODE(_floppy, FD_FORMAT);
  1879. DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
  1880. F_SIZECODE = FD_SIZECODE(_floppy);
  1881. F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
  1882. F_GAP = _floppy->fmt_gap;
  1883. F_FILL = FD_FILL_BYTE;
  1884. raw_cmd->kernel_data = floppy_track_buffer;
  1885. raw_cmd->length = 4 * F_SECT_PER_TRACK;
  1886. /* allow for about 30ms for data transport per track */
  1887. head_shift = (F_SECT_PER_TRACK + 5) / 6;
  1888. /* a ``cylinder'' is two tracks plus a little stepping time */
  1889. track_shift = 2 * head_shift + 3;
  1890. /* position of logical sector 1 on this track */
  1891. n = (track_shift * format_req.track + head_shift * format_req.head)
  1892. % F_SECT_PER_TRACK;
  1893. /* determine interleave */
  1894. il = 1;
  1895. if (_floppy->fmt_gap < 0x22)
  1896. il++;
  1897. /* initialize field */
  1898. for (count = 0; count < F_SECT_PER_TRACK; ++count) {
  1899. here[count].track = format_req.track;
  1900. here[count].head = format_req.head;
  1901. here[count].sect = 0;
  1902. here[count].size = F_SIZECODE;
  1903. }
  1904. /* place logical sectors */
  1905. for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
  1906. here[n].sect = count;
  1907. n = (n + il) % F_SECT_PER_TRACK;
  1908. if (here[n].sect) { /* sector busy, find next free sector */
  1909. ++n;
  1910. if (n >= F_SECT_PER_TRACK) {
  1911. n -= F_SECT_PER_TRACK;
  1912. while (here[n].sect)
  1913. ++n;
  1914. }
  1915. }
  1916. }
  1917. if (_floppy->stretch & FD_SECTBASEMASK) {
  1918. for (count = 0; count < F_SECT_PER_TRACK; count++)
  1919. here[count].sect += FD_SECTBASE(_floppy) - 1;
  1920. }
  1921. }
  1922. static void redo_format(void)
  1923. {
  1924. buffer_track = -1;
  1925. setup_format_params(format_req.track << STRETCH(_floppy));
  1926. floppy_start();
  1927. debugt("queue format request");
  1928. }
  1929. static struct cont_t format_cont = {
  1930. .interrupt = format_interrupt,
  1931. .redo = redo_format,
  1932. .error = bad_flp_intr,
  1933. .done = generic_done
  1934. };
  1935. static int do_format(int drive, struct format_descr *tmp_format_req)
  1936. {
  1937. int ret;
  1938. if (lock_fdc(drive, true))
  1939. return -EINTR;
  1940. set_floppy(drive);
  1941. if (!_floppy ||
  1942. _floppy->track > DP->tracks ||
  1943. tmp_format_req->track >= _floppy->track ||
  1944. tmp_format_req->head >= _floppy->head ||
  1945. (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
  1946. !_floppy->fmt_gap) {
  1947. process_fd_request();
  1948. return -EINVAL;
  1949. }
  1950. format_req = *tmp_format_req;
  1951. format_errors = 0;
  1952. cont = &format_cont;
  1953. errors = &format_errors;
  1954. ret = wait_til_done(redo_format, true);
  1955. if (ret == -EINTR)
  1956. return -EINTR;
  1957. process_fd_request();
  1958. return ret;
  1959. }
  1960. /*
  1961. * Buffer read/write and support
  1962. * =============================
  1963. */
  1964. static void floppy_end_request(struct request *req, int error)
  1965. {
  1966. unsigned int nr_sectors = current_count_sectors;
  1967. unsigned int drive = (unsigned long)req->rq_disk->private_data;
  1968. /* current_count_sectors can be zero if transfer failed */
  1969. if (error)
  1970. nr_sectors = blk_rq_cur_sectors(req);
  1971. if (__blk_end_request(req, error, nr_sectors << 9))
  1972. return;
  1973. /* We're done with the request */
  1974. floppy_off(drive);
  1975. current_req = NULL;
  1976. }
  1977. /* new request_done. Can handle physical sectors which are smaller than a
  1978. * logical buffer */
  1979. static void request_done(int uptodate)
  1980. {
  1981. struct request_queue *q = floppy_queue;
  1982. struct request *req = current_req;
  1983. unsigned long flags;
  1984. int block;
  1985. char msg[sizeof("request done ") + sizeof(int) * 3];
  1986. probing = 0;
  1987. snprintf(msg, sizeof(msg), "request done %d", uptodate);
  1988. reschedule_timeout(MAXTIMEOUT, msg);
  1989. if (!req) {
  1990. pr_info("floppy.c: no request in request_done\n");
  1991. return;
  1992. }
  1993. if (uptodate) {
  1994. /* maintain values for invalidation on geometry
  1995. * change */
  1996. block = current_count_sectors + blk_rq_pos(req);
  1997. INFBOUND(DRS->maxblock, block);
  1998. if (block > _floppy->sect)
  1999. DRS->maxtrack = 1;
  2000. /* unlock chained buffers */
  2001. spin_lock_irqsave(q->queue_lock, flags);
  2002. floppy_end_request(req, 0);
  2003. spin_unlock_irqrestore(q->queue_lock, flags);
  2004. } else {
  2005. if (rq_data_dir(req) == WRITE) {
  2006. /* record write error information */
  2007. DRWE->write_errors++;
  2008. if (DRWE->write_errors == 1) {
  2009. DRWE->first_error_sector = blk_rq_pos(req);
  2010. DRWE->first_error_generation = DRS->generation;
  2011. }
  2012. DRWE->last_error_sector = blk_rq_pos(req);
  2013. DRWE->last_error_generation = DRS->generation;
  2014. }
  2015. spin_lock_irqsave(q->queue_lock, flags);
  2016. floppy_end_request(req, -EIO);
  2017. spin_unlock_irqrestore(q->queue_lock, flags);
  2018. }
  2019. }
  2020. /* Interrupt handler evaluating the result of the r/w operation */
  2021. static void rw_interrupt(void)
  2022. {
  2023. int eoc;
  2024. int ssize;
  2025. int heads;
  2026. int nr_sectors;
  2027. if (R_HEAD >= 2) {
  2028. /* some Toshiba floppy controllers occasionnally seem to
  2029. * return bogus interrupts after read/write operations, which
  2030. * can be recognized by a bad head number (>= 2) */
  2031. return;
  2032. }
  2033. if (!DRS->first_read_date)
  2034. DRS->first_read_date = jiffies;
  2035. nr_sectors = 0;
  2036. CODE2SIZE;
  2037. if (ST1 & ST1_EOC)
  2038. eoc = 1;
  2039. else
  2040. eoc = 0;
  2041. if (COMMAND & 0x80)
  2042. heads = 2;
  2043. else
  2044. heads = 1;
  2045. nr_sectors = (((R_TRACK - TRACK) * heads +
  2046. R_HEAD - HEAD) * SECT_PER_TRACK +
  2047. R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
  2048. if (nr_sectors / ssize >
  2049. DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {
  2050. DPRINT("long rw: %x instead of %lx\n",
  2051. nr_sectors, current_count_sectors);
  2052. pr_info("rs=%d s=%d\n", R_SECTOR, SECTOR);
  2053. pr_info("rh=%d h=%d\n", R_HEAD, HEAD);
  2054. pr_info("rt=%d t=%d\n", R_TRACK, TRACK);
  2055. pr_info("heads=%d eoc=%d\n", heads, eoc);
  2056. pr_info("spt=%d st=%d ss=%d\n",
  2057. SECT_PER_TRACK, fsector_t, ssize);
  2058. pr_info("in_sector_offset=%d\n", in_sector_offset);
  2059. }
  2060. nr_sectors -= in_sector_offset;
  2061. INFBOUND(nr_sectors, 0);
  2062. SUPBOUND(current_count_sectors, nr_sectors);
  2063. switch (interpret_errors()) {
  2064. case 2:
  2065. cont->redo();
  2066. return;
  2067. case 1:
  2068. if (!current_count_sectors) {
  2069. cont->error();
  2070. cont->redo();
  2071. return;
  2072. }
  2073. break;
  2074. case 0:
  2075. if (!current_count_sectors) {
  2076. cont->redo();
  2077. return;
  2078. }
  2079. current_type[current_drive] = _floppy;
  2080. floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
  2081. break;
  2082. }
  2083. if (probing) {
  2084. if (DP->flags & FTD_MSG)
  2085. DPRINT("Auto-detected floppy type %s in fd%d\n",
  2086. _floppy->name, current_drive);
  2087. current_type[current_drive] = _floppy;
  2088. floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
  2089. probing = 0;
  2090. }
  2091. if (CT(COMMAND) != FD_READ ||
  2092. raw_cmd->kernel_data == current_req->buffer) {
  2093. /* transfer directly from buffer */
  2094. cont->done(1);
  2095. } else if (CT(COMMAND) == FD_READ) {
  2096. buffer_track = raw_cmd->track;
  2097. buffer_drive = current_drive;
  2098. INFBOUND(buffer_max, nr_sectors + fsector_t);
  2099. }
  2100. cont->redo();
  2101. }
  2102. /* Compute maximal contiguous buffer size. */
  2103. static int buffer_chain_size(void)
  2104. {
  2105. struct bio_vec *bv;
  2106. int size;
  2107. struct req_iterator iter;
  2108. char *base;
  2109. base = bio_data(current_req->bio);
  2110. size = 0;
  2111. rq_for_each_segment(bv, current_req, iter) {
  2112. if (page_address(bv->bv_page) + bv->bv_offset != base + size)
  2113. break;
  2114. size += bv->bv_len;
  2115. }
  2116. return size >> 9;
  2117. }
  2118. /* Compute the maximal transfer size */
  2119. static int transfer_size(int ssize, int max_sector, int max_size)
  2120. {
  2121. SUPBOUND(max_sector, fsector_t + max_size);
  2122. /* alignment */
  2123. max_sector -= (max_sector % _floppy->sect) % ssize;
  2124. /* transfer size, beginning not aligned */
  2125. current_count_sectors = max_sector - fsector_t;
  2126. return max_sector;
  2127. }
  2128. /*
  2129. * Move data from/to the track buffer to/from the buffer cache.
  2130. */
  2131. static void copy_buffer(int ssize, int max_sector, int max_sector_2)
  2132. {
  2133. int remaining; /* number of transferred 512-byte sectors */
  2134. struct bio_vec *bv;
  2135. char *buffer;
  2136. char *dma_buffer;
  2137. int size;
  2138. struct req_iterator iter;
  2139. max_sector = transfer_size(ssize,
  2140. min(max_sector, max_sector_2),
  2141. blk_rq_sectors(current_req));
  2142. if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
  2143. buffer_max > fsector_t + blk_rq_sectors(current_req))
  2144. current_count_sectors = min_t(int, buffer_max - fsector_t,
  2145. blk_rq_sectors(current_req));
  2146. remaining = current_count_sectors << 9;
  2147. if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {
  2148. DPRINT("in copy buffer\n");
  2149. pr_info("current_count_sectors=%ld\n", current_count_sectors);
  2150. pr_info("remaining=%d\n", remaining >> 9);
  2151. pr_info("current_req->nr_sectors=%u\n",
  2152. blk_rq_sectors(current_req));
  2153. pr_info("current_req->current_nr_sectors=%u\n",
  2154. blk_rq_cur_sectors(current_req));
  2155. pr_info("max_sector=%d\n", max_sector);
  2156. pr_info("ssize=%d\n", ssize);
  2157. }
  2158. buffer_max = max(max_sector, buffer_max);
  2159. dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
  2160. size = blk_rq_cur_bytes(current_req);
  2161. rq_for_each_segment(bv, current_req, iter) {
  2162. if (!remaining)
  2163. break;
  2164. size = bv->bv_len;
  2165. SUPBOUND(size, remaining);
  2166. buffer = page_address(bv->bv_page) + bv->bv_offset;
  2167. if (dma_buffer + size >
  2168. floppy_track_buffer + (max_buffer_sectors << 10) ||
  2169. dma_buffer < floppy_track_buffer) {
  2170. DPRINT("buffer overrun in copy buffer %d\n",
  2171. (int)((floppy_track_buffer - dma_buffer) >> 9));
  2172. pr_info("fsector_t=%d buffer_min=%d\n",
  2173. fsector_t, buffer_min);
  2174. pr_info("current_count_sectors=%ld\n",
  2175. current_count_sectors);
  2176. if (CT(COMMAND) == FD_READ)
  2177. pr_info("read\n");
  2178. if (CT(COMMAND) == FD_WRITE)
  2179. pr_info("write\n");
  2180. break;
  2181. }
  2182. if (((unsigned long)buffer) % 512)
  2183. DPRINT("%p buffer not aligned\n", buffer);
  2184. if (CT(COMMAND) == FD_READ)
  2185. memcpy(buffer, dma_buffer, size);
  2186. else
  2187. memcpy(dma_buffer, buffer, size);
  2188. remaining -= size;
  2189. dma_buffer += size;
  2190. }
  2191. if (remaining) {
  2192. if (remaining > 0)
  2193. max_sector -= remaining >> 9;
  2194. DPRINT("weirdness: remaining %d\n", remaining >> 9);
  2195. }
  2196. }
  2197. /* work around a bug in pseudo DMA
  2198. * (on some FDCs) pseudo DMA does not stop when the CPU stops
  2199. * sending data. Hence we need a different way to signal the
  2200. * transfer length: We use SECT_PER_TRACK. Unfortunately, this
  2201. * does not work with MT, hence we can only transfer one head at
  2202. * a time
  2203. */
  2204. static void virtualdmabug_workaround(void)
  2205. {
  2206. int hard_sectors;
  2207. int end_sector;
  2208. if (CT(COMMAND) == FD_WRITE) {
  2209. COMMAND &= ~0x80; /* switch off multiple track mode */
  2210. hard_sectors = raw_cmd->length >> (7 + SIZECODE);
  2211. end_sector = SECTOR + hard_sectors - 1;
  2212. if (end_sector > SECT_PER_TRACK) {
  2213. pr_info("too many sectors %d > %d\n",
  2214. end_sector, SECT_PER_TRACK);
  2215. return;
  2216. }
  2217. SECT_PER_TRACK = end_sector;
  2218. /* make sure SECT_PER_TRACK
  2219. * points to end of transfer */
  2220. }
  2221. }
  2222. /*
  2223. * Formulate a read/write request.
  2224. * this routine decides where to load the data (directly to buffer, or to
  2225. * tmp floppy area), how much data to load (the size of the buffer, the whole
  2226. * track, or a single sector)
  2227. * All floppy_track_buffer handling goes in here. If we ever add track buffer
  2228. * allocation on the fly, it should be done here. No other part should need
  2229. * modification.
  2230. */
  2231. static int make_raw_rw_request(void)
  2232. {
  2233. int aligned_sector_t;
  2234. int max_sector;
  2235. int max_size;
  2236. int tracksize;
  2237. int ssize;
  2238. if (max_buffer_sectors == 0) {
  2239. pr_info("VFS: Block I/O scheduled on unopened device\n");
  2240. return 0;
  2241. }
  2242. set_fdc((long)current_req->rq_disk->private_data);
  2243. raw_cmd = &default_raw_cmd;
  2244. raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
  2245. FD_RAW_NEED_SEEK;
  2246. raw_cmd->cmd_count = NR_RW;
  2247. if (rq_data_dir(current_req) == READ) {
  2248. raw_cmd->flags |= FD_RAW_READ;
  2249. COMMAND = FM_MODE(_floppy, FD_READ);
  2250. } else if (rq_data_dir(current_req) == WRITE) {
  2251. raw_cmd->flags |= FD_RAW_WRITE;
  2252. COMMAND = FM_MODE(_floppy, FD_WRITE);
  2253. } else {
  2254. DPRINT("%s: unknown command\n", __func__);
  2255. return 0;
  2256. }
  2257. max_sector = _floppy->sect * _floppy->head;
  2258. TRACK = (int)blk_rq_pos(current_req) / max_sector;
  2259. fsector_t = (int)blk_rq_pos(current_req) % max_sector;
  2260. if (_floppy->track && TRACK >= _floppy->track) {
  2261. if (blk_rq_cur_sectors(current_req) & 1) {
  2262. current_count_sectors = 1;
  2263. return 1;
  2264. } else
  2265. return 0;
  2266. }
  2267. HEAD = fsector_t / _floppy->sect;
  2268. if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) ||
  2269. test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags)) &&
  2270. fsector_t < _floppy->sect)
  2271. max_sector = _floppy->sect;
  2272. /* 2M disks have phantom sectors on the first track */
  2273. if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
  2274. max_sector = 2 * _floppy->sect / 3;
  2275. if (fsector_t >= max_sector) {
  2276. current_count_sectors =
  2277. min_t(int, _floppy->sect - fsector_t,
  2278. blk_rq_sectors(current_req));
  2279. return 1;
  2280. }
  2281. SIZECODE = 2;
  2282. } else
  2283. SIZECODE = FD_SIZECODE(_floppy);
  2284. raw_cmd->rate = _floppy->rate & 0x43;
  2285. if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
  2286. raw_cmd->rate = 1;
  2287. if (SIZECODE)
  2288. SIZECODE2 = 0xff;
  2289. else
  2290. SIZECODE2 = 0x80;
  2291. raw_cmd->track = TRACK << STRETCH(_floppy);
  2292. DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
  2293. GAP = _floppy->gap;
  2294. CODE2SIZE;
  2295. SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
  2296. SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
  2297. FD_SECTBASE(_floppy);
  2298. /* tracksize describes the size which can be filled up with sectors
  2299. * of size ssize.
  2300. */
  2301. tracksize = _floppy->sect - _floppy->sect % ssize;
  2302. if (tracksize < _floppy->sect) {
  2303. SECT_PER_TRACK++;
  2304. if (tracksize <= fsector_t % _floppy->sect)
  2305. SECTOR--;
  2306. /* if we are beyond tracksize, fill up using smaller sectors */
  2307. while (tracksize <= fsector_t % _floppy->sect) {
  2308. while (tracksize + ssize > _floppy->sect) {
  2309. SIZECODE--;
  2310. ssize >>= 1;
  2311. }
  2312. SECTOR++;
  2313. SECT_PER_TRACK++;
  2314. tracksize += ssize;
  2315. }
  2316. max_sector = HEAD * _floppy->sect + tracksize;
  2317. } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
  2318. max_sector = _floppy->sect;
  2319. } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
  2320. /* for virtual DMA bug workaround */
  2321. max_sector = _floppy->sect;
  2322. }
  2323. in_sector_offset = (fsector_t % _floppy->sect) % ssize;
  2324. aligned_sector_t = fsector_t - in_sector_offset;
  2325. max_size = blk_rq_sectors(current_req);
  2326. if ((raw_cmd->track == buffer_track) &&
  2327. (current_drive == buffer_drive) &&
  2328. (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
  2329. /* data already in track buffer */
  2330. if (CT(COMMAND) == FD_READ) {
  2331. copy_buffer(1, max_sector, buffer_max);
  2332. return 1;
  2333. }
  2334. } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
  2335. if (CT(COMMAND) == FD_WRITE) {
  2336. unsigned int sectors;
  2337. sectors = fsector_t + blk_rq_sectors(current_req);
  2338. if (sectors > ssize && sectors < ssize + ssize)
  2339. max_size = ssize + ssize;
  2340. else
  2341. max_size = ssize;
  2342. }
  2343. raw_cmd->flags &= ~FD_RAW_WRITE;
  2344. raw_cmd->flags |= FD_RAW_READ;
  2345. COMMAND = FM_MODE(_floppy, FD_READ);
  2346. } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
  2347. unsigned long dma_limit;
  2348. int direct, indirect;
  2349. indirect =
  2350. transfer_size(ssize, max_sector,
  2351. max_buffer_sectors * 2) - fsector_t;
  2352. /*
  2353. * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
  2354. * on a 64 bit machine!
  2355. */
  2356. max_size = buffer_chain_size();
  2357. dma_limit = (MAX_DMA_ADDRESS -
  2358. ((unsigned long)current_req->buffer)) >> 9;
  2359. if ((unsigned long)max_size > dma_limit)
  2360. max_size = dma_limit;
  2361. /* 64 kb boundaries */
  2362. if (CROSS_64KB(current_req->buffer, max_size << 9))
  2363. max_size = (K_64 -
  2364. ((unsigned long)current_req->buffer) %
  2365. K_64) >> 9;
  2366. direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
  2367. /*
  2368. * We try to read tracks, but if we get too many errors, we
  2369. * go back to reading just one sector at a time.
  2370. *
  2371. * This means we should be able to read a sector even if there
  2372. * are other bad sectors on this track.
  2373. */
  2374. if (!direct ||
  2375. (indirect * 2 > direct * 3 &&
  2376. *errors < DP->max_errors.read_track &&
  2377. ((!probing ||
  2378. (DP->read_track & (1 << DRS->probed_format)))))) {
  2379. max_size = blk_rq_sectors(current_req);
  2380. } else {
  2381. raw_cmd->kernel_data = current_req->buffer;
  2382. raw_cmd->length = current_count_sectors << 9;
  2383. if (raw_cmd->length == 0) {
  2384. DPRINT("%s: zero dma transfer attempted\n", __func__);
  2385. DPRINT("indirect=%d direct=%d fsector_t=%d\n",
  2386. indirect, direct, fsector_t);
  2387. return 0;
  2388. }
  2389. virtualdmabug_workaround();
  2390. return 2;
  2391. }
  2392. }
  2393. if (CT(COMMAND) == FD_READ)
  2394. max_size = max_sector; /* unbounded */
  2395. /* claim buffer track if needed */
  2396. if (buffer_track != raw_cmd->track || /* bad track */
  2397. buffer_drive != current_drive || /* bad drive */
  2398. fsector_t > buffer_max ||
  2399. fsector_t < buffer_min ||
  2400. ((CT(COMMAND) == FD_READ ||
  2401. (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
  2402. max_sector > 2 * max_buffer_sectors + buffer_min &&
  2403. max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)) {
  2404. /* not enough space */
  2405. buffer_track = -1;
  2406. buffer_drive = current_drive;
  2407. buffer_max = buffer_min = aligned_sector_t;
  2408. }
  2409. raw_cmd->kernel_data = floppy_track_buffer +
  2410. ((aligned_sector_t - buffer_min) << 9);
  2411. if (CT(COMMAND) == FD_WRITE) {
  2412. /* copy write buffer to track buffer.
  2413. * if we get here, we know that the write
  2414. * is either aligned or the data already in the buffer
  2415. * (buffer will be overwritten) */
  2416. if (in_sector_offset && buffer_track == -1)
  2417. DPRINT("internal error offset !=0 on write\n");
  2418. buffer_track = raw_cmd->track;
  2419. buffer_drive = current_drive;
  2420. copy_buffer(ssize, max_sector,
  2421. 2 * max_buffer_sectors + buffer_min);
  2422. } else
  2423. transfer_size(ssize, max_sector,
  2424. 2 * max_buffer_sectors + buffer_min -
  2425. aligned_sector_t);
  2426. /* round up current_count_sectors to get dma xfer size */
  2427. raw_cmd->length = in_sector_offset + current_count_sectors;
  2428. raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
  2429. raw_cmd->length <<= 9;
  2430. if ((raw_cmd->length < current_count_sectors << 9) ||
  2431. (raw_cmd->kernel_data != current_req->buffer &&
  2432. CT(COMMAND) == FD_WRITE &&
  2433. (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
  2434. aligned_sector_t < buffer_min)) ||
  2435. raw_cmd->length % (128 << SIZECODE) ||
  2436. raw_cmd->length <= 0 || current_count_sectors <= 0) {
  2437. DPRINT("fractionary current count b=%lx s=%lx\n",
  2438. raw_cmd->length, current_count_sectors);
  2439. if (raw_cmd->kernel_data != current_req->buffer)
  2440. pr_info("addr=%d, length=%ld\n",
  2441. (int)((raw_cmd->kernel_data -
  2442. floppy_track_buffer) >> 9),
  2443. current_count_sectors);
  2444. pr_info("st=%d ast=%d mse=%d msi=%d\n",
  2445. fsector_t, aligned_sector_t, max_sector, max_size);
  2446. pr_info("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
  2447. pr_info("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
  2448. COMMAND, SECTOR, HEAD, TRACK);
  2449. pr_info("buffer drive=%d\n", buffer_drive);
  2450. pr_info("buffer track=%d\n", buffer_track);
  2451. pr_info("buffer_min=%d\n", buffer_min);
  2452. pr_info("buffer_max=%d\n", buffer_max);
  2453. return 0;
  2454. }
  2455. if (raw_cmd->kernel_data != current_req->buffer) {
  2456. if (raw_cmd->kernel_data < floppy_track_buffer ||
  2457. current_count_sectors < 0 ||
  2458. raw_cmd->length < 0 ||
  2459. raw_cmd->kernel_data + raw_cmd->length >
  2460. floppy_track_buffer + (max_buffer_sectors << 10)) {
  2461. DPRINT("buffer overrun in schedule dma\n");
  2462. pr_info("fsector_t=%d buffer_min=%d current_count=%ld\n",
  2463. fsector_t, buffer_min, raw_cmd->length >> 9);
  2464. pr_info("current_count_sectors=%ld\n",
  2465. current_count_sectors);
  2466. if (CT(COMMAND) == FD_READ)
  2467. pr_info("read\n");
  2468. if (CT(COMMAND) == FD_WRITE)
  2469. pr_info("write\n");
  2470. return 0;
  2471. }
  2472. } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
  2473. current_count_sectors > blk_rq_sectors(current_req)) {
  2474. DPRINT("buffer overrun in direct transfer\n");
  2475. return 0;
  2476. } else if (raw_cmd->length < current_count_sectors << 9) {
  2477. DPRINT("more sectors than bytes\n");
  2478. pr_info("bytes=%ld\n", raw_cmd->length >> 9);
  2479. pr_info("sectors=%ld\n", current_count_sectors);
  2480. }
  2481. if (raw_cmd->length == 0) {
  2482. DPRINT("zero dma transfer attempted from make_raw_request\n");
  2483. return 0;
  2484. }
  2485. virtualdmabug_workaround();
  2486. return 2;
  2487. }
  2488. static void redo_fd_request(void)
  2489. {
  2490. int drive;
  2491. int tmp;
  2492. lastredo = jiffies;
  2493. if (current_drive < N_DRIVE)
  2494. floppy_off(current_drive);
  2495. do_request:
  2496. if (!current_req) {
  2497. struct request *req;
  2498. spin_lock_irq(floppy_queue->queue_lock);
  2499. req = blk_fetch_request(floppy_queue);
  2500. spin_unlock_irq(floppy_queue->queue_lock);
  2501. if (!req) {
  2502. do_floppy = NULL;
  2503. unlock_fdc();
  2504. return;
  2505. }
  2506. current_req = req;
  2507. }
  2508. drive = (long)current_req->rq_disk->private_data;
  2509. set_fdc(drive);
  2510. reschedule_timeout(current_reqD, "redo fd request");
  2511. set_floppy(drive);
  2512. raw_cmd = &default_raw_cmd;
  2513. raw_cmd->flags = 0;
  2514. if (start_motor(redo_fd_request))
  2515. return;
  2516. disk_change(current_drive);
  2517. if (test_bit(current_drive, &fake_change) ||
  2518. test_bit(FD_DISK_CHANGED_BIT, &DRS->flags)) {
  2519. DPRINT("disk absent or changed during operation\n");
  2520. request_done(0);
  2521. goto do_request;
  2522. }
  2523. if (!_floppy) { /* Autodetection */
  2524. if (!probing) {
  2525. DRS->probed_format = 0;
  2526. if (next_valid_format()) {
  2527. DPRINT("no autodetectable formats\n");
  2528. _floppy = NULL;
  2529. request_done(0);
  2530. goto do_request;
  2531. }
  2532. }
  2533. probing = 1;
  2534. _floppy = floppy_type + DP->autodetect[DRS->probed_format];
  2535. } else
  2536. probing = 0;
  2537. errors = &(current_req->errors);
  2538. tmp = make_raw_rw_request();
  2539. if (tmp < 2) {
  2540. request_done(tmp);
  2541. goto do_request;
  2542. }
  2543. if (test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags))
  2544. twaddle();
  2545. schedule_bh(floppy_start);
  2546. debugt("queue fd request");
  2547. return;
  2548. }
  2549. static struct cont_t rw_cont = {
  2550. .interrupt = rw_interrupt,
  2551. .redo = redo_fd_request,
  2552. .error = bad_flp_intr,
  2553. .done = request_done
  2554. };
  2555. static void process_fd_request(void)
  2556. {
  2557. cont = &rw_cont;
  2558. schedule_bh(redo_fd_request);
  2559. }
  2560. static void do_fd_request(struct request_queue *q)
  2561. {
  2562. if (max_buffer_sectors == 0) {
  2563. pr_info("VFS: %s called on non-open device\n", __func__);
  2564. return;
  2565. }
  2566. if (usage_count == 0) {
  2567. pr_info("warning: usage count=0, current_req=%p exiting\n",
  2568. current_req);
  2569. pr_info("sect=%ld type=%x flags=%x\n",
  2570. (long)blk_rq_pos(current_req), current_req->cmd_type,
  2571. current_req->cmd_flags);
  2572. return;
  2573. }
  2574. if (test_bit(0, &fdc_busy)) {
  2575. /* fdc busy, this new request will be treated when the
  2576. current one is done */
  2577. is_alive(__func__, "old request running");
  2578. return;
  2579. }
  2580. lock_fdc(MAXTIMEOUT, false);
  2581. process_fd_request();
  2582. is_alive(__func__, "");
  2583. }
  2584. static struct cont_t poll_cont = {
  2585. .interrupt = success_and_wakeup,
  2586. .redo = floppy_ready,
  2587. .error = generic_failure,
  2588. .done = generic_done
  2589. };
  2590. static int poll_drive(bool interruptible, int flag)
  2591. {
  2592. /* no auto-sense, just clear dcl */
  2593. raw_cmd = &default_raw_cmd;
  2594. raw_cmd->flags = flag;
  2595. raw_cmd->track = 0;
  2596. raw_cmd->cmd_count = 0;
  2597. cont = &poll_cont;
  2598. debug_dcl(DP->flags, "setting NEWCHANGE in poll_drive\n");
  2599. set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
  2600. return wait_til_done(floppy_ready, interruptible);
  2601. }
  2602. /*
  2603. * User triggered reset
  2604. * ====================
  2605. */
  2606. static void reset_intr(void)
  2607. {
  2608. pr_info("weird, reset interrupt called\n");
  2609. }
  2610. static struct cont_t reset_cont = {
  2611. .interrupt = reset_intr,
  2612. .redo = success_and_wakeup,
  2613. .error = generic_failure,
  2614. .done = generic_done
  2615. };
  2616. static int user_reset_fdc(int drive, int arg, bool interruptible)
  2617. {
  2618. int ret;
  2619. if (lock_fdc(drive, interruptible))
  2620. return -EINTR;
  2621. if (arg == FD_RESET_ALWAYS)
  2622. FDCS->reset = 1;
  2623. if (FDCS->reset) {
  2624. cont = &reset_cont;
  2625. ret = wait_til_done(reset_fdc, interruptible);
  2626. if (ret == -EINTR)
  2627. return -EINTR;
  2628. }
  2629. process_fd_request();
  2630. return 0;
  2631. }
  2632. /*
  2633. * Misc Ioctl's and support
  2634. * ========================
  2635. */
  2636. static inline int fd_copyout(void __user *param, const void *address,
  2637. unsigned long size)
  2638. {
  2639. return copy_to_user(param, address, size) ? -EFAULT : 0;
  2640. }
  2641. static inline int fd_copyin(void __user *param, void *address,
  2642. unsigned long size)
  2643. {
  2644. return copy_from_user(address, param, size) ? -EFAULT : 0;
  2645. }
  2646. static inline const char *drive_name(int type, int drive)
  2647. {
  2648. struct floppy_struct *floppy;
  2649. if (type)
  2650. floppy = floppy_type + type;
  2651. else {
  2652. if (UDP->native_format)
  2653. floppy = floppy_type + UDP->native_format;
  2654. else
  2655. return "(null)";
  2656. }
  2657. if (floppy->name)
  2658. return floppy->name;
  2659. else
  2660. return "(null)";
  2661. }
  2662. /* raw commands */
  2663. static void raw_cmd_done(int flag)
  2664. {
  2665. int i;
  2666. if (!flag) {
  2667. raw_cmd->flags |= FD_RAW_FAILURE;
  2668. raw_cmd->flags |= FD_RAW_HARDFAILURE;
  2669. } else {
  2670. raw_cmd->reply_count = inr;
  2671. if (raw_cmd->reply_count > MAX_REPLIES)
  2672. raw_cmd->reply_count = 0;
  2673. for (i = 0; i < raw_cmd->reply_count; i++)
  2674. raw_cmd->reply[i] = reply_buffer[i];
  2675. if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
  2676. unsigned long flags;
  2677. flags = claim_dma_lock();
  2678. raw_cmd->length = fd_get_dma_residue();
  2679. release_dma_lock(flags);
  2680. }
  2681. if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
  2682. (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
  2683. raw_cmd->flags |= FD_RAW_FAILURE;
  2684. if (disk_change(current_drive))
  2685. raw_cmd->flags |= FD_RAW_DISK_CHANGE;
  2686. else
  2687. raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
  2688. if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
  2689. motor_off_callback(current_drive);
  2690. if (raw_cmd->next &&
  2691. (!(raw_cmd->flags & FD_RAW_FAILURE) ||
  2692. !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
  2693. ((raw_cmd->flags & FD_RAW_FAILURE) ||
  2694. !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
  2695. raw_cmd = raw_cmd->next;
  2696. return;
  2697. }
  2698. }
  2699. generic_done(flag);
  2700. }
  2701. static struct cont_t raw_cmd_cont = {
  2702. .interrupt = success_and_wakeup,
  2703. .redo = floppy_start,
  2704. .error = generic_failure,
  2705. .done = raw_cmd_done
  2706. };
  2707. static inline int raw_cmd_copyout(int cmd, void __user *param,
  2708. struct floppy_raw_cmd *ptr)
  2709. {
  2710. int ret;
  2711. while (ptr) {
  2712. ret = copy_to_user(param, ptr, sizeof(*ptr));
  2713. if (ret)
  2714. return -EFAULT;
  2715. param += sizeof(struct floppy_raw_cmd);
  2716. if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
  2717. if (ptr->length >= 0 &&
  2718. ptr->length <= ptr->buffer_length) {
  2719. long length = ptr->buffer_length - ptr->length;
  2720. ret = fd_copyout(ptr->data, ptr->kernel_data,
  2721. length);
  2722. if (ret)
  2723. return ret;
  2724. }
  2725. }
  2726. ptr = ptr->next;
  2727. }
  2728. return 0;
  2729. }
  2730. static void raw_cmd_free(struct floppy_raw_cmd **ptr)
  2731. {
  2732. struct floppy_raw_cmd *next;
  2733. struct floppy_raw_cmd *this;
  2734. this = *ptr;
  2735. *ptr = NULL;
  2736. while (this) {
  2737. if (this->buffer_length) {
  2738. fd_dma_mem_free((unsigned long)this->kernel_data,
  2739. this->buffer_length);
  2740. this->buffer_length = 0;
  2741. }
  2742. next = this->next;
  2743. kfree(this);
  2744. this = next;
  2745. }
  2746. }
  2747. static inline int raw_cmd_copyin(int cmd, void __user *param,
  2748. struct floppy_raw_cmd **rcmd)
  2749. {
  2750. struct floppy_raw_cmd *ptr;
  2751. int ret;
  2752. int i;
  2753. *rcmd = NULL;
  2754. loop:
  2755. ptr = kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
  2756. if (!ptr)
  2757. return -ENOMEM;
  2758. *rcmd = ptr;
  2759. ret = copy_from_user(ptr, param, sizeof(*ptr));
  2760. if (ret)
  2761. return -EFAULT;
  2762. ptr->next = NULL;
  2763. ptr->buffer_length = 0;
  2764. param += sizeof(struct floppy_raw_cmd);
  2765. if (ptr->cmd_count > 33)
  2766. /* the command may now also take up the space
  2767. * initially intended for the reply & the
  2768. * reply count. Needed for long 82078 commands
  2769. * such as RESTORE, which takes ... 17 command
  2770. * bytes. Murphy's law #137: When you reserve
  2771. * 16 bytes for a structure, you'll one day
  2772. * discover that you really need 17...
  2773. */
  2774. return -EINVAL;
  2775. for (i = 0; i < 16; i++)
  2776. ptr->reply[i] = 0;
  2777. ptr->resultcode = 0;
  2778. ptr->kernel_data = NULL;
  2779. if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
  2780. if (ptr->length <= 0)
  2781. return -EINVAL;
  2782. ptr->kernel_data = (char *)fd_dma_mem_alloc(ptr->length);
  2783. fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
  2784. if (!ptr->kernel_data)
  2785. return -ENOMEM;
  2786. ptr->buffer_length = ptr->length;
  2787. }
  2788. if (ptr->flags & FD_RAW_WRITE) {
  2789. ret = fd_copyin(ptr->data, ptr->kernel_data, ptr->length);
  2790. if (ret)
  2791. return ret;
  2792. }
  2793. if (ptr->flags & FD_RAW_MORE) {
  2794. rcmd = &(ptr->next);
  2795. ptr->rate &= 0x43;
  2796. goto loop;
  2797. }
  2798. return 0;
  2799. }
  2800. static int raw_cmd_ioctl(int cmd, void __user *param)
  2801. {
  2802. struct floppy_raw_cmd *my_raw_cmd;
  2803. int drive;
  2804. int ret2;
  2805. int ret;
  2806. if (FDCS->rawcmd <= 1)
  2807. FDCS->rawcmd = 1;
  2808. for (drive = 0; drive < N_DRIVE; drive++) {
  2809. if (FDC(drive) != fdc)
  2810. continue;
  2811. if (drive == current_drive) {
  2812. if (UDRS->fd_ref > 1) {
  2813. FDCS->rawcmd = 2;
  2814. break;
  2815. }
  2816. } else if (UDRS->fd_ref) {
  2817. FDCS->rawcmd = 2;
  2818. break;
  2819. }
  2820. }
  2821. if (FDCS->reset)
  2822. return -EIO;
  2823. ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
  2824. if (ret) {
  2825. raw_cmd_free(&my_raw_cmd);
  2826. return ret;
  2827. }
  2828. raw_cmd = my_raw_cmd;
  2829. cont = &raw_cmd_cont;
  2830. ret = wait_til_done(floppy_start, true);
  2831. debug_dcl(DP->flags, "calling disk change from raw_cmd ioctl\n");
  2832. if (ret != -EINTR && FDCS->reset)
  2833. ret = -EIO;
  2834. DRS->track = NO_TRACK;
  2835. ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
  2836. if (!ret)
  2837. ret = ret2;
  2838. raw_cmd_free(&my_raw_cmd);
  2839. return ret;
  2840. }
  2841. static int invalidate_drive(struct block_device *bdev)
  2842. {
  2843. /* invalidate the buffer track to force a reread */
  2844. set_bit((long)bdev->bd_disk->private_data, &fake_change);
  2845. process_fd_request();
  2846. check_disk_change(bdev);
  2847. return 0;
  2848. }
  2849. static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
  2850. int drive, int type, struct block_device *bdev)
  2851. {
  2852. int cnt;
  2853. /* sanity checking for parameters. */
  2854. if (g->sect <= 0 ||
  2855. g->head <= 0 ||
  2856. g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
  2857. /* check if reserved bits are set */
  2858. (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
  2859. return -EINVAL;
  2860. if (type) {
  2861. if (!capable(CAP_SYS_ADMIN))
  2862. return -EPERM;
  2863. mutex_lock(&open_lock);
  2864. if (lock_fdc(drive, true)) {
  2865. mutex_unlock(&open_lock);
  2866. return -EINTR;
  2867. }
  2868. floppy_type[type] = *g;
  2869. floppy_type[type].name = "user format";
  2870. for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
  2871. floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
  2872. floppy_type[type].size + 1;
  2873. process_fd_request();
  2874. for (cnt = 0; cnt < N_DRIVE; cnt++) {
  2875. struct block_device *bdev = opened_bdev[cnt];
  2876. if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
  2877. continue;
  2878. __invalidate_device(bdev);
  2879. }
  2880. mutex_unlock(&open_lock);
  2881. } else {
  2882. int oldStretch;
  2883. if (lock_fdc(drive, true))
  2884. return -EINTR;
  2885. if (cmd != FDDEFPRM) {
  2886. /* notice a disk change immediately, else
  2887. * we lose our settings immediately*/
  2888. if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
  2889. return -EINTR;
  2890. }
  2891. oldStretch = g->stretch;
  2892. user_params[drive] = *g;
  2893. if (buffer_drive == drive)
  2894. SUPBOUND(buffer_max, user_params[drive].sect);
  2895. current_type[drive] = &user_params[drive];
  2896. floppy_sizes[drive] = user_params[drive].size;
  2897. if (cmd == FDDEFPRM)
  2898. DRS->keep_data = -1;
  2899. else
  2900. DRS->keep_data = 1;
  2901. /* invalidation. Invalidate only when needed, i.e.
  2902. * when there are already sectors in the buffer cache
  2903. * whose number will change. This is useful, because
  2904. * mtools often changes the geometry of the disk after
  2905. * looking at the boot block */
  2906. if (DRS->maxblock > user_params[drive].sect ||
  2907. DRS->maxtrack ||
  2908. ((user_params[drive].sect ^ oldStretch) &
  2909. (FD_SWAPSIDES | FD_SECTBASEMASK)))
  2910. invalidate_drive(bdev);
  2911. else
  2912. process_fd_request();
  2913. }
  2914. return 0;
  2915. }
  2916. /* handle obsolete ioctl's */
  2917. static int ioctl_table[] = {
  2918. FDCLRPRM,
  2919. FDSETPRM,
  2920. FDDEFPRM,
  2921. FDGETPRM,
  2922. FDMSGON,
  2923. FDMSGOFF,
  2924. FDFMTBEG,
  2925. FDFMTTRK,
  2926. FDFMTEND,
  2927. FDSETEMSGTRESH,
  2928. FDFLUSH,
  2929. FDSETMAXERRS,
  2930. FDGETMAXERRS,
  2931. FDGETDRVTYP,
  2932. FDSETDRVPRM,
  2933. FDGETDRVPRM,
  2934. FDGETDRVSTAT,
  2935. FDPOLLDRVSTAT,
  2936. FDRESET,
  2937. FDGETFDCSTAT,
  2938. FDWERRORCLR,
  2939. FDWERRORGET,
  2940. FDRAWCMD,
  2941. FDEJECT,
  2942. FDTWADDLE
  2943. };
  2944. static inline int normalize_ioctl(int *cmd, int *size)
  2945. {
  2946. int i;
  2947. for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
  2948. if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
  2949. *size = _IOC_SIZE(*cmd);
  2950. *cmd = ioctl_table[i];
  2951. if (*size > _IOC_SIZE(*cmd)) {
  2952. pr_info("ioctl not yet supported\n");
  2953. return -EFAULT;
  2954. }
  2955. return 0;
  2956. }
  2957. }
  2958. return -EINVAL;
  2959. }
  2960. static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
  2961. {
  2962. if (type)
  2963. *g = &floppy_type[type];
  2964. else {
  2965. if (lock_fdc(drive, false))
  2966. return -EINTR;
  2967. if (poll_drive(false, 0) == -EINTR)
  2968. return -EINTR;
  2969. process_fd_request();
  2970. *g = current_type[drive];
  2971. }
  2972. if (!*g)
  2973. return -ENODEV;
  2974. return 0;
  2975. }
  2976. static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  2977. {
  2978. int drive = (long)bdev->bd_disk->private_data;
  2979. int type = ITYPE(drive_state[drive].fd_device);
  2980. struct floppy_struct *g;
  2981. int ret;
  2982. ret = get_floppy_geometry(drive, type, &g);
  2983. if (ret)
  2984. return ret;
  2985. geo->heads = g->head;
  2986. geo->sectors = g->sect;
  2987. geo->cylinders = g->track;
  2988. return 0;
  2989. }
  2990. static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
  2991. unsigned long param)
  2992. {
  2993. #define FD_IOCTL_ALLOWED (mode & (FMODE_WRITE|FMODE_WRITE_IOCTL))
  2994. int drive = (long)bdev->bd_disk->private_data;
  2995. int type = ITYPE(UDRS->fd_device);
  2996. int i;
  2997. int ret;
  2998. int size;
  2999. union inparam {
  3000. struct floppy_struct g; /* geometry */
  3001. struct format_descr f;
  3002. struct floppy_max_errors max_errors;
  3003. struct floppy_drive_params dp;
  3004. } inparam; /* parameters coming from user space */
  3005. const char *outparam; /* parameters passed back to user space */
  3006. /* convert compatibility eject ioctls into floppy eject ioctl.
  3007. * We do this in order to provide a means to eject floppy disks before
  3008. * installing the new fdutils package */
  3009. if (cmd == CDROMEJECT || /* CD-ROM eject */
  3010. cmd == 0x6470) { /* SunOS floppy eject */
  3011. DPRINT("obsolete eject ioctl\n");
  3012. DPRINT("please use floppycontrol --eject\n");
  3013. cmd = FDEJECT;
  3014. }
  3015. if (!((cmd & 0xff00) == 0x0200))
  3016. return -EINVAL;
  3017. /* convert the old style command into a new style command */
  3018. ret = normalize_ioctl(&cmd, &size);
  3019. if (ret)
  3020. return ret;
  3021. /* permission checks */
  3022. if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
  3023. ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
  3024. return -EPERM;
  3025. if (WARN_ON(size < 0 || size > sizeof(inparam)))
  3026. return -EINVAL;
  3027. /* copyin */
  3028. memset(&inparam, 0, sizeof(inparam));
  3029. if (_IOC_DIR(cmd) & _IOC_WRITE) {
  3030. ret = fd_copyin((void __user *)param, &inparam, size);
  3031. if (ret)
  3032. return ret;
  3033. }
  3034. switch (cmd) {
  3035. case FDEJECT:
  3036. if (UDRS->fd_ref != 1)
  3037. /* somebody else has this drive open */
  3038. return -EBUSY;
  3039. if (lock_fdc(drive, true))
  3040. return -EINTR;
  3041. /* do the actual eject. Fails on
  3042. * non-Sparc architectures */
  3043. ret = fd_eject(UNIT(drive));
  3044. set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
  3045. set_bit(FD_VERIFY_BIT, &UDRS->flags);
  3046. process_fd_request();
  3047. return ret;
  3048. case FDCLRPRM:
  3049. if (lock_fdc(drive, true))
  3050. return -EINTR;
  3051. current_type[drive] = NULL;
  3052. floppy_sizes[drive] = MAX_DISK_SIZE << 1;
  3053. UDRS->keep_data = 0;
  3054. return invalidate_drive(bdev);
  3055. case FDSETPRM:
  3056. case FDDEFPRM:
  3057. return set_geometry(cmd, &inparam.g, drive, type, bdev);
  3058. case FDGETPRM:
  3059. ret = get_floppy_geometry(drive, type,
  3060. (struct floppy_struct **)
  3061. &outparam);
  3062. if (ret)
  3063. return ret;
  3064. break;
  3065. case FDMSGON:
  3066. UDP->flags |= FTD_MSG;
  3067. return 0;
  3068. case FDMSGOFF:
  3069. UDP->flags &= ~FTD_MSG;
  3070. return 0;
  3071. case FDFMTBEG:
  3072. if (lock_fdc(drive, true))
  3073. return -EINTR;
  3074. if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
  3075. return -EINTR;
  3076. ret = UDRS->flags;
  3077. process_fd_request();
  3078. if (ret & FD_VERIFY)
  3079. return -ENODEV;
  3080. if (!(ret & FD_DISK_WRITABLE))
  3081. return -EROFS;
  3082. return 0;
  3083. case FDFMTTRK:
  3084. if (UDRS->fd_ref != 1)
  3085. return -EBUSY;
  3086. return do_format(drive, &inparam.f);
  3087. case FDFMTEND:
  3088. case FDFLUSH:
  3089. if (lock_fdc(drive, true))
  3090. return -EINTR;
  3091. return invalidate_drive(bdev);
  3092. case FDSETEMSGTRESH:
  3093. UDP->max_errors.reporting = (unsigned short)(param & 0x0f);
  3094. return 0;
  3095. case FDGETMAXERRS:
  3096. outparam = (const char *)&UDP->max_errors;
  3097. break;
  3098. case FDSETMAXERRS:
  3099. UDP->max_errors = inparam.max_errors;
  3100. break;
  3101. case FDGETDRVTYP:
  3102. outparam = drive_name(type, drive);
  3103. SUPBOUND(size, strlen(outparam) + 1);
  3104. break;
  3105. case FDSETDRVPRM:
  3106. *UDP = inparam.dp;
  3107. break;
  3108. case FDGETDRVPRM:
  3109. outparam = (const char *)UDP;
  3110. break;
  3111. case FDPOLLDRVSTAT:
  3112. if (lock_fdc(drive, true))
  3113. return -EINTR;
  3114. if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
  3115. return -EINTR;
  3116. process_fd_request();
  3117. /* fall through */
  3118. case FDGETDRVSTAT:
  3119. outparam = (const char *)UDRS;
  3120. break;
  3121. case FDRESET:
  3122. return user_reset_fdc(drive, (int)param, true);
  3123. case FDGETFDCSTAT:
  3124. outparam = (const char *)UFDCS;
  3125. break;
  3126. case FDWERRORCLR:
  3127. memset(UDRWE, 0, sizeof(*UDRWE));
  3128. return 0;
  3129. case FDWERRORGET:
  3130. outparam = (const char *)UDRWE;
  3131. break;
  3132. case FDRAWCMD:
  3133. if (type)
  3134. return -EINVAL;
  3135. if (lock_fdc(drive, true))
  3136. return -EINTR;
  3137. set_floppy(drive);
  3138. i = raw_cmd_ioctl(cmd, (void __user *)param);
  3139. if (i == -EINTR)
  3140. return -EINTR;
  3141. process_fd_request();
  3142. return i;
  3143. case FDTWADDLE:
  3144. if (lock_fdc(drive, true))
  3145. return -EINTR;
  3146. twaddle();
  3147. process_fd_request();
  3148. return 0;
  3149. default:
  3150. return -EINVAL;
  3151. }
  3152. if (_IOC_DIR(cmd) & _IOC_READ)
  3153. return fd_copyout((void __user *)param, outparam, size);
  3154. return 0;
  3155. }
  3156. static void __init config_types(void)
  3157. {
  3158. bool has_drive = false;
  3159. int drive;
  3160. /* read drive info out of physical CMOS */
  3161. drive = 0;
  3162. if (!UDP->cmos)
  3163. UDP->cmos = FLOPPY0_TYPE;
  3164. drive = 1;
  3165. if (!UDP->cmos && FLOPPY1_TYPE)
  3166. UDP->cmos = FLOPPY1_TYPE;
  3167. /* FIXME: additional physical CMOS drive detection should go here */
  3168. for (drive = 0; drive < N_DRIVE; drive++) {
  3169. unsigned int type = UDP->cmos;
  3170. struct floppy_drive_params *params;
  3171. const char *name = NULL;
  3172. static char temparea[32];
  3173. if (type < ARRAY_SIZE(default_drive_params)) {
  3174. params = &default_drive_params[type].params;
  3175. if (type) {
  3176. name = default_drive_params[type].name;
  3177. allowed_drive_mask |= 1 << drive;
  3178. } else
  3179. allowed_drive_mask &= ~(1 << drive);
  3180. } else {
  3181. params = &default_drive_params[0].params;
  3182. sprintf(temparea, "unknown type %d (usb?)", type);
  3183. name = temparea;
  3184. }
  3185. if (name) {
  3186. const char *prepend;
  3187. if (!has_drive) {
  3188. prepend = "";
  3189. has_drive = true;
  3190. pr_info("Floppy drive(s):");
  3191. } else {
  3192. prepend = ",";
  3193. }
  3194. pr_cont("%s fd%d is %s", prepend, drive, name);
  3195. }
  3196. *UDP = *params;
  3197. }
  3198. if (has_drive)
  3199. pr_cont("\n");
  3200. }
  3201. static int floppy_release(struct gendisk *disk, fmode_t mode)
  3202. {
  3203. int drive = (long)disk->private_data;
  3204. mutex_lock(&open_lock);
  3205. if (UDRS->fd_ref < 0)
  3206. UDRS->fd_ref = 0;
  3207. else if (!UDRS->fd_ref--) {
  3208. DPRINT("floppy_release with fd_ref == 0");
  3209. UDRS->fd_ref = 0;
  3210. }
  3211. if (!UDRS->fd_ref)
  3212. opened_bdev[drive] = NULL;
  3213. mutex_unlock(&open_lock);
  3214. return 0;
  3215. }
  3216. /*
  3217. * floppy_open check for aliasing (/dev/fd0 can be the same as
  3218. * /dev/PS0 etc), and disallows simultaneous access to the same
  3219. * drive with different device numbers.
  3220. */
  3221. static int floppy_open(struct block_device *bdev, fmode_t mode)
  3222. {
  3223. int drive = (long)bdev->bd_disk->private_data;
  3224. int old_dev, new_dev;
  3225. int try;
  3226. int res = -EBUSY;
  3227. char *tmp;
  3228. mutex_lock(&open_lock);
  3229. old_dev = UDRS->fd_device;
  3230. if (opened_bdev[drive] && opened_bdev[drive] != bdev)
  3231. goto out2;
  3232. if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
  3233. set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
  3234. set_bit(FD_VERIFY_BIT, &UDRS->flags);
  3235. }
  3236. if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (mode & FMODE_EXCL)))
  3237. goto out2;
  3238. if (mode & FMODE_EXCL)
  3239. UDRS->fd_ref = -1;
  3240. else
  3241. UDRS->fd_ref++;
  3242. opened_bdev[drive] = bdev;
  3243. res = -ENXIO;
  3244. if (!floppy_track_buffer) {
  3245. /* if opening an ED drive, reserve a big buffer,
  3246. * else reserve a small one */
  3247. if ((UDP->cmos == 6) || (UDP->cmos == 5))
  3248. try = 64; /* Only 48 actually useful */
  3249. else
  3250. try = 32; /* Only 24 actually useful */
  3251. tmp = (char *)fd_dma_mem_alloc(1024 * try);
  3252. if (!tmp && !floppy_track_buffer) {
  3253. try >>= 1; /* buffer only one side */
  3254. INFBOUND(try, 16);
  3255. tmp = (char *)fd_dma_mem_alloc(1024 * try);
  3256. }
  3257. if (!tmp && !floppy_track_buffer)
  3258. fallback_on_nodma_alloc(&tmp, 2048 * try);
  3259. if (!tmp && !floppy_track_buffer) {
  3260. DPRINT("Unable to allocate DMA memory\n");
  3261. goto out;
  3262. }
  3263. if (floppy_track_buffer) {
  3264. if (tmp)
  3265. fd_dma_mem_free((unsigned long)tmp, try * 1024);
  3266. } else {
  3267. buffer_min = buffer_max = -1;
  3268. floppy_track_buffer = tmp;
  3269. max_buffer_sectors = try;
  3270. }
  3271. }
  3272. new_dev = MINOR(bdev->bd_dev);
  3273. UDRS->fd_device = new_dev;
  3274. set_capacity(disks[drive], floppy_sizes[new_dev]);
  3275. if (old_dev != -1 && old_dev != new_dev) {
  3276. if (buffer_drive == drive)
  3277. buffer_track = -1;
  3278. }
  3279. if (UFDCS->rawcmd == 1)
  3280. UFDCS->rawcmd = 2;
  3281. if (!(mode & FMODE_NDELAY)) {
  3282. if (mode & (FMODE_READ|FMODE_WRITE)) {
  3283. UDRS->last_checked = 0;
  3284. check_disk_change(bdev);
  3285. if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
  3286. goto out;
  3287. }
  3288. res = -EROFS;
  3289. if ((mode & FMODE_WRITE) &&
  3290. !test_bit(FD_DISK_WRITABLE_BIT, &UDRS->flags))
  3291. goto out;
  3292. }
  3293. mutex_unlock(&open_lock);
  3294. return 0;
  3295. out:
  3296. if (UDRS->fd_ref < 0)
  3297. UDRS->fd_ref = 0;
  3298. else
  3299. UDRS->fd_ref--;
  3300. if (!UDRS->fd_ref)
  3301. opened_bdev[drive] = NULL;
  3302. out2:
  3303. mutex_unlock(&open_lock);
  3304. return res;
  3305. }
  3306. /*
  3307. * Check if the disk has been changed or if a change has been faked.
  3308. */
  3309. static int check_floppy_change(struct gendisk *disk)
  3310. {
  3311. int drive = (long)disk->private_data;
  3312. if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
  3313. test_bit(FD_VERIFY_BIT, &UDRS->flags))
  3314. return 1;
  3315. if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
  3316. lock_fdc(drive, false);
  3317. poll_drive(false, 0);
  3318. process_fd_request();
  3319. }
  3320. if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
  3321. test_bit(FD_VERIFY_BIT, &UDRS->flags) ||
  3322. test_bit(drive, &fake_change) ||
  3323. (!ITYPE(UDRS->fd_device) && !current_type[drive]))
  3324. return 1;
  3325. return 0;
  3326. }
  3327. /*
  3328. * This implements "read block 0" for floppy_revalidate().
  3329. * Needed for format autodetection, checking whether there is
  3330. * a disk in the drive, and whether that disk is writable.
  3331. */
  3332. static void floppy_rb0_complete(struct bio *bio, int err)
  3333. {
  3334. complete((struct completion *)bio->bi_private);
  3335. }
  3336. static int __floppy_read_block_0(struct block_device *bdev)
  3337. {
  3338. struct bio bio;
  3339. struct bio_vec bio_vec;
  3340. struct completion complete;
  3341. struct page *page;
  3342. size_t size;
  3343. page = alloc_page(GFP_NOIO);
  3344. if (!page) {
  3345. process_fd_request();
  3346. return -ENOMEM;
  3347. }
  3348. size = bdev->bd_block_size;
  3349. if (!size)
  3350. size = 1024;
  3351. bio_init(&bio);
  3352. bio.bi_io_vec = &bio_vec;
  3353. bio_vec.bv_page = page;
  3354. bio_vec.bv_len = size;
  3355. bio_vec.bv_offset = 0;
  3356. bio.bi_vcnt = 1;
  3357. bio.bi_idx = 0;
  3358. bio.bi_size = size;
  3359. bio.bi_bdev = bdev;
  3360. bio.bi_sector = 0;
  3361. init_completion(&complete);
  3362. bio.bi_private = &complete;
  3363. bio.bi_end_io = floppy_rb0_complete;
  3364. submit_bio(READ, &bio);
  3365. generic_unplug_device(bdev_get_queue(bdev));
  3366. process_fd_request();
  3367. wait_for_completion(&complete);
  3368. __free_page(page);
  3369. return 0;
  3370. }
  3371. /* revalidate the floppy disk, i.e. trigger format autodetection by reading
  3372. * the bootblock (block 0). "Autodetection" is also needed to check whether
  3373. * there is a disk in the drive at all... Thus we also do it for fixed
  3374. * geometry formats */
  3375. static int floppy_revalidate(struct gendisk *disk)
  3376. {
  3377. int drive = (long)disk->private_data;
  3378. #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
  3379. int cf;
  3380. int res = 0;
  3381. if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
  3382. test_bit(FD_VERIFY_BIT, &UDRS->flags) ||
  3383. test_bit(drive, &fake_change) || NO_GEOM) {
  3384. if (usage_count == 0) {
  3385. pr_info("VFS: revalidate called on non-open device.\n");
  3386. return -EFAULT;
  3387. }
  3388. lock_fdc(drive, false);
  3389. cf = (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
  3390. test_bit(FD_VERIFY_BIT, &UDRS->flags));
  3391. if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
  3392. process_fd_request(); /*already done by another thread */
  3393. return 0;
  3394. }
  3395. UDRS->maxblock = 0;
  3396. UDRS->maxtrack = 0;
  3397. if (buffer_drive == drive)
  3398. buffer_track = -1;
  3399. clear_bit(drive, &fake_change);
  3400. clear_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
  3401. if (cf)
  3402. UDRS->generation++;
  3403. if (NO_GEOM) {
  3404. /* auto-sensing */
  3405. res = __floppy_read_block_0(opened_bdev[drive]);
  3406. } else {
  3407. if (cf)
  3408. poll_drive(false, FD_RAW_NEED_DISK);
  3409. process_fd_request();
  3410. }
  3411. }
  3412. set_capacity(disk, floppy_sizes[UDRS->fd_device]);
  3413. return res;
  3414. }
  3415. static const struct block_device_operations floppy_fops = {
  3416. .owner = THIS_MODULE,
  3417. .open = floppy_open,
  3418. .release = floppy_release,
  3419. .locked_ioctl = fd_ioctl,
  3420. .getgeo = fd_getgeo,
  3421. .media_changed = check_floppy_change,
  3422. .revalidate_disk = floppy_revalidate,
  3423. };
  3424. /*
  3425. * Floppy Driver initialization
  3426. * =============================
  3427. */
  3428. /* Determine the floppy disk controller type */
  3429. /* This routine was written by David C. Niemi */
  3430. static char __init get_fdc_version(void)
  3431. {
  3432. int r;
  3433. output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
  3434. if (FDCS->reset)
  3435. return FDC_NONE;
  3436. r = result();
  3437. if (r <= 0x00)
  3438. return FDC_NONE; /* No FDC present ??? */
  3439. if ((r == 1) && (reply_buffer[0] == 0x80)) {
  3440. pr_info("FDC %d is an 8272A\n", fdc);
  3441. return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
  3442. }
  3443. if (r != 10) {
  3444. pr_info("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
  3445. fdc, r);
  3446. return FDC_UNKNOWN;
  3447. }
  3448. if (!fdc_configure()) {
  3449. pr_info("FDC %d is an 82072\n", fdc);
  3450. return FDC_82072; /* 82072 doesn't know CONFIGURE */
  3451. }
  3452. output_byte(FD_PERPENDICULAR);
  3453. if (need_more_output() == MORE_OUTPUT) {
  3454. output_byte(0);
  3455. } else {
  3456. pr_info("FDC %d is an 82072A\n", fdc);
  3457. return FDC_82072A; /* 82072A as found on Sparcs. */
  3458. }
  3459. output_byte(FD_UNLOCK);
  3460. r = result();
  3461. if ((r == 1) && (reply_buffer[0] == 0x80)) {
  3462. pr_info("FDC %d is a pre-1991 82077\n", fdc);
  3463. return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
  3464. * LOCK/UNLOCK */
  3465. }
  3466. if ((r != 1) || (reply_buffer[0] != 0x00)) {
  3467. pr_info("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
  3468. fdc, r);
  3469. return FDC_UNKNOWN;
  3470. }
  3471. output_byte(FD_PARTID);
  3472. r = result();
  3473. if (r != 1) {
  3474. pr_info("FDC %d init: PARTID: unexpected return of %d bytes.\n",
  3475. fdc, r);
  3476. return FDC_UNKNOWN;
  3477. }
  3478. if (reply_buffer[0] == 0x80) {
  3479. pr_info("FDC %d is a post-1991 82077\n", fdc);
  3480. return FDC_82077; /* Revised 82077AA passes all the tests */
  3481. }
  3482. switch (reply_buffer[0] >> 5) {
  3483. case 0x0:
  3484. /* Either a 82078-1 or a 82078SL running at 5Volt */
  3485. pr_info("FDC %d is an 82078.\n", fdc);
  3486. return FDC_82078;
  3487. case 0x1:
  3488. pr_info("FDC %d is a 44pin 82078\n", fdc);
  3489. return FDC_82078;
  3490. case 0x2:
  3491. pr_info("FDC %d is a S82078B\n", fdc);
  3492. return FDC_S82078B;
  3493. case 0x3:
  3494. pr_info("FDC %d is a National Semiconductor PC87306\n", fdc);
  3495. return FDC_87306;
  3496. default:
  3497. pr_info("FDC %d init: 82078 variant with unknown PARTID=%d.\n",
  3498. fdc, reply_buffer[0] >> 5);
  3499. return FDC_82078_UNKN;
  3500. }
  3501. } /* get_fdc_version */
  3502. /* lilo configuration */
  3503. static void __init floppy_set_flags(int *ints, int param, int param2)
  3504. {
  3505. int i;
  3506. for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
  3507. if (param)
  3508. default_drive_params[i].params.flags |= param2;
  3509. else
  3510. default_drive_params[i].params.flags &= ~param2;
  3511. }
  3512. DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
  3513. }
  3514. static void __init daring(int *ints, int param, int param2)
  3515. {
  3516. int i;
  3517. for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
  3518. if (param) {
  3519. default_drive_params[i].params.select_delay = 0;
  3520. default_drive_params[i].params.flags |=
  3521. FD_SILENT_DCL_CLEAR;
  3522. } else {
  3523. default_drive_params[i].params.select_delay =
  3524. 2 * HZ / 100;
  3525. default_drive_params[i].params.flags &=
  3526. ~FD_SILENT_DCL_CLEAR;
  3527. }
  3528. }
  3529. DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
  3530. }
  3531. static void __init set_cmos(int *ints, int dummy, int dummy2)
  3532. {
  3533. int current_drive = 0;
  3534. if (ints[0] != 2) {
  3535. DPRINT("wrong number of parameters for CMOS\n");
  3536. return;
  3537. }
  3538. current_drive = ints[1];
  3539. if (current_drive < 0 || current_drive >= 8) {
  3540. DPRINT("bad drive for set_cmos\n");
  3541. return;
  3542. }
  3543. #if N_FDC > 1
  3544. if (current_drive >= 4 && !FDC2)
  3545. FDC2 = 0x370;
  3546. #endif
  3547. DP->cmos = ints[2];
  3548. DPRINT("setting CMOS code to %d\n", ints[2]);
  3549. }
  3550. static struct param_table {
  3551. const char *name;
  3552. void (*fn) (int *ints, int param, int param2);
  3553. int *var;
  3554. int def_param;
  3555. int param2;
  3556. } config_params[] __initdata = {
  3557. {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
  3558. {"all_drives", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
  3559. {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
  3560. {"irq", NULL, &FLOPPY_IRQ, 6, 0},
  3561. {"dma", NULL, &FLOPPY_DMA, 2, 0},
  3562. {"daring", daring, NULL, 1, 0},
  3563. #if N_FDC > 1
  3564. {"two_fdc", NULL, &FDC2, 0x370, 0},
  3565. {"one_fdc", NULL, &FDC2, 0, 0},
  3566. #endif
  3567. {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
  3568. {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
  3569. {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
  3570. {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
  3571. {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
  3572. {"nodma", NULL, &can_use_virtual_dma, 1, 0},
  3573. {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
  3574. {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
  3575. {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
  3576. {"nofifo", NULL, &no_fifo, 0x20, 0},
  3577. {"usefifo", NULL, &no_fifo, 0, 0},
  3578. {"cmos", set_cmos, NULL, 0, 0},
  3579. {"slow", NULL, &slow_floppy, 1, 0},
  3580. {"unexpected_interrupts", NULL, &print_unex, 1, 0},
  3581. {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
  3582. {"L40SX", NULL, &print_unex, 0, 0}
  3583. EXTRA_FLOPPY_PARAMS
  3584. };
  3585. static int __init floppy_setup(char *str)
  3586. {
  3587. int i;
  3588. int param;
  3589. int ints[11];
  3590. str = get_options(str, ARRAY_SIZE(ints), ints);
  3591. if (str) {
  3592. for (i = 0; i < ARRAY_SIZE(config_params); i++) {
  3593. if (strcmp(str, config_params[i].name) == 0) {
  3594. if (ints[0])
  3595. param = ints[1];
  3596. else
  3597. param = config_params[i].def_param;
  3598. if (config_params[i].fn)
  3599. config_params[i].fn(ints, param,
  3600. config_params[i].
  3601. param2);
  3602. if (config_params[i].var) {
  3603. DPRINT("%s=%d\n", str, param);
  3604. *config_params[i].var = param;
  3605. }
  3606. return 1;
  3607. }
  3608. }
  3609. }
  3610. if (str) {
  3611. DPRINT("unknown floppy option [%s]\n", str);
  3612. DPRINT("allowed options are:");
  3613. for (i = 0; i < ARRAY_SIZE(config_params); i++)
  3614. pr_cont(" %s", config_params[i].name);
  3615. pr_cont("\n");
  3616. } else
  3617. DPRINT("botched floppy option\n");
  3618. DPRINT("Read Documentation/blockdev/floppy.txt\n");
  3619. return 0;
  3620. }
  3621. static int have_no_fdc = -ENODEV;
  3622. static ssize_t floppy_cmos_show(struct device *dev,
  3623. struct device_attribute *attr, char *buf)
  3624. {
  3625. struct platform_device *p = to_platform_device(dev);
  3626. int drive;
  3627. drive = p->id;
  3628. return sprintf(buf, "%X\n", UDP->cmos);
  3629. }
  3630. DEVICE_ATTR(cmos, S_IRUGO, floppy_cmos_show, NULL);
  3631. static void floppy_device_release(struct device *dev)
  3632. {
  3633. }
  3634. static int floppy_resume(struct device *dev)
  3635. {
  3636. int fdc;
  3637. for (fdc = 0; fdc < N_FDC; fdc++)
  3638. if (FDCS->address != -1)
  3639. user_reset_fdc(-1, FD_RESET_ALWAYS, false);
  3640. return 0;
  3641. }
  3642. static const struct dev_pm_ops floppy_pm_ops = {
  3643. .resume = floppy_resume,
  3644. .restore = floppy_resume,
  3645. };
  3646. static struct platform_driver floppy_driver = {
  3647. .driver = {
  3648. .name = "floppy",
  3649. .pm = &floppy_pm_ops,
  3650. },
  3651. };
  3652. static struct platform_device floppy_device[N_DRIVE];
  3653. static struct kobject *floppy_find(dev_t dev, int *part, void *data)
  3654. {
  3655. int drive = (*part & 3) | ((*part & 0x80) >> 5);
  3656. if (drive >= N_DRIVE ||
  3657. !(allowed_drive_mask & (1 << drive)) ||
  3658. fdc_state[FDC(drive)].version == FDC_NONE)
  3659. return NULL;
  3660. if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
  3661. return NULL;
  3662. *part = 0;
  3663. return get_disk(disks[drive]);
  3664. }
  3665. static int __init floppy_init(void)
  3666. {
  3667. int i, unit, drive;
  3668. int err, dr;
  3669. #if defined(CONFIG_PPC)
  3670. if (check_legacy_ioport(FDC1))
  3671. return -ENODEV;
  3672. #endif
  3673. raw_cmd = NULL;
  3674. for (dr = 0; dr < N_DRIVE; dr++) {
  3675. disks[dr] = alloc_disk(1);
  3676. if (!disks[dr]) {
  3677. err = -ENOMEM;
  3678. goto out_put_disk;
  3679. }
  3680. disks[dr]->major = FLOPPY_MAJOR;
  3681. disks[dr]->first_minor = TOMINOR(dr);
  3682. disks[dr]->fops = &floppy_fops;
  3683. sprintf(disks[dr]->disk_name, "fd%d", dr);
  3684. init_timer(&motor_off_timer[dr]);
  3685. motor_off_timer[dr].data = dr;
  3686. motor_off_timer[dr].function = motor_off_callback;
  3687. }
  3688. err = register_blkdev(FLOPPY_MAJOR, "fd");
  3689. if (err)
  3690. goto out_put_disk;
  3691. err = platform_driver_register(&floppy_driver);
  3692. if (err)
  3693. goto out_unreg_blkdev;
  3694. floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
  3695. if (!floppy_queue) {
  3696. err = -ENOMEM;
  3697. goto out_unreg_driver;
  3698. }
  3699. blk_queue_max_hw_sectors(floppy_queue, 64);
  3700. blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
  3701. floppy_find, NULL, NULL);
  3702. for (i = 0; i < 256; i++)
  3703. if (ITYPE(i))
  3704. floppy_sizes[i] = floppy_type[ITYPE(i)].size;
  3705. else
  3706. floppy_sizes[i] = MAX_DISK_SIZE << 1;
  3707. reschedule_timeout(MAXTIMEOUT, "floppy init");
  3708. config_types();
  3709. for (i = 0; i < N_FDC; i++) {
  3710. fdc = i;
  3711. memset(FDCS, 0, sizeof(*FDCS));
  3712. FDCS->dtr = -1;
  3713. FDCS->dor = 0x4;
  3714. #if defined(__sparc__) || defined(__mc68000__)
  3715. /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
  3716. #ifdef __mc68000__
  3717. if (MACH_IS_SUN3X)
  3718. #endif
  3719. FDCS->version = FDC_82072A;
  3720. #endif
  3721. }
  3722. use_virtual_dma = can_use_virtual_dma & 1;
  3723. fdc_state[0].address = FDC1;
  3724. if (fdc_state[0].address == -1) {
  3725. del_timer(&fd_timeout);
  3726. err = -ENODEV;
  3727. goto out_unreg_region;
  3728. }
  3729. #if N_FDC > 1
  3730. fdc_state[1].address = FDC2;
  3731. #endif
  3732. fdc = 0; /* reset fdc in case of unexpected interrupt */
  3733. err = floppy_grab_irq_and_dma();
  3734. if (err) {
  3735. del_timer(&fd_timeout);
  3736. err = -EBUSY;
  3737. goto out_unreg_region;
  3738. }
  3739. /* initialise drive state */
  3740. for (drive = 0; drive < N_DRIVE; drive++) {
  3741. memset(UDRS, 0, sizeof(*UDRS));
  3742. memset(UDRWE, 0, sizeof(*UDRWE));
  3743. set_bit(FD_DISK_NEWCHANGE_BIT, &UDRS->flags);
  3744. set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
  3745. set_bit(FD_VERIFY_BIT, &UDRS->flags);
  3746. UDRS->fd_device = -1;
  3747. floppy_track_buffer = NULL;
  3748. max_buffer_sectors = 0;
  3749. }
  3750. /*
  3751. * Small 10 msec delay to let through any interrupt that
  3752. * initialization might have triggered, to not
  3753. * confuse detection:
  3754. */
  3755. msleep(10);
  3756. for (i = 0; i < N_FDC; i++) {
  3757. fdc = i;
  3758. FDCS->driver_version = FD_DRIVER_VERSION;
  3759. for (unit = 0; unit < 4; unit++)
  3760. FDCS->track[unit] = 0;
  3761. if (FDCS->address == -1)
  3762. continue;
  3763. FDCS->rawcmd = 2;
  3764. if (user_reset_fdc(-1, FD_RESET_ALWAYS, false)) {
  3765. /* free ioports reserved by floppy_grab_irq_and_dma() */
  3766. floppy_release_regions(fdc);
  3767. FDCS->address = -1;
  3768. FDCS->version = FDC_NONE;
  3769. continue;
  3770. }
  3771. /* Try to determine the floppy controller type */
  3772. FDCS->version = get_fdc_version();
  3773. if (FDCS->version == FDC_NONE) {
  3774. /* free ioports reserved by floppy_grab_irq_and_dma() */
  3775. floppy_release_regions(fdc);
  3776. FDCS->address = -1;
  3777. continue;
  3778. }
  3779. if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
  3780. can_use_virtual_dma = 0;
  3781. have_no_fdc = 0;
  3782. /* Not all FDCs seem to be able to handle the version command
  3783. * properly, so force a reset for the standard FDC clones,
  3784. * to avoid interrupt garbage.
  3785. */
  3786. user_reset_fdc(-1, FD_RESET_ALWAYS, false);
  3787. }
  3788. fdc = 0;
  3789. del_timer(&fd_timeout);
  3790. current_drive = 0;
  3791. initialized = true;
  3792. if (have_no_fdc) {
  3793. DPRINT("no floppy controllers found\n");
  3794. err = have_no_fdc;
  3795. goto out_flush_work;
  3796. }
  3797. for (drive = 0; drive < N_DRIVE; drive++) {
  3798. if (!(allowed_drive_mask & (1 << drive)))
  3799. continue;
  3800. if (fdc_state[FDC(drive)].version == FDC_NONE)
  3801. continue;
  3802. floppy_device[drive].name = floppy_device_name;
  3803. floppy_device[drive].id = drive;
  3804. floppy_device[drive].dev.release = floppy_device_release;
  3805. err = platform_device_register(&floppy_device[drive]);
  3806. if (err)
  3807. goto out_flush_work;
  3808. err = device_create_file(&floppy_device[drive].dev,
  3809. &dev_attr_cmos);
  3810. if (err)
  3811. goto out_unreg_platform_dev;
  3812. /* to be cleaned up... */
  3813. disks[drive]->private_data = (void *)(long)drive;
  3814. disks[drive]->queue = floppy_queue;
  3815. disks[drive]->flags |= GENHD_FL_REMOVABLE;
  3816. disks[drive]->driverfs_dev = &floppy_device[drive].dev;
  3817. add_disk(disks[drive]);
  3818. }
  3819. return 0;
  3820. out_unreg_platform_dev:
  3821. platform_device_unregister(&floppy_device[drive]);
  3822. out_flush_work:
  3823. flush_scheduled_work();
  3824. if (usage_count)
  3825. floppy_release_irq_and_dma();
  3826. out_unreg_region:
  3827. blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
  3828. blk_cleanup_queue(floppy_queue);
  3829. out_unreg_driver:
  3830. platform_driver_unregister(&floppy_driver);
  3831. out_unreg_blkdev:
  3832. unregister_blkdev(FLOPPY_MAJOR, "fd");
  3833. out_put_disk:
  3834. while (dr--) {
  3835. del_timer(&motor_off_timer[dr]);
  3836. put_disk(disks[dr]);
  3837. }
  3838. return err;
  3839. }
  3840. static DEFINE_SPINLOCK(floppy_usage_lock);
  3841. static const struct io_region {
  3842. int offset;
  3843. int size;
  3844. } io_regions[] = {
  3845. { 2, 1 },
  3846. /* address + 3 is sometimes reserved by pnp bios for motherboard */
  3847. { 4, 2 },
  3848. /* address + 6 is reserved, and may be taken by IDE.
  3849. * Unfortunately, Adaptec doesn't know this :-(, */
  3850. { 7, 1 },
  3851. };
  3852. static void floppy_release_allocated_regions(int fdc, const struct io_region *p)
  3853. {
  3854. while (p != io_regions) {
  3855. p--;
  3856. release_region(FDCS->address + p->offset, p->size);
  3857. }
  3858. }
  3859. #define ARRAY_END(X) (&((X)[ARRAY_SIZE(X)]))
  3860. static int floppy_request_regions(int fdc)
  3861. {
  3862. const struct io_region *p;
  3863. for (p = io_regions; p < ARRAY_END(io_regions); p++) {
  3864. if (!request_region(FDCS->address + p->offset,
  3865. p->size, "floppy")) {
  3866. DPRINT("Floppy io-port 0x%04lx in use\n",
  3867. FDCS->address + p->offset);
  3868. floppy_release_allocated_regions(fdc, p);
  3869. return -EBUSY;
  3870. }
  3871. }
  3872. return 0;
  3873. }
  3874. static void floppy_release_regions(int fdc)
  3875. {
  3876. floppy_release_allocated_regions(fdc, ARRAY_END(io_regions));
  3877. }
  3878. static int floppy_grab_irq_and_dma(void)
  3879. {
  3880. unsigned long flags;
  3881. spin_lock_irqsave(&floppy_usage_lock, flags);
  3882. if (usage_count++) {
  3883. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  3884. return 0;
  3885. }
  3886. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  3887. /*
  3888. * We might have scheduled a free_irq(), wait it to
  3889. * drain first:
  3890. */
  3891. flush_scheduled_work();
  3892. if (fd_request_irq()) {
  3893. DPRINT("Unable to grab IRQ%d for the floppy driver\n",
  3894. FLOPPY_IRQ);
  3895. spin_lock_irqsave(&floppy_usage_lock, flags);
  3896. usage_count--;
  3897. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  3898. return -1;
  3899. }
  3900. if (fd_request_dma()) {
  3901. DPRINT("Unable to grab DMA%d for the floppy driver\n",
  3902. FLOPPY_DMA);
  3903. if (can_use_virtual_dma & 2)
  3904. use_virtual_dma = can_use_virtual_dma = 1;
  3905. if (!(can_use_virtual_dma & 1)) {
  3906. fd_free_irq();
  3907. spin_lock_irqsave(&floppy_usage_lock, flags);
  3908. usage_count--;
  3909. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  3910. return -1;
  3911. }
  3912. }
  3913. for (fdc = 0; fdc < N_FDC; fdc++) {
  3914. if (FDCS->address != -1) {
  3915. if (floppy_request_regions(fdc))
  3916. goto cleanup;
  3917. }
  3918. }
  3919. for (fdc = 0; fdc < N_FDC; fdc++) {
  3920. if (FDCS->address != -1) {
  3921. reset_fdc_info(1);
  3922. fd_outb(FDCS->dor, FD_DOR);
  3923. }
  3924. }
  3925. fdc = 0;
  3926. set_dor(0, ~0, 8); /* avoid immediate interrupt */
  3927. for (fdc = 0; fdc < N_FDC; fdc++)
  3928. if (FDCS->address != -1)
  3929. fd_outb(FDCS->dor, FD_DOR);
  3930. /*
  3931. * The driver will try and free resources and relies on us
  3932. * to know if they were allocated or not.
  3933. */
  3934. fdc = 0;
  3935. irqdma_allocated = 1;
  3936. return 0;
  3937. cleanup:
  3938. fd_free_irq();
  3939. fd_free_dma();
  3940. while (--fdc >= 0)
  3941. floppy_release_regions(fdc);
  3942. spin_lock_irqsave(&floppy_usage_lock, flags);
  3943. usage_count--;
  3944. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  3945. return -1;
  3946. }
  3947. static void floppy_release_irq_and_dma(void)
  3948. {
  3949. int old_fdc;
  3950. #ifndef __sparc__
  3951. int drive;
  3952. #endif
  3953. long tmpsize;
  3954. unsigned long tmpaddr;
  3955. unsigned long flags;
  3956. spin_lock_irqsave(&floppy_usage_lock, flags);
  3957. if (--usage_count) {
  3958. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  3959. return;
  3960. }
  3961. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  3962. if (irqdma_allocated) {
  3963. fd_disable_dma();
  3964. fd_free_dma();
  3965. fd_free_irq();
  3966. irqdma_allocated = 0;
  3967. }
  3968. set_dor(0, ~0, 8);
  3969. #if N_FDC > 1
  3970. set_dor(1, ~8, 0);
  3971. #endif
  3972. floppy_enable_hlt();
  3973. if (floppy_track_buffer && max_buffer_sectors) {
  3974. tmpsize = max_buffer_sectors * 1024;
  3975. tmpaddr = (unsigned long)floppy_track_buffer;
  3976. floppy_track_buffer = NULL;
  3977. max_buffer_sectors = 0;
  3978. buffer_min = buffer_max = -1;
  3979. fd_dma_mem_free(tmpaddr, tmpsize);
  3980. }
  3981. #ifndef __sparc__
  3982. for (drive = 0; drive < N_FDC * 4; drive++)
  3983. if (timer_pending(motor_off_timer + drive))
  3984. pr_info("motor off timer %d still active\n", drive);
  3985. #endif
  3986. if (timer_pending(&fd_timeout))
  3987. pr_info("floppy timer still active:%s\n", timeout_message);
  3988. if (timer_pending(&fd_timer))
  3989. pr_info("auxiliary floppy timer still active\n");
  3990. if (work_pending(&floppy_work))
  3991. pr_info("work still pending\n");
  3992. old_fdc = fdc;
  3993. for (fdc = 0; fdc < N_FDC; fdc++)
  3994. if (FDCS->address != -1)
  3995. floppy_release_regions(fdc);
  3996. fdc = old_fdc;
  3997. }
  3998. #ifdef MODULE
  3999. static char *floppy;
  4000. static void __init parse_floppy_cfg_string(char *cfg)
  4001. {
  4002. char *ptr;
  4003. while (*cfg) {
  4004. ptr = cfg;
  4005. while (*cfg && *cfg != ' ' && *cfg != '\t')
  4006. cfg++;
  4007. if (*cfg) {
  4008. *cfg = '\0';
  4009. cfg++;
  4010. }
  4011. if (*ptr)
  4012. floppy_setup(ptr);
  4013. }
  4014. }
  4015. static int __init floppy_module_init(void)
  4016. {
  4017. if (floppy)
  4018. parse_floppy_cfg_string(floppy);
  4019. return floppy_init();
  4020. }
  4021. module_init(floppy_module_init);
  4022. static void __exit floppy_module_exit(void)
  4023. {
  4024. int drive;
  4025. blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
  4026. unregister_blkdev(FLOPPY_MAJOR, "fd");
  4027. platform_driver_unregister(&floppy_driver);
  4028. for (drive = 0; drive < N_DRIVE; drive++) {
  4029. del_timer_sync(&motor_off_timer[drive]);
  4030. if ((allowed_drive_mask & (1 << drive)) &&
  4031. fdc_state[FDC(drive)].version != FDC_NONE) {
  4032. del_gendisk(disks[drive]);
  4033. device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
  4034. platform_device_unregister(&floppy_device[drive]);
  4035. }
  4036. put_disk(disks[drive]);
  4037. }
  4038. del_timer_sync(&fd_timeout);
  4039. del_timer_sync(&fd_timer);
  4040. blk_cleanup_queue(floppy_queue);
  4041. if (usage_count)
  4042. floppy_release_irq_and_dma();
  4043. /* eject disk, if any */
  4044. fd_eject(0);
  4045. }
  4046. module_exit(floppy_module_exit);
  4047. module_param(floppy, charp, 0);
  4048. module_param(FLOPPY_IRQ, int, 0);
  4049. module_param(FLOPPY_DMA, int, 0);
  4050. MODULE_AUTHOR("Alain L. Knaff");
  4051. MODULE_SUPPORTED_DEVICE("fd");
  4052. MODULE_LICENSE("GPL");
  4053. /* This doesn't actually get used other than for module information */
  4054. static const struct pnp_device_id floppy_pnpids[] = {
  4055. {"PNP0700", 0},
  4056. {}
  4057. };
  4058. MODULE_DEVICE_TABLE(pnp, floppy_pnpids);
  4059. #else
  4060. __setup("floppy=", floppy_setup);
  4061. module_init(floppy_init)
  4062. #endif
  4063. MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);