hp100.c 88 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067
  1. /*
  2. ** hp100.c
  3. ** HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters
  4. **
  5. ** $Id: hp100.c,v 1.58 2001/09/24 18:03:01 perex Exp perex $
  6. **
  7. ** Based on the HP100 driver written by Jaroslav Kysela <perex@jcu.cz>
  8. ** Extended for new busmaster capable chipsets by
  9. ** Siegfried "Frieder" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de>
  10. **
  11. ** Maintained by: Jaroslav Kysela <perex@perex.cz>
  12. **
  13. ** This driver has only been tested with
  14. ** -- HP J2585B 10/100 Mbit/s PCI Busmaster
  15. ** -- HP J2585A 10/100 Mbit/s PCI
  16. ** -- HP J2970A 10 Mbit/s PCI Combo 10base-T/BNC
  17. ** -- HP J2973A 10 Mbit/s PCI 10base-T
  18. ** -- HP J2573 10/100 ISA
  19. ** -- Compex ReadyLink ENET100-VG4 10/100 Mbit/s PCI / EISA
  20. ** -- Compex FreedomLine 100/VG 10/100 Mbit/s ISA / EISA / PCI
  21. **
  22. ** but it should also work with the other CASCADE based adapters.
  23. **
  24. ** TODO:
  25. ** - J2573 seems to hang sometimes when in shared memory mode.
  26. ** - Mode for Priority TX
  27. ** - Check PCI registers, performance might be improved?
  28. ** - To reduce interrupt load in busmaster, one could switch off
  29. ** the interrupts that are used to refill the queues whenever the
  30. ** queues are filled up to more than a certain threshold.
  31. ** - some updates for EISA version of card
  32. **
  33. **
  34. ** This code is free software; you can redistribute it and/or modify
  35. ** it under the terms of the GNU General Public License as published by
  36. ** the Free Software Foundation; either version 2 of the License, or
  37. ** (at your option) any later version.
  38. **
  39. ** This code is distributed in the hope that it will be useful,
  40. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  41. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  42. ** GNU General Public License for more details.
  43. **
  44. ** You should have received a copy of the GNU General Public License
  45. ** along with this program; if not, write to the Free Software
  46. ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  47. **
  48. ** 1.57c -> 1.58
  49. ** - used indent to change coding-style
  50. ** - added KTI DP-200 EISA ID
  51. ** - ioremap is also used for low (<1MB) memory (multi-architecture support)
  52. **
  53. ** 1.57b -> 1.57c - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  54. ** - release resources on failure in init_module
  55. **
  56. ** 1.57 -> 1.57b - Jean II
  57. ** - fix spinlocks, SMP is now working !
  58. **
  59. ** 1.56 -> 1.57
  60. ** - updates for new PCI interface for 2.1 kernels
  61. **
  62. ** 1.55 -> 1.56
  63. ** - removed printk in misc. interrupt and update statistics to allow
  64. ** monitoring of card status
  65. ** - timing changes in xmit routines, relogin to 100VG hub added when
  66. ** driver does reset
  67. ** - included fix for Compex FreedomLine PCI adapter
  68. **
  69. ** 1.54 -> 1.55
  70. ** - fixed bad initialization in init_module
  71. ** - added Compex FreedomLine adapter
  72. ** - some fixes in card initialization
  73. **
  74. ** 1.53 -> 1.54
  75. ** - added hardware multicast filter support (doesn't work)
  76. ** - little changes in hp100_sense_lan routine
  77. ** - added support for Coax and AUI (J2970)
  78. ** - fix for multiple cards and hp100_mode parameter (insmod)
  79. ** - fix for shared IRQ
  80. **
  81. ** 1.52 -> 1.53
  82. ** - fixed bug in multicast support
  83. **
  84. */
  85. #define HP100_DEFAULT_PRIORITY_TX 0
  86. #undef HP100_DEBUG
  87. #undef HP100_DEBUG_B /* Trace */
  88. #undef HP100_DEBUG_BM /* Debug busmaster code (PDL stuff) */
  89. #undef HP100_DEBUG_TRAINING /* Debug login-to-hub procedure */
  90. #undef HP100_DEBUG_TX
  91. #undef HP100_DEBUG_IRQ
  92. #undef HP100_DEBUG_RX
  93. #undef HP100_MULTICAST_FILTER /* Need to be debugged... */
  94. #include <linux/module.h>
  95. #include <linux/kernel.h>
  96. #include <linux/sched.h>
  97. #include <linux/string.h>
  98. #include <linux/errno.h>
  99. #include <linux/ioport.h>
  100. #include <linux/interrupt.h>
  101. #include <linux/eisa.h>
  102. #include <linux/pci.h>
  103. #include <linux/dma-mapping.h>
  104. #include <linux/spinlock.h>
  105. #include <linux/netdevice.h>
  106. #include <linux/etherdevice.h>
  107. #include <linux/skbuff.h>
  108. #include <linux/types.h>
  109. #include <linux/delay.h>
  110. #include <linux/init.h>
  111. #include <linux/bitops.h>
  112. #include <linux/jiffies.h>
  113. #include <asm/io.h>
  114. #include "hp100.h"
  115. /*
  116. * defines
  117. */
  118. #define HP100_BUS_ISA 0
  119. #define HP100_BUS_EISA 1
  120. #define HP100_BUS_PCI 2
  121. #define HP100_REGION_SIZE 0x20 /* for ioports */
  122. #define HP100_SIG_LEN 8 /* same as EISA_SIG_LEN */
  123. #define HP100_MAX_PACKET_SIZE (1536+4)
  124. #define HP100_MIN_PACKET_SIZE 60
  125. #ifndef HP100_DEFAULT_RX_RATIO
  126. /* default - 75% onboard memory on the card are used for RX packets */
  127. #define HP100_DEFAULT_RX_RATIO 75
  128. #endif
  129. #ifndef HP100_DEFAULT_PRIORITY_TX
  130. /* default - don't enable transmit outgoing packets as priority */
  131. #define HP100_DEFAULT_PRIORITY_TX 0
  132. #endif
  133. /*
  134. * structures
  135. */
  136. struct hp100_private {
  137. spinlock_t lock;
  138. char id[HP100_SIG_LEN];
  139. u_short chip;
  140. u_short soft_model;
  141. u_int memory_size;
  142. u_int virt_memory_size;
  143. u_short rx_ratio; /* 1 - 99 */
  144. u_short priority_tx; /* != 0 - priority tx */
  145. u_short mode; /* PIO, Shared Mem or Busmaster */
  146. u_char bus;
  147. struct pci_dev *pci_dev;
  148. short mem_mapped; /* memory mapped access */
  149. void __iomem *mem_ptr_virt; /* virtual memory mapped area, maybe NULL */
  150. unsigned long mem_ptr_phys; /* physical memory mapped area */
  151. short lan_type; /* 10Mb/s, 100Mb/s or -1 (error) */
  152. int hub_status; /* was login to hub successful? */
  153. u_char mac1_mode;
  154. u_char mac2_mode;
  155. u_char hash_bytes[8];
  156. /* Rings for busmaster mode: */
  157. hp100_ring_t *rxrhead; /* Head (oldest) index into rxring */
  158. hp100_ring_t *rxrtail; /* Tail (newest) index into rxring */
  159. hp100_ring_t *txrhead; /* Head (oldest) index into txring */
  160. hp100_ring_t *txrtail; /* Tail (newest) index into txring */
  161. hp100_ring_t rxring[MAX_RX_PDL];
  162. hp100_ring_t txring[MAX_TX_PDL];
  163. u_int *page_vaddr_algn; /* Aligned virtual address of allocated page */
  164. u_long whatever_offset; /* Offset to bus/phys/dma address */
  165. int rxrcommit; /* # Rx PDLs committed to adapter */
  166. int txrcommit; /* # Tx PDLs committed to adapter */
  167. };
  168. /*
  169. * variables
  170. */
  171. #ifdef CONFIG_ISA
  172. static const char *hp100_isa_tbl[] = {
  173. "HWPF150", /* HP J2573 rev A */
  174. "HWP1950", /* HP J2573 */
  175. };
  176. #endif
  177. #ifdef CONFIG_EISA
  178. static struct eisa_device_id hp100_eisa_tbl[] = {
  179. { "HWPF180" }, /* HP J2577 rev A */
  180. { "HWP1920" }, /* HP 27248B */
  181. { "HWP1940" }, /* HP J2577 */
  182. { "HWP1990" }, /* HP J2577 */
  183. { "CPX0301" }, /* ReadyLink ENET100-VG4 */
  184. { "CPX0401" }, /* FreedomLine 100/VG */
  185. { "" } /* Mandatory final entry ! */
  186. };
  187. MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl);
  188. #endif
  189. #ifdef CONFIG_PCI
  190. static DEFINE_PCI_DEVICE_TABLE(hp100_pci_tbl) = {
  191. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A, PCI_ANY_ID, PCI_ANY_ID,},
  192. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B, PCI_ANY_ID, PCI_ANY_ID,},
  193. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2970A, PCI_ANY_ID, PCI_ANY_ID,},
  194. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2973A, PCI_ANY_ID, PCI_ANY_ID,},
  195. {PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_ENET100VG4, PCI_ANY_ID, PCI_ANY_ID,},
  196. {PCI_VENDOR_ID_COMPEX2, PCI_DEVICE_ID_COMPEX2_100VG, PCI_ANY_ID, PCI_ANY_ID,},
  197. /* {PCI_VENDOR_ID_KTI, PCI_DEVICE_ID_KTI_DP200, PCI_ANY_ID, PCI_ANY_ID }, */
  198. {} /* Terminating entry */
  199. };
  200. MODULE_DEVICE_TABLE(pci, hp100_pci_tbl);
  201. #endif
  202. static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO;
  203. static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX;
  204. static int hp100_mode = 1;
  205. module_param(hp100_rx_ratio, int, 0);
  206. module_param(hp100_priority_tx, int, 0);
  207. module_param(hp100_mode, int, 0);
  208. /*
  209. * prototypes
  210. */
  211. static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus,
  212. struct pci_dev *pci_dev);
  213. static int hp100_open(struct net_device *dev);
  214. static int hp100_close(struct net_device *dev);
  215. static netdev_tx_t hp100_start_xmit(struct sk_buff *skb,
  216. struct net_device *dev);
  217. static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb,
  218. struct net_device *dev);
  219. static void hp100_rx(struct net_device *dev);
  220. static struct net_device_stats *hp100_get_stats(struct net_device *dev);
  221. static void hp100_misc_interrupt(struct net_device *dev);
  222. static void hp100_update_stats(struct net_device *dev);
  223. static void hp100_clear_stats(struct hp100_private *lp, int ioaddr);
  224. static void hp100_set_multicast_list(struct net_device *dev);
  225. static irqreturn_t hp100_interrupt(int irq, void *dev_id);
  226. static void hp100_start_interface(struct net_device *dev);
  227. static void hp100_stop_interface(struct net_device *dev);
  228. static void hp100_load_eeprom(struct net_device *dev, u_short ioaddr);
  229. static int hp100_sense_lan(struct net_device *dev);
  230. static int hp100_login_to_vg_hub(struct net_device *dev,
  231. u_short force_relogin);
  232. static int hp100_down_vg_link(struct net_device *dev);
  233. static void hp100_cascade_reset(struct net_device *dev, u_short enable);
  234. static void hp100_BM_shutdown(struct net_device *dev);
  235. static void hp100_mmuinit(struct net_device *dev);
  236. static void hp100_init_pdls(struct net_device *dev);
  237. static int hp100_init_rxpdl(struct net_device *dev,
  238. register hp100_ring_t * ringptr,
  239. register u_int * pdlptr);
  240. static int hp100_init_txpdl(struct net_device *dev,
  241. register hp100_ring_t * ringptr,
  242. register u_int * pdlptr);
  243. static void hp100_rxfill(struct net_device *dev);
  244. static void hp100_hwinit(struct net_device *dev);
  245. static void hp100_clean_txring(struct net_device *dev);
  246. #ifdef HP100_DEBUG
  247. static void hp100_RegisterDump(struct net_device *dev);
  248. #endif
  249. /* Conversion to new PCI API :
  250. * Convert an address in a kernel buffer to a bus/phys/dma address.
  251. * This work *only* for memory fragments part of lp->page_vaddr,
  252. * because it was properly DMA allocated via pci_alloc_consistent(),
  253. * so we just need to "retrieve" the original mapping to bus/phys/dma
  254. * address - Jean II */
  255. static inline dma_addr_t virt_to_whatever(struct net_device *dev, u32 * ptr)
  256. {
  257. struct hp100_private *lp = netdev_priv(dev);
  258. return ((u_long) ptr) + lp->whatever_offset;
  259. }
  260. static inline u_int pdl_map_data(struct hp100_private *lp, void *data)
  261. {
  262. return pci_map_single(lp->pci_dev, data,
  263. MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
  264. }
  265. /* TODO: This function should not really be needed in a good design... */
  266. static void wait(void)
  267. {
  268. mdelay(1);
  269. }
  270. /*
  271. * probe functions
  272. * These functions should - if possible - avoid doing write operations
  273. * since this could cause problems when the card is not installed.
  274. */
  275. /*
  276. * Read board id and convert to string.
  277. * Effectively same code as decode_eisa_sig
  278. */
  279. static __devinit const char *hp100_read_id(int ioaddr)
  280. {
  281. int i;
  282. static char str[HP100_SIG_LEN];
  283. unsigned char sig[4], sum;
  284. unsigned short rev;
  285. hp100_page(ID_MAC_ADDR);
  286. sum = 0;
  287. for (i = 0; i < 4; i++) {
  288. sig[i] = hp100_inb(BOARD_ID + i);
  289. sum += sig[i];
  290. }
  291. sum += hp100_inb(BOARD_ID + i);
  292. if (sum != 0xff)
  293. return NULL; /* bad checksum */
  294. str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1);
  295. str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1);
  296. str[2] = (sig[1] & 0x1f) + ('A' - 1);
  297. rev = (sig[2] << 8) | sig[3];
  298. sprintf(str + 3, "%04X", rev);
  299. return str;
  300. }
  301. #ifdef CONFIG_ISA
  302. static __init int hp100_isa_probe1(struct net_device *dev, int ioaddr)
  303. {
  304. const char *sig;
  305. int i;
  306. if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
  307. goto err;
  308. if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE) {
  309. release_region(ioaddr, HP100_REGION_SIZE);
  310. goto err;
  311. }
  312. sig = hp100_read_id(ioaddr);
  313. release_region(ioaddr, HP100_REGION_SIZE);
  314. if (sig == NULL)
  315. goto err;
  316. for (i = 0; i < ARRAY_SIZE(hp100_isa_tbl); i++) {
  317. if (!strcmp(hp100_isa_tbl[i], sig))
  318. break;
  319. }
  320. if (i < ARRAY_SIZE(hp100_isa_tbl))
  321. return hp100_probe1(dev, ioaddr, HP100_BUS_ISA, NULL);
  322. err:
  323. return -ENODEV;
  324. }
  325. /*
  326. * Probe for ISA board.
  327. * EISA and PCI are handled by device infrastructure.
  328. */
  329. static int __init hp100_isa_probe(struct net_device *dev, int addr)
  330. {
  331. int err = -ENODEV;
  332. /* Probe for a specific ISA address */
  333. if (addr > 0xff && addr < 0x400)
  334. err = hp100_isa_probe1(dev, addr);
  335. else if (addr != 0)
  336. err = -ENXIO;
  337. else {
  338. /* Probe all ISA possible port regions */
  339. for (addr = 0x100; addr < 0x400; addr += 0x20) {
  340. err = hp100_isa_probe1(dev, addr);
  341. if (!err)
  342. break;
  343. }
  344. }
  345. return err;
  346. }
  347. #endif /* CONFIG_ISA */
  348. #if !defined(MODULE) && defined(CONFIG_ISA)
  349. struct net_device * __init hp100_probe(int unit)
  350. {
  351. struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
  352. int err;
  353. if (!dev)
  354. return ERR_PTR(-ENODEV);
  355. #ifdef HP100_DEBUG_B
  356. hp100_outw(0x4200, TRACE);
  357. printk("hp100: %s: probe\n", dev->name);
  358. #endif
  359. if (unit >= 0) {
  360. sprintf(dev->name, "eth%d", unit);
  361. netdev_boot_setup_check(dev);
  362. }
  363. err = hp100_isa_probe(dev, dev->base_addr);
  364. if (err)
  365. goto out;
  366. return dev;
  367. out:
  368. free_netdev(dev);
  369. return ERR_PTR(err);
  370. }
  371. #endif /* !MODULE && CONFIG_ISA */
  372. static const struct net_device_ops hp100_bm_netdev_ops = {
  373. .ndo_open = hp100_open,
  374. .ndo_stop = hp100_close,
  375. .ndo_start_xmit = hp100_start_xmit_bm,
  376. .ndo_get_stats = hp100_get_stats,
  377. .ndo_set_rx_mode = hp100_set_multicast_list,
  378. .ndo_change_mtu = eth_change_mtu,
  379. .ndo_set_mac_address = eth_mac_addr,
  380. .ndo_validate_addr = eth_validate_addr,
  381. };
  382. static const struct net_device_ops hp100_netdev_ops = {
  383. .ndo_open = hp100_open,
  384. .ndo_stop = hp100_close,
  385. .ndo_start_xmit = hp100_start_xmit,
  386. .ndo_get_stats = hp100_get_stats,
  387. .ndo_set_rx_mode = hp100_set_multicast_list,
  388. .ndo_change_mtu = eth_change_mtu,
  389. .ndo_set_mac_address = eth_mac_addr,
  390. .ndo_validate_addr = eth_validate_addr,
  391. };
  392. static int __devinit hp100_probe1(struct net_device *dev, int ioaddr,
  393. u_char bus, struct pci_dev *pci_dev)
  394. {
  395. int i;
  396. int err = -ENODEV;
  397. const char *eid;
  398. u_int chip;
  399. u_char uc;
  400. u_int memory_size = 0, virt_memory_size = 0;
  401. u_short local_mode, lsw;
  402. short mem_mapped;
  403. unsigned long mem_ptr_phys;
  404. void __iomem *mem_ptr_virt;
  405. struct hp100_private *lp;
  406. #ifdef HP100_DEBUG_B
  407. hp100_outw(0x4201, TRACE);
  408. printk("hp100: %s: probe1\n", dev->name);
  409. #endif
  410. /* memory region for programmed i/o */
  411. if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
  412. goto out1;
  413. if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE)
  414. goto out2;
  415. chip = hp100_inw(PAGING) & HP100_CHIPID_MASK;
  416. #ifdef HP100_DEBUG
  417. if (chip == HP100_CHIPID_SHASTA)
  418. printk("hp100: %s: Shasta Chip detected. (This is a pre 802.12 chip)\n", dev->name);
  419. else if (chip == HP100_CHIPID_RAINIER)
  420. printk("hp100: %s: Rainier Chip detected. (This is a pre 802.12 chip)\n", dev->name);
  421. else if (chip == HP100_CHIPID_LASSEN)
  422. printk("hp100: %s: Lassen Chip detected.\n", dev->name);
  423. else
  424. printk("hp100: %s: Warning: Unknown CASCADE chip (id=0x%.4x).\n", dev->name, chip);
  425. #endif
  426. dev->base_addr = ioaddr;
  427. eid = hp100_read_id(ioaddr);
  428. if (eid == NULL) { /* bad checksum? */
  429. printk(KERN_WARNING "hp100_probe: bad ID checksum at base port 0x%x\n", ioaddr);
  430. goto out2;
  431. }
  432. hp100_page(ID_MAC_ADDR);
  433. for (i = uc = 0; i < 7; i++)
  434. uc += hp100_inb(LAN_ADDR + i);
  435. if (uc != 0xff) {
  436. printk(KERN_WARNING "hp100_probe: bad lan address checksum at port 0x%x)\n", ioaddr);
  437. err = -EIO;
  438. goto out2;
  439. }
  440. /* Make sure, that all registers are correctly updated... */
  441. hp100_load_eeprom(dev, ioaddr);
  442. wait();
  443. /*
  444. * Determine driver operation mode
  445. *
  446. * Use the variable "hp100_mode" upon insmod or as kernel parameter to
  447. * force driver modes:
  448. * hp100_mode=1 -> default, use busmaster mode if configured.
  449. * hp100_mode=2 -> enable shared memory mode
  450. * hp100_mode=3 -> force use of i/o mapped mode.
  451. * hp100_mode=4 -> same as 1, but re-set the enable bit on the card.
  452. */
  453. /*
  454. * LSW values:
  455. * 0x2278 -> J2585B, PnP shared memory mode
  456. * 0x2270 -> J2585B, shared memory mode, 0xdc000
  457. * 0xa23c -> J2585B, I/O mapped mode
  458. * 0x2240 -> EISA COMPEX, BusMaster (Shasta Chip)
  459. * 0x2220 -> EISA HP, I/O (Shasta Chip)
  460. * 0x2260 -> EISA HP, BusMaster (Shasta Chip)
  461. */
  462. #if 0
  463. local_mode = 0x2270;
  464. hp100_outw(0xfefe, OPTION_LSW);
  465. hp100_outw(local_mode | HP100_SET_LB | HP100_SET_HB, OPTION_LSW);
  466. #endif
  467. /* hp100_mode value maybe used in future by another card */
  468. local_mode = hp100_mode;
  469. if (local_mode < 1 || local_mode > 4)
  470. local_mode = 1; /* default */
  471. #ifdef HP100_DEBUG
  472. printk("hp100: %s: original LSW = 0x%x\n", dev->name,
  473. hp100_inw(OPTION_LSW));
  474. #endif
  475. if (local_mode == 3) {
  476. hp100_outw(HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
  477. hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
  478. hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
  479. printk("hp100: IO mapped mode forced.\n");
  480. } else if (local_mode == 2) {
  481. hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
  482. hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
  483. hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
  484. printk("hp100: Shared memory mode requested.\n");
  485. } else if (local_mode == 4) {
  486. if (chip == HP100_CHIPID_LASSEN) {
  487. hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_SET_HB, OPTION_LSW);
  488. hp100_outw(HP100_IO_EN | HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
  489. printk("hp100: Busmaster mode requested.\n");
  490. }
  491. local_mode = 1;
  492. }
  493. if (local_mode == 1) { /* default behaviour */
  494. lsw = hp100_inw(OPTION_LSW);
  495. if ((lsw & HP100_IO_EN) && (~lsw & HP100_MEM_EN) &&
  496. (~lsw & (HP100_BM_WRITE | HP100_BM_READ))) {
  497. #ifdef HP100_DEBUG
  498. printk("hp100: %s: IO_EN bit is set on card.\n", dev->name);
  499. #endif
  500. local_mode = 3;
  501. } else if (chip == HP100_CHIPID_LASSEN &&
  502. (lsw & (HP100_BM_WRITE | HP100_BM_READ)) == (HP100_BM_WRITE | HP100_BM_READ)) {
  503. /* Conversion to new PCI API :
  504. * I don't have the doc, but I assume that the card
  505. * can map the full 32bit address space.
  506. * Also, we can have EISA Busmaster cards (not tested),
  507. * so beware !!! - Jean II */
  508. if((bus == HP100_BUS_PCI) &&
  509. (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)))) {
  510. /* Gracefully fallback to shared memory */
  511. goto busmasterfail;
  512. }
  513. printk("hp100: Busmaster mode enabled.\n");
  514. hp100_outw(HP100_MEM_EN | HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
  515. } else {
  516. busmasterfail:
  517. #ifdef HP100_DEBUG
  518. printk("hp100: %s: Card not configured for BM or BM not supported with this card.\n", dev->name);
  519. printk("hp100: %s: Trying shared memory mode.\n", dev->name);
  520. #endif
  521. /* In this case, try shared memory mode */
  522. local_mode = 2;
  523. hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
  524. /* hp100_outw(HP100_IO_EN|HP100_RESET_LB, OPTION_LSW); */
  525. }
  526. }
  527. #ifdef HP100_DEBUG
  528. printk("hp100: %s: new LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW));
  529. #endif
  530. /* Check for shared memory on the card, eventually remap it */
  531. hp100_page(HW_MAP);
  532. mem_mapped = ((hp100_inw(OPTION_LSW) & (HP100_MEM_EN)) != 0);
  533. mem_ptr_phys = 0UL;
  534. mem_ptr_virt = NULL;
  535. memory_size = (8192 << ((hp100_inb(SRAM) >> 5) & 0x07));
  536. virt_memory_size = 0;
  537. /* For memory mapped or busmaster mode, we want the memory address */
  538. if (mem_mapped || (local_mode == 1)) {
  539. mem_ptr_phys = (hp100_inw(MEM_MAP_LSW) | (hp100_inw(MEM_MAP_MSW) << 16));
  540. mem_ptr_phys &= ~0x1fff; /* 8k alignment */
  541. if (bus == HP100_BUS_ISA && (mem_ptr_phys & ~0xfffff) != 0) {
  542. printk("hp100: Can only use programmed i/o mode.\n");
  543. mem_ptr_phys = 0;
  544. mem_mapped = 0;
  545. local_mode = 3; /* Use programmed i/o */
  546. }
  547. /* We do not need access to shared memory in busmaster mode */
  548. /* However in slave mode we need to remap high (>1GB) card memory */
  549. if (local_mode != 1) { /* = not busmaster */
  550. /* We try with smaller memory sizes, if ioremap fails */
  551. for (virt_memory_size = memory_size; virt_memory_size > 16383; virt_memory_size >>= 1) {
  552. if ((mem_ptr_virt = ioremap((u_long) mem_ptr_phys, virt_memory_size)) == NULL) {
  553. #ifdef HP100_DEBUG
  554. printk("hp100: %s: ioremap for 0x%x bytes high PCI memory at 0x%lx failed\n", dev->name, virt_memory_size, mem_ptr_phys);
  555. #endif
  556. } else {
  557. #ifdef HP100_DEBUG
  558. printk("hp100: %s: remapped 0x%x bytes high PCI memory at 0x%lx to %p.\n", dev->name, virt_memory_size, mem_ptr_phys, mem_ptr_virt);
  559. #endif
  560. break;
  561. }
  562. }
  563. if (mem_ptr_virt == NULL) { /* all ioremap tries failed */
  564. printk("hp100: Failed to ioremap the PCI card memory. Will have to use i/o mapped mode.\n");
  565. local_mode = 3;
  566. virt_memory_size = 0;
  567. }
  568. }
  569. }
  570. if (local_mode == 3) { /* io mapped forced */
  571. mem_mapped = 0;
  572. mem_ptr_phys = 0;
  573. mem_ptr_virt = NULL;
  574. printk("hp100: Using (slow) programmed i/o mode.\n");
  575. }
  576. /* Initialise the "private" data structure for this card. */
  577. lp = netdev_priv(dev);
  578. spin_lock_init(&lp->lock);
  579. strlcpy(lp->id, eid, HP100_SIG_LEN);
  580. lp->chip = chip;
  581. lp->mode = local_mode;
  582. lp->bus = bus;
  583. lp->pci_dev = pci_dev;
  584. lp->priority_tx = hp100_priority_tx;
  585. lp->rx_ratio = hp100_rx_ratio;
  586. lp->mem_ptr_phys = mem_ptr_phys;
  587. lp->mem_ptr_virt = mem_ptr_virt;
  588. hp100_page(ID_MAC_ADDR);
  589. lp->soft_model = hp100_inb(SOFT_MODEL);
  590. lp->mac1_mode = HP100_MAC1MODE3;
  591. lp->mac2_mode = HP100_MAC2MODE3;
  592. memset(&lp->hash_bytes, 0x00, 8);
  593. dev->base_addr = ioaddr;
  594. lp->memory_size = memory_size;
  595. lp->virt_memory_size = virt_memory_size;
  596. lp->rx_ratio = hp100_rx_ratio; /* can be conf'd with insmod */
  597. if (lp->mode == 1) /* busmaster */
  598. dev->netdev_ops = &hp100_bm_netdev_ops;
  599. else
  600. dev->netdev_ops = &hp100_netdev_ops;
  601. /* Ask the card for which IRQ line it is configured */
  602. if (bus == HP100_BUS_PCI) {
  603. dev->irq = pci_dev->irq;
  604. } else {
  605. hp100_page(HW_MAP);
  606. dev->irq = hp100_inb(IRQ_CHANNEL) & HP100_IRQMASK;
  607. if (dev->irq == 2)
  608. dev->irq = 9;
  609. }
  610. if (lp->mode == 1) /* busmaster */
  611. dev->dma = 4;
  612. /* Ask the card for its MAC address and store it for later use. */
  613. hp100_page(ID_MAC_ADDR);
  614. for (i = uc = 0; i < 6; i++)
  615. dev->dev_addr[i] = hp100_inb(LAN_ADDR + i);
  616. /* Reset statistics (counters) */
  617. hp100_clear_stats(lp, ioaddr);
  618. /* If busmaster mode is wanted, a dma-capable memory area is needed for
  619. * the rx and tx PDLs
  620. * PCI cards can access the whole PC memory. Therefore GFP_DMA is not
  621. * needed for the allocation of the memory area.
  622. */
  623. /* TODO: We do not need this with old cards, where PDLs are stored
  624. * in the cards shared memory area. But currently, busmaster has been
  625. * implemented/tested only with the lassen chip anyway... */
  626. if (lp->mode == 1) { /* busmaster */
  627. dma_addr_t page_baddr;
  628. /* Get physically continuous memory for TX & RX PDLs */
  629. /* Conversion to new PCI API :
  630. * Pages are always aligned and zeroed, no need to it ourself.
  631. * Doc says should be OK for EISA bus as well - Jean II */
  632. lp->page_vaddr_algn = pci_alloc_consistent(lp->pci_dev, MAX_RINGSIZE, &page_baddr);
  633. if (!lp->page_vaddr_algn) {
  634. err = -ENOMEM;
  635. goto out_mem_ptr;
  636. }
  637. lp->whatever_offset = ((u_long) page_baddr) - ((u_long) lp->page_vaddr_algn);
  638. #ifdef HP100_DEBUG_BM
  639. printk("hp100: %s: Reserved DMA memory from 0x%x to 0x%x\n", dev->name, (u_int) lp->page_vaddr_algn, (u_int) lp->page_vaddr_algn + MAX_RINGSIZE);
  640. #endif
  641. lp->rxrcommit = lp->txrcommit = 0;
  642. lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
  643. lp->txrhead = lp->txrtail = &(lp->txring[0]);
  644. }
  645. /* Initialise the card. */
  646. /* (I'm not really sure if it's a good idea to do this during probing, but
  647. * like this it's assured that the lan connection type can be sensed
  648. * correctly)
  649. */
  650. hp100_hwinit(dev);
  651. /* Try to find out which kind of LAN the card is connected to. */
  652. lp->lan_type = hp100_sense_lan(dev);
  653. /* Print out a message what about what we think we have probed. */
  654. printk("hp100: at 0x%x, IRQ %d, ", ioaddr, dev->irq);
  655. switch (bus) {
  656. case HP100_BUS_EISA:
  657. printk("EISA");
  658. break;
  659. case HP100_BUS_PCI:
  660. printk("PCI");
  661. break;
  662. default:
  663. printk("ISA");
  664. break;
  665. }
  666. printk(" bus, %dk SRAM (rx/tx %d%%).\n", lp->memory_size >> 10, lp->rx_ratio);
  667. if (lp->mode == 2) { /* memory mapped */
  668. printk("hp100: Memory area at 0x%lx-0x%lx", mem_ptr_phys,
  669. (mem_ptr_phys + (mem_ptr_phys > 0x100000 ? (u_long) lp->memory_size : 16 * 1024)) - 1);
  670. if (mem_ptr_virt)
  671. printk(" (virtual base %p)", mem_ptr_virt);
  672. printk(".\n");
  673. /* Set for info when doing ifconfig */
  674. dev->mem_start = mem_ptr_phys;
  675. dev->mem_end = mem_ptr_phys + lp->memory_size;
  676. }
  677. printk("hp100: ");
  678. if (lp->lan_type != HP100_LAN_ERR)
  679. printk("Adapter is attached to ");
  680. switch (lp->lan_type) {
  681. case HP100_LAN_100:
  682. printk("100Mb/s Voice Grade AnyLAN network.\n");
  683. break;
  684. case HP100_LAN_10:
  685. printk("10Mb/s network (10baseT).\n");
  686. break;
  687. case HP100_LAN_COAX:
  688. printk("10Mb/s network (coax).\n");
  689. break;
  690. default:
  691. printk("Warning! Link down.\n");
  692. }
  693. err = register_netdev(dev);
  694. if (err)
  695. goto out3;
  696. return 0;
  697. out3:
  698. if (local_mode == 1)
  699. pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f,
  700. lp->page_vaddr_algn,
  701. virt_to_whatever(dev, lp->page_vaddr_algn));
  702. out_mem_ptr:
  703. if (mem_ptr_virt)
  704. iounmap(mem_ptr_virt);
  705. out2:
  706. release_region(ioaddr, HP100_REGION_SIZE);
  707. out1:
  708. return err;
  709. }
  710. /* This procedure puts the card into a stable init state */
  711. static void hp100_hwinit(struct net_device *dev)
  712. {
  713. int ioaddr = dev->base_addr;
  714. struct hp100_private *lp = netdev_priv(dev);
  715. #ifdef HP100_DEBUG_B
  716. hp100_outw(0x4202, TRACE);
  717. printk("hp100: %s: hwinit\n", dev->name);
  718. #endif
  719. /* Initialise the card. -------------------------------------------- */
  720. /* Clear all pending Ints and disable Ints */
  721. hp100_page(PERFORMANCE);
  722. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  723. hp100_outw(0xffff, IRQ_STATUS); /* clear all pending ints */
  724. hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
  725. hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
  726. if (lp->mode == 1) {
  727. hp100_BM_shutdown(dev); /* disables BM, puts cascade in reset */
  728. wait();
  729. } else {
  730. hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
  731. hp100_cascade_reset(dev, 1);
  732. hp100_page(MAC_CTRL);
  733. hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
  734. }
  735. /* Initiate EEPROM reload */
  736. hp100_load_eeprom(dev, 0);
  737. wait();
  738. /* Go into reset again. */
  739. hp100_cascade_reset(dev, 1);
  740. /* Set Option Registers to a safe state */
  741. hp100_outw(HP100_DEBUG_EN |
  742. HP100_RX_HDR |
  743. HP100_EE_EN |
  744. HP100_BM_WRITE |
  745. HP100_BM_READ | HP100_RESET_HB |
  746. HP100_FAKE_INT |
  747. HP100_INT_EN |
  748. HP100_MEM_EN |
  749. HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
  750. hp100_outw(HP100_TRI_INT |
  751. HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
  752. hp100_outb(HP100_PRIORITY_TX |
  753. HP100_ADV_NXT_PKT |
  754. HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
  755. /* TODO: Configure MMU for Ram Test. */
  756. /* TODO: Ram Test. */
  757. /* Re-check if adapter is still at same i/o location */
  758. /* (If the base i/o in eeprom has been changed but the */
  759. /* registers had not been changed, a reload of the eeprom */
  760. /* would move the adapter to the address stored in eeprom */
  761. /* TODO: Code to implement. */
  762. /* Until here it was code from HWdiscover procedure. */
  763. /* Next comes code from mmuinit procedure of SCO BM driver which is
  764. * called from HWconfigure in the SCO driver. */
  765. /* Initialise MMU, eventually switch on Busmaster Mode, initialise
  766. * multicast filter...
  767. */
  768. hp100_mmuinit(dev);
  769. /* We don't turn the interrupts on here - this is done by start_interface. */
  770. wait(); /* TODO: Do we really need this? */
  771. /* Enable Hardware (e.g. unreset) */
  772. hp100_cascade_reset(dev, 0);
  773. /* ------- initialisation complete ----------- */
  774. /* Finally try to log in the Hub if there may be a VG connection. */
  775. if ((lp->lan_type == HP100_LAN_100) || (lp->lan_type == HP100_LAN_ERR))
  776. hp100_login_to_vg_hub(dev, 0); /* relogin */
  777. }
  778. /*
  779. * mmuinit - Reinitialise Cascade MMU and MAC settings.
  780. * Note: Must already be in reset and leaves card in reset.
  781. */
  782. static void hp100_mmuinit(struct net_device *dev)
  783. {
  784. int ioaddr = dev->base_addr;
  785. struct hp100_private *lp = netdev_priv(dev);
  786. int i;
  787. #ifdef HP100_DEBUG_B
  788. hp100_outw(0x4203, TRACE);
  789. printk("hp100: %s: mmuinit\n", dev->name);
  790. #endif
  791. #ifdef HP100_DEBUG
  792. if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
  793. printk("hp100: %s: Not in reset when entering mmuinit. Fix me.\n", dev->name);
  794. return;
  795. }
  796. #endif
  797. /* Make sure IRQs are masked off and ack'ed. */
  798. hp100_page(PERFORMANCE);
  799. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  800. hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
  801. /*
  802. * Enable Hardware
  803. * - Clear Debug En, Rx Hdr Pipe, EE En, I/O En, Fake Int and Intr En
  804. * - Set Tri-State Int, Bus Master Rd/Wr, and Mem Map Disable
  805. * - Clear Priority, Advance Pkt and Xmit Cmd
  806. */
  807. hp100_outw(HP100_DEBUG_EN |
  808. HP100_RX_HDR |
  809. HP100_EE_EN | HP100_RESET_HB |
  810. HP100_IO_EN |
  811. HP100_FAKE_INT |
  812. HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
  813. hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
  814. if (lp->mode == 1) { /* busmaster */
  815. hp100_outw(HP100_BM_WRITE |
  816. HP100_BM_READ |
  817. HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
  818. } else if (lp->mode == 2) { /* memory mapped */
  819. hp100_outw(HP100_BM_WRITE |
  820. HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
  821. hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
  822. hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
  823. hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
  824. } else if (lp->mode == 3) { /* i/o mapped mode */
  825. hp100_outw(HP100_MMAP_DIS | HP100_SET_HB |
  826. HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
  827. }
  828. hp100_page(HW_MAP);
  829. hp100_outb(0, EARLYRXCFG);
  830. hp100_outw(0, EARLYTXCFG);
  831. /*
  832. * Enable Bus Master mode
  833. */
  834. if (lp->mode == 1) { /* busmaster */
  835. /* Experimental: Set some PCI configuration bits */
  836. hp100_page(HW_MAP);
  837. hp100_andb(~HP100_PDL_USE3, MODECTRL1); /* BM engine read maximum */
  838. hp100_andb(~HP100_TX_DUALQ, MODECTRL1); /* No Queue for Priority TX */
  839. /* PCI Bus failures should result in a Misc. Interrupt */
  840. hp100_orb(HP100_EN_BUS_FAIL, MODECTRL2);
  841. hp100_outw(HP100_BM_READ | HP100_BM_WRITE | HP100_SET_HB, OPTION_LSW);
  842. hp100_page(HW_MAP);
  843. /* Use Burst Mode and switch on PAGE_CK */
  844. hp100_orb(HP100_BM_BURST_RD | HP100_BM_BURST_WR, BM);
  845. if ((lp->chip == HP100_CHIPID_RAINIER) || (lp->chip == HP100_CHIPID_SHASTA))
  846. hp100_orb(HP100_BM_PAGE_CK, BM);
  847. hp100_orb(HP100_BM_MASTER, BM);
  848. } else { /* not busmaster */
  849. hp100_page(HW_MAP);
  850. hp100_andb(~HP100_BM_MASTER, BM);
  851. }
  852. /*
  853. * Divide card memory into regions for Rx, Tx and, if non-ETR chip, PDLs
  854. */
  855. hp100_page(MMU_CFG);
  856. if (lp->mode == 1) { /* only needed for Busmaster */
  857. int xmit_stop, recv_stop;
  858. if ((lp->chip == HP100_CHIPID_RAINIER) ||
  859. (lp->chip == HP100_CHIPID_SHASTA)) {
  860. int pdl_stop;
  861. /*
  862. * Each pdl is 508 bytes long. (63 frags * 4 bytes for address and
  863. * 4 bytes for header). We will leave NUM_RXPDLS * 508 (rounded
  864. * to the next higher 1k boundary) bytes for the rx-pdl's
  865. * Note: For non-etr chips the transmit stop register must be
  866. * programmed on a 1k boundary, i.e. bits 9:0 must be zero.
  867. */
  868. pdl_stop = lp->memory_size;
  869. xmit_stop = (pdl_stop - 508 * (MAX_RX_PDL) - 16) & ~(0x03ff);
  870. recv_stop = (xmit_stop * (lp->rx_ratio) / 100) & ~(0x03ff);
  871. hp100_outw((pdl_stop >> 4) - 1, PDL_MEM_STOP);
  872. #ifdef HP100_DEBUG_BM
  873. printk("hp100: %s: PDL_STOP = 0x%x\n", dev->name, pdl_stop);
  874. #endif
  875. } else {
  876. /* ETR chip (Lassen) in busmaster mode */
  877. xmit_stop = (lp->memory_size) - 1;
  878. recv_stop = ((lp->memory_size * lp->rx_ratio) / 100) & ~(0x03ff);
  879. }
  880. hp100_outw(xmit_stop >> 4, TX_MEM_STOP);
  881. hp100_outw(recv_stop >> 4, RX_MEM_STOP);
  882. #ifdef HP100_DEBUG_BM
  883. printk("hp100: %s: TX_STOP = 0x%x\n", dev->name, xmit_stop >> 4);
  884. printk("hp100: %s: RX_STOP = 0x%x\n", dev->name, recv_stop >> 4);
  885. #endif
  886. } else {
  887. /* Slave modes (memory mapped and programmed io) */
  888. hp100_outw((((lp->memory_size * lp->rx_ratio) / 100) >> 4), RX_MEM_STOP);
  889. hp100_outw(((lp->memory_size - 1) >> 4), TX_MEM_STOP);
  890. #ifdef HP100_DEBUG
  891. printk("hp100: %s: TX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(TX_MEM_STOP));
  892. printk("hp100: %s: RX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(RX_MEM_STOP));
  893. #endif
  894. }
  895. /* Write MAC address into page 1 */
  896. hp100_page(MAC_ADDRESS);
  897. for (i = 0; i < 6; i++)
  898. hp100_outb(dev->dev_addr[i], MAC_ADDR + i);
  899. /* Zero the multicast hash registers */
  900. for (i = 0; i < 8; i++)
  901. hp100_outb(0x0, HASH_BYTE0 + i);
  902. /* Set up MAC defaults */
  903. hp100_page(MAC_CTRL);
  904. /* Go to LAN Page and zero all filter bits */
  905. /* Zero accept error, accept multicast, accept broadcast and accept */
  906. /* all directed packet bits */
  907. hp100_andb(~(HP100_RX_EN |
  908. HP100_TX_EN |
  909. HP100_ACC_ERRORED |
  910. HP100_ACC_MC |
  911. HP100_ACC_BC | HP100_ACC_PHY), MAC_CFG_1);
  912. hp100_outb(0x00, MAC_CFG_2);
  913. /* Zero the frame format bit. This works around a training bug in the */
  914. /* new hubs. */
  915. hp100_outb(0x00, VG_LAN_CFG_2); /* (use 802.3) */
  916. if (lp->priority_tx)
  917. hp100_outb(HP100_PRIORITY_TX | HP100_SET_LB, OPTION_MSW);
  918. else
  919. hp100_outb(HP100_PRIORITY_TX | HP100_RESET_LB, OPTION_MSW);
  920. hp100_outb(HP100_ADV_NXT_PKT |
  921. HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
  922. /* If busmaster, initialize the PDLs */
  923. if (lp->mode == 1)
  924. hp100_init_pdls(dev);
  925. /* Go to performance page and initialize isr and imr registers */
  926. hp100_page(PERFORMANCE);
  927. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  928. hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
  929. }
  930. /*
  931. * open/close functions
  932. */
  933. static int hp100_open(struct net_device *dev)
  934. {
  935. struct hp100_private *lp = netdev_priv(dev);
  936. #ifdef HP100_DEBUG_B
  937. int ioaddr = dev->base_addr;
  938. #endif
  939. #ifdef HP100_DEBUG_B
  940. hp100_outw(0x4204, TRACE);
  941. printk("hp100: %s: open\n", dev->name);
  942. #endif
  943. /* New: if bus is PCI or EISA, interrupts might be shared interrupts */
  944. if (request_irq(dev->irq, hp100_interrupt,
  945. lp->bus == HP100_BUS_PCI || lp->bus ==
  946. HP100_BUS_EISA ? IRQF_SHARED : IRQF_DISABLED,
  947. "hp100", dev)) {
  948. printk("hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq);
  949. return -EAGAIN;
  950. }
  951. dev->trans_start = jiffies; /* prevent tx timeout */
  952. netif_start_queue(dev);
  953. lp->lan_type = hp100_sense_lan(dev);
  954. lp->mac1_mode = HP100_MAC1MODE3;
  955. lp->mac2_mode = HP100_MAC2MODE3;
  956. memset(&lp->hash_bytes, 0x00, 8);
  957. hp100_stop_interface(dev);
  958. hp100_hwinit(dev);
  959. hp100_start_interface(dev); /* sets mac modes, enables interrupts */
  960. return 0;
  961. }
  962. /* The close function is called when the interface is to be brought down */
  963. static int hp100_close(struct net_device *dev)
  964. {
  965. int ioaddr = dev->base_addr;
  966. struct hp100_private *lp = netdev_priv(dev);
  967. #ifdef HP100_DEBUG_B
  968. hp100_outw(0x4205, TRACE);
  969. printk("hp100: %s: close\n", dev->name);
  970. #endif
  971. hp100_page(PERFORMANCE);
  972. hp100_outw(0xfefe, IRQ_MASK); /* mask off all IRQs */
  973. hp100_stop_interface(dev);
  974. if (lp->lan_type == HP100_LAN_100)
  975. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  976. netif_stop_queue(dev);
  977. free_irq(dev->irq, dev);
  978. #ifdef HP100_DEBUG
  979. printk("hp100: %s: close LSW = 0x%x\n", dev->name,
  980. hp100_inw(OPTION_LSW));
  981. #endif
  982. return 0;
  983. }
  984. /*
  985. * Configure the PDL Rx rings and LAN
  986. */
  987. static void hp100_init_pdls(struct net_device *dev)
  988. {
  989. struct hp100_private *lp = netdev_priv(dev);
  990. hp100_ring_t *ringptr;
  991. u_int *pageptr; /* Warning : increment by 4 - Jean II */
  992. int i;
  993. #ifdef HP100_DEBUG_B
  994. int ioaddr = dev->base_addr;
  995. #endif
  996. #ifdef HP100_DEBUG_B
  997. hp100_outw(0x4206, TRACE);
  998. printk("hp100: %s: init pdls\n", dev->name);
  999. #endif
  1000. if (!lp->page_vaddr_algn)
  1001. printk("hp100: %s: Warning: lp->page_vaddr_algn not initialised!\n", dev->name);
  1002. else {
  1003. /* pageptr shall point into the DMA accessible memory region */
  1004. /* we use this pointer to status the upper limit of allocated */
  1005. /* memory in the allocated page. */
  1006. /* note: align the pointers to the pci cache line size */
  1007. memset(lp->page_vaddr_algn, 0, MAX_RINGSIZE); /* Zero Rx/Tx ring page */
  1008. pageptr = lp->page_vaddr_algn;
  1009. lp->rxrcommit = 0;
  1010. ringptr = lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
  1011. /* Initialise Rx Ring */
  1012. for (i = MAX_RX_PDL - 1; i >= 0; i--) {
  1013. lp->rxring[i].next = ringptr;
  1014. ringptr = &(lp->rxring[i]);
  1015. pageptr += hp100_init_rxpdl(dev, ringptr, pageptr);
  1016. }
  1017. /* Initialise Tx Ring */
  1018. lp->txrcommit = 0;
  1019. ringptr = lp->txrhead = lp->txrtail = &(lp->txring[0]);
  1020. for (i = MAX_TX_PDL - 1; i >= 0; i--) {
  1021. lp->txring[i].next = ringptr;
  1022. ringptr = &(lp->txring[i]);
  1023. pageptr += hp100_init_txpdl(dev, ringptr, pageptr);
  1024. }
  1025. }
  1026. }
  1027. /* These functions "format" the entries in the pdl structure */
  1028. /* They return how much memory the fragments need. */
  1029. static int hp100_init_rxpdl(struct net_device *dev,
  1030. register hp100_ring_t * ringptr,
  1031. register u32 * pdlptr)
  1032. {
  1033. /* pdlptr is starting address for this pdl */
  1034. if (0 != (((unsigned long) pdlptr) & 0xf))
  1035. printk("hp100: %s: Init rxpdl: Unaligned pdlptr 0x%lx.\n",
  1036. dev->name, (unsigned long) pdlptr);
  1037. ringptr->pdl = pdlptr + 1;
  1038. ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr + 1);
  1039. ringptr->skb = NULL;
  1040. /*
  1041. * Write address and length of first PDL Fragment (which is used for
  1042. * storing the RX-Header
  1043. * We use the 4 bytes _before_ the PDH in the pdl memory area to
  1044. * store this information. (PDH is at offset 0x04)
  1045. */
  1046. /* Note that pdlptr+1 and not pdlptr is the pointer to the PDH */
  1047. *(pdlptr + 2) = (u_int) virt_to_whatever(dev, pdlptr); /* Address Frag 1 */
  1048. *(pdlptr + 3) = 4; /* Length Frag 1 */
  1049. return roundup(MAX_RX_FRAG * 2 + 2, 4);
  1050. }
  1051. static int hp100_init_txpdl(struct net_device *dev,
  1052. register hp100_ring_t * ringptr,
  1053. register u32 * pdlptr)
  1054. {
  1055. if (0 != (((unsigned long) pdlptr) & 0xf))
  1056. printk("hp100: %s: Init txpdl: Unaligned pdlptr 0x%lx.\n", dev->name, (unsigned long) pdlptr);
  1057. ringptr->pdl = pdlptr; /* +1; */
  1058. ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr); /* +1 */
  1059. ringptr->skb = NULL;
  1060. return roundup(MAX_TX_FRAG * 2 + 2, 4);
  1061. }
  1062. /*
  1063. * hp100_build_rx_pdl allocates an skb_buff of maximum size plus two bytes
  1064. * for possible odd word alignment rounding up to next dword and set PDL
  1065. * address for fragment#2
  1066. * Returns: 0 if unable to allocate skb_buff
  1067. * 1 if successful
  1068. */
  1069. static int hp100_build_rx_pdl(hp100_ring_t * ringptr,
  1070. struct net_device *dev)
  1071. {
  1072. #ifdef HP100_DEBUG_B
  1073. int ioaddr = dev->base_addr;
  1074. #endif
  1075. #ifdef HP100_DEBUG_BM
  1076. u_int *p;
  1077. #endif
  1078. #ifdef HP100_DEBUG_B
  1079. hp100_outw(0x4207, TRACE);
  1080. printk("hp100: %s: build rx pdl\n", dev->name);
  1081. #endif
  1082. /* Allocate skb buffer of maximum size */
  1083. /* Note: This depends on the alloc_skb functions allocating more
  1084. * space than requested, i.e. aligning to 16bytes */
  1085. ringptr->skb = netdev_alloc_skb(dev, roundup(MAX_ETHER_SIZE + 2, 4));
  1086. if (NULL != ringptr->skb) {
  1087. /*
  1088. * Reserve 2 bytes at the head of the buffer to land the IP header
  1089. * on a long word boundary (According to the Network Driver section
  1090. * in the Linux KHG, this should help to increase performance.)
  1091. */
  1092. skb_reserve(ringptr->skb, 2);
  1093. ringptr->skb->data = (u_char *) skb_put(ringptr->skb, MAX_ETHER_SIZE);
  1094. /* ringptr->pdl points to the beginning of the PDL, i.e. the PDH */
  1095. /* Note: 1st Fragment is used for the 4 byte packet status
  1096. * (receive header). Its PDL entries are set up by init_rxpdl. So
  1097. * here we only have to set up the PDL fragment entries for the data
  1098. * part. Those 4 bytes will be stored in the DMA memory region
  1099. * directly before the PDL.
  1100. */
  1101. #ifdef HP100_DEBUG_BM
  1102. printk("hp100: %s: build_rx_pdl: PDH@0x%x, skb->data (len %d) at 0x%x\n",
  1103. dev->name, (u_int) ringptr->pdl,
  1104. roundup(MAX_ETHER_SIZE + 2, 4),
  1105. (unsigned int) ringptr->skb->data);
  1106. #endif
  1107. /* Conversion to new PCI API : map skbuf data to PCI bus.
  1108. * Doc says it's OK for EISA as well - Jean II */
  1109. ringptr->pdl[0] = 0x00020000; /* Write PDH */
  1110. ringptr->pdl[3] = pdl_map_data(netdev_priv(dev),
  1111. ringptr->skb->data);
  1112. ringptr->pdl[4] = MAX_ETHER_SIZE; /* Length of Data */
  1113. #ifdef HP100_DEBUG_BM
  1114. for (p = (ringptr->pdl); p < (ringptr->pdl + 5); p++)
  1115. printk("hp100: %s: Adr 0x%.8x = 0x%.8x\n", dev->name, (u_int) p, (u_int) * p);
  1116. #endif
  1117. return 1;
  1118. }
  1119. /* else: */
  1120. /* alloc_skb failed (no memory) -> still can receive the header
  1121. * fragment into PDL memory. make PDL safe by clearing msgptr and
  1122. * making the PDL only 1 fragment (i.e. the 4 byte packet status)
  1123. */
  1124. #ifdef HP100_DEBUG_BM
  1125. printk("hp100: %s: build_rx_pdl: PDH@0x%x, No space for skb.\n", dev->name, (u_int) ringptr->pdl);
  1126. #endif
  1127. ringptr->pdl[0] = 0x00010000; /* PDH: Count=1 Fragment */
  1128. return 0;
  1129. }
  1130. /*
  1131. * hp100_rxfill - attempt to fill the Rx Ring will empty skb's
  1132. *
  1133. * Makes assumption that skb's are always contiguous memory areas and
  1134. * therefore PDLs contain only 2 physical fragments.
  1135. * - While the number of Rx PDLs with buffers is less than maximum
  1136. * a. Get a maximum packet size skb
  1137. * b. Put the physical address of the buffer into the PDL.
  1138. * c. Output physical address of PDL to adapter.
  1139. */
  1140. static void hp100_rxfill(struct net_device *dev)
  1141. {
  1142. int ioaddr = dev->base_addr;
  1143. struct hp100_private *lp = netdev_priv(dev);
  1144. hp100_ring_t *ringptr;
  1145. #ifdef HP100_DEBUG_B
  1146. hp100_outw(0x4208, TRACE);
  1147. printk("hp100: %s: rxfill\n", dev->name);
  1148. #endif
  1149. hp100_page(PERFORMANCE);
  1150. while (lp->rxrcommit < MAX_RX_PDL) {
  1151. /*
  1152. ** Attempt to get a buffer and build a Rx PDL.
  1153. */
  1154. ringptr = lp->rxrtail;
  1155. if (0 == hp100_build_rx_pdl(ringptr, dev)) {
  1156. return; /* None available, return */
  1157. }
  1158. /* Hand this PDL over to the card */
  1159. /* Note: This needs performance page selected! */
  1160. #ifdef HP100_DEBUG_BM
  1161. printk("hp100: %s: rxfill: Hand to card: pdl #%d @0x%x phys:0x%x, buffer: 0x%x\n",
  1162. dev->name, lp->rxrcommit, (u_int) ringptr->pdl,
  1163. (u_int) ringptr->pdl_paddr, (u_int) ringptr->pdl[3]);
  1164. #endif
  1165. hp100_outl((u32) ringptr->pdl_paddr, RX_PDA);
  1166. lp->rxrcommit += 1;
  1167. lp->rxrtail = ringptr->next;
  1168. }
  1169. }
  1170. /*
  1171. * BM_shutdown - shutdown bus mastering and leave chip in reset state
  1172. */
  1173. static void hp100_BM_shutdown(struct net_device *dev)
  1174. {
  1175. int ioaddr = dev->base_addr;
  1176. struct hp100_private *lp = netdev_priv(dev);
  1177. unsigned long time;
  1178. #ifdef HP100_DEBUG_B
  1179. hp100_outw(0x4209, TRACE);
  1180. printk("hp100: %s: bm shutdown\n", dev->name);
  1181. #endif
  1182. hp100_page(PERFORMANCE);
  1183. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  1184. hp100_outw(0xffff, IRQ_STATUS); /* Ack all ints */
  1185. /* Ensure Interrupts are off */
  1186. hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
  1187. /* Disable all MAC activity */
  1188. hp100_page(MAC_CTRL);
  1189. hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); /* stop rx/tx */
  1190. /* If cascade MMU is not already in reset */
  1191. if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
  1192. /* Wait 1.3ms (10Mb max packet time) to ensure MAC is idle so
  1193. * MMU pointers will not be reset out from underneath
  1194. */
  1195. hp100_page(MAC_CTRL);
  1196. for (time = 0; time < 5000; time++) {
  1197. if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE))
  1198. break;
  1199. }
  1200. /* Shutdown algorithm depends on the generation of Cascade */
  1201. if (lp->chip == HP100_CHIPID_LASSEN) { /* ETR shutdown/reset */
  1202. /* Disable Busmaster mode and wait for bit to go to zero. */
  1203. hp100_page(HW_MAP);
  1204. hp100_andb(~HP100_BM_MASTER, BM);
  1205. /* 100 ms timeout */
  1206. for (time = 0; time < 32000; time++) {
  1207. if (0 == (hp100_inb(BM) & HP100_BM_MASTER))
  1208. break;
  1209. }
  1210. } else { /* Shasta or Rainier Shutdown/Reset */
  1211. /* To ensure all bus master inloading activity has ceased,
  1212. * wait for no Rx PDAs or no Rx packets on card.
  1213. */
  1214. hp100_page(PERFORMANCE);
  1215. /* 100 ms timeout */
  1216. for (time = 0; time < 10000; time++) {
  1217. /* RX_PDL: PDLs not executed. */
  1218. /* RX_PKT_CNT: RX'd packets on card. */
  1219. if ((hp100_inb(RX_PDL) == 0) && (hp100_inb(RX_PKT_CNT) == 0))
  1220. break;
  1221. }
  1222. if (time >= 10000)
  1223. printk("hp100: %s: BM shutdown error.\n", dev->name);
  1224. /* To ensure all bus master outloading activity has ceased,
  1225. * wait until the Tx PDA count goes to zero or no more Tx space
  1226. * available in the Tx region of the card.
  1227. */
  1228. /* 100 ms timeout */
  1229. for (time = 0; time < 10000; time++) {
  1230. if ((0 == hp100_inb(TX_PKT_CNT)) &&
  1231. (0 != (hp100_inb(TX_MEM_FREE) & HP100_AUTO_COMPARE)))
  1232. break;
  1233. }
  1234. /* Disable Busmaster mode */
  1235. hp100_page(HW_MAP);
  1236. hp100_andb(~HP100_BM_MASTER, BM);
  1237. } /* end of shutdown procedure for non-etr parts */
  1238. hp100_cascade_reset(dev, 1);
  1239. }
  1240. hp100_page(PERFORMANCE);
  1241. /* hp100_outw( HP100_BM_READ | HP100_BM_WRITE | HP100_RESET_HB, OPTION_LSW ); */
  1242. /* Busmaster mode should be shut down now. */
  1243. }
  1244. static int hp100_check_lan(struct net_device *dev)
  1245. {
  1246. struct hp100_private *lp = netdev_priv(dev);
  1247. if (lp->lan_type < 0) { /* no LAN type detected yet? */
  1248. hp100_stop_interface(dev);
  1249. if ((lp->lan_type = hp100_sense_lan(dev)) < 0) {
  1250. printk("hp100: %s: no connection found - check wire\n", dev->name);
  1251. hp100_start_interface(dev); /* 10Mb/s RX packets maybe handled */
  1252. return -EIO;
  1253. }
  1254. if (lp->lan_type == HP100_LAN_100)
  1255. lp->hub_status = hp100_login_to_vg_hub(dev, 0); /* relogin */
  1256. hp100_start_interface(dev);
  1257. }
  1258. return 0;
  1259. }
  1260. /*
  1261. * transmit functions
  1262. */
  1263. /* tx function for busmaster mode */
  1264. static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb,
  1265. struct net_device *dev)
  1266. {
  1267. unsigned long flags;
  1268. int i, ok_flag;
  1269. int ioaddr = dev->base_addr;
  1270. struct hp100_private *lp = netdev_priv(dev);
  1271. hp100_ring_t *ringptr;
  1272. #ifdef HP100_DEBUG_B
  1273. hp100_outw(0x4210, TRACE);
  1274. printk("hp100: %s: start_xmit_bm\n", dev->name);
  1275. #endif
  1276. if (skb->len <= 0)
  1277. goto drop;
  1278. if (lp->chip == HP100_CHIPID_SHASTA && skb_padto(skb, ETH_ZLEN))
  1279. return NETDEV_TX_OK;
  1280. /* Get Tx ring tail pointer */
  1281. if (lp->txrtail->next == lp->txrhead) {
  1282. /* No memory. */
  1283. #ifdef HP100_DEBUG
  1284. printk("hp100: %s: start_xmit_bm: No TX PDL available.\n", dev->name);
  1285. #endif
  1286. /* not waited long enough since last tx? */
  1287. if (time_before(jiffies, dev_trans_start(dev) + HZ))
  1288. goto drop;
  1289. if (hp100_check_lan(dev))
  1290. goto drop;
  1291. if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
  1292. /* we have a 100Mb/s adapter but it isn't connected to hub */
  1293. printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
  1294. hp100_stop_interface(dev);
  1295. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1296. hp100_start_interface(dev);
  1297. } else {
  1298. spin_lock_irqsave(&lp->lock, flags);
  1299. hp100_ints_off(); /* Useful ? Jean II */
  1300. i = hp100_sense_lan(dev);
  1301. hp100_ints_on();
  1302. spin_unlock_irqrestore(&lp->lock, flags);
  1303. if (i == HP100_LAN_ERR)
  1304. printk("hp100: %s: link down detected\n", dev->name);
  1305. else if (lp->lan_type != i) { /* cable change! */
  1306. /* it's very hard - all network settings must be changed!!! */
  1307. printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
  1308. lp->lan_type = i;
  1309. hp100_stop_interface(dev);
  1310. if (lp->lan_type == HP100_LAN_100)
  1311. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1312. hp100_start_interface(dev);
  1313. } else {
  1314. printk("hp100: %s: interface reset\n", dev->name);
  1315. hp100_stop_interface(dev);
  1316. if (lp->lan_type == HP100_LAN_100)
  1317. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1318. hp100_start_interface(dev);
  1319. }
  1320. }
  1321. goto drop;
  1322. }
  1323. /*
  1324. * we have to turn int's off before modifying this, otherwise
  1325. * a tx_pdl_cleanup could occur at the same time
  1326. */
  1327. spin_lock_irqsave(&lp->lock, flags);
  1328. ringptr = lp->txrtail;
  1329. lp->txrtail = ringptr->next;
  1330. /* Check whether packet has minimal packet size */
  1331. ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
  1332. i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
  1333. ringptr->skb = skb;
  1334. ringptr->pdl[0] = ((1 << 16) | i); /* PDH: 1 Fragment & length */
  1335. if (lp->chip == HP100_CHIPID_SHASTA) {
  1336. /* TODO:Could someone who has the EISA card please check if this works? */
  1337. ringptr->pdl[2] = i;
  1338. } else { /* Lassen */
  1339. /* In the PDL, don't use the padded size but the real packet size: */
  1340. ringptr->pdl[2] = skb->len; /* 1st Frag: Length of frag */
  1341. }
  1342. /* Conversion to new PCI API : map skbuf data to PCI bus.
  1343. * Doc says it's OK for EISA as well - Jean II */
  1344. ringptr->pdl[1] = ((u32) pci_map_single(lp->pci_dev, skb->data, ringptr->pdl[2], PCI_DMA_TODEVICE)); /* 1st Frag: Adr. of data */
  1345. /* Hand this PDL to the card. */
  1346. hp100_outl(ringptr->pdl_paddr, TX_PDA_L); /* Low Prio. Queue */
  1347. lp->txrcommit++;
  1348. dev->stats.tx_packets++;
  1349. dev->stats.tx_bytes += skb->len;
  1350. spin_unlock_irqrestore(&lp->lock, flags);
  1351. return NETDEV_TX_OK;
  1352. drop:
  1353. dev_kfree_skb(skb);
  1354. return NETDEV_TX_OK;
  1355. }
  1356. /* clean_txring checks if packets have been sent by the card by reading
  1357. * the TX_PDL register from the performance page and comparing it to the
  1358. * number of committed packets. It then frees the skb's of the packets that
  1359. * obviously have been sent to the network.
  1360. *
  1361. * Needs the PERFORMANCE page selected.
  1362. */
  1363. static void hp100_clean_txring(struct net_device *dev)
  1364. {
  1365. struct hp100_private *lp = netdev_priv(dev);
  1366. int ioaddr = dev->base_addr;
  1367. int donecount;
  1368. #ifdef HP100_DEBUG_B
  1369. hp100_outw(0x4211, TRACE);
  1370. printk("hp100: %s: clean txring\n", dev->name);
  1371. #endif
  1372. /* How many PDLs have been transmitted? */
  1373. donecount = (lp->txrcommit) - hp100_inb(TX_PDL);
  1374. #ifdef HP100_DEBUG
  1375. if (donecount > MAX_TX_PDL)
  1376. printk("hp100: %s: Warning: More PDLs transmitted than committed to card???\n", dev->name);
  1377. #endif
  1378. for (; 0 != donecount; donecount--) {
  1379. #ifdef HP100_DEBUG_BM
  1380. printk("hp100: %s: Free skb: data @0x%.8x txrcommit=0x%x TXPDL=0x%x, done=0x%x\n",
  1381. dev->name, (u_int) lp->txrhead->skb->data,
  1382. lp->txrcommit, hp100_inb(TX_PDL), donecount);
  1383. #endif
  1384. /* Conversion to new PCI API : NOP */
  1385. pci_unmap_single(lp->pci_dev, (dma_addr_t) lp->txrhead->pdl[1], lp->txrhead->pdl[2], PCI_DMA_TODEVICE);
  1386. dev_kfree_skb_any(lp->txrhead->skb);
  1387. lp->txrhead->skb = NULL;
  1388. lp->txrhead = lp->txrhead->next;
  1389. lp->txrcommit--;
  1390. }
  1391. }
  1392. /* tx function for slave modes */
  1393. static netdev_tx_t hp100_start_xmit(struct sk_buff *skb,
  1394. struct net_device *dev)
  1395. {
  1396. unsigned long flags;
  1397. int i, ok_flag;
  1398. int ioaddr = dev->base_addr;
  1399. u_short val;
  1400. struct hp100_private *lp = netdev_priv(dev);
  1401. #ifdef HP100_DEBUG_B
  1402. hp100_outw(0x4212, TRACE);
  1403. printk("hp100: %s: start_xmit\n", dev->name);
  1404. #endif
  1405. if (skb->len <= 0)
  1406. goto drop;
  1407. if (hp100_check_lan(dev))
  1408. goto drop;
  1409. /* If there is not enough free memory on the card... */
  1410. i = hp100_inl(TX_MEM_FREE) & 0x7fffffff;
  1411. if (!(((i / 2) - 539) > (skb->len + 16) && (hp100_inb(TX_PKT_CNT) < 255))) {
  1412. #ifdef HP100_DEBUG
  1413. printk("hp100: %s: start_xmit: tx free mem = 0x%x\n", dev->name, i);
  1414. #endif
  1415. /* not waited long enough since last failed tx try? */
  1416. if (time_before(jiffies, dev_trans_start(dev) + HZ)) {
  1417. #ifdef HP100_DEBUG
  1418. printk("hp100: %s: trans_start timing problem\n",
  1419. dev->name);
  1420. #endif
  1421. goto drop;
  1422. }
  1423. if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
  1424. /* we have a 100Mb/s adapter but it isn't connected to hub */
  1425. printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
  1426. hp100_stop_interface(dev);
  1427. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1428. hp100_start_interface(dev);
  1429. } else {
  1430. spin_lock_irqsave(&lp->lock, flags);
  1431. hp100_ints_off(); /* Useful ? Jean II */
  1432. i = hp100_sense_lan(dev);
  1433. hp100_ints_on();
  1434. spin_unlock_irqrestore(&lp->lock, flags);
  1435. if (i == HP100_LAN_ERR)
  1436. printk("hp100: %s: link down detected\n", dev->name);
  1437. else if (lp->lan_type != i) { /* cable change! */
  1438. /* it's very hard - all network setting must be changed!!! */
  1439. printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
  1440. lp->lan_type = i;
  1441. hp100_stop_interface(dev);
  1442. if (lp->lan_type == HP100_LAN_100)
  1443. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1444. hp100_start_interface(dev);
  1445. } else {
  1446. printk("hp100: %s: interface reset\n", dev->name);
  1447. hp100_stop_interface(dev);
  1448. if (lp->lan_type == HP100_LAN_100)
  1449. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1450. hp100_start_interface(dev);
  1451. mdelay(1);
  1452. }
  1453. }
  1454. goto drop;
  1455. }
  1456. for (i = 0; i < 6000 && (hp100_inb(OPTION_MSW) & HP100_TX_CMD); i++) {
  1457. #ifdef HP100_DEBUG_TX
  1458. printk("hp100: %s: start_xmit: busy\n", dev->name);
  1459. #endif
  1460. }
  1461. spin_lock_irqsave(&lp->lock, flags);
  1462. hp100_ints_off();
  1463. val = hp100_inw(IRQ_STATUS);
  1464. /* Ack / clear the interrupt TX_COMPLETE interrupt - this interrupt is set
  1465. * when the current packet being transmitted on the wire is completed. */
  1466. hp100_outw(HP100_TX_COMPLETE, IRQ_STATUS);
  1467. #ifdef HP100_DEBUG_TX
  1468. printk("hp100: %s: start_xmit: irq_status=0x%.4x, irqmask=0x%.4x, len=%d\n",
  1469. dev->name, val, hp100_inw(IRQ_MASK), (int) skb->len);
  1470. #endif
  1471. ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
  1472. i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
  1473. hp100_outw(i, DATA32); /* tell card the total packet length */
  1474. hp100_outw(i, FRAGMENT_LEN); /* and first/only fragment length */
  1475. if (lp->mode == 2) { /* memory mapped */
  1476. /* Note: The J2585B needs alignment to 32bits here! */
  1477. memcpy_toio(lp->mem_ptr_virt, skb->data, (skb->len + 3) & ~3);
  1478. if (!ok_flag)
  1479. memset_io(lp->mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb->len);
  1480. } else { /* programmed i/o */
  1481. outsl(ioaddr + HP100_REG_DATA32, skb->data,
  1482. (skb->len + 3) >> 2);
  1483. if (!ok_flag)
  1484. for (i = (skb->len + 3) & ~3; i < HP100_MIN_PACKET_SIZE; i += 4)
  1485. hp100_outl(0, DATA32);
  1486. }
  1487. hp100_outb(HP100_TX_CMD | HP100_SET_LB, OPTION_MSW); /* send packet */
  1488. dev->stats.tx_packets++;
  1489. dev->stats.tx_bytes += skb->len;
  1490. hp100_ints_on();
  1491. spin_unlock_irqrestore(&lp->lock, flags);
  1492. dev_kfree_skb_any(skb);
  1493. #ifdef HP100_DEBUG_TX
  1494. printk("hp100: %s: start_xmit: end\n", dev->name);
  1495. #endif
  1496. return NETDEV_TX_OK;
  1497. drop:
  1498. dev_kfree_skb(skb);
  1499. return NETDEV_TX_OK;
  1500. }
  1501. /*
  1502. * Receive Function (Non-Busmaster mode)
  1503. * Called when an "Receive Packet" interrupt occurs, i.e. the receive
  1504. * packet counter is non-zero.
  1505. * For non-busmaster, this function does the whole work of transferring
  1506. * the packet to the host memory and then up to higher layers via skb
  1507. * and netif_rx.
  1508. */
  1509. static void hp100_rx(struct net_device *dev)
  1510. {
  1511. int packets, pkt_len;
  1512. int ioaddr = dev->base_addr;
  1513. struct hp100_private *lp = netdev_priv(dev);
  1514. u_int header;
  1515. struct sk_buff *skb;
  1516. #ifdef DEBUG_B
  1517. hp100_outw(0x4213, TRACE);
  1518. printk("hp100: %s: rx\n", dev->name);
  1519. #endif
  1520. /* First get indication of received lan packet */
  1521. /* RX_PKT_CND indicates the number of packets which have been fully */
  1522. /* received onto the card but have not been fully transferred of the card */
  1523. packets = hp100_inb(RX_PKT_CNT);
  1524. #ifdef HP100_DEBUG_RX
  1525. if (packets > 1)
  1526. printk("hp100: %s: rx: waiting packets = %d\n", dev->name, packets);
  1527. #endif
  1528. while (packets-- > 0) {
  1529. /* If ADV_NXT_PKT is still set, we have to wait until the card has */
  1530. /* really advanced to the next packet. */
  1531. for (pkt_len = 0; pkt_len < 6000 && (hp100_inb(OPTION_MSW) & HP100_ADV_NXT_PKT); pkt_len++) {
  1532. #ifdef HP100_DEBUG_RX
  1533. printk ("hp100: %s: rx: busy, remaining packets = %d\n", dev->name, packets);
  1534. #endif
  1535. }
  1536. /* First we get the header, which contains information about the */
  1537. /* actual length of the received packet. */
  1538. if (lp->mode == 2) { /* memory mapped mode */
  1539. header = readl(lp->mem_ptr_virt);
  1540. } else /* programmed i/o */
  1541. header = hp100_inl(DATA32);
  1542. pkt_len = ((header & HP100_PKT_LEN_MASK) + 3) & ~3;
  1543. #ifdef HP100_DEBUG_RX
  1544. printk("hp100: %s: rx: new packet - length=%d, errors=0x%x, dest=0x%x\n",
  1545. dev->name, header & HP100_PKT_LEN_MASK,
  1546. (header >> 16) & 0xfff8, (header >> 16) & 7);
  1547. #endif
  1548. /* Now we allocate the skb and transfer the data into it. */
  1549. skb = netdev_alloc_skb(dev, pkt_len + 2);
  1550. if (skb == NULL) { /* Not enough memory->drop packet */
  1551. #ifdef HP100_DEBUG
  1552. printk("hp100: %s: rx: couldn't allocate a sk_buff of size %d\n",
  1553. dev->name, pkt_len);
  1554. #endif
  1555. dev->stats.rx_dropped++;
  1556. } else { /* skb successfully allocated */
  1557. u_char *ptr;
  1558. skb_reserve(skb,2);
  1559. /* ptr to start of the sk_buff data area */
  1560. skb_put(skb, pkt_len);
  1561. ptr = skb->data;
  1562. /* Now transfer the data from the card into that area */
  1563. if (lp->mode == 2)
  1564. memcpy_fromio(ptr, lp->mem_ptr_virt,pkt_len);
  1565. else /* io mapped */
  1566. insl(ioaddr + HP100_REG_DATA32, ptr, pkt_len >> 2);
  1567. skb->protocol = eth_type_trans(skb, dev);
  1568. #ifdef HP100_DEBUG_RX
  1569. printk("hp100: %s: rx: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
  1570. dev->name, ptr[0], ptr[1], ptr[2], ptr[3],
  1571. ptr[4], ptr[5], ptr[6], ptr[7], ptr[8],
  1572. ptr[9], ptr[10], ptr[11]);
  1573. #endif
  1574. netif_rx(skb);
  1575. dev->stats.rx_packets++;
  1576. dev->stats.rx_bytes += pkt_len;
  1577. }
  1578. /* Indicate the card that we have got the packet */
  1579. hp100_outb(HP100_ADV_NXT_PKT | HP100_SET_LB, OPTION_MSW);
  1580. switch (header & 0x00070000) {
  1581. case (HP100_MULTI_ADDR_HASH << 16):
  1582. case (HP100_MULTI_ADDR_NO_HASH << 16):
  1583. dev->stats.multicast++;
  1584. break;
  1585. }
  1586. } /* end of while(there are packets) loop */
  1587. #ifdef HP100_DEBUG_RX
  1588. printk("hp100_rx: %s: end\n", dev->name);
  1589. #endif
  1590. }
  1591. /*
  1592. * Receive Function for Busmaster Mode
  1593. */
  1594. static void hp100_rx_bm(struct net_device *dev)
  1595. {
  1596. int ioaddr = dev->base_addr;
  1597. struct hp100_private *lp = netdev_priv(dev);
  1598. hp100_ring_t *ptr;
  1599. u_int header;
  1600. int pkt_len;
  1601. #ifdef HP100_DEBUG_B
  1602. hp100_outw(0x4214, TRACE);
  1603. printk("hp100: %s: rx_bm\n", dev->name);
  1604. #endif
  1605. #ifdef HP100_DEBUG
  1606. if (0 == lp->rxrcommit) {
  1607. printk("hp100: %s: rx_bm called although no PDLs were committed to adapter?\n", dev->name);
  1608. return;
  1609. } else
  1610. /* RX_PKT_CNT states how many PDLs are currently formatted and available to
  1611. * the cards BM engine */
  1612. if ((hp100_inw(RX_PKT_CNT) & 0x00ff) >= lp->rxrcommit) {
  1613. printk("hp100: %s: More packets received than committed? RX_PKT_CNT=0x%x, commit=0x%x\n",
  1614. dev->name, hp100_inw(RX_PKT_CNT) & 0x00ff,
  1615. lp->rxrcommit);
  1616. return;
  1617. }
  1618. #endif
  1619. while ((lp->rxrcommit > hp100_inb(RX_PDL))) {
  1620. /*
  1621. * The packet was received into the pdl pointed to by lp->rxrhead (
  1622. * the oldest pdl in the ring
  1623. */
  1624. /* First we get the header, which contains information about the */
  1625. /* actual length of the received packet. */
  1626. ptr = lp->rxrhead;
  1627. header = *(ptr->pdl - 1);
  1628. pkt_len = (header & HP100_PKT_LEN_MASK);
  1629. /* Conversion to new PCI API : NOP */
  1630. pci_unmap_single(lp->pci_dev, (dma_addr_t) ptr->pdl[3], MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
  1631. #ifdef HP100_DEBUG_BM
  1632. printk("hp100: %s: rx_bm: header@0x%x=0x%x length=%d, errors=0x%x, dest=0x%x\n",
  1633. dev->name, (u_int) (ptr->pdl - 1), (u_int) header,
  1634. pkt_len, (header >> 16) & 0xfff8, (header >> 16) & 7);
  1635. printk("hp100: %s: RX_PDL_COUNT:0x%x TX_PDL_COUNT:0x%x, RX_PKT_CNT=0x%x PDH=0x%x, Data@0x%x len=0x%x\n",
  1636. dev->name, hp100_inb(RX_PDL), hp100_inb(TX_PDL),
  1637. hp100_inb(RX_PKT_CNT), (u_int) * (ptr->pdl),
  1638. (u_int) * (ptr->pdl + 3), (u_int) * (ptr->pdl + 4));
  1639. #endif
  1640. if ((pkt_len >= MIN_ETHER_SIZE) &&
  1641. (pkt_len <= MAX_ETHER_SIZE)) {
  1642. if (ptr->skb == NULL) {
  1643. printk("hp100: %s: rx_bm: skb null\n", dev->name);
  1644. /* can happen if we only allocated room for the pdh due to memory shortage. */
  1645. dev->stats.rx_dropped++;
  1646. } else {
  1647. skb_trim(ptr->skb, pkt_len); /* Shorten it */
  1648. ptr->skb->protocol =
  1649. eth_type_trans(ptr->skb, dev);
  1650. netif_rx(ptr->skb); /* Up and away... */
  1651. dev->stats.rx_packets++;
  1652. dev->stats.rx_bytes += pkt_len;
  1653. }
  1654. switch (header & 0x00070000) {
  1655. case (HP100_MULTI_ADDR_HASH << 16):
  1656. case (HP100_MULTI_ADDR_NO_HASH << 16):
  1657. dev->stats.multicast++;
  1658. break;
  1659. }
  1660. } else {
  1661. #ifdef HP100_DEBUG
  1662. printk("hp100: %s: rx_bm: Received bad packet (length=%d)\n", dev->name, pkt_len);
  1663. #endif
  1664. if (ptr->skb != NULL)
  1665. dev_kfree_skb_any(ptr->skb);
  1666. dev->stats.rx_errors++;
  1667. }
  1668. lp->rxrhead = lp->rxrhead->next;
  1669. /* Allocate a new rx PDL (so lp->rxrcommit stays the same) */
  1670. if (0 == hp100_build_rx_pdl(lp->rxrtail, dev)) {
  1671. /* No space for skb, header can still be received. */
  1672. #ifdef HP100_DEBUG
  1673. printk("hp100: %s: rx_bm: No space for new PDL.\n", dev->name);
  1674. #endif
  1675. return;
  1676. } else { /* successfully allocated new PDL - put it in ringlist at tail. */
  1677. hp100_outl((u32) lp->rxrtail->pdl_paddr, RX_PDA);
  1678. lp->rxrtail = lp->rxrtail->next;
  1679. }
  1680. }
  1681. }
  1682. /*
  1683. * statistics
  1684. */
  1685. static struct net_device_stats *hp100_get_stats(struct net_device *dev)
  1686. {
  1687. unsigned long flags;
  1688. int ioaddr = dev->base_addr;
  1689. struct hp100_private *lp = netdev_priv(dev);
  1690. #ifdef HP100_DEBUG_B
  1691. hp100_outw(0x4215, TRACE);
  1692. #endif
  1693. spin_lock_irqsave(&lp->lock, flags);
  1694. hp100_ints_off(); /* Useful ? Jean II */
  1695. hp100_update_stats(dev);
  1696. hp100_ints_on();
  1697. spin_unlock_irqrestore(&lp->lock, flags);
  1698. return &(dev->stats);
  1699. }
  1700. static void hp100_update_stats(struct net_device *dev)
  1701. {
  1702. int ioaddr = dev->base_addr;
  1703. u_short val;
  1704. #ifdef HP100_DEBUG_B
  1705. hp100_outw(0x4216, TRACE);
  1706. printk("hp100: %s: update-stats\n", dev->name);
  1707. #endif
  1708. /* Note: Statistics counters clear when read. */
  1709. hp100_page(MAC_CTRL);
  1710. val = hp100_inw(DROPPED) & 0x0fff;
  1711. dev->stats.rx_errors += val;
  1712. dev->stats.rx_over_errors += val;
  1713. val = hp100_inb(CRC);
  1714. dev->stats.rx_errors += val;
  1715. dev->stats.rx_crc_errors += val;
  1716. val = hp100_inb(ABORT);
  1717. dev->stats.tx_errors += val;
  1718. dev->stats.tx_aborted_errors += val;
  1719. hp100_page(PERFORMANCE);
  1720. }
  1721. static void hp100_misc_interrupt(struct net_device *dev)
  1722. {
  1723. #ifdef HP100_DEBUG_B
  1724. int ioaddr = dev->base_addr;
  1725. #endif
  1726. #ifdef HP100_DEBUG_B
  1727. int ioaddr = dev->base_addr;
  1728. hp100_outw(0x4216, TRACE);
  1729. printk("hp100: %s: misc_interrupt\n", dev->name);
  1730. #endif
  1731. /* Note: Statistics counters clear when read. */
  1732. dev->stats.rx_errors++;
  1733. dev->stats.tx_errors++;
  1734. }
  1735. static void hp100_clear_stats(struct hp100_private *lp, int ioaddr)
  1736. {
  1737. unsigned long flags;
  1738. #ifdef HP100_DEBUG_B
  1739. hp100_outw(0x4217, TRACE);
  1740. printk("hp100: %s: clear_stats\n", dev->name);
  1741. #endif
  1742. spin_lock_irqsave(&lp->lock, flags);
  1743. hp100_page(MAC_CTRL); /* get all statistics bytes */
  1744. hp100_inw(DROPPED);
  1745. hp100_inb(CRC);
  1746. hp100_inb(ABORT);
  1747. hp100_page(PERFORMANCE);
  1748. spin_unlock_irqrestore(&lp->lock, flags);
  1749. }
  1750. /*
  1751. * multicast setup
  1752. */
  1753. /*
  1754. * Set or clear the multicast filter for this adapter.
  1755. */
  1756. static void hp100_set_multicast_list(struct net_device *dev)
  1757. {
  1758. unsigned long flags;
  1759. int ioaddr = dev->base_addr;
  1760. struct hp100_private *lp = netdev_priv(dev);
  1761. #ifdef HP100_DEBUG_B
  1762. hp100_outw(0x4218, TRACE);
  1763. printk("hp100: %s: set_mc_list\n", dev->name);
  1764. #endif
  1765. spin_lock_irqsave(&lp->lock, flags);
  1766. hp100_ints_off();
  1767. hp100_page(MAC_CTRL);
  1768. hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); /* stop rx/tx */
  1769. if (dev->flags & IFF_PROMISC) {
  1770. lp->mac2_mode = HP100_MAC2MODE6; /* promiscuous mode = get all good */
  1771. lp->mac1_mode = HP100_MAC1MODE6; /* packets on the net */
  1772. memset(&lp->hash_bytes, 0xff, 8);
  1773. } else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI)) {
  1774. lp->mac2_mode = HP100_MAC2MODE5; /* multicast mode = get packets for */
  1775. lp->mac1_mode = HP100_MAC1MODE5; /* me, broadcasts and all multicasts */
  1776. #ifdef HP100_MULTICAST_FILTER /* doesn't work!!! */
  1777. if (dev->flags & IFF_ALLMULTI) {
  1778. /* set hash filter to receive all multicast packets */
  1779. memset(&lp->hash_bytes, 0xff, 8);
  1780. } else {
  1781. int i, idx;
  1782. u_char *addrs;
  1783. struct netdev_hw_addr *ha;
  1784. memset(&lp->hash_bytes, 0x00, 8);
  1785. #ifdef HP100_DEBUG
  1786. printk("hp100: %s: computing hash filter - mc_count = %i\n",
  1787. dev->name, netdev_mc_count(dev));
  1788. #endif
  1789. netdev_for_each_mc_addr(ha, dev) {
  1790. addrs = ha->addr;
  1791. #ifdef HP100_DEBUG
  1792. printk("hp100: %s: multicast = %pM, ",
  1793. dev->name, addrs);
  1794. #endif
  1795. for (i = idx = 0; i < 6; i++) {
  1796. idx ^= *addrs++ & 0x3f;
  1797. printk(":%02x:", idx);
  1798. }
  1799. #ifdef HP100_DEBUG
  1800. printk("idx = %i\n", idx);
  1801. #endif
  1802. lp->hash_bytes[idx >> 3] |= (1 << (idx & 7));
  1803. }
  1804. }
  1805. #else
  1806. memset(&lp->hash_bytes, 0xff, 8);
  1807. #endif
  1808. } else {
  1809. lp->mac2_mode = HP100_MAC2MODE3; /* normal mode = get packets for me */
  1810. lp->mac1_mode = HP100_MAC1MODE3; /* and broadcasts */
  1811. memset(&lp->hash_bytes, 0x00, 8);
  1812. }
  1813. if (((hp100_inb(MAC_CFG_1) & 0x0f) != lp->mac1_mode) ||
  1814. (hp100_inb(MAC_CFG_2) != lp->mac2_mode)) {
  1815. int i;
  1816. hp100_outb(lp->mac2_mode, MAC_CFG_2);
  1817. hp100_andb(HP100_MAC1MODEMASK, MAC_CFG_1); /* clear mac1 mode bits */
  1818. hp100_orb(lp->mac1_mode, MAC_CFG_1); /* and set the new mode */
  1819. hp100_page(MAC_ADDRESS);
  1820. for (i = 0; i < 8; i++)
  1821. hp100_outb(lp->hash_bytes[i], HASH_BYTE0 + i);
  1822. #ifdef HP100_DEBUG
  1823. printk("hp100: %s: mac1 = 0x%x, mac2 = 0x%x, multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
  1824. dev->name, lp->mac1_mode, lp->mac2_mode,
  1825. lp->hash_bytes[0], lp->hash_bytes[1],
  1826. lp->hash_bytes[2], lp->hash_bytes[3],
  1827. lp->hash_bytes[4], lp->hash_bytes[5],
  1828. lp->hash_bytes[6], lp->hash_bytes[7]);
  1829. #endif
  1830. if (lp->lan_type == HP100_LAN_100) {
  1831. #ifdef HP100_DEBUG
  1832. printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
  1833. #endif
  1834. lp->hub_status = hp100_login_to_vg_hub(dev, 1); /* force a relogin to the hub */
  1835. }
  1836. } else {
  1837. int i;
  1838. u_char old_hash_bytes[8];
  1839. hp100_page(MAC_ADDRESS);
  1840. for (i = 0; i < 8; i++)
  1841. old_hash_bytes[i] = hp100_inb(HASH_BYTE0 + i);
  1842. if (memcmp(old_hash_bytes, &lp->hash_bytes, 8)) {
  1843. for (i = 0; i < 8; i++)
  1844. hp100_outb(lp->hash_bytes[i], HASH_BYTE0 + i);
  1845. #ifdef HP100_DEBUG
  1846. printk("hp100: %s: multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
  1847. dev->name, lp->hash_bytes[0],
  1848. lp->hash_bytes[1], lp->hash_bytes[2],
  1849. lp->hash_bytes[3], lp->hash_bytes[4],
  1850. lp->hash_bytes[5], lp->hash_bytes[6],
  1851. lp->hash_bytes[7]);
  1852. #endif
  1853. if (lp->lan_type == HP100_LAN_100) {
  1854. #ifdef HP100_DEBUG
  1855. printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
  1856. #endif
  1857. lp->hub_status = hp100_login_to_vg_hub(dev, 1); /* force a relogin to the hub */
  1858. }
  1859. }
  1860. }
  1861. hp100_page(MAC_CTRL);
  1862. hp100_orb(HP100_RX_EN | HP100_RX_IDLE | /* enable rx */
  1863. HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1); /* enable tx */
  1864. hp100_page(PERFORMANCE);
  1865. hp100_ints_on();
  1866. spin_unlock_irqrestore(&lp->lock, flags);
  1867. }
  1868. /*
  1869. * hardware interrupt handling
  1870. */
  1871. static irqreturn_t hp100_interrupt(int irq, void *dev_id)
  1872. {
  1873. struct net_device *dev = (struct net_device *) dev_id;
  1874. struct hp100_private *lp = netdev_priv(dev);
  1875. int ioaddr;
  1876. u_int val;
  1877. if (dev == NULL)
  1878. return IRQ_NONE;
  1879. ioaddr = dev->base_addr;
  1880. spin_lock(&lp->lock);
  1881. hp100_ints_off();
  1882. #ifdef HP100_DEBUG_B
  1883. hp100_outw(0x4219, TRACE);
  1884. #endif
  1885. /* hp100_page( PERFORMANCE ); */
  1886. val = hp100_inw(IRQ_STATUS);
  1887. #ifdef HP100_DEBUG_IRQ
  1888. printk("hp100: %s: mode=%x,IRQ_STAT=0x%.4x,RXPKTCNT=0x%.2x RXPDL=0x%.2x TXPKTCNT=0x%.2x TXPDL=0x%.2x\n",
  1889. dev->name, lp->mode, (u_int) val, hp100_inb(RX_PKT_CNT),
  1890. hp100_inb(RX_PDL), hp100_inb(TX_PKT_CNT), hp100_inb(TX_PDL));
  1891. #endif
  1892. if (val == 0) { /* might be a shared interrupt */
  1893. spin_unlock(&lp->lock);
  1894. hp100_ints_on();
  1895. return IRQ_NONE;
  1896. }
  1897. /* We're only interested in those interrupts we really enabled. */
  1898. /* val &= hp100_inw( IRQ_MASK ); */
  1899. /*
  1900. * RX_PDL_FILL_COMPL is set whenever a RX_PDL has been executed. A RX_PDL
  1901. * is considered executed whenever the RX_PDL data structure is no longer
  1902. * needed.
  1903. */
  1904. if (val & HP100_RX_PDL_FILL_COMPL) {
  1905. if (lp->mode == 1)
  1906. hp100_rx_bm(dev);
  1907. else {
  1908. printk("hp100: %s: rx_pdl_fill_compl interrupt although not busmaster?\n", dev->name);
  1909. }
  1910. }
  1911. /*
  1912. * The RX_PACKET interrupt is set, when the receive packet counter is
  1913. * non zero. We use this interrupt for receiving in slave mode. In
  1914. * busmaster mode, we use it to make sure we did not miss any rx_pdl_fill
  1915. * interrupts. If rx_pdl_fill_compl is not set and rx_packet is set, then
  1916. * we somehow have missed a rx_pdl_fill_compl interrupt.
  1917. */
  1918. if (val & HP100_RX_PACKET) { /* Receive Packet Counter is non zero */
  1919. if (lp->mode != 1) /* non busmaster */
  1920. hp100_rx(dev);
  1921. else if (!(val & HP100_RX_PDL_FILL_COMPL)) {
  1922. /* Shouldn't happen - maybe we missed a RX_PDL_FILL Interrupt? */
  1923. hp100_rx_bm(dev);
  1924. }
  1925. }
  1926. /*
  1927. * Ack. that we have noticed the interrupt and thereby allow next one.
  1928. * Note that this is now done after the slave rx function, since first
  1929. * acknowledging and then setting ADV_NXT_PKT caused an extra interrupt
  1930. * on the J2573.
  1931. */
  1932. hp100_outw(val, IRQ_STATUS);
  1933. /*
  1934. * RX_ERROR is set when a packet is dropped due to no memory resources on
  1935. * the card or when a RCV_ERR occurs.
  1936. * TX_ERROR is set when a TX_ABORT condition occurs in the MAC->exists
  1937. * only in the 802.3 MAC and happens when 16 collisions occur during a TX
  1938. */
  1939. if (val & (HP100_TX_ERROR | HP100_RX_ERROR)) {
  1940. #ifdef HP100_DEBUG_IRQ
  1941. printk("hp100: %s: TX/RX Error IRQ\n", dev->name);
  1942. #endif
  1943. hp100_update_stats(dev);
  1944. if (lp->mode == 1) {
  1945. hp100_rxfill(dev);
  1946. hp100_clean_txring(dev);
  1947. }
  1948. }
  1949. /*
  1950. * RX_PDA_ZERO is set when the PDA count goes from non-zero to zero.
  1951. */
  1952. if ((lp->mode == 1) && (val & (HP100_RX_PDA_ZERO)))
  1953. hp100_rxfill(dev);
  1954. /*
  1955. * HP100_TX_COMPLETE interrupt occurs when packet transmitted on wire
  1956. * is completed
  1957. */
  1958. if ((lp->mode == 1) && (val & (HP100_TX_COMPLETE)))
  1959. hp100_clean_txring(dev);
  1960. /*
  1961. * MISC_ERROR is set when either the LAN link goes down or a detected
  1962. * bus error occurs.
  1963. */
  1964. if (val & HP100_MISC_ERROR) { /* New for J2585B */
  1965. #ifdef HP100_DEBUG_IRQ
  1966. printk
  1967. ("hp100: %s: Misc. Error Interrupt - Check cabling.\n",
  1968. dev->name);
  1969. #endif
  1970. if (lp->mode == 1) {
  1971. hp100_clean_txring(dev);
  1972. hp100_rxfill(dev);
  1973. }
  1974. hp100_misc_interrupt(dev);
  1975. }
  1976. spin_unlock(&lp->lock);
  1977. hp100_ints_on();
  1978. return IRQ_HANDLED;
  1979. }
  1980. /*
  1981. * some misc functions
  1982. */
  1983. static void hp100_start_interface(struct net_device *dev)
  1984. {
  1985. unsigned long flags;
  1986. int ioaddr = dev->base_addr;
  1987. struct hp100_private *lp = netdev_priv(dev);
  1988. #ifdef HP100_DEBUG_B
  1989. hp100_outw(0x4220, TRACE);
  1990. printk("hp100: %s: hp100_start_interface\n", dev->name);
  1991. #endif
  1992. spin_lock_irqsave(&lp->lock, flags);
  1993. /* Ensure the adapter does not want to request an interrupt when */
  1994. /* enabling the IRQ line to be active on the bus (i.e. not tri-stated) */
  1995. hp100_page(PERFORMANCE);
  1996. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  1997. hp100_outw(0xffff, IRQ_STATUS); /* ack all IRQs */
  1998. hp100_outw(HP100_FAKE_INT | HP100_INT_EN | HP100_RESET_LB,
  1999. OPTION_LSW);
  2000. /* Un Tri-state int. TODO: Check if shared interrupts can be realised? */
  2001. hp100_outw(HP100_TRI_INT | HP100_RESET_HB, OPTION_LSW);
  2002. if (lp->mode == 1) {
  2003. /* Make sure BM bit is set... */
  2004. hp100_page(HW_MAP);
  2005. hp100_orb(HP100_BM_MASTER, BM);
  2006. hp100_rxfill(dev);
  2007. } else if (lp->mode == 2) {
  2008. /* Enable memory mapping. Note: Don't do this when busmaster. */
  2009. hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
  2010. }
  2011. hp100_page(PERFORMANCE);
  2012. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  2013. hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
  2014. /* enable a few interrupts: */
  2015. if (lp->mode == 1) { /* busmaster mode */
  2016. hp100_outw(HP100_RX_PDL_FILL_COMPL |
  2017. HP100_RX_PDA_ZERO | HP100_RX_ERROR |
  2018. /* HP100_RX_PACKET | */
  2019. /* HP100_RX_EARLY_INT | */ HP100_SET_HB |
  2020. /* HP100_TX_PDA_ZERO | */
  2021. HP100_TX_COMPLETE |
  2022. /* HP100_MISC_ERROR | */
  2023. HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK);
  2024. } else {
  2025. hp100_outw(HP100_RX_PACKET |
  2026. HP100_RX_ERROR | HP100_SET_HB |
  2027. HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK);
  2028. }
  2029. /* Note : before hp100_set_multicast_list(), because it will play with
  2030. * spinlock itself... Jean II */
  2031. spin_unlock_irqrestore(&lp->lock, flags);
  2032. /* Enable MAC Tx and RX, set MAC modes, ... */
  2033. hp100_set_multicast_list(dev);
  2034. }
  2035. static void hp100_stop_interface(struct net_device *dev)
  2036. {
  2037. struct hp100_private *lp = netdev_priv(dev);
  2038. int ioaddr = dev->base_addr;
  2039. u_int val;
  2040. #ifdef HP100_DEBUG_B
  2041. printk("hp100: %s: hp100_stop_interface\n", dev->name);
  2042. hp100_outw(0x4221, TRACE);
  2043. #endif
  2044. if (lp->mode == 1)
  2045. hp100_BM_shutdown(dev);
  2046. else {
  2047. /* Note: MMAP_DIS will be reenabled by start_interface */
  2048. hp100_outw(HP100_INT_EN | HP100_RESET_LB |
  2049. HP100_TRI_INT | HP100_MMAP_DIS | HP100_SET_HB,
  2050. OPTION_LSW);
  2051. val = hp100_inw(OPTION_LSW);
  2052. hp100_page(MAC_CTRL);
  2053. hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
  2054. if (!(val & HP100_HW_RST))
  2055. return; /* If reset, imm. return ... */
  2056. /* ... else: busy wait until idle */
  2057. for (val = 0; val < 6000; val++)
  2058. if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE)) {
  2059. hp100_page(PERFORMANCE);
  2060. return;
  2061. }
  2062. printk("hp100: %s: hp100_stop_interface - timeout\n", dev->name);
  2063. hp100_page(PERFORMANCE);
  2064. }
  2065. }
  2066. static void hp100_load_eeprom(struct net_device *dev, u_short probe_ioaddr)
  2067. {
  2068. int i;
  2069. int ioaddr = probe_ioaddr > 0 ? probe_ioaddr : dev->base_addr;
  2070. #ifdef HP100_DEBUG_B
  2071. hp100_outw(0x4222, TRACE);
  2072. #endif
  2073. hp100_page(EEPROM_CTRL);
  2074. hp100_andw(~HP100_EEPROM_LOAD, EEPROM_CTRL);
  2075. hp100_orw(HP100_EEPROM_LOAD, EEPROM_CTRL);
  2076. for (i = 0; i < 10000; i++)
  2077. if (!(hp100_inb(OPTION_MSW) & HP100_EE_LOAD))
  2078. return;
  2079. printk("hp100: %s: hp100_load_eeprom - timeout\n", dev->name);
  2080. }
  2081. /* Sense connection status.
  2082. * return values: LAN_10 - Connected to 10Mbit/s network
  2083. * LAN_100 - Connected to 100Mbit/s network
  2084. * LAN_ERR - not connected or 100Mbit/s Hub down
  2085. */
  2086. static int hp100_sense_lan(struct net_device *dev)
  2087. {
  2088. int ioaddr = dev->base_addr;
  2089. u_short val_VG, val_10;
  2090. struct hp100_private *lp = netdev_priv(dev);
  2091. #ifdef HP100_DEBUG_B
  2092. hp100_outw(0x4223, TRACE);
  2093. #endif
  2094. hp100_page(MAC_CTRL);
  2095. val_10 = hp100_inb(10_LAN_CFG_1);
  2096. val_VG = hp100_inb(VG_LAN_CFG_1);
  2097. hp100_page(PERFORMANCE);
  2098. #ifdef HP100_DEBUG
  2099. printk("hp100: %s: sense_lan: val_VG = 0x%04x, val_10 = 0x%04x\n",
  2100. dev->name, val_VG, val_10);
  2101. #endif
  2102. if (val_10 & HP100_LINK_BEAT_ST) /* 10Mb connection is active */
  2103. return HP100_LAN_10;
  2104. if (val_10 & HP100_AUI_ST) { /* have we BNC or AUI onboard? */
  2105. /*
  2106. * This can be overriden by dos utility, so if this has no effect,
  2107. * perhaps you need to download that utility from HP and set card
  2108. * back to "auto detect".
  2109. */
  2110. val_10 |= HP100_AUI_SEL | HP100_LOW_TH;
  2111. hp100_page(MAC_CTRL);
  2112. hp100_outb(val_10, 10_LAN_CFG_1);
  2113. hp100_page(PERFORMANCE);
  2114. return HP100_LAN_COAX;
  2115. }
  2116. /* Those cards don't have a 100 Mbit connector */
  2117. if ( !strcmp(lp->id, "HWP1920") ||
  2118. (lp->pci_dev &&
  2119. lp->pci_dev->vendor == PCI_VENDOR_ID &&
  2120. (lp->pci_dev->device == PCI_DEVICE_ID_HP_J2970A ||
  2121. lp->pci_dev->device == PCI_DEVICE_ID_HP_J2973A)))
  2122. return HP100_LAN_ERR;
  2123. if (val_VG & HP100_LINK_CABLE_ST) /* Can hear the HUBs tone. */
  2124. return HP100_LAN_100;
  2125. return HP100_LAN_ERR;
  2126. }
  2127. static int hp100_down_vg_link(struct net_device *dev)
  2128. {
  2129. struct hp100_private *lp = netdev_priv(dev);
  2130. int ioaddr = dev->base_addr;
  2131. unsigned long time;
  2132. long savelan, newlan;
  2133. #ifdef HP100_DEBUG_B
  2134. hp100_outw(0x4224, TRACE);
  2135. printk("hp100: %s: down_vg_link\n", dev->name);
  2136. #endif
  2137. hp100_page(MAC_CTRL);
  2138. time = jiffies + (HZ / 4);
  2139. do {
  2140. if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
  2141. break;
  2142. if (!in_interrupt())
  2143. schedule_timeout_interruptible(1);
  2144. } while (time_after(time, jiffies));
  2145. if (time_after_eq(jiffies, time)) /* no signal->no logout */
  2146. return 0;
  2147. /* Drop the VG Link by clearing the link up cmd and load addr. */
  2148. hp100_andb(~(HP100_LOAD_ADDR | HP100_LINK_CMD), VG_LAN_CFG_1);
  2149. hp100_orb(HP100_VG_SEL, VG_LAN_CFG_1);
  2150. /* Conditionally stall for >250ms on Link-Up Status (to go down) */
  2151. time = jiffies + (HZ / 2);
  2152. do {
  2153. if (!(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
  2154. break;
  2155. if (!in_interrupt())
  2156. schedule_timeout_interruptible(1);
  2157. } while (time_after(time, jiffies));
  2158. #ifdef HP100_DEBUG
  2159. if (time_after_eq(jiffies, time))
  2160. printk("hp100: %s: down_vg_link: Link does not go down?\n", dev->name);
  2161. #endif
  2162. /* To prevent condition where Rev 1 VG MAC and old hubs do not complete */
  2163. /* logout under traffic (even though all the status bits are cleared), */
  2164. /* do this workaround to get the Rev 1 MAC in its idle state */
  2165. if (lp->chip == HP100_CHIPID_LASSEN) {
  2166. /* Reset VG MAC to insure it leaves the logoff state even if */
  2167. /* the Hub is still emitting tones */
  2168. hp100_andb(~HP100_VG_RESET, VG_LAN_CFG_1);
  2169. udelay(1500); /* wait for >1ms */
  2170. hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1); /* Release Reset */
  2171. udelay(1500);
  2172. }
  2173. /* New: For lassen, switch to 10 Mbps mac briefly to clear training ACK */
  2174. /* to get the VG mac to full reset. This is not req.d with later chips */
  2175. /* Note: It will take the between 1 and 2 seconds for the VG mac to be */
  2176. /* selected again! This will be left to the connect hub function to */
  2177. /* perform if desired. */
  2178. if (lp->chip == HP100_CHIPID_LASSEN) {
  2179. /* Have to write to 10 and 100VG control registers simultaneously */
  2180. savelan = newlan = hp100_inl(10_LAN_CFG_1); /* read 10+100 LAN_CFG regs */
  2181. newlan &= ~(HP100_VG_SEL << 16);
  2182. newlan |= (HP100_DOT3_MAC) << 8;
  2183. hp100_andb(~HP100_AUTO_MODE, MAC_CFG_3); /* Autosel off */
  2184. hp100_outl(newlan, 10_LAN_CFG_1);
  2185. /* Conditionally stall for 5sec on VG selected. */
  2186. time = jiffies + (HZ * 5);
  2187. do {
  2188. if (!(hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST))
  2189. break;
  2190. if (!in_interrupt())
  2191. schedule_timeout_interruptible(1);
  2192. } while (time_after(time, jiffies));
  2193. hp100_orb(HP100_AUTO_MODE, MAC_CFG_3); /* Autosel back on */
  2194. hp100_outl(savelan, 10_LAN_CFG_1);
  2195. }
  2196. time = jiffies + (3 * HZ); /* Timeout 3s */
  2197. do {
  2198. if ((hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST) == 0)
  2199. break;
  2200. if (!in_interrupt())
  2201. schedule_timeout_interruptible(1);
  2202. } while (time_after(time, jiffies));
  2203. if (time_before_eq(time, jiffies)) {
  2204. #ifdef HP100_DEBUG
  2205. printk("hp100: %s: down_vg_link: timeout\n", dev->name);
  2206. #endif
  2207. return -EIO;
  2208. }
  2209. time = jiffies + (2 * HZ); /* This seems to take a while.... */
  2210. do {
  2211. if (!in_interrupt())
  2212. schedule_timeout_interruptible(1);
  2213. } while (time_after(time, jiffies));
  2214. return 0;
  2215. }
  2216. static int hp100_login_to_vg_hub(struct net_device *dev, u_short force_relogin)
  2217. {
  2218. int ioaddr = dev->base_addr;
  2219. struct hp100_private *lp = netdev_priv(dev);
  2220. u_short val = 0;
  2221. unsigned long time;
  2222. int startst;
  2223. #ifdef HP100_DEBUG_B
  2224. hp100_outw(0x4225, TRACE);
  2225. printk("hp100: %s: login_to_vg_hub\n", dev->name);
  2226. #endif
  2227. /* Initiate a login sequence iff VG MAC is enabled and either Load Address
  2228. * bit is zero or the force relogin flag is set (e.g. due to MAC address or
  2229. * promiscuous mode change)
  2230. */
  2231. hp100_page(MAC_CTRL);
  2232. startst = hp100_inb(VG_LAN_CFG_1);
  2233. if ((force_relogin == 1) || (hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST)) {
  2234. #ifdef HP100_DEBUG_TRAINING
  2235. printk("hp100: %s: Start training\n", dev->name);
  2236. #endif
  2237. /* Ensure VG Reset bit is 1 (i.e., do not reset) */
  2238. hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1);
  2239. /* If Lassen AND auto-select-mode AND VG tones were sensed on */
  2240. /* entry then temporarily put them into force 100Mbit mode */
  2241. if ((lp->chip == HP100_CHIPID_LASSEN) && (startst & HP100_LINK_CABLE_ST))
  2242. hp100_andb(~HP100_DOT3_MAC, 10_LAN_CFG_2);
  2243. /* Drop the VG link by zeroing Link Up Command and Load Address */
  2244. hp100_andb(~(HP100_LINK_CMD /* |HP100_LOAD_ADDR */ ), VG_LAN_CFG_1);
  2245. #ifdef HP100_DEBUG_TRAINING
  2246. printk("hp100: %s: Bring down the link\n", dev->name);
  2247. #endif
  2248. /* Wait for link to drop */
  2249. time = jiffies + (HZ / 10);
  2250. do {
  2251. if (~(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
  2252. break;
  2253. if (!in_interrupt())
  2254. schedule_timeout_interruptible(1);
  2255. } while (time_after(time, jiffies));
  2256. /* Start an addressed training and optionally request promiscuous port */
  2257. if ((dev->flags) & IFF_PROMISC) {
  2258. hp100_orb(HP100_PROM_MODE, VG_LAN_CFG_2);
  2259. if (lp->chip == HP100_CHIPID_LASSEN)
  2260. hp100_orw(HP100_MACRQ_PROMSC, TRAIN_REQUEST);
  2261. } else {
  2262. hp100_andb(~HP100_PROM_MODE, VG_LAN_CFG_2);
  2263. /* For ETR parts we need to reset the prom. bit in the training
  2264. * register, otherwise promiscious mode won't be disabled.
  2265. */
  2266. if (lp->chip == HP100_CHIPID_LASSEN) {
  2267. hp100_andw(~HP100_MACRQ_PROMSC, TRAIN_REQUEST);
  2268. }
  2269. }
  2270. /* With ETR parts, frame format request bits can be set. */
  2271. if (lp->chip == HP100_CHIPID_LASSEN)
  2272. hp100_orb(HP100_MACRQ_FRAMEFMT_EITHER, TRAIN_REQUEST);
  2273. hp100_orb(HP100_LINK_CMD | HP100_LOAD_ADDR | HP100_VG_RESET, VG_LAN_CFG_1);
  2274. /* Note: Next wait could be omitted for Hood and earlier chips under */
  2275. /* certain circumstances */
  2276. /* TODO: check if hood/earlier and skip wait. */
  2277. /* Wait for either short timeout for VG tones or long for login */
  2278. /* Wait for the card hardware to signalise link cable status ok... */
  2279. hp100_page(MAC_CTRL);
  2280. time = jiffies + (1 * HZ); /* 1 sec timeout for cable st */
  2281. do {
  2282. if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
  2283. break;
  2284. if (!in_interrupt())
  2285. schedule_timeout_interruptible(1);
  2286. } while (time_before(jiffies, time));
  2287. if (time_after_eq(jiffies, time)) {
  2288. #ifdef HP100_DEBUG_TRAINING
  2289. printk("hp100: %s: Link cable status not ok? Training aborted.\n", dev->name);
  2290. #endif
  2291. } else {
  2292. #ifdef HP100_DEBUG_TRAINING
  2293. printk
  2294. ("hp100: %s: HUB tones detected. Trying to train.\n",
  2295. dev->name);
  2296. #endif
  2297. time = jiffies + (2 * HZ); /* again a timeout */
  2298. do {
  2299. val = hp100_inb(VG_LAN_CFG_1);
  2300. if ((val & (HP100_LINK_UP_ST))) {
  2301. #ifdef HP100_DEBUG_TRAINING
  2302. printk("hp100: %s: Passed training.\n", dev->name);
  2303. #endif
  2304. break;
  2305. }
  2306. if (!in_interrupt())
  2307. schedule_timeout_interruptible(1);
  2308. } while (time_after(time, jiffies));
  2309. }
  2310. /* If LINK_UP_ST is set, then we are logged into the hub. */
  2311. if (time_before_eq(jiffies, time) && (val & HP100_LINK_UP_ST)) {
  2312. #ifdef HP100_DEBUG_TRAINING
  2313. printk("hp100: %s: Successfully logged into the HUB.\n", dev->name);
  2314. if (lp->chip == HP100_CHIPID_LASSEN) {
  2315. val = hp100_inw(TRAIN_ALLOW);
  2316. printk("hp100: %s: Card supports 100VG MAC Version \"%s\" ",
  2317. dev->name, (hp100_inw(TRAIN_REQUEST) & HP100_CARD_MACVER) ? "802.12" : "Pre");
  2318. printk("Driver will use MAC Version \"%s\"\n", (val & HP100_HUB_MACVER) ? "802.12" : "Pre");
  2319. printk("hp100: %s: Frame format is %s.\n", dev->name, (val & HP100_MALLOW_FRAMEFMT) ? "802.5" : "802.3");
  2320. }
  2321. #endif
  2322. } else {
  2323. /* If LINK_UP_ST is not set, login was not successful */
  2324. printk("hp100: %s: Problem logging into the HUB.\n", dev->name);
  2325. if (lp->chip == HP100_CHIPID_LASSEN) {
  2326. /* Check allowed Register to find out why there is a problem. */
  2327. val = hp100_inw(TRAIN_ALLOW); /* won't work on non-ETR card */
  2328. #ifdef HP100_DEBUG_TRAINING
  2329. printk("hp100: %s: MAC Configuration requested: 0x%04x, HUB allowed: 0x%04x\n", dev->name, hp100_inw(TRAIN_REQUEST), val);
  2330. #endif
  2331. if (val & HP100_MALLOW_ACCDENIED)
  2332. printk("hp100: %s: HUB access denied.\n", dev->name);
  2333. if (val & HP100_MALLOW_CONFIGURE)
  2334. printk("hp100: %s: MAC Configuration is incompatible with the Network.\n", dev->name);
  2335. if (val & HP100_MALLOW_DUPADDR)
  2336. printk("hp100: %s: Duplicate MAC Address on the Network.\n", dev->name);
  2337. }
  2338. }
  2339. /* If we have put the chip into forced 100 Mbit mode earlier, go back */
  2340. /* to auto-select mode */
  2341. if ((lp->chip == HP100_CHIPID_LASSEN) && (startst & HP100_LINK_CABLE_ST)) {
  2342. hp100_page(MAC_CTRL);
  2343. hp100_orb(HP100_DOT3_MAC, 10_LAN_CFG_2);
  2344. }
  2345. val = hp100_inb(VG_LAN_CFG_1);
  2346. /* Clear the MISC_ERROR Interrupt, which might be generated when doing the relogin */
  2347. hp100_page(PERFORMANCE);
  2348. hp100_outw(HP100_MISC_ERROR, IRQ_STATUS);
  2349. if (val & HP100_LINK_UP_ST)
  2350. return 0; /* login was ok */
  2351. else {
  2352. printk("hp100: %s: Training failed.\n", dev->name);
  2353. hp100_down_vg_link(dev);
  2354. return -EIO;
  2355. }
  2356. }
  2357. /* no forced relogin & already link there->no training. */
  2358. return -EIO;
  2359. }
  2360. static void hp100_cascade_reset(struct net_device *dev, u_short enable)
  2361. {
  2362. int ioaddr = dev->base_addr;
  2363. struct hp100_private *lp = netdev_priv(dev);
  2364. #ifdef HP100_DEBUG_B
  2365. hp100_outw(0x4226, TRACE);
  2366. printk("hp100: %s: cascade_reset\n", dev->name);
  2367. #endif
  2368. if (enable) {
  2369. hp100_outw(HP100_HW_RST | HP100_RESET_LB, OPTION_LSW);
  2370. if (lp->chip == HP100_CHIPID_LASSEN) {
  2371. /* Lassen requires a PCI transmit fifo reset */
  2372. hp100_page(HW_MAP);
  2373. hp100_andb(~HP100_PCI_RESET, PCICTRL2);
  2374. hp100_orb(HP100_PCI_RESET, PCICTRL2);
  2375. /* Wait for min. 300 ns */
  2376. /* we can't use jiffies here, because it may be */
  2377. /* that we have disabled the timer... */
  2378. udelay(400);
  2379. hp100_andb(~HP100_PCI_RESET, PCICTRL2);
  2380. hp100_page(PERFORMANCE);
  2381. }
  2382. } else { /* bring out of reset */
  2383. hp100_outw(HP100_HW_RST | HP100_SET_LB, OPTION_LSW);
  2384. udelay(400);
  2385. hp100_page(PERFORMANCE);
  2386. }
  2387. }
  2388. #ifdef HP100_DEBUG
  2389. void hp100_RegisterDump(struct net_device *dev)
  2390. {
  2391. int ioaddr = dev->base_addr;
  2392. int Page;
  2393. int Register;
  2394. /* Dump common registers */
  2395. printk("hp100: %s: Cascade Register Dump\n", dev->name);
  2396. printk("hardware id #1: 0x%.2x\n", hp100_inb(HW_ID));
  2397. printk("hardware id #2/paging: 0x%.2x\n", hp100_inb(PAGING));
  2398. printk("option #1: 0x%.4x\n", hp100_inw(OPTION_LSW));
  2399. printk("option #2: 0x%.4x\n", hp100_inw(OPTION_MSW));
  2400. /* Dump paged registers */
  2401. for (Page = 0; Page < 8; Page++) {
  2402. /* Dump registers */
  2403. printk("page: 0x%.2x\n", Page);
  2404. outw(Page, ioaddr + 0x02);
  2405. for (Register = 0x8; Register < 0x22; Register += 2) {
  2406. /* Display Register contents except data port */
  2407. if (((Register != 0x10) && (Register != 0x12)) || (Page > 0)) {
  2408. printk("0x%.2x = 0x%.4x\n", Register, inw(ioaddr + Register));
  2409. }
  2410. }
  2411. }
  2412. hp100_page(PERFORMANCE);
  2413. }
  2414. #endif
  2415. static void cleanup_dev(struct net_device *d)
  2416. {
  2417. struct hp100_private *p = netdev_priv(d);
  2418. unregister_netdev(d);
  2419. release_region(d->base_addr, HP100_REGION_SIZE);
  2420. if (p->mode == 1) /* busmaster */
  2421. pci_free_consistent(p->pci_dev, MAX_RINGSIZE + 0x0f,
  2422. p->page_vaddr_algn,
  2423. virt_to_whatever(d, p->page_vaddr_algn));
  2424. if (p->mem_ptr_virt)
  2425. iounmap(p->mem_ptr_virt);
  2426. free_netdev(d);
  2427. }
  2428. #ifdef CONFIG_EISA
  2429. static int __init hp100_eisa_probe (struct device *gendev)
  2430. {
  2431. struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
  2432. struct eisa_device *edev = to_eisa_device(gendev);
  2433. int err;
  2434. if (!dev)
  2435. return -ENOMEM;
  2436. SET_NETDEV_DEV(dev, &edev->dev);
  2437. err = hp100_probe1(dev, edev->base_addr + 0xC38, HP100_BUS_EISA, NULL);
  2438. if (err)
  2439. goto out1;
  2440. #ifdef HP100_DEBUG
  2441. printk("hp100: %s: EISA adapter found at 0x%x\n", dev->name,
  2442. dev->base_addr);
  2443. #endif
  2444. dev_set_drvdata(gendev, dev);
  2445. return 0;
  2446. out1:
  2447. free_netdev(dev);
  2448. return err;
  2449. }
  2450. static int __devexit hp100_eisa_remove (struct device *gendev)
  2451. {
  2452. struct net_device *dev = dev_get_drvdata(gendev);
  2453. cleanup_dev(dev);
  2454. return 0;
  2455. }
  2456. static struct eisa_driver hp100_eisa_driver = {
  2457. .id_table = hp100_eisa_tbl,
  2458. .driver = {
  2459. .name = "hp100",
  2460. .probe = hp100_eisa_probe,
  2461. .remove = __devexit_p (hp100_eisa_remove),
  2462. }
  2463. };
  2464. #endif
  2465. #ifdef CONFIG_PCI
  2466. static int __devinit hp100_pci_probe (struct pci_dev *pdev,
  2467. const struct pci_device_id *ent)
  2468. {
  2469. struct net_device *dev;
  2470. int ioaddr;
  2471. u_short pci_command;
  2472. int err;
  2473. if (pci_enable_device(pdev))
  2474. return -ENODEV;
  2475. dev = alloc_etherdev(sizeof(struct hp100_private));
  2476. if (!dev) {
  2477. err = -ENOMEM;
  2478. goto out0;
  2479. }
  2480. SET_NETDEV_DEV(dev, &pdev->dev);
  2481. pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
  2482. if (!(pci_command & PCI_COMMAND_IO)) {
  2483. #ifdef HP100_DEBUG
  2484. printk("hp100: %s: PCI I/O Bit has not been set. Setting...\n", dev->name);
  2485. #endif
  2486. pci_command |= PCI_COMMAND_IO;
  2487. pci_write_config_word(pdev, PCI_COMMAND, pci_command);
  2488. }
  2489. if (!(pci_command & PCI_COMMAND_MASTER)) {
  2490. #ifdef HP100_DEBUG
  2491. printk("hp100: %s: PCI Master Bit has not been set. Setting...\n", dev->name);
  2492. #endif
  2493. pci_command |= PCI_COMMAND_MASTER;
  2494. pci_write_config_word(pdev, PCI_COMMAND, pci_command);
  2495. }
  2496. ioaddr = pci_resource_start(pdev, 0);
  2497. err = hp100_probe1(dev, ioaddr, HP100_BUS_PCI, pdev);
  2498. if (err)
  2499. goto out1;
  2500. #ifdef HP100_DEBUG
  2501. printk("hp100: %s: PCI adapter found at 0x%x\n", dev->name, ioaddr);
  2502. #endif
  2503. pci_set_drvdata(pdev, dev);
  2504. return 0;
  2505. out1:
  2506. free_netdev(dev);
  2507. out0:
  2508. pci_disable_device(pdev);
  2509. return err;
  2510. }
  2511. static void __devexit hp100_pci_remove (struct pci_dev *pdev)
  2512. {
  2513. struct net_device *dev = pci_get_drvdata(pdev);
  2514. cleanup_dev(dev);
  2515. pci_disable_device(pdev);
  2516. }
  2517. static struct pci_driver hp100_pci_driver = {
  2518. .name = "hp100",
  2519. .id_table = hp100_pci_tbl,
  2520. .probe = hp100_pci_probe,
  2521. .remove = __devexit_p(hp100_pci_remove),
  2522. };
  2523. #endif
  2524. /*
  2525. * module section
  2526. */
  2527. MODULE_LICENSE("GPL");
  2528. MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, "
  2529. "Siegfried \"Frieder\" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de>");
  2530. MODULE_DESCRIPTION("HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters");
  2531. /*
  2532. * Note: to register three isa devices, use:
  2533. * option hp100 hp100_port=0,0,0
  2534. * to register one card at io 0x280 as eth239, use:
  2535. * option hp100 hp100_port=0x280
  2536. */
  2537. #if defined(MODULE) && defined(CONFIG_ISA)
  2538. #define HP100_DEVICES 5
  2539. /* Parameters set by insmod */
  2540. static int hp100_port[HP100_DEVICES] = { 0, [1 ... (HP100_DEVICES-1)] = -1 };
  2541. module_param_array(hp100_port, int, NULL, 0);
  2542. /* List of devices */
  2543. static struct net_device *hp100_devlist[HP100_DEVICES];
  2544. static int __init hp100_isa_init(void)
  2545. {
  2546. struct net_device *dev;
  2547. int i, err, cards = 0;
  2548. /* Don't autoprobe ISA bus */
  2549. if (hp100_port[0] == 0)
  2550. return -ENODEV;
  2551. /* Loop on all possible base addresses */
  2552. for (i = 0; i < HP100_DEVICES && hp100_port[i] != -1; ++i) {
  2553. dev = alloc_etherdev(sizeof(struct hp100_private));
  2554. if (!dev) {
  2555. while (cards > 0)
  2556. cleanup_dev(hp100_devlist[--cards]);
  2557. return -ENOMEM;
  2558. }
  2559. err = hp100_isa_probe(dev, hp100_port[i]);
  2560. if (!err)
  2561. hp100_devlist[cards++] = dev;
  2562. else
  2563. free_netdev(dev);
  2564. }
  2565. return cards > 0 ? 0 : -ENODEV;
  2566. }
  2567. static void hp100_isa_cleanup(void)
  2568. {
  2569. int i;
  2570. for (i = 0; i < HP100_DEVICES; i++) {
  2571. struct net_device *dev = hp100_devlist[i];
  2572. if (dev)
  2573. cleanup_dev(dev);
  2574. }
  2575. }
  2576. #else
  2577. #define hp100_isa_init() (0)
  2578. #define hp100_isa_cleanup() do { } while(0)
  2579. #endif
  2580. static int __init hp100_module_init(void)
  2581. {
  2582. int err;
  2583. err = hp100_isa_init();
  2584. if (err && err != -ENODEV)
  2585. goto out;
  2586. #ifdef CONFIG_EISA
  2587. err = eisa_driver_register(&hp100_eisa_driver);
  2588. if (err && err != -ENODEV)
  2589. goto out2;
  2590. #endif
  2591. #ifdef CONFIG_PCI
  2592. err = pci_register_driver(&hp100_pci_driver);
  2593. if (err && err != -ENODEV)
  2594. goto out3;
  2595. #endif
  2596. out:
  2597. return err;
  2598. out3:
  2599. #ifdef CONFIG_EISA
  2600. eisa_driver_unregister (&hp100_eisa_driver);
  2601. out2:
  2602. #endif
  2603. hp100_isa_cleanup();
  2604. goto out;
  2605. }
  2606. static void __exit hp100_module_exit(void)
  2607. {
  2608. hp100_isa_cleanup();
  2609. #ifdef CONFIG_EISA
  2610. eisa_driver_unregister (&hp100_eisa_driver);
  2611. #endif
  2612. #ifdef CONFIG_PCI
  2613. pci_unregister_driver (&hp100_pci_driver);
  2614. #endif
  2615. }
  2616. module_init(hp100_module_init)
  2617. module_exit(hp100_module_exit)