开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
usbKlsiEnd.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：114k
源码类别：

VxWorks

开发平台：

C/C++

usbKlsiEnd.c：源码内容
  1. /* usbKlsiEnd.c - USB Ethernet driver for the KLSI USB-Ethernet adapter */
  3. /* Copyright 2000-2001 Wind river systems, Inc */
  5. /*
  6. Modification history
  7. --------------------
  8. 01g,15oct01,wef  fix SPR 70953 - fixes man page generation and 70716 - fixes
  9.                  coding convention and some warnings
  10. 01f,08aug01,dat  Removing warnings
  11. 01e,01aug31,wef  fixed man page generation comments
  12. 01d,03may01,wef  moved ATTACH_CALLBACK typedef to this file from .h 
  13. 01c,30apr01,wef  changed USB_DEV to USB_KLSI_DEV
  14. 01b,11aug00,bri  Dynamic memory allocation for input and output buffers 
  15.  and removal of wrappers for klsiEndStart and klsiEndStop.
  16. 01a,03may00,bri  Created
  17. */
  19. /*
  20. DESCRIPTION
  21.  
  22. This module is the END (Enhanced Network Driver) driver for USB-ethernet 
  23. adapters built around the Kawasaki-LSI KL5KUSB101 chip for the VxWorks 
  24. operating system. This device falls under subclass Ethernet Networking 
  25. Control Model (Clause 3.8.2) of USB Class Definition for Communication 
  26. Devices (Ver1.1). 
  28. This driver is designed to be moderately generic for all KLSI devices. 
  29. To achieve this, the driver load routine requires an input string consisting 
  30. of some target-specific values. These are described below.
  32. As this adapter deviates from the standard specification in some respects, 
  33. it calls for addition of certain extensions which are required to fulfill 
  34. the requirements of the hot-plugging USB environment. 
  37. EXTERNAL INTERFACE
  39. There are only two external interfaces usbKlsiEndInit() and klsiEndLoad() 
  40. in this driver.  usbKlsiEndInit() is called before the muxLoad() calls 
  41. sysEndLoad(), to register with USBD. sysEndLoad() function calls klsiEndLoad().  
  42. klsiEndLoad() function expects a <initString> parameter as input which 
  43. describes some target specific parameters.  
  44. This parameter is passed in a colon-delimited string of the format:
  46. <initString>
  47. "unit : vendorId : productId : noOfInBfrs : noOfIrps"
  49. The klsiEndLoad() function uses strtok() to parse the string. 
  51. TARGET-SPECIFIC PARAMETERS
  52. is
  53.  i <unit>
  54. A convenient holdover from the former model. This parameter is used only 
  55. in the string as name of the driver
  56.  i <vendorId>
  57. This is a vendorId for the target device supplied by the manufacturer.
  58.  i <productId>
  59. This is a productId for the target device supplied by the manufacturer.  
  60.  i <noOfInBfrs>
  61. Tells the driver no of input buffers to be allocated for usage.
  62.  i <noOfIrps>
  63. Tells the driver no of output IRPs to be allocated for usage.
  64. ie
  65.  
  66. DEVICE FUNCTIONALITY
  67.  
  68. The KLSI USB to ethernet adapter chip contains an USB serial interface,
  69. ethernet MAC and embedded microcontroller (called the QT Engine).
  70. The chip must have firmware loaded into it before it can operate.
  71. The KLSI Chip supports 4 End Points. The first is the default end point, 
  72. which is of control type. The Second and the Third are BULK IN and BULK OUT 
  73. end points respectively for transferring the data into the Host and from the 
  74. Host. The Fourth End Point is an Interrupt end point that is currently not used.
  76. This device supports one configuration, which contains One Interface. This 
  77. interface contains the 3 end points i.e. the Bulk IN/OUT and interrupt
  78. end points. Issuing a SET_CONFIGURATION command will cause the MAC to be 
  79. reset.
  80.  
  81. Apart from the traditional commands, the device supports as many as 12 
  82. vendor specific commands. These commands are described in the device manual. 
  83. This device even allows the user to change the contents of the EEPROM. 
  85. Packets are passed between the chip and host via bulk transfers.
  86. There is an interrupt endpoint mentioned in the software spec, however
  87. it is currently unused. This device is 10Mbps half-duplex only, hence
  88. there is no media selection logic. The MAC supports a 128 entry multicast 
  89. filter, though the exact size of the filter can depend on the firmware. 
  90. Curiously, while the software specification describes various ethernet 
  91. statistics counters, this adapter and firmware combination claims not 
  92. to support any statistics counters at all.
  94. The device supports the following (vendor specific )commands :
  95. is 
  96. i USB_REQ_KLSI_ETHDESC_GET Retrieves the Ethernet functional descriptor from 
  97. the device.
  98. i USB_REQ_KLSI_SET_MCAST_FILTER Sets the ethernet device multicast filters as 
  99. specified in the sequential list if 48 bit addresses ethernet multicast
  100. addresses.
  101. i USB_REQ_KLSI_SET_PACKET_FILTER This Sets the Ethernet packet filter settings.
  102. i USB_REQ_KLSI_GET_STATS Retrieves the device statistics of the feature
  103. requested.
  104. i USB_REQ_KLSI_GET_AUX_INPUTS Reads four auxiliary input pins from the 
  105. USB-Ethernet controller chip.
  106. i USB_REQ_KLSI_SET_AUX_OUTPUTS Sets four auxiliary input pins from the 
  107. USB-Ethernet controller chip.
  108. i USB_REQ_KLSI_SET_TEMP_MAC Obtains the MAC address currently used by the 
  109. ethernet adapter.
  110. i USB_REQ_KLSI_GET_TEMP_MAC Sets the MAC address to be used by the ethernet 
  111. adapter.
  112. i USB_REQ_KLSI_SET_URB_SIZE Sets the USB Request Block size to be used by the 
  113. ethernet adapter.
  114. i USB_REQ_KLSI_SET_SOFS_TO_WAIT Sets the no. of Start of Frames to wait while 
  115. filling a URB before sending a ZLP.
  116. i USB_REQ_KLSI_SET_EVEN_PACKETS Specific to Win95. Not Applicable.
  117. i USB_REQ_KLSI_SCAN Request to modify the I2C EEPROM on the device at a 
  118. specified address.
  119. ie
  124. DRIVER FUNCTIONALITY
  125.  
  126. The function usbKlsiEndInit() is called at the time of usb system 
  127. initialization. It registers as a client with the USBD. This function also
  128. registers for the dynamic attachment and removal of the USB devices.
  129. Ideally the registering should be done for a specific Class ID and a Subclass
  130. ID. Since the device doesn't support these parameters in the Device descriptor, 
  131. ALL kinds of devices are registered for. A list of the ethernet devices on USB 
  132. is maintained in a linked list "klsiDevList". This list is created and 
  133. maintained using the linked list library provided as a part of the USBD. 
  134. API calls are provided to find if the device exists in the list, by taking 
  135. either the device "node ID" or the vendorID and productID as the parameters. 
  136. klsiAttachCallback(), which is the Callback function registered for the 
  137. dynamic attachment/removal, will be called if any device is found on the 
  138. USB or removed from the USB. This function checks if this is duplicate 
  139. information, by checking if this device already exists in the List. If not, 
  140. the device descriptor is parsed to obtain the Vendor ID and Product ID. If the
  141. Vendor ID and Product ID match with KLSI IDs, then the device is added to the 
  142. list of ethernet devices found on the USB.
  144. klsiDevInit() does most of the device structure initialization. This routine 
  145. checks if the device corresponding to the VendorID and ProductID match to any 
  146. of the devices in the "List". If matched, a pointer structure on the list will 
  147. be assigned to one of the device structure parameters. Next, InPut and OutPut 
  148. end point details are found by parsing through the configuration descriptor and 
  149. interface descriptor. Once these end point descriptors are found, respective 
  150. input and output Pipes are created and assigned to the corresponding structure. 
  151. At this moment device is triggered to reset.
  153. This driver is a Polled mode driver. It keeps listening on the input pipe by 
  154. calling "klsiListenToInput" all the time, from the first time it is called 
  155. by klsiEndStart(). Pre allocated buffer IRP is submitted. Unless the IRP is 
  156. cancelled (by klsiEndStop()), it will be submitted again and again.
  157. If cancelled, it will again start listening only if klsiEndStart() is called.
  158. If there is data (IRP successful), then it will be passed on to upper layer by
  159. calling klsiEndRecv().
  161. Rest of the functionality of the driver is straight forward and most of
  162. the places is achieved by sending a vendor specific command from the list
  163. described above, to the device.
  165. INCLUDE FILES:
  166. end.h endLib.h lstLib.h etherMultiLib.h usbPlatform.h usb.h usbListLib.h 
  167. usbdLib.h usbLib.h usbKlsiEnd.h
  169. SEE ALSO:
  170. muxLib, endLib,  usbLib, usbdLib, ossLib 
  172. .I "Writing and Enhanced Network Driver" and
  173. .I "USB Developer's Kit User's Guide"
  175. */
  177. /* includes */
  179. #include "vxWorks.h"
  180. #include "stdlib.h"
  181. #include "stdio.h"
  182. #include "string.h"
  183. #include "cacheLib.h"
  184. #include "intLib.h"
  185. #include "end.h" /* Common END structures. */
  186. #include "endLib.h"
  187. #include "lstLib.h" /* Needed to maintain protocol list */
  188. #include "wdLib.h"
  189. #include "iv.h"
  190. #include "semLib.h"
  191. #include "etherLib.h"
  192. #include "logLib.h"
  193. #include "netLib.h"
  194. #include "stdio.h"
  195. #include "sysLib.h"
  196. #include "errno.h"
  197. #include "errnoLib.h"
  198. #include "memLib.h"
  199. #include "iosLib.h"
  200. #undef ETHER_MAP_IP_MULTICAST
  201. #include "etherMultiLib.h" /* multicast stuff. */
  203. #include "net/mbuf.h"
  204. #include "net/unixLib.h"
  205. #include "net/protosw.h"
  206. #include "net/systm.h"
  207. #include "net/if_subr.h"
  208. #include "net/route.h"
  210. #include "sys/socket.h"
  211. #include "sys/ioctl.h"
  212. #include "sys/times.h"
  214. #include "usb/usbPlatform.h"
  215. #include "usb/ossLib.h"  /* operations system services */
  216. #include "usb/usb.h" /* general USB definitions */
  217. #include "usb/usbListLib.h" /* linked list functions */
  218. #include "usb/usbdLib.h" /* USBD interface */
  219. #include "usb/usbLib.h"  /* USB utility functions */
  221. #include "drv/usb/usbKlsiEnd.h"
  223. /* defines */
  225. /* for debugging */
  227. #define KLSI_DBG
  229. #ifdef KLSI_DBG
  231. #define KLSI_DBG_OFF 0x0000
  232. #define KLSI_DBG_RX 0x0001
  233. #define KLSI_DBG_TX 0x0002
  234. #define KLSI_DBG_MCAST 0x0004
  235. #define KLSI_DBG_ATTACH 0x0008
  236. #define KLSI_DBG_INIT 0x0010
  237. #define KLSI_DBG_START 0x0020
  238. #define KLSI_DBG_STOP 0x0040
  239. #define KLSI_DBG_RESET 0x0080
  240. #define KLSI_DBG_MAC 0x0100
  241. #define KLSI_DBG_POLL_RX 0x0200
  242. #define KLSI_DBG_POLL_TX 0x0400
  243. #define KLSI_DBG_LOAD 0x0800
  244. #define KLSI_DBG_IOCTL 0x1000
  245. #define KLSI_DBG_DNLD 0x2000
  247. int klsiDebug = (0x0000);
  249. #define KLSI_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)    
  250. if (klsiDebug & FLG)                         
  251.             logMsg(X0, X1, X2, X3, X4, X5, X6);
  253. #define KLSI_PRINT(FLG,X)                            
  254. if (klsiDebug & FLG) printf X;
  256. #else /*KLSI_DBG*/
  258. #define KLSI_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)
  260. #define KLSI_PRINT(DBG_SW,X)
  262. #endif /*KLSI_DBG*/
  265. #if (CPU == PPC604)
  266.  #undef CACHE_PIPE_FLUSH()
  267.  #define CACHE_PIPE_FLUSH() vxEieio()
  268. #endif
  270. #define KLSI_FIRMWARE_BUF 4096
  272. #define KLSI_CLIENT_NAME "usb"
  274. #define KLSI_BUFSIZ   (ETHERMTU + ENET_HDR_REAL_SIZ + 6) 
  276. #define EH_SIZE (14)
  278. #define END_SPEED_10M 10000000 /* 10Mbs */
  280. #define KLSI_SPEED    END_SPEED_10M
  282. #define KLSI_NAME "usb"
  284. #define KLSI_NAME_LEN sizeof(KLSI_NAME)+1
  287. /* A shortcut for getting the hardware address from the MIB II stuff. */
  289. #define END_HADDR(pEnd)
  290. ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  292. #define END_HADDR_LEN(pEnd) 
  293. ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  296. #define KLSI_MIN_FBUF (1514) /* min first buffer size */
  299. /* typedefs */
  301. /*
  302.  * This will only work if there is only a single unit, for multiple
  303.  * unit device drivers these should be integrated into the KLSI_DEVICE
  304.  * structure.
  305.  */
  307. M_CL_CONFIG klsiMclBlkConfig =  /* network mbuf configuration table */
  308.     {
  309.     /* 
  310.     no. mBlks no. clBlks memArea memSize
  311.     ----------- ---------- ------- -------
  312.     */
  313.     0,  0,  NULL,  0
  314.     };
  316. CL_DESC klsiClDescTbl [] =  /* network cluster pool configuration table */
  317.     {
  318.     /* 
  319.     clusterSize num memArea memSize
  320.     ----------- ---- ------- -------
  321.     */
  322.     {ETHERMTU + EH_SIZE + 2, 0, NULL, 0}
  323.     }; 
  325. int klsiClDescTblNumEnt = (NELEMENTS(klsiClDescTbl));
  329. typedef struct attach_request
  330.     {
  331.     LINK reqLink;                       /* linked list of requests */
  332.     USB_KLSI_ATTACH_CALLBACK callback;  /* client callback routine */
  333.     pVOID callbackArg;                  /* client callback argument*/
  334.     } ATTACH_REQUEST, *pATTACH_REQUEST;
  337. /* globals */
  340. USBD_CLIENT_HANDLE klsiHandle;  /* our USBD client handle */
  342. /* Locals */
  344. /* Firmware Download details */
  346. /*
  347.  * NOTE: B6/C3 is data header signature   
  348.  *       0xAA/0xBB is data length = total 
  349.  *       bytes - 7, 0xCC is type, 0xDD is 
  350.  *       interrupt to use.                
  351.  */
  353. /*
  354.  *     klsiNewCode
  355.  */
  356. static UINT8 klsiNewCode[] = 
  357. {
  358.     0xB6, 0xC3, 0xAA, 0xBB, 0xCC, 0xDD,
  359.     0x9f, 0xcf, 0xbc, 0x08, 0xe7, 0x57, 0x00, 0x00,
  360.     0x9a, 0x08, 0x97, 0xc1, 0xe7, 0x67, 0xff, 0x1f,
  361.     0x28, 0xc0, 0xe7, 0x87, 0x00, 0x04, 0x24, 0xc0,
  362.     0xe7, 0x67, 0xff, 0xf9, 0x22, 0xc0, 0x97, 0xcf,
  363.     0xe7, 0x09, 0xa2, 0xc0, 0x94, 0x08, 0xd7, 0x09,
  364.     0x00, 0xc0, 0xe7, 0x59, 0xba, 0x08, 0x94, 0x08,
  365.     0x03, 0xc1, 0xe7, 0x67, 0xff, 0xf7, 0x24, 0xc0,
  366.     0xe7, 0x05, 0x00, 0xc0, 0xa7, 0xcf, 0x92, 0x08,
  367.     0xe7, 0x57, 0x00, 0x00, 0x8e, 0x08, 0xa7, 0xa1,
  368.     0x8e, 0x08, 0x97, 0xcf, 0xe7, 0x57, 0x00, 0x00,
  369.     0xf2, 0x09, 0x0a, 0xc0, 0xe7, 0x57, 0x00, 0x00,
  370.     0xa4, 0xc0, 0xa7, 0xc0, 0x56, 0x08, 0x9f, 0xaf,
  371.     0x70, 0x09, 0xe7, 0x07, 0x00, 0x00, 0xf2, 0x09,
  372.     0xe7, 0x57, 0xff, 0xff, 0x90, 0x08, 0x9f, 0xa0,
  373.     0x40, 0x00, 0xe7, 0x59, 0x90, 0x08, 0x94, 0x08,
  374.     0x9f, 0xa0, 0x40, 0x00, 0xc8, 0x09, 0xa2, 0x08,
  375.     0x08, 0x62, 0x9f, 0xa1, 0x14, 0x0a, 0xe7, 0x57,
  376.     0x00, 0x00, 0x52, 0x08, 0xa7, 0xc0, 0x56, 0x08,
  377.     0x9f, 0xaf, 0x04, 0x00, 0xe7, 0x57, 0x00, 0x00,
  378.     0x8e, 0x08, 0xa7, 0xc1, 0x56, 0x08, 0xc0, 0x09,
  379.     0xa8, 0x08, 0x00, 0x60, 0x05, 0xc4, 0xc0, 0x59,
  380.     0x94, 0x08, 0x02, 0xc0, 0x9f, 0xaf, 0xee, 0x00,
  381.     0xe7, 0x59, 0xae, 0x08, 0x94, 0x08, 0x02, 0xc1,
  382.     0x9f, 0xaf, 0xf6, 0x00, 0x9f, 0xaf, 0x9e, 0x03,
  383.     0xef, 0x57, 0x00, 0x00, 0xf0, 0x09, 0x9f, 0xa1,
  384.     0xde, 0x01, 0xe7, 0x57, 0x00, 0x00, 0x78, 0x08,
  385.     0x9f, 0xa0, 0xe4, 0x03, 0x9f, 0xaf, 0x2c, 0x04,
  386.     0xa7, 0xcf, 0x56, 0x08, 0x48, 0x02, 0xe7, 0x09,
  387.     0x94, 0x08, 0xa8, 0x08, 0xc8, 0x37, 0x04, 0x00,
  388.     0x9f, 0xaf, 0x68, 0x04, 0x97, 0xcf, 0xe7, 0x57,
  389.     0x00, 0x00, 0xa6, 0x08, 0x97, 0xc0, 0xd7, 0x09,
  390.     0x00, 0xc0, 0xc1, 0xdf, 0xc8, 0x09, 0x9c, 0x08,
  391.     0x08, 0x62, 0x1d, 0xc0, 0x27, 0x04, 0x9c, 0x08,
  392.     0x10, 0x94, 0xf0, 0x07, 0xee, 0x09, 0x02, 0x00,
  393.     0xc1, 0x07, 0x01, 0x00, 0x70, 0x00, 0x04, 0x00,
  394.     0xf0, 0x07, 0x44, 0x01, 0x06, 0x00, 0x50, 0xaf,
  395.     0xe7, 0x09, 0x94, 0x08, 0xae, 0x08, 0xe7, 0x17,
  396.     0x14, 0x00, 0xae, 0x08, 0xe7, 0x67, 0xff, 0x07,
  397.     0xae, 0x08, 0xe7, 0x07, 0xff, 0xff, 0xa8, 0x08,
  398.     0xe7, 0x07, 0x00, 0x00, 0xa6, 0x08, 0xe7, 0x05,
  399.     0x00, 0xc0, 0x97, 0xcf, 0xd7, 0x09, 0x00, 0xc0,
  400.     0xc1, 0xdf, 0x48, 0x02, 0xd0, 0x09, 0x9c, 0x08,
  401.     0x27, 0x02, 0x9c, 0x08, 0xe7, 0x09, 0x20, 0xc0,
  402.     0xee, 0x09, 0xe7, 0xd0, 0xee, 0x09, 0xe7, 0x05,
  403.     0x00, 0xc0, 0x97, 0xcf, 0x48, 0x02, 0xc8, 0x37,
  404.     0x04, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00, 0x60,
  405.     0x21, 0xc0, 0xc0, 0x37, 0x3e, 0x00, 0x23, 0xc9,
  406.     0xc0, 0x57, 0xb4, 0x05, 0x1b, 0xc8, 0xc0, 0x17,
  407.     0x3f, 0x00, 0xc0, 0x67, 0xc0, 0xff, 0x30, 0x00,
  408.     0x08, 0x00, 0xf0, 0x07, 0x00, 0x00, 0x04, 0x00,
  409.     0x00, 0x02, 0xc0, 0x17, 0x4c, 0x00, 0x30, 0x00,
  410.     0x06, 0x00, 0xf0, 0x07, 0xbe, 0x01, 0x0a, 0x00,
  411.     0x48, 0x02, 0xc1, 0x07, 0x02, 0x00, 0xd7, 0x09,
  412.     0x00, 0xc0, 0xc1, 0xdf, 0x51, 0xaf, 0xe7, 0x05,
  413.     0x00, 0xc0, 0x97, 0xcf, 0x9f, 0xaf, 0x68, 0x04,
  414.     0x9f, 0xaf, 0xe4, 0x03, 0x97, 0xcf, 0x9f, 0xaf,
  415.     0xe4, 0x03, 0xc9, 0x37, 0x04, 0x00, 0xc1, 0xdf,
  416.     0xc8, 0x09, 0x70, 0x08, 0x50, 0x02, 0x67, 0x02,
  417.     0x70, 0x08, 0xd1, 0x07, 0x00, 0x00, 0xc0, 0xdf,
  418.     0x9f, 0xaf, 0xde, 0x01, 0x97, 0xcf, 0xe7, 0x57,
  419.     0x00, 0x00, 0xaa, 0x08, 0x97, 0xc1, 0xe7, 0x57,
  420.     0x01, 0x00, 0x7a, 0x08, 0x97, 0xc0, 0xc8, 0x09,
  421.     0x6e, 0x08, 0x08, 0x62, 0x97, 0xc0, 0x00, 0x02,
  422.     0xc0, 0x17, 0x0e, 0x00, 0x27, 0x00, 0x34, 0x01,
  423.     0x27, 0x0c, 0x0c, 0x00, 0x36, 0x01, 0xef, 0x57,
  424.     0x00, 0x00, 0xf0, 0x09, 0x9f, 0xc0, 0xbe, 0x02,
  425.     0xe7, 0x57, 0x00, 0x00, 0xb0, 0x08, 0x97, 0xc1,
  426.     0xe7, 0x07, 0x09, 0x00, 0x12, 0xc0, 0xe7, 0x77,
  427.     0x00, 0x08, 0x20, 0xc0, 0x9f, 0xc1, 0xb6, 0x02,
  428.     0xe7, 0x57, 0x09, 0x00, 0x12, 0xc0, 0x77, 0xc9,
  429.     0xd7, 0x09, 0x00, 0xc0, 0xc1, 0xdf, 0xe7, 0x77,
  430.     0x00, 0x08, 0x20, 0xc0, 0x2f, 0xc1, 0xe7, 0x07,
  431.     0x00, 0x00, 0x42, 0xc0, 0xe7, 0x07, 0x05, 0x00,
  432.     0x90, 0xc0, 0xc8, 0x07, 0x0a, 0x00, 0xe7, 0x77,
  433.     0x04, 0x00, 0x20, 0xc0, 0x09, 0xc1, 0x08, 0xda,
  434.     0x7a, 0xc1, 0xe7, 0x07, 0x00, 0x01, 0x42, 0xc0,
  435.     0xe7, 0x07, 0x04, 0x00, 0x90, 0xc0, 0x1a, 0xcf,
  436.     0xe7, 0x07, 0x01, 0x00, 0x7a, 0x08, 0x00, 0xd8,
  437.     0x27, 0x50, 0x34, 0x01, 0x17, 0xc1, 0xe7, 0x77,
  438.     0x02, 0x00, 0x20, 0xc0, 0x79, 0xc1, 0x27, 0x50,
  439.     0x34, 0x01, 0x10, 0xc1, 0xe7, 0x77, 0x02, 0x00,
  440.     0x20, 0xc0, 0x79, 0xc0, 0x9f, 0xaf, 0xd8, 0x02,
  441.     0xe7, 0x05, 0x00, 0xc0, 0x00, 0x60, 0x9f, 0xc0,
  442.     0xde, 0x01, 0x97, 0xcf, 0xe7, 0x07, 0x01, 0x00,
  443.     0xb8, 0x08, 0x06, 0xcf, 0xe7, 0x07, 0x30, 0x0e,
  444.     0x02, 0x00, 0xe7, 0x07, 0x50, 0xc3, 0x12, 0xc0,
  445.     0xe7, 0x05, 0x00, 0xc0, 0x97, 0xcf, 0xe7, 0x07,
  446.     0x01, 0x00, 0xb8, 0x08, 0x97, 0xcf, 0xe7, 0x07,
  447.     0x50, 0xc3, 0x12, 0xc0, 0xe7, 0x07, 0x30, 0x0e,
  448.     0x02, 0x00, 0xe7, 0x07, 0x01, 0x00, 0x7a, 0x08,
  449.     0xe7, 0x07, 0x05, 0x00, 0x90, 0xc0, 0x97, 0xcf,
  450.     0xe7, 0x07, 0x00, 0x01, 0x42, 0xc0, 0xe7, 0x07,
  451.     0x04, 0x00, 0x90, 0xc0, 0xe7, 0x07, 0x00, 0x00,
  452.     0x7a, 0x08, 0xe7, 0x57, 0x0f, 0x00, 0xb2, 0x08,
  453.     0x13, 0xc1, 0x9f, 0xaf, 0x2e, 0x08, 0xca, 0x09,
  454.     0xac, 0x08, 0xf2, 0x17, 0x01, 0x00, 0x5c, 0x00,
  455.     0xf2, 0x27, 0x00, 0x00, 0x5e, 0x00, 0xe7, 0x07,
  456.     0x00, 0x00, 0xb2, 0x08, 0xe7, 0x07, 0x01, 0x00,
  457.     0xb4, 0x08, 0xc0, 0x07, 0xff, 0xff, 0x97, 0xcf,
  458.     0x9f, 0xaf, 0x4c, 0x03, 0xc0, 0x69, 0xb4, 0x08,
  459.     0x57, 0x00, 0x9f, 0xde, 0x33, 0x00, 0xc1, 0x05,
  460.     0x27, 0xd8, 0xb2, 0x08, 0x27, 0xd2, 0xb4, 0x08,
  461.     0xe7, 0x87, 0x01, 0x00, 0xb4, 0x08, 0xe7, 0x67,
  462.     0xff, 0x03, 0xb4, 0x08, 0x00, 0x60, 0x97, 0xc0,
  463.     0xe7, 0x07, 0x01, 0x00, 0xb0, 0x08, 0x27, 0x00,
  464.     0x12, 0xc0, 0x97, 0xcf, 0xc0, 0x09, 0xb6, 0x08,
  465.     0x00, 0xd2, 0x02, 0xc3, 0xc0, 0x97, 0x05, 0x80,
  466.     0x27, 0x00, 0xb6, 0x08, 0xc0, 0x99, 0x82, 0x08,
  467.     0xc0, 0x99, 0xa2, 0xc0, 0x97, 0xcf, 0xe7, 0x07,
  468.     0x00, 0x00, 0xb0, 0x08, 0xc0, 0xdf, 0x97, 0xcf,
  469.     0xc8, 0x09, 0x72, 0x08, 0x08, 0x62, 0x02, 0xc0,
  470.     0x10, 0x64, 0x07, 0xc1, 0xe7, 0x07, 0x00, 0x00,
  471.     0x64, 0x08, 0xe7, 0x07, 0xc8, 0x05, 0x24, 0x00,
  472.     0x97, 0xcf, 0x27, 0x04, 0x72, 0x08, 0xc8, 0x17,
  473.     0x0e, 0x00, 0x27, 0x02, 0x64, 0x08, 0xe7, 0x07,
  474.     0xd6, 0x05, 0x24, 0x00, 0x97, 0xcf, 0xd7, 0x09,
  475.     0x00, 0xc0, 0xc1, 0xdf, 0xe7, 0x57, 0x00, 0x00,
  476.     0x62, 0x08, 0x13, 0xc1, 0x9f, 0xaf, 0x70, 0x03,
  477.     0xe7, 0x57, 0x00, 0x00, 0x64, 0x08, 0x13, 0xc0,
  478.     0xe7, 0x09, 0x64, 0x08, 0x30, 0x01, 0xe7, 0x07,
  479.     0xf2, 0x05, 0x32, 0x01, 0xe7, 0x07, 0x10, 0x00,
  480.     0x96, 0xc0, 0xe7, 0x09, 0x64, 0x08, 0x62, 0x08,
  481.     0x04, 0xcf, 0xe7, 0x57, 0x00, 0x00, 0x64, 0x08,
  482.     0x02, 0xc1, 0x9f, 0xaf, 0x70, 0x03, 0xe7, 0x05,
  483.     0x00, 0xc0, 0x97, 0xcf, 0xd7, 0x09, 0x00, 0xc0,
  484.     0xc1, 0xdf, 0xc8, 0x09, 0x72, 0x08, 0x27, 0x02,
  485.     0x78, 0x08, 0x08, 0x62, 0x03, 0xc1, 0xe7, 0x05,
  486.     0x00, 0xc0, 0x97, 0xcf, 0x27, 0x04, 0x72, 0x08,
  487.     0xe7, 0x05, 0x00, 0xc0, 0xf0, 0x07, 0x40, 0x00,
  488.     0x08, 0x00, 0xf0, 0x07, 0x00, 0x00, 0x04, 0x00,
  489.     0x00, 0x02, 0xc0, 0x17, 0x0c, 0x00, 0x30, 0x00,
  490.     0x06, 0x00, 0xf0, 0x07, 0x64, 0x01, 0x0a, 0x00,
  491.     0xc8, 0x17, 0x04, 0x00, 0xc1, 0x07, 0x02, 0x00,
  492.     0x51, 0xaf, 0x97, 0xcf, 0xe7, 0x57, 0x00, 0x00,
  493.     0x6a, 0x08, 0x97, 0xc0, 0xc1, 0xdf, 0xc8, 0x09,
  494.     0x6a, 0x08, 0x27, 0x04, 0x6a, 0x08, 0x27, 0x52,
  495.     0x6c, 0x08, 0x03, 0xc1, 0xe7, 0x07, 0x6a, 0x08,
  496.     0x6c, 0x08, 0xc0, 0xdf, 0x17, 0x02, 0xc8, 0x17,
  497.     0x0e, 0x00, 0x9f, 0xaf, 0x16, 0x05, 0xc8, 0x05,
  498.     0x00, 0x60, 0x03, 0xc0, 0x9f, 0xaf, 0x80, 0x04,
  499.     0x97, 0xcf, 0x9f, 0xaf, 0x68, 0x04, 0x97, 0xcf,
  500.     0xd7, 0x09, 0x00, 0xc0, 0xc1, 0xdf, 0x08, 0x62,
  501.     0x1c, 0xc0, 0xd0, 0x09, 0x72, 0x08, 0x27, 0x02,
  502.     0x72, 0x08, 0xe7, 0x05, 0x00, 0xc0, 0x97, 0xcf,
  503.     0x97, 0x02, 0xca, 0x09, 0xac, 0x08, 0xf2, 0x17,
  504.     0x01, 0x00, 0x04, 0x00, 0xf2, 0x27, 0x00, 0x00,
  505.     0x06, 0x00, 0xca, 0x17, 0x2c, 0x00, 0xf8, 0x77,
  506.     0x01, 0x00, 0x0e, 0x00, 0x06, 0xc0, 0xca, 0xd9,
  507.     0xf8, 0x57, 0xff, 0x00, 0x0e, 0x00, 0x01, 0xc1,
  508.     0xca, 0xd9, 0x22, 0x1c, 0x0c, 0x00, 0xe2, 0x27,
  509.     0x00, 0x00, 0xe2, 0x17, 0x01, 0x00, 0xe2, 0x27,
  510.     0x00, 0x00, 0xca, 0x05, 0x00, 0x0c, 0x0c, 0x00,
  511.     0xc0, 0x17, 0x41, 0x00, 0xc0, 0x67, 0xc0, 0xff,
  512.     0x30, 0x00, 0x08, 0x00, 0x00, 0x02, 0xc0, 0x17,
  513.     0x0c, 0x00, 0x30, 0x00, 0x06, 0x00, 0xf0, 0x07,
  514.     0xdc, 0x00, 0x0a, 0x00, 0xf0, 0x07, 0x00, 0x00,
  515.     0x04, 0x00, 0x00, 0x0c, 0x08, 0x00, 0x40, 0xd1,
  516.     0x01, 0x00, 0xc0, 0x19, 0xa6, 0x08, 0xc0, 0x59,
  517.     0x98, 0x08, 0x04, 0xc9, 0x49, 0xaf, 0x9f, 0xaf,
  518.     0xee, 0x00, 0x4a, 0xaf, 0x67, 0x10, 0xa6, 0x08,
  519.     0xc8, 0x17, 0x04, 0x00, 0xc1, 0x07, 0x01, 0x00,
  520.     0xd7, 0x09, 0x00, 0xc0, 0xc1, 0xdf, 0x50, 0xaf,
  521.     0xe7, 0x05, 0x00, 0xc0, 0x97, 0xcf, 0xc0, 0x07,
  522.     0x01, 0x00, 0xc1, 0x09, 0x7c, 0x08, 0xc1, 0x77,
  523.     0x01, 0x00, 0x97, 0xc1, 0xd8, 0x77, 0x01, 0x00,
  524.     0x12, 0xc0, 0xc9, 0x07, 0x4c, 0x08, 0x9f, 0xaf,
  525.     0x64, 0x05, 0x04, 0xc1, 0xc1, 0x77, 0x08, 0x00,
  526.     0x13, 0xc0, 0x97, 0xcf, 0xc1, 0x77, 0x02, 0x00,
  527.     0x97, 0xc1, 0xc1, 0x77, 0x10, 0x00, 0x0c, 0xc0,
  528.     0x9f, 0xaf, 0x86, 0x05, 0x97, 0xcf, 0xc1, 0x77,
  529.     0x04, 0x00, 0x06, 0xc0, 0xc9, 0x07, 0x7e, 0x08,
  530.     0x9f, 0xaf, 0x64, 0x05, 0x97, 0xc0, 0x00, 0xcf,
  531.     0x00, 0x90, 0x97, 0xcf, 0x50, 0x54, 0x97, 0xc1,
  532.     0x70, 0x5c, 0x02, 0x00, 0x02, 0x00, 0x97, 0xc1,
  533.     0x70, 0x5c, 0x04, 0x00, 0x04, 0x00, 0x97, 0xcf,
  534.     0xc0, 0x00, 0x60, 0x00, 0x30, 0x00, 0x18, 0x00,
  535.     0x0c, 0x00, 0x06, 0x00, 0x00, 0x00, 0xcb, 0x09,
  536.     0x88, 0x08, 0xcc, 0x09, 0x8a, 0x08, 0x0b, 0x53,
  537.     0x11, 0xc0, 0xc9, 0x02, 0xca, 0x07, 0x78, 0x05,
  538.     0x9f, 0xaf, 0x64, 0x05, 0x97, 0xc0, 0x0a, 0xc8,
  539.     0x82, 0x08, 0x0a, 0xcf, 0x82, 0x08, 0x9f, 0xaf,
  540.     0x64, 0x05, 0x97, 0xc0, 0x05, 0xc2, 0x89, 0x30,
  541.     0x82, 0x60, 0x78, 0xc1, 0x00, 0x90, 0x97, 0xcf,
  542.     0x89, 0x10, 0x09, 0x53, 0x79, 0xc2, 0x89, 0x30,
  543.     0x82, 0x08, 0x7a, 0xcf, 0xc0, 0xdf, 0x97, 0xcf,
  544.     0xe7, 0x09, 0x96, 0xc0, 0x66, 0x08, 0xe7, 0x09,
  545.     0x98, 0xc0, 0x68, 0x08, 0x0f, 0xcf, 0xe7, 0x09,
  546.     0x96, 0xc0, 0x66, 0x08, 0xe7, 0x09, 0x98, 0xc0,
  547.     0x68, 0x08, 0xe7, 0x09, 0x64, 0x08, 0x30, 0x01,
  548.     0xe7, 0x07, 0xf2, 0x05, 0x32, 0x01, 0xe7, 0x07,
  549.     0x10, 0x00, 0x96, 0xc0, 0xd7, 0x09, 0x00, 0xc0,
  550.     0x17, 0x02, 0xc8, 0x09, 0x62, 0x08, 0xc8, 0x37,
  551.     0x0e, 0x00, 0xe7, 0x57, 0x04, 0x00, 0x68, 0x08,
  552.     0x3d, 0xc0, 0xe7, 0x87, 0x00, 0x08, 0x24, 0xc0,
  553.     0xe7, 0x09, 0x94, 0x08, 0xba, 0x08, 0xe7, 0x17,
  554.     0x64, 0x00, 0xba, 0x08, 0xe7, 0x67, 0xff, 0x07,
  555.     0xba, 0x08, 0xe7, 0x77, 0x2a, 0x00, 0x66, 0x08,
  556.     0x30, 0xc0, 0x97, 0x02, 0xca, 0x09, 0xac, 0x08,
  557.     0xe7, 0x77, 0x20, 0x00, 0x66, 0x08, 0x0e, 0xc0,
  558.     0xf2, 0x17, 0x01, 0x00, 0x10, 0x00, 0xf2, 0x27,
  559.     0x00, 0x00, 0x12, 0x00, 0xe7, 0x77, 0x0a, 0x00,
  560.     0x66, 0x08, 0xca, 0x05, 0x1e, 0xc0, 0x97, 0x02,
  561.     0xca, 0x09, 0xac, 0x08, 0xf2, 0x17, 0x01, 0x00,
  562.     0x0c, 0x00, 0xf2, 0x27, 0x00, 0x00, 0x0e, 0x00,
  563.     0xe7, 0x77, 0x02, 0x00, 0x66, 0x08, 0x07, 0xc0,
  564.     0xf2, 0x17, 0x01, 0x00, 0x44, 0x00, 0xf2, 0x27,
  565.     0x00, 0x00, 0x46, 0x00, 0x06, 0xcf, 0xf2, 0x17,
  566.     0x01, 0x00, 0x60, 0x00, 0xf2, 0x27, 0x00, 0x00,
  567.     0x62, 0x00, 0xca, 0x05, 0x9f, 0xaf, 0x68, 0x04,
  568.     0x0f, 0xcf, 0x57, 0x02, 0x09, 0x02, 0xf1, 0x09,
  569.     0x68, 0x08, 0x0c, 0x00, 0xf1, 0xda, 0x0c, 0x00,
  570.     0xc8, 0x09, 0x6c, 0x08, 0x50, 0x02, 0x67, 0x02,
  571.     0x6c, 0x08, 0xd1, 0x07, 0x00, 0x00, 0xc9, 0x05,
  572.     0xe7, 0x09, 0x64, 0x08, 0x62, 0x08, 0xe7, 0x57,
  573.     0x00, 0x00, 0x62, 0x08, 0x02, 0xc0, 0x9f, 0xaf,
  574.     0x70, 0x03, 0xc8, 0x05, 0xe7, 0x05, 0x00, 0xc0,
  575.     0xc0, 0xdf, 0x97, 0xcf, 0xd7, 0x09, 0x00, 0xc0,
  576.     0x17, 0x00, 0x17, 0x02, 0x97, 0x02, 0xc0, 0x09,
  577.     0x92, 0xc0, 0xe7, 0x87, 0x00, 0x08, 0x24, 0xc0,
  578.     0xe7, 0x09, 0x94, 0x08, 0xba, 0x08, 0xe7, 0x17,
  579.     0x64, 0x00, 0xba, 0x08, 0xe7, 0x67, 0xff, 0x07,
  580.     0xba, 0x08, 0xe7, 0x07, 0x04, 0x00, 0x90, 0xc0,
  581.     0xca, 0x09, 0xac, 0x08, 0xe7, 0x07, 0x00, 0x00,
  582.     0x7a, 0x08, 0xe7, 0x07, 0x66, 0x03, 0x02, 0x00,
  583.     0xc0, 0x77, 0x02, 0x00, 0x10, 0xc0, 0xef, 0x57,
  584.     0x00, 0x00, 0xf0, 0x09, 0x04, 0xc0, 0x9f, 0xaf,
  585.     0xd8, 0x02, 0x9f, 0xcf, 0x12, 0x08, 0xf2, 0x17,
  586.     0x01, 0x00, 0x50, 0x00, 0xf2, 0x27, 0x00, 0x00,
  587.     0x52, 0x00, 0x9f, 0xcf, 0x12, 0x08, 0xef, 0x57,
  588.     0x00, 0x00, 0xf0, 0x09, 0x08, 0xc0, 0xe7, 0x57,
  589.     0x00, 0x00, 0xb8, 0x08, 0xe7, 0x07, 0x00, 0x00,
  590.     0xb8, 0x08, 0x0a, 0xc0, 0x03, 0xcf, 0xc0, 0x77,
  591.     0x10, 0x00, 0x06, 0xc0, 0xf2, 0x17, 0x01, 0x00,
  592.     0x58, 0x00, 0xf2, 0x27, 0x00, 0x00, 0x5a, 0x00,
  593.     0xc0, 0x77, 0x80, 0x00, 0x06, 0xc0, 0xf2, 0x17,
  594.     0x01, 0x00, 0x70, 0x00, 0xf2, 0x27, 0x00, 0x00,
  595.     0x72, 0x00, 0xc0, 0x77, 0x08, 0x00, 0x1d, 0xc1,
  596.     0xf2, 0x17, 0x01, 0x00, 0x08, 0x00, 0xf2, 0x27,
  597.     0x00, 0x00, 0x0a, 0x00, 0xc0, 0x77, 0x00, 0x02,
  598.     0x06, 0xc0, 0xf2, 0x17, 0x01, 0x00, 0x64, 0x00,
  599.     0xf2, 0x27, 0x00, 0x00, 0x66, 0x00, 0xc0, 0x77,
  600.     0x40, 0x00, 0x06, 0xc0, 0xf2, 0x17, 0x01, 0x00,
  601.     0x5c, 0x00, 0xf2, 0x27, 0x00, 0x00, 0x5e, 0x00,
  602.     0xc0, 0x77, 0x01, 0x00, 0x01, 0xc0, 0x37, 0xcf,
  603.     0x36, 0xcf, 0xf2, 0x17, 0x01, 0x00, 0x00, 0x00,
  604.     0xf2, 0x27, 0x00, 0x00, 0x02, 0x00, 0xef, 0x57,
  605.     0x00, 0x00, 0xf0, 0x09, 0x18, 0xc0, 0xe7, 0x57,
  606.     0x01, 0x00, 0xb2, 0x08, 0x0e, 0xc2, 0x07, 0xc8,
  607.     0xf2, 0x17, 0x01, 0x00, 0x50, 0x00, 0xf2, 0x27,
  608.     0x00, 0x00, 0x52, 0x00, 0x06, 0xcf, 0xf2, 0x17,
  609.     0x01, 0x00, 0x54, 0x00, 0xf2, 0x27, 0x00, 0x00,
  610.     0x56, 0x00, 0xe7, 0x07, 0x00, 0x00, 0xb2, 0x08,
  611.     0xe7, 0x07, 0x01, 0x00, 0xb4, 0x08, 0xc8, 0x09,
  612.     0x34, 0x01, 0xca, 0x17, 0x14, 0x00, 0xd8, 0x77,
  613.     0x01, 0x00, 0x05, 0xc0, 0xca, 0xd9, 0xd8, 0x57,
  614.     0xff, 0x00, 0x01, 0xc0, 0xca, 0xd9, 0xe2, 0x19,
  615.     0x94, 0xc0, 0xe2, 0x27, 0x00, 0x00, 0xe2, 0x17,
  616.     0x01, 0x00, 0xe2, 0x27, 0x00, 0x00, 0x9f, 0xaf,
  617.     0x2e, 0x08, 0x9f, 0xaf, 0xde, 0x01, 0xe7, 0x57,
  618.     0x00, 0x00, 0xaa, 0x08, 0x9f, 0xa1, 0xf0, 0x0b,
  619.     0xca, 0x05, 0xc8, 0x05, 0xc0, 0x05, 0xe7, 0x05,
  620.     0x00, 0xc0, 0xc0, 0xdf, 0x97, 0xcf, 0xc8, 0x09,
  621.     0x6e, 0x08, 0x08, 0x62, 0x97, 0xc0, 0x27, 0x04,
  622.     0x6e, 0x08, 0x27, 0x52, 0x70, 0x08, 0x03, 0xc1,
  623.     0xe7, 0x07, 0x6e, 0x08, 0x70, 0x08, 0x9f, 0xaf,
  624.     0x68, 0x04, 0x97, 0xcf, 0xff, 0xff, 0xff, 0xff,
  625.     0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  626.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  627.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  628.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  629.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  630.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  631.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  632.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  633.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  634.     0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  635.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  636.     0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
  637.     0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x33, 0xcc,
  638.     0x00, 0x00, 0x00, 0x00, 0xe7, 0x57, 0x00, 0x80,
  639.     0xb2, 0x00, 0x06, 0xc2, 0xe7, 0x07, 0x52, 0x0e,
  640.     0x12, 0x00, 0xe7, 0x07, 0x98, 0x0e, 0xb2, 0x00,
  641.     0xe7, 0x07, 0xa4, 0x09, 0xf2, 0x02, 0xc8, 0x09,
  642.     0xb4, 0x00, 0xf8, 0x07, 0x02, 0x00, 0x0d, 0x00,
  643.     0xd7, 0x09, 0x0e, 0xc0, 0xe7, 0x07, 0x00, 0x00,
  644.     0x0e, 0xc0, 0xc8, 0x09, 0xdc, 0x00, 0xf0, 0x07,
  645.     0xff, 0xff, 0x09, 0x00, 0xf0, 0x07, 0xfb, 0x13,
  646.     0x0b, 0x00, 0xe7, 0x09, 0xc0, 0x00, 0x58, 0x08,
  647.     0xe7, 0x09, 0xbe, 0x00, 0x54, 0x08, 0xe7, 0x09,
  648.     0x10, 0x00, 0x92, 0x08, 0xc8, 0x07, 0xb4, 0x09,
  649.     0x9f, 0xaf, 0x8c, 0x09, 0x9f, 0xaf, 0xe2, 0x0b,
  650.     0xc0, 0x07, 0x80, 0x01, 0x44, 0xaf, 0x27, 0x00,
  651.     0x88, 0x08, 0x27, 0x00, 0x8a, 0x08, 0x27, 0x00,
  652.     0x8c, 0x08, 0xc0, 0x07, 0x74, 0x00, 0x44, 0xaf,
  653.     0x27, 0x00, 0xac, 0x08, 0x08, 0x00, 0x00, 0x90,
  654.     0xc1, 0x07, 0x1d, 0x00, 0x20, 0x00, 0x20, 0x00,
  655.     0x01, 0xda, 0x7c, 0xc1, 0x9f, 0xaf, 0x8a, 0x0b,
  656.     0xc0, 0x07, 0x4c, 0x00, 0x48, 0xaf, 0x27, 0x00,
  657.     0x56, 0x08, 0x9f, 0xaf, 0x72, 0x0c, 0xe7, 0x07,
  658.     0x00, 0x80, 0x96, 0x08, 0xef, 0x57, 0x00, 0x00,
  659.     0xf0, 0x09, 0x03, 0xc0, 0xe7, 0x07, 0x01, 0x00,
  660.     0x1c, 0xc0, 0xe7, 0x05, 0x0e, 0xc0, 0x97, 0xcf,
  661.     0x49, 0xaf, 0xe7, 0x87, 0x43, 0x00, 0x0e, 0xc0,
  662.     0xe7, 0x07, 0xff, 0xff, 0x94, 0x08, 0x9f, 0xaf,
  663.     0x8a, 0x0c, 0xc0, 0x07, 0x01, 0x00, 0x60, 0xaf,
  664.     0x4a, 0xaf, 0x97, 0xcf, 0x00, 0x08, 0x09, 0x08,
  665.     0x11, 0x08, 0x00, 0xda, 0x7c, 0xc1, 0x97, 0xcf,
  666.     0x67, 0x04, 0xcc, 0x02, 0xc0, 0xdf, 0x51, 0x94,
  667.     0xb1, 0xaf, 0x06, 0x00, 0xc1, 0xdf, 0xc9, 0x09,
  668.     0xcc, 0x02, 0x49, 0x62, 0x75, 0xc1, 0xc0, 0xdf,
  669.     0xa7, 0xcf, 0xd6, 0x02, 0x0e, 0x00, 0x24, 0x00,
  670.     0xd6, 0x05, 0x22, 0x00, 0xc4, 0x06, 0xd0, 0x00,
  671.     0xf0, 0x0b, 0xaa, 0x00, 0x0e, 0x0a, 0xbe, 0x00,
  672.     0x2c, 0x0c, 0x10, 0x00, 0x20, 0x00, 0x04, 0x00,
  673.     0xc4, 0x05, 0x02, 0x00, 0x66, 0x03, 0x06, 0x00,
  674.     0x00, 0x00, 0x24, 0xc0, 0x04, 0x04, 0x28, 0xc0,
  675.     0xfe, 0xfb, 0x1e, 0xc0, 0x00, 0x04, 0x22, 0xc0,
  676.     0xff, 0xf0, 0xc0, 0x00, 0x60, 0x0b, 0x00, 0x00,
  677.     0x00, 0x00, 0xff, 0xff, 0x34, 0x0a, 0x3e, 0x0a,
  678.     0x9e, 0x0a, 0xa8, 0x0a, 0xce, 0x0a, 0xd2, 0x0a,
  679.     0xd6, 0x0a, 0x00, 0x0b, 0x10, 0x0b, 0x1e, 0x0b,
  680.     0x20, 0x0b, 0x28, 0x0b, 0x28, 0x0b, 0x27, 0x02,
  681.     0xa2, 0x08, 0x97, 0xcf, 0xe7, 0x07, 0x00, 0x00,
  682.     0xa2, 0x08, 0x0a, 0x0e, 0x01, 0x00, 0xca, 0x57,
  683.     0x0e, 0x00, 0x9f, 0xc3, 0x2a, 0x0b, 0xca, 0x37,
  684.     0x00, 0x00, 0x9f, 0xc2, 0x2a, 0x0b, 0x0a, 0xd2,
  685.     0xb2, 0xcf, 0xf4, 0x09, 0xc8, 0x09, 0xde, 0x00,
  686.     0x07, 0x06, 0x9f, 0xcf, 0x3c, 0x0b, 0xf0, 0x57,
  687.     0x80, 0x01, 0x06, 0x00, 0x9f, 0xc8, 0x2a, 0x0b,
  688.     0x27, 0x0c, 0x02, 0x00, 0x86, 0x08, 0xc0, 0x09,
  689.     0x88, 0x08, 0x27, 0x00, 0x8a, 0x08, 0xe7, 0x07,
  690.     0x00, 0x00, 0x84, 0x08, 0x27, 0x00, 0x5c, 0x08,
  691.     0x00, 0x1c, 0x06, 0x00, 0x27, 0x00, 0x8c, 0x08,
  692.     0x41, 0x90, 0x67, 0x50, 0x86, 0x08, 0x0d, 0xc0,
  693.     0x67, 0x00, 0x5a, 0x08, 0x27, 0x0c, 0x06, 0x00,
  694.     0x5e, 0x08, 0xe7, 0x07, 0x8a, 0x0a, 0x60, 0x08,
  695.     0xc8, 0x07, 0x5a, 0x08, 0x41, 0x90, 0x51, 0xaf,
  696.     0x97, 0xcf, 0x9f, 0xaf, 0xac, 0x0e, 0xe7, 0x09,
  697.     0x8c, 0x08, 0x8a, 0x08, 0xe7, 0x09, 0x86, 0x08,
  698.     0x84, 0x08, 0x59, 0xaf, 0x97, 0xcf, 0x27, 0x0c,
  699.     0x02, 0x00, 0x7c, 0x08, 0x59, 0xaf, 0x97, 0xcf,
  700.     0x09, 0x0c, 0x02, 0x00, 0x09, 0xda, 0x49, 0xd2,
  701.     0xc9, 0x19, 0xac, 0x08, 0xc8, 0x07, 0x5a, 0x08,
  702.     0xe0, 0x07, 0x00, 0x00, 0x60, 0x02, 0xe0, 0x07,
  703.     0x04, 0x00, 0xd0, 0x07, 0x9a, 0x0a, 0x48, 0xdb,
  704.     0x41, 0x90, 0x50, 0xaf, 0x97, 0xcf, 0x59, 0xaf,
  705.     0x97, 0xcf, 0x59, 0xaf, 0x97, 0xcf, 0xf0, 0x57,
  706.     0x06, 0x00, 0x06, 0x00, 0x26, 0xc1, 0xe7, 0x07,
  707.     0x7e, 0x08, 0x5c, 0x08, 0x41, 0x90, 0x67, 0x00,
  708.     0x5a, 0x08, 0x27, 0x0c, 0x06, 0x00, 0x5e, 0x08,
  709.     0xe7, 0x07, 0x5c, 0x0b, 0x60, 0x08, 0xc8, 0x07,
  710.     0x5a, 0x08, 0x41, 0x90, 0x51, 0xaf, 0x97, 0xcf,
  711.     0x07, 0x0c, 0x06, 0x00, 0xc7, 0x57, 0x06, 0x00,
  712.     0x10, 0xc1, 0xc8, 0x07, 0x7e, 0x08, 0x16, 0xcf,
  713.     0x00, 0x0c, 0x02, 0x00, 0x00, 0xda, 0x40, 0xd1,
  714.     0x27, 0x00, 0x98, 0x08, 0x1f, 0xcf, 0x1e, 0xcf,
  715.     0x27, 0x0c, 0x02, 0x00, 0xa4, 0x08, 0x1a, 0xcf,
  716.     0x00, 0xcf, 0x27, 0x02, 0x20, 0x01, 0xe7, 0x07,
  717.     0x08, 0x00, 0x22, 0x01, 0xe7, 0x07, 0x13, 0x00,
  718.     0xb0, 0xc0, 0x97, 0xcf, 0x41, 0x90, 0x67, 0x00,
  719.     0x5a, 0x08, 0xe7, 0x01, 0x5e, 0x08, 0x27, 0x02,
  720.     0x5c, 0x08, 0xe7, 0x07, 0x5c, 0x0b, 0x60, 0x08,
  721.     0xc8, 0x07, 0x5a, 0x08, 0xc1, 0x07, 0x00, 0x80,
  722.     0x50, 0xaf, 0x97, 0xcf, 0x59, 0xaf, 0x97, 0xcf,
  723.     0x00, 0x60, 0x05, 0xc0, 0xe7, 0x07, 0x00, 0x00,
  724.     0x9a, 0x08, 0xa7, 0xcf, 0x58, 0x08, 0x9f, 0xaf,
  725.     0xe2, 0x0b, 0xe7, 0x07, 0x01, 0x00, 0x9a, 0x08,
  726.     0x49, 0xaf, 0xd7, 0x09, 0x00, 0xc0, 0x07, 0xaf,
  727.     0xe7, 0x05, 0x00, 0xc0, 0x4a, 0xaf, 0xa7, 0xcf,
  728.     0x58, 0x08, 0xc0, 0x07, 0x40, 0x00, 0x44, 0xaf,
  729.     0x27, 0x00, 0xa0, 0x08, 0x08, 0x00, 0xc0, 0x07,
  730.     0x20, 0x00, 0x20, 0x94, 0x00, 0xda, 0x7d, 0xc1,
  731.     0xc0, 0x07, 0xfe, 0x7f, 0x44, 0xaf, 0x40, 0x00,
  732.     0x41, 0x90, 0xc0, 0x37, 0x08, 0x00, 0xdf, 0xde,
  733.     0x50, 0x06, 0xc0, 0x57, 0x10, 0x00, 0x02, 0xc2,
  734.     0xc0, 0x07, 0x10, 0x00, 0x27, 0x00, 0x76, 0x08,
  735.     0x41, 0x90, 0x9f, 0xde, 0x40, 0x06, 0x44, 0xaf,
  736.     0x27, 0x00, 0x74, 0x08, 0xc0, 0x09, 0x76, 0x08,
  737.     0x41, 0x90, 0x00, 0xd2, 0x00, 0xd8, 0x9f, 0xde,
  738.     0x08, 0x00, 0x44, 0xaf, 0x27, 0x00, 0x9e, 0x08,
  739.     0x97, 0xcf, 0xe7, 0x87, 0x00, 0x84, 0x28, 0xc0,
  740.     0xe7, 0x67, 0xff, 0xf3, 0x24, 0xc0, 0x97, 0xcf,
  741.     0xe7, 0x87, 0x01, 0x00, 0xaa, 0x08, 0xe7, 0x57,
  742.     0x00, 0x00, 0x7a, 0x08, 0x97, 0xc1, 0x9f, 0xaf,
  743.     0xe2, 0x0b, 0xe7, 0x87, 0x00, 0x06, 0x22, 0xc0,
  744.     0xe7, 0x07, 0x00, 0x00, 0x90, 0xc0, 0xe7, 0x67,
  745.     0xfe, 0xff, 0x3e, 0xc0, 0xe7, 0x07, 0x2e, 0x00,
  746.     0x0a, 0xc0, 0xe7, 0x87, 0x01, 0x00, 0x3e, 0xc0,
  747.     0xe7, 0x07, 0xff, 0xff, 0x94, 0x08, 0x9f, 0xaf,
  748.     0xf0, 0x0c, 0x97, 0xcf, 0x17, 0x00, 0xa7, 0xaf,
  749.     0x54, 0x08, 0xc0, 0x05, 0x27, 0x00, 0x52, 0x08,
  750.     0xe7, 0x87, 0x01, 0x00, 0xaa, 0x08, 0x9f, 0xaf,
  751.     0xe2, 0x0b, 0xe7, 0x07, 0x0c, 0x00, 0x40, 0xc0,
  752.     0x9f, 0xaf, 0xf0, 0x0c, 0xe7, 0x07, 0x00, 0x00,
  753.     0x78, 0x08, 0x00, 0x90, 0xe7, 0x09, 0x88, 0x08,
  754.     0x8a, 0x08, 0x27, 0x00, 0x84, 0x08, 0x27, 0x00,
  755.     0x7c, 0x08, 0x9f, 0xaf, 0x8a, 0x0c, 0xe7, 0x07,
  756.     0x00, 0x00, 0xb2, 0x02, 0xe7, 0x07, 0x00, 0x00,
  757.     0xb4, 0x02, 0xc0, 0x07, 0x06, 0x00, 0xc8, 0x09,
  758.     0xde, 0x00, 0xc8, 0x17, 0x03, 0x00, 0xc9, 0x07,
  759.     0x7e, 0x08, 0x29, 0x0a, 0x00, 0xda, 0x7d, 0xc1,
  760.     0x97, 0xcf, 0xd7, 0x09, 0x00, 0xc0, 0xc1, 0xdf,
  761.     0x00, 0x90, 0x27, 0x00, 0x6a, 0x08, 0xe7, 0x07,
  762.     0x6a, 0x08, 0x6c, 0x08, 0x27, 0x00, 0x6e, 0x08,
  763.     0xe7, 0x07, 0x6e, 0x08, 0x70, 0x08, 0x27, 0x00,
  764.     0x78, 0x08, 0x27, 0x00, 0x62, 0x08, 0x27, 0x00,
  765.     0x64, 0x08, 0xc8, 0x09, 0x74, 0x08, 0xc1, 0x09,
  766.     0x76, 0x08, 0xc9, 0x07, 0x72, 0x08, 0x11, 0x02,
  767.     0x09, 0x02, 0xc8, 0x17, 0x40, 0x06, 0x01, 0xda,
  768.     0x7a, 0xc1, 0x51, 0x94, 0xc8, 0x09, 0x9e, 0x08,
  769.     0xc9, 0x07, 0x9c, 0x08, 0xc1, 0x09, 0x76, 0x08,
  770.     0x01, 0xd2, 0x01, 0xd8, 0x11, 0x02, 0x09, 0x02,
  771.     0xc8, 0x17, 0x08, 0x00, 0x01, 0xda, 0x7a, 0xc1,
  772.     0x51, 0x94, 0xe7, 0x05, 0x00, 0xc0, 0x97, 0xcf,
  773.     0xe7, 0x57, 0x00, 0x00, 0x52, 0x08, 0x97, 0xc0,
  774.     0x9f, 0xaf, 0x04, 0x00, 0xe7, 0x09, 0x94, 0x08,
  775.     0x90, 0x08, 0xe7, 0x57, 0xff, 0xff, 0x90, 0x08,
  776.     0x04, 0xc1, 0xe7, 0x07, 0xf0, 0x0c, 0x8e, 0x08,
  777.     0x97, 0xcf, 0xe7, 0x17, 0x32, 0x00, 0x90, 0x08,
  778.     0xe7, 0x67, 0xff, 0x07, 0x90, 0x08, 0xe7, 0x07,
  779.     0x26, 0x0d, 0x8e, 0x08, 0x97, 0xcf, 0xd7, 0x09,
  780.     0x00, 0xc0, 0xc1, 0xdf, 0xe7, 0x57, 0x00, 0x00,
  781.     0x96, 0x08, 0x23, 0xc0, 0xe7, 0x07, 0x00, 0x80,
  782.     0x80, 0xc0, 0xe7, 0x07, 0x04, 0x00, 0x90, 0xc0,
  783.     0xe7, 0x07, 0x00, 0x00, 0x80, 0xc0, 0xe7, 0x07,
  784.     0x00, 0x80, 0x80, 0xc0, 0xc0, 0x07, 0x00, 0x00,
  785.     0xc0, 0x07, 0x00, 0x00, 0xc0, 0x07, 0x00, 0x00,
  786.     0xe7, 0x07, 0x00, 0x00, 0x80, 0xc0, 0xe7, 0x07,
  787.     0x00, 0x80, 0x80, 0xc0, 0xe7, 0x07, 0x00, 0x80,
  788.     0x40, 0xc0, 0xc0, 0x07, 0x00, 0x00, 0xe7, 0x07,
  789.     0x00, 0x00, 0x40, 0xc0, 0xe7, 0x07, 0x00, 0x00,
  790.     0x80, 0xc0, 0xef, 0x57, 0x00, 0x00, 0xf1, 0x09,
  791.     0x9f, 0xa0, 0xc0, 0x0d, 0xe7, 0x07, 0x04, 0x00,
  792.     0x90, 0xc0, 0xe7, 0x07, 0x00, 0x02, 0x40, 0xc0,
  793.     0xe7, 0x07, 0x0c, 0x02, 0x40, 0xc0, 0xe7, 0x07,
  794.     0x00, 0x00, 0x96, 0x08, 0xe7, 0x07, 0x00, 0x00,
  795.     0x8e, 0x08, 0xe7, 0x07, 0x00, 0x00, 0xaa, 0x08,
  796.     0xd7, 0x09, 0x00, 0xc0, 0xc1, 0xdf, 0x9f, 0xaf,
  797.     0x9e, 0x03, 0xe7, 0x05, 0x00, 0xc0, 0x9f, 0xaf,
  798.     0xde, 0x01, 0xe7, 0x05, 0x00, 0xc0, 0x97, 0xcf,
  799.     0x9f, 0xaf, 0xde, 0x0d, 0xef, 0x77, 0x00, 0x00,
  800.     0xf1, 0x09, 0x97, 0xc1, 0x9f, 0xaf, 0xde, 0x0d,
  801.     0xef, 0x77, 0x00, 0x00, 0xf1, 0x09, 0x97, 0xc1,
  802.     0xef, 0x07, 0x01, 0x00, 0xf1, 0x09, 0xe7, 0x87,
  803.     0x00, 0x08, 0x1e, 0xc0, 0xe7, 0x87, 0x00, 0x08,
  804.     0x22, 0xc0, 0xe7, 0x67, 0xff, 0xf7, 0x22, 0xc0,
  805.     0xe7, 0x77, 0x00, 0x08, 0x20, 0xc0, 0x11, 0xc0,
  806.     0xe7, 0x67, 0xff, 0xf7, 0x1e, 0xc0, 0xe7, 0x87,
  807.     0x00, 0x08, 0x22, 0xc0, 0xe7, 0x67, 0xff, 0xf7,
  808.     0x22, 0xc0, 0xe7, 0x77, 0x00, 0x08, 0x20, 0xc0,
  809.     0x04, 0xc1, 0xe7, 0x87, 0x00, 0x08, 0x22, 0xc0,
  810.     0x97, 0xcf, 0xe7, 0x07, 0x01, 0x01, 0xf0, 0x09,
  811.     0xef, 0x57, 0x18, 0x00, 0xfe, 0xff, 0x97, 0xc2,
  812.     0xef, 0x07, 0x00, 0x00, 0xf0, 0x09, 0x97, 0xcf,
  813.     0xd7, 0x09, 0x00, 0xc0, 0x17, 0x00, 0x17, 0x02,
  814.     0x97, 0x02, 0xe7, 0x57, 0x00, 0x00, 0x7a, 0x08,
  815.     0x06, 0xc0, 0xc0, 0x09, 0x92, 0xc0, 0xc0, 0x77,
  816.     0x09, 0x02, 0x9f, 0xc1, 0xea, 0x06, 0x9f, 0xcf,
  817.     0x20, 0x08, 0xd7, 0x09, 0x0e, 0xc0, 0xe7, 0x07,
  818.     0x00, 0x00, 0x0e, 0xc0, 0x9f, 0xaf, 0x66, 0x0e,
  819.     0xe7, 0x05, 0x0e, 0xc0, 0x97, 0xcf, 0xd7, 0x09,
  820.     0x00, 0xc0, 0x17, 0x02, 0xc8, 0x09, 0xb0, 0xc0,
  821.     0xe7, 0x67, 0xfe, 0x7f, 0xb0, 0xc0, 0xc8, 0x77,
  822.     0x00, 0x20, 0x9f, 0xc1, 0x64, 0xeb, 0xe7, 0x57,
  823.     0x00, 0x00, 0xc8, 0x02, 0x9f, 0xc1, 0x80, 0xeb,
  824.     0xc8, 0x99, 0xca, 0x02, 0xc8, 0x67, 0x04, 0x00,
  825.     0x9f, 0xc1, 0x96, 0xeb, 0x9f, 0xcf, 0x4c, 0xeb,
  826.     0xe7, 0x07, 0x00, 0x00, 0xa6, 0xc0, 0xe7, 0x09,
  827.     0xb0, 0xc0, 0xc8, 0x02, 0xe7, 0x07, 0x03, 0x00,
  828.     0xb0, 0xc0, 0x97, 0xcf, 0xc0, 0x09, 0x86, 0x08,
  829.     0xc0, 0x37, 0x01, 0x00, 0x97, 0xc9, 0xc9, 0x09,
  830.     0x88, 0x08, 0x02, 0x00, 0x41, 0x90, 0x48, 0x02,
  831.     0xc9, 0x17, 0x06, 0x00, 0x9f, 0xaf, 0x64, 0x05,
  832.     0x9f, 0xa2, 0xd6, 0x0e, 0x02, 0xda, 0x77, 0xc1,
  833.     0x41, 0x60, 0x71, 0xc1, 0x97, 0xcf, 0x17, 0x02,
  834.     0x57, 0x02, 0x43, 0x04, 0x21, 0x04, 0xe0, 0x00,
  835.     0x43, 0x04, 0x21, 0x04, 0xe0, 0x00, 0x43, 0x04,
  836.     0x21, 0x04, 0xe0, 0x00, 0xc1, 0x07, 0x01, 0x00,
  837.     0xc9, 0x05, 0xc8, 0x05, 0x97, 0xcf,
  838.     0,    0
  839. };
  841. /*
  842.  *     klsiNewCodeFix
  843.  */
  844. static UINT8 klsiNewCodeFix[] = 
  845. {
  846.     0xB6, 0xC3, 0xAA, 0xBB, 0xCC, 0xDD,
  847.     0x02, 0x00, 0x08, 0x00, 0x24, 0x00, 0x2e, 0x00,
  848.     0x2c, 0x00, 0x3e, 0x00, 0x44, 0x00, 0x48, 0x00,
  849.     0x50, 0x00, 0x5c, 0x00, 0x60, 0x00, 0x66, 0x00,
  850.     0x6c, 0x00, 0x70, 0x00, 0x76, 0x00, 0x74, 0x00,
  851.     0x7a, 0x00, 0x7e, 0x00, 0x84, 0x00, 0x8a, 0x00,
  852.     0x8e, 0x00, 0x92, 0x00, 0x98, 0x00, 0x9c, 0x00,
  853.     0xa0, 0x00, 0xa8, 0x00, 0xae, 0x00, 0xb4, 0x00,
  854.     0xb2, 0x00, 0xba, 0x00, 0xbe, 0x00, 0xc4, 0x00,
  855.     0xc8, 0x00, 0xce, 0x00, 0xd2, 0x00, 0xd6, 0x00,
  856.     0xda, 0x00, 0xe2, 0x00, 0xe0, 0x00, 0xea, 0x00,
  857.     0xf2, 0x00, 0xfe, 0x00, 0x06, 0x01, 0x0c, 0x01,
  858.     0x1a, 0x01, 0x24, 0x01, 0x22, 0x01, 0x2a, 0x01,
  859.     0x30, 0x01, 0x36, 0x01, 0x3c, 0x01, 0x4e, 0x01,
  860.     0x52, 0x01, 0x58, 0x01, 0x5c, 0x01, 0x9c, 0x01,
  861.     0xb6, 0x01, 0xba, 0x01, 0xc0, 0x01, 0xca, 0x01,
  862.     0xd0, 0x01, 0xda, 0x01, 0xe2, 0x01, 0xea, 0x01,
  863.     0xf0, 0x01, 0x0a, 0x02, 0x0e, 0x02, 0x14, 0x02,
  864.     0x26, 0x02, 0x6c, 0x02, 0x8e, 0x02, 0x98, 0x02,
  865.     0xa0, 0x02, 0xa6, 0x02, 0xba, 0x02, 0xc6, 0x02,
  866.     0xce, 0x02, 0xe8, 0x02, 0xee, 0x02, 0xf4, 0x02,
  867.     0xf8, 0x02, 0x0a, 0x03, 0x10, 0x03, 0x1a, 0x03,
  868.     0x1e, 0x03, 0x2a, 0x03, 0x2e, 0x03, 0x34, 0x03,
  869.     0x3a, 0x03, 0x44, 0x03, 0x4e, 0x03, 0x5a, 0x03,
  870.     0x5e, 0x03, 0x6a, 0x03, 0x72, 0x03, 0x80, 0x03,
  871.     0x84, 0x03, 0x8c, 0x03, 0x94, 0x03, 0x98, 0x03,
  872.     0xa8, 0x03, 0xae, 0x03, 0xb4, 0x03, 0xba, 0x03,
  873.     0xce, 0x03, 0xcc, 0x03, 0xd6, 0x03, 0xdc, 0x03,
  874.     0xec, 0x03, 0xf0, 0x03, 0xfe, 0x03, 0x1c, 0x04,
  875.     0x30, 0x04, 0x38, 0x04, 0x3c, 0x04, 0x40, 0x04,
  876.     0x48, 0x04, 0x46, 0x04, 0x54, 0x04, 0x5e, 0x04,
  877.     0x64, 0x04, 0x74, 0x04, 0x78, 0x04, 0x84, 0x04,
  878.     0xd8, 0x04, 0xec, 0x04, 0xf0, 0x04, 0xf8, 0x04,
  879.     0xfe, 0x04, 0x1c, 0x05, 0x2c, 0x05, 0x30, 0x05,
  880.     0x4a, 0x05, 0x56, 0x05, 0x5a, 0x05, 0x88, 0x05,
  881.     0x8c, 0x05, 0x96, 0x05, 0x9a, 0x05, 0xa8, 0x05,
  882.     0xcc, 0x05, 0xd2, 0x05, 0xda, 0x05, 0xe0, 0x05,
  883.     0xe4, 0x05, 0xfc, 0x05, 0x06, 0x06, 0x14, 0x06,
  884.     0x12, 0x06, 0x1a, 0x06, 0x20, 0x06, 0x26, 0x06,
  885.     0x2e, 0x06, 0x34, 0x06, 0x48, 0x06, 0x52, 0x06,
  886.     0x64, 0x06, 0x86, 0x06, 0x90, 0x06, 0x9a, 0x06,
  887.     0xa0, 0x06, 0xac, 0x06, 0xaa, 0x06, 0xb2, 0x06,
  888.     0xb8, 0x06, 0xdc, 0x06, 0xda, 0x06, 0xe2, 0x06,
  889.     0xe8, 0x06, 0xf2, 0x06, 0xf8, 0x06, 0xfc, 0x06,
  890.     0x0a, 0x07, 0x10, 0x07, 0x14, 0x07, 0x24, 0x07,
  891.     0x2a, 0x07, 0x32, 0x07, 0x38, 0x07, 0xb2, 0x07,
  892.     0xba, 0x07, 0xde, 0x07, 0xe4, 0x07, 0x10, 0x08,
  893.     0x14, 0x08, 0x1a, 0x08, 0x1e, 0x08, 0x30, 0x08,
  894.     0x38, 0x08, 0x3c, 0x08, 0x44, 0x08, 0x42, 0x08,
  895.     0x48, 0x08, 0xc6, 0x08, 0xcc, 0x08, 0xd2, 0x08,
  896.     0xfe, 0x08, 0x04, 0x09, 0x0a, 0x09, 0x0e, 0x09,
  897.     0x12, 0x09, 0x16, 0x09, 0x20, 0x09, 0x24, 0x09,
  898.     0x28, 0x09, 0x32, 0x09, 0x46, 0x09, 0x4a, 0x09,
  899.     0x50, 0x09, 0x54, 0x09, 0x5a, 0x09, 0x60, 0x09,
  900.     0x7c, 0x09, 0x80, 0x09, 0xb8, 0x09, 0xbc, 0x09,
  901.     0xc0, 0x09, 0xc4, 0x09, 0xc8, 0x09, 0xcc, 0x09,
  902.     0xd0, 0x09, 0xd4, 0x09, 0xec, 0x09, 0xf4, 0x09,
  903.     0xf6, 0x09, 0xf8, 0x09, 0xfa, 0x09, 0xfc, 0x09,
  904.     0xfe, 0x09, 0x00, 0x0a, 0x02, 0x0a, 0x04, 0x0a,
  905.     0x06, 0x0a, 0x08, 0x0a, 0x0a, 0x0a, 0x0c, 0x0a,
  906.     0x10, 0x0a, 0x18, 0x0a, 0x24, 0x0a, 0x2c, 0x0a,
  907.     0x32, 0x0a, 0x3c, 0x0a, 0x46, 0x0a, 0x4c, 0x0a,
  908.     0x50, 0x0a, 0x54, 0x0a, 0x5a, 0x0a, 0x5e, 0x0a,
  909.     0x66, 0x0a, 0x6c, 0x0a, 0x72, 0x0a, 0x78, 0x0a,
  910.     0x7e, 0x0a, 0x7c, 0x0a, 0x82, 0x0a, 0x8c, 0x0a,
  911.     0x92, 0x0a, 0x90, 0x0a, 0x98, 0x0a, 0x96, 0x0a,
  912.     0xa2, 0x0a, 0xb2, 0x0a, 0xb6, 0x0a, 0xc4, 0x0a,
  913.     0xe2, 0x0a, 0xe0, 0x0a, 0xe8, 0x0a, 0xee, 0x0a,
  914.     0xf4, 0x0a, 0xf2, 0x0a, 0xf8, 0x0a, 0x0c, 0x0b,
  915.     0x1a, 0x0b, 0x24, 0x0b, 0x40, 0x0b, 0x44, 0x0b,
  916.     0x48, 0x0b, 0x4e, 0x0b, 0x4c, 0x0b, 0x52, 0x0b,
  917.     0x68, 0x0b, 0x6c, 0x0b, 0x70, 0x0b, 0x76, 0x0b,
  918.     0x88, 0x0b, 0x92, 0x0b, 0xbe, 0x0b, 0xca, 0x0b,
  919.     0xce, 0x0b, 0xde, 0x0b, 0xf4, 0x0b, 0xfa, 0x0b,
  920.     0x00, 0x0c, 0x24, 0x0c, 0x28, 0x0c, 0x30, 0x0c,
  921.     0x36, 0x0c, 0x3c, 0x0c, 0x40, 0x0c, 0x4a, 0x0c,
  922.     0x50, 0x0c, 0x58, 0x0c, 0x56, 0x0c, 0x5c, 0x0c,
  923.     0x60, 0x0c, 0x64, 0x0c, 0x80, 0x0c, 0x94, 0x0c,
  924.     0x9a, 0x0c, 0x98, 0x0c, 0x9e, 0x0c, 0xa4, 0x0c,
  925.     0xa2, 0x0c, 0xa8, 0x0c, 0xac, 0x0c, 0xb0, 0x0c,
  926.     0xb4, 0x0c, 0xb8, 0x0c, 0xbc, 0x0c, 0xce, 0x0c,
  927.     0xd2, 0x0c, 0xd6, 0x0c, 0xf4, 0x0c, 0xfa, 0x0c,
  928.     0x00, 0x0d, 0xfe, 0x0c, 0x06, 0x0d, 0x0e, 0x0d,
  929.     0x0c, 0x0d, 0x16, 0x0d, 0x1c, 0x0d, 0x22, 0x0d,
  930.     0x20, 0x0d, 0x30, 0x0d, 0x7e, 0x0d, 0x82, 0x0d,
  931.     0x9a, 0x0d, 0xa0, 0x0d, 0xa6, 0x0d, 0xb0, 0x0d,
  932.     0xb8, 0x0d, 0xc2, 0x0d, 0xc8, 0x0d, 0xce, 0x0d,
  933.     0xd4, 0x0d, 0xdc, 0x0d, 0x1e, 0x0e, 0x2c, 0x0e,
  934.     0x3e, 0x0e, 0x4c, 0x0e, 0x50, 0x0e, 0x5e, 0x0e,
  935.     0xae, 0x0e, 0xb8, 0x0e, 0xc6, 0x0e, 0xca, 0x0e,
  936.     0,    0
  937. };
  940. const int  lenKlsiNewCode = sizeof (klsiNewCode);
  941. const int  lenKlsiNewCodeFix = sizeof (klsiNewCodeFix);
  943. LOCAL UINT16  initCount = 0; /* Count of init nesting */
  945. LOCAL MUTEX_HANDLE  klsiMutex; /* to protect internal structs */
  946. LOCAL LIST_HEAD klsiDevList; /* linked list of Device Structs */
  947. LOCAL LIST_HEAD     reqList;        /* Attach callback request list */
  951. LOCAL MUTEX_HANDLE  klsiTxMutex; /* to protect internal structs */
  952. LOCAL MUTEX_HANDLE  klsiRxMutex; /* to protect internal structs */
  954. /* forward declarartions */
  956. /* END Specific Externally imported interfaces. */
  958. IMPORT int  endMultiLstCnt  (END_OBJ* pEnd);
  960. /* Externally visible interfaces. */
  962. END_OBJ *  KlsiEndLoad  (char * initString);
  963. STATUS  usbKlsiEndInit  (void);
  965. /*  LOCAL functions */
  967. LOCAL STATUS klsiEndStart (KLSI_DEVICE * pDrvCtrl);
  968. LOCAL STATUS klsiEndStop (KLSI_DEVICE * pDrvCtrl);
  969. LOCAL int klsiEndIoctl    (KLSI_DEVICE * pDrvCtrl, 
  970.  int cmd, caddr_t data);
  971. LOCAL STATUS klsiEndUnload (KLSI_DEVICE * pDrvCtrl);
  972. LOCAL STATUS klsiEndSend (KLSI_DEVICE * pDrvCtrl, M_BLK_ID pBuf);
  973.   
  974. LOCAL STATUS klsiEndMCastAdd (KLSI_DEVICE * pDrvCtrl, char * pAddress);
  975. LOCAL STATUS klsiEndMCastDel (KLSI_DEVICE * pDrvCtrl, char * pAddress);
  976. LOCAL STATUS klsiEndMCastGet (KLSI_DEVICE * pDrvCtrl, 
  977.  MULTI_TABLE * pTable);
  978. LOCAL STATUS klsiEndPollSend (KLSI_DEVICE * pDrvCtrl, M_BLK_ID pBuf);
  979. LOCAL STATUS klsiEndPollRcv  (KLSI_DEVICE * pDrvCtrl, M_BLK_ID pBuf);
  980. LOCAL STATUS klsiEndParse (KLSI_DEVICE * pDrvCtrl,
  981.       char * initString,
  982. UINT16 * pVendorId,
  983.      UINT16 * pProductId
  984. );
  985. LOCAL STATUS klsiEndMemInit (KLSI_DEVICE * pDrvCtrl);
  986. LOCAL STATUS klsiEndConfig (KLSI_DEVICE * pDrvCtrl);
  987. LOCAL STATUS  klsiDevInit  (KLSI_DEVICE* pDevCtrl, 
  988.     UINT16 vendorId, 
  989.     UINT16 productId
  990. );
  992. LOCAL void  klsiTxCallback (pVOID p);
  993. LOCAL void  klsiRxCallback (pVOID p);
  994. LOCAL STATUS  klsiShutdown  (int errCode);
  995. LOCAL STATUS  klsiReset  (KLSI_DEVICE* pDevCtrl);
  996. LOCAL STATUS  klsiInit (KLSI_DEVICE * pDevCtrl);
  997. LOCAL STATUS  klsiSend (KLSI_DEVICE* pDevCtrl,UINT8* pBfr,
  998.  UINT32 size);
  999. LOCAL STATUS  klsiListenForInput    (KLSI_DEVICE * pDevCtrl);
  1000. LOCAL USB_KLSI_DEV * klsiFindDevice (USBD_NODE_ID nodeId);
  1001. LOCAL USB_KLSI_DEV * klsiEndFindDevice  (UINT16 vendorId, UINT16 productId);
  1002. LOCAL void  klsiDestroyDevice  (KLSI_DEVICE * pDevCtrl);
  1003. LOCAL STATUS  klsiMCastFilterSet  (KLSI_DEVICE* pDevCtrl,
  1004.                      UINT8* pAddress,
  1005.                  UINT32 noOfFilters);
  1006. LOCAL STATUS  klsiPacketFilterSet  (KLSI_DEVICE* pDevCtrl,
  1007.          UINT8 bitmap);
  1008. LOCAL STATUS  klsiMacAddressSet (KLSI_DEVICE* pDevCtrl,
  1009.                       UINT8 * pAddress);
  1011. LOCAL void  klsiAttachCallback   (USBD_NODE_ID nodeId, 
  1012.              UINT16 attachAction, 
  1013.               UINT16 configuration,
  1014.               UINT16 interface,
  1015.               UINT16 deviceClass, 
  1016.               UINT16 deviceSubClass, 
  1017.               UINT16 deviceProtocol);
  1018. LOCAL STATUS  klsiEndRecv (KLSI_DEVICE *pDrvCtrl, UINT8* pData, UINT32 len);
  1021. LOCAL VOID  notifyAttach  (USBD_NODE_ID nodeId,
  1022.       UINT16 attachCode);
  1025. /*
  1026.  * Our driver function table.  This is static across all driver instances.
  1027.  */
  1029. LOCAL NET_FUNCS klsiEndFuncTable =
  1030.     {
  1031.     (FUNCPTR) klsiEndStart, /* Function to start the device. */
  1032.     (FUNCPTR) klsiEndStop, /* Function to stop the device. */
  1033.     (FUNCPTR) klsiEndUnload, /* Unloading function for the driver. */
  1034.     (FUNCPTR) klsiEndIoctl, /* Ioctl function for the driver. */
  1035.     (FUNCPTR) klsiEndSend, /* Send function for the driver. */
  1036.     (FUNCPTR) klsiEndMCastAdd, /* Multicast add function for the */
  1037. /* driver. */
  1038.     (FUNCPTR) klsiEndMCastDel, /* Multicast delete function for */
  1039. /* the driver. */
  1040.     (FUNCPTR) klsiEndMCastGet, /* Multicast retrieve function for */
  1041. /* the driver. */
  1042.     (FUNCPTR) klsiEndPollSend, /* Polling send function */
  1043.     (FUNCPTR) klsiEndPollRcv, /* Polling receive function */
  1044.     endEtherAddressForm, /* put address info into a NET_BUFFER */
  1045.     endEtherPacketDataGet, /* get pointer to data in NET_BUFFER */
  1046.     endEtherPacketAddrGet   /* Get packet addresses. */
  1047.     };
  1050. /***************************************************************************
  1051. *
  1052. * klsiAttachCallback - Gets called for attachment/detachment of devices
  1053. *
  1054. * The USBD will invoke this callback when a USB ethernet device is 
  1055. * attached to or removed from the system.  
  1056. * <nodeId> is the USBD_NODE_ID of the node being attached or removed.
  1057. * <attachAction> is USBD_DYNA_ATTACH or USBD_DYNA_REMOVE.
  1058. * Communication device functionality resides at the interface level, with
  1059. * the exception of being the definition of the Communication device class
  1060. * code.so <configuration> and <interface> will indicate the configuration
  1061. * / interface that reports itself as a network device.
  1062. * <deviceClass> and <deviceSubClass> will match the class/subclass for 
  1063. * which registration is done.  
  1064. * <deviceProtocol> doesn't have any meaning for the ethernet devices.
  1065. * This field is ignored.
  1066. *
  1067. * NOTE: The USBD will invoke this function once for each configuration/
  1068. * interface, which reports itself as a network device.
  1069. * So, it is possible that a single device insertion/removal may trigger 
  1070. * multiple callbacks. All callbacks are ignored except the first  
  1071. * for a given device.
  1072. *
  1073. * RETURNS: N/A
  1074. */
  1076. LOCAL void  klsiAttachCallback
  1077.     (
  1078.     USBD_NODE_ID nodeId, 
  1079.     UINT16 attachAction, 
  1080.     UINT16 configuration,
  1081.     UINT16 interface,
  1082.     UINT16 deviceClass, 
  1083.     UINT16 deviceSubClass, 
  1084.     UINT16 deviceProtocol
  1085.     )
  1086.     {
  1087.      
  1088.     pUsbListDev pNewDev;
  1090.     UINT8 bfr[30];
  1091.     UINT16 actLen;
  1093.     UINT16 vendorId;
  1094.     UINT16 productId;
  1096.     int noOfSupportedDevices = (sizeof (klsiAdapterList) /
  1097.  (2 * sizeof (UINT16)));
  1099.     int index = 0;
  1102.     OSS_MUTEX_TAKE (klsiMutex, OSS_BLOCK);
  1105.     switch (attachAction)
  1106. {
  1107. case USBD_DYNA_ATTACH :
  1109.     /* a new device is found */
  1111.     KLSI_LOG (KLSI_DBG_ATTACH, 
  1112.                       "New Device found : %0x Class %0x Subclass %0x Protocol "
  1113.                       "%0x Configuration %0x Interface  %0x nodeId n", 
  1114.         deviceClass, deviceSubClass, deviceProtocol, 
  1115.       configuration, interface, (UINT)nodeId);
  1117.     /* First Ensure that this device is not already on the list */
  1119.  
  1120.     if (klsiFindDevice (nodeId) != NULL)
  1121. {
  1122. KLSI_LOG (KLSI_DBG_ATTACH, "Device already exists. n",
  1123.           0, 0, 0, 0, 0, 0);
  1124.         break;
  1125. }
  1127.     /* Now, Ensure that it is a KLSI device */
  1129.             if (usbdDescriptorGet (klsiHandle, 
  1130.    nodeId, 
  1131.    USB_RT_STANDARD | USB_RT_DEVICE, 
  1132.    USB_DESCR_DEVICE, 
  1133.    0, 
  1134.    0, 
  1135.    30, 
  1136.    bfr, 
  1137.    &actLen) 
  1138. != OK)
  1139.         {
  1140. break;
  1141.              }
  1142. #if 0
  1143.     for(index=0;index<actLen;index++)
  1144. printf(" 0x%x",bfr[index]);
  1145.     printf("n");
  1146. #endif
  1148.             vendorId = (*(bfr+9) << 8)&0xff00;
  1149.             vendorId |= *(bfr+8);
  1150.             productId = (*(bfr+11) << 8)&0xff00;
  1151.             productId |= *(bfr+10);
  1154.             for (index = 0; index < noOfSupportedDevices; index++)
  1155. if (vendorId == klsiAdapterList[index][0])
  1156.     if (productId == klsiAdapterList[index][1])
  1157. break;
  1158.   
  1159.     if (index == noOfSupportedDevices )
  1160. {
  1162. /* device not supported */
  1164. KLSI_LOG (KLSI_DBG_ATTACH, 
  1165.                           " Unsupported device found vId %0x; pId %0x! n", 
  1166.   vendorId, productId, 0, 0, 0, 0);
  1167. break;
  1168. }
  1170.        KLSI_LOG (KLSI_DBG_ATTACH, 
  1171.                       " Found a KLSI Adapter!  %0x  %0xn", 
  1172.                       vendorId, productId, 0, 0, 0, 0);
  1174.     /* 
  1175.      * Now create a strcture for the newly found device and add 
  1176.      * it to the linked list 
  1177.      */
  1179.             /* Try to allocate space for a new device struct */
  1181.     if ((pNewDev = OSS_CALLOC (sizeof (*pNewDev))) == NULL)
  1182.        {
  1183. break;     
  1184. }
  1186.     /* Fill in the device structure */
  1188.     pNewDev->nodeId = nodeId;
  1189.     pNewDev->configuration = configuration;
  1190.     pNewDev->interface = interface;
  1191.     pNewDev->vendorId = vendorId;
  1192.     pNewDev->productId = productId;
  1194.     /* Add this device to the linked list */
  1196.     usbListLink (&klsiDevList, pNewDev, &pNewDev->devLink, 
  1197.  LINK_TAIL);
  1199.  /* Notify registered callers that a klsi device has been added */
  1201.     notifyAttach (pNewDev->nodeId, USB_KLSI_ATTACH);  /*##*/
  1203.     break;
  1205. case USBD_DYNA_REMOVE:
  1207.     KLSI_LOG (KLSI_DBG_ATTACH, "Device Removed  %x n", (int) nodeId,
  1208.     0, 0, 0, 0, 0);
  1210.   /* First Ensure that this device is on the list */
  1212.     if ((pNewDev = klsiFindDevice (nodeId)) == NULL)
  1213.         break;
  1215.      /* Check the connected flag  */
  1217.             if (pNewDev->connected == FALSE)
  1218.                 break;    
  1219.      
  1220.      pNewDev->connected = FALSE;
  1222.     /* Notify registered callers that the klsi device has been
  1223.      * removed 
  1224.      *
  1225.      * NOTE: We temporarily increment the device's lock count
  1226.      * to prevent usbKlsiDevUnlock() from destroying the
  1227.      * structure while we're still using it.
  1228.      */
  1230.             pNewDev->lockCount++; 
  1232.             notifyAttach (pNewDev->nodeId, USB_KLSI_REMOVE); 
  1234.             pNewDev->lockCount--; 
  1236.     if (pNewDev->lockCount == 0)
  1237. klsiDestroyDevice((KLSI_DEVICE *)pNewDev->pDevStructure);
  1239.     break;
  1241. }
  1243.     OSS_MUTEX_RELEASE (klsiMutex);
  1245.     }
  1247. /***************************************************************************
  1248. *
  1249. * usbKlsiEndInit - Initializes the klsi Library
  1250. *
  1251. * Initizes the klsi Library. The Library maintains an initialization
  1252. * count so that the calls to this function can be nested.
  1253. *
  1254. * This function initializes the system resources required for the library
  1255. * initializes the linked list for the ethernet devices found.
  1256. * This function registers the library as a client for the USBD calls and 
  1257. * registers for dynamic attachment notification of USB communication device
  1258. * class and Ethernet sub class of devices.
  1259. *
  1260. * This function is to be called after the USBD initialization and before 
  1261. * the endStart gets called. Otherwise the Library can't perform.
  1262. *
  1263. * RETURNS : OK or ERROR
  1264. *
  1265. * ERRNO :
  1266. *
  1267. * S_klsiLib_OUT_OF_RESOURCES
  1268. * S_klsiLib_USBD_FAULT
  1269. */
  1271. STATUS usbKlsiEndInit (void)
  1272.     {
  1274.  
  1275.     /* see if already initialized. if not, initialize the library */
  1277.     initCount++;
  1279.     if(initCount != 1) /* already registered */
  1280. return OK;
  1282.     /* 
  1283.      * Initialize USBD
  1284.      * The assumption is made that the USB host stack has already been
  1285.      * initialized elsewhere.  
  1286.      */
  1287.     /* usbdInitialize(); */
  1289.     memset (&klsiDevList, 0, sizeof (klsiDevList));
  1290.     
  1291.     klsiMutex = NULL;
  1292.     klsiTxMutex = NULL;
  1293.     klsiRxMutex = NULL;
  1295.     klsiHandle = NULL;
  1297.     /* create the mutex */
  1299.     if (OSS_MUTEX_CREATE (&klsiMutex) != OK)
  1300. return klsiShutdown (S_usbKlsiLib_OUT_OF_RESOURCES);
  1301.     
  1302.     if (OSS_MUTEX_CREATE (&klsiTxMutex) != OK)
  1303. return klsiShutdown (S_usbKlsiLib_OUT_OF_RESOURCES);
  1304.     
  1305.     if (OSS_MUTEX_CREATE (&klsiRxMutex) != OK)
  1306. return klsiShutdown (S_usbKlsiLib_OUT_OF_RESOURCES);
  1308.     /* 
  1309.      * Register the Library as a Client and register for 
  1310.      * dynamic attachment callback.
  1311.      */
  1313.     /* 
  1314.      if((usbdClientRegister (KLSI_CLIENT_NAME, &klsiHandle) != OK) ||
  1315. usbdDynamicAttachRegister (klsiHandle, 
  1316.    USB_CLASS_COMMDEVICE, 
  1317.    USB_SUBCLASS_ENET, 
  1318.    USBD_NOTIFY_ALL, 
  1319.    klsiAttachCallback) 
  1320. != OK))
  1321. {
  1322.      return klsiShutdown (S_klsiLib_USBD_FAULT);
  1323. }
  1324.     */
  1325.     /*
  1326.      * The above registration doesn't work for KLSI chip based adapters.
  1327.      * This is because the chip doesn't show up as a communications class
  1328.      * device. It shows up as  a proprietary device. Decifering that a 
  1329.      * given device is a KLSI device is done from its product ID and
  1330.      * vendor ID. This is done in the dynamic attachment call back function.
  1331.      */
  1333.      if((usbdClientRegister (KLSI_CLIENT_NAME, &klsiHandle) != OK) ||
  1334. (usbdDynamicAttachRegister (klsiHandle, 
  1335.     USBD_NOTIFY_ALL, 
  1336.     USBD_NOTIFY_ALL, 
  1337.     USBD_NOTIFY_ALL, 
  1338.     (USBD_ATTACH_CALLBACK) klsiAttachCallback)
  1339.  != OK))
  1340. {
  1341. logMsg(" Registration Failed..n", 0, 0, 0, 0, 0, 0);
  1342.      return klsiShutdown (S_usbKlsiLib_USBD_FAULT);
  1343. }
  1344.     
  1345.     return OK;
  1346.     }
  1348. /***************************************************************************
  1349. *
  1350. * findEndpoint - Searches for a BULK endpoint of the indicated direction.
  1351. *
  1352. * RETURNS: pointer to matching endpoint descriptor or NULL if not found
  1353. * 
  1354. */
  1356. LOCAL pUSB_ENDPOINT_DESCR findEndpoint
  1357.     (
  1358.     pUINT8 pBfr, /* buffer to search for */
  1359.     UINT16 bfrLen, /* buffer length */
  1360.     UINT16 direction /* end point direction */
  1361.     )
  1362.     {
  1363.     pUSB_ENDPOINT_DESCR pEp;
  1365.     while ((pEp = (pUSB_ENDPOINT_DESCR) 
  1366.           usbDescrParseSkip (&pBfr, &bfrLen, USB_DESCR_ENDPOINT)) 
  1367.    != NULL)
  1368. {
  1369. if ((pEp->attributes & USB_ATTR_EPTYPE_MASK) == USB_ATTR_BULK &&
  1370.     (pEp->endpointAddress & USB_ENDPOINT_DIR_MASK) == direction)
  1371.     break;
  1372. }
  1374.     return pEp;
  1375.     }
  1377. /***************************************************************************
  1378. *
  1379. * klsiDevInit - Initializes the klsi Device structure.
  1380. *
  1381. * This function initializes the USB ethernet device. It is called by 
  1382. * klsiEndLoad() as part of the end driver initialization. klsiEndLoad()
  1383. * expects this routine to perform all the device and USB specific 
  1384. * initialization and fill in the corresponding member fields in the 
  1385. * KLSI_DEVICE structure.
  1386. *
  1387. * This function first checks to see if the device corresponding to
  1388. * <vendorId> and <productId> exits in the linkedlist klsiDevList.
  1389. * It allocates memory for the input and output buffers. The device 
  1390. * descriptors are retrieved andused to findout the IN and OUT
  1391. * bulk end points. Once the end points are found, the corresponding
  1392. * pipes are constructed. The Pipe handles are stored in the device 
  1393. * structure <pDevCtrl>. The device's Ethernet Address (MAC address) 
  1394. * is retrieved and the corresponding field in the device structure
  1395. * is updated. This is followed by setting up of the parameters 
  1396. * like Multicast address filter list, Packet Filter bitmap etc.
  1397. *
  1398. * RETURNS : OK or ERROR
  1399. *
  1400. */
  1402. STATUS klsiDevInit
  1403.     (
  1404.     KLSI_DEVICE* pDevCtrl, /* the device structure to be updated */
  1405.     UINT16 vendorId, /* manufacturer id of the device */
  1406.     UINT16 productId     /* product id of the device */
  1407.     )
  1408.     {
  1410.     USB_KLSI_DEV* pNewDev;
  1412.     pUSB_CONFIG_DESCR pCfgDescr;
  1414.     pUSB_INTERFACE_DESCR pIfDescr;
  1416.     pUSB_ENDPOINT_DESCR pOutEp;
  1417.     pUSB_ENDPOINT_DESCR pInEp;
  1418.     
  1419.     KLSI_ENET_IRP * pIrpBfrs;
  1421.     UINT8 bfr[30];   
  1423.     pUINT8 pBfr;
  1425.     UINT8** pInBfr;
  1426.     UINT16 actLen;
  1427.     
  1428.     int index = 0;
  1430.     if(pDevCtrl == NULL)
  1431. {
  1432. KLSI_LOG (KLSI_DBG_INIT,"Null Device n", 0, 0, 0, 0, 0, 0);
  1433. return ERROR;
  1434. }
  1436.     /* Find if the device is in the found devices list */
  1437.      
  1438.     if ((pNewDev = klsiEndFindDevice (vendorId,productId)) == NULL)
  1439. {
  1440. printf("Could not find KLSI device.n");
  1441. return ERROR;
  1442. }
  1444.     /* Link the End Structure and the device that is found */
  1446.     pDevCtrl->pDev = pNewDev;
  1448.     /* Allocate memory for the input and output buffers..*/
  1450.     if ((pIrpBfrs = (KLSI_ENET_IRP *) memalign (sizeof(ULONG), 
  1451. pDevCtrl->noOfIrps * 
  1452. sizeof (KLSI_ENET_IRP))) 
  1453.  == NULL)
  1454. {
  1455. KLSI_LOG (KLSI_DBG_INIT,"Could not allocate memory for IRPs.n",
  1456.      0, 0, 0, 0, 0, 0);
  1457. return ERROR;
  1458. }
  1460.     if ((pInBfr = (pUINT8*) memalign (sizeof(ULONG),
  1461.          pDevCtrl->noOfInBfrs * sizeof (char *))) 
  1462.      ==NULL)
  1463. {
  1464. KLSI_LOG (KLSI_DBG_INIT,"Could Not align Memory for pInBfrs ...n",
  1465.          0, 0, 0, 0, 0, 0);
  1466.         return ERROR;
  1467.         }
  1469.     for (index=0;index<pDevCtrl->noOfInBfrs;index++)
  1470. {
  1471. if ((pInBfr[index] = (pUINT8)memalign(sizeof(ULONG),
  1472.    KLSI_IN_BFR_SIZE+8)) == NULL)
  1473.    {
  1474.    KLSI_LOG (KLSI_DBG_INIT,"Could Not align Memory for InBfrs  %d...n",
  1475.     index, 0, 0, 0, 0, 0);
  1476.    return ERROR;
  1477.    }
  1478. }
  1480.     pDevCtrl->pEnetIrp = pIrpBfrs;
  1481.     pDevCtrl->pInBfrArray = pInBfr;
  1483.     for (index = 0; index < pDevCtrl->noOfIrps; index++)
  1484.         {
  1485.         pIrpBfrs->outIrpInUse = FALSE;
  1486.         pIrpBfrs ++;
  1487.         }
  1489.     pDevCtrl->rxIndex = 0;    
  1490.     pDevCtrl->txIrpIndex = 0;
  1492.     pDevCtrl->outBfrLen = KLSI_OUT_BFR_SIZE;
  1493.     pDevCtrl->inBfrLen = KLSI_IN_BFR_SIZE;
  1494.    
  1495.     /* Do the device specific initialization */
  1496.     
  1497.     klsiInit (pDevCtrl);
  1499.     /* 
  1500.      * Decifer the descriptors provided by the device 
  1501.      * and try to find out which end point is what.
  1502.      * Here it is assumed that there aren't any alternate 
  1503.      * settings for interfaces.
  1504.      */
  1506.     /* To start with, get the configuration descriptor */
  1508.     if (usbdDescriptorGet (klsiHandle, 
  1509.    pNewDev->nodeId, 
  1510.    USB_RT_STANDARD | USB_RT_DEVICE, 
  1511.    USB_DESCR_CONFIGURATION, 
  1512.    0, 
  1513.    0, 
  1514.    sizeof (bfr), 
  1515.    bfr, 
  1516.    &actLen) 
  1517.    != OK)
  1518. {
  1519. KLSI_LOG (KLSI_DBG_INIT, "Could not GET Descriptor.n",
  1520.      0, 0, 0, 0, 0, 0);
  1521. return ERROR;
  1522. }
  1524.     if ((pCfgDescr = (pUSB_CONFIG_DESCR) 
  1525. usbDescrParse (bfr, actLen, USB_DESCR_CONFIGURATION)) == NULL)
  1526. {
  1527. KLSI_LOG (KLSI_DBG_INIT, "Could not find Config. Descriptor.n",
  1528.      0, 0, 0, 0, 0, 0);
  1529. return ERROR;
  1530. }
  1532.     pBfr = bfr;
  1534.     /*
  1535.      * Since we registered for NOTIFY_ALL for attachment of devices,
  1536.      * the configuration no. and interface number as reported by the 
  1537.      * call back function doesn't have any meaning. The KLSI document 
  1538.      * says that it has only one interface with number 0. So the first 
  1539.      * (and only) interface found is the interface desited. 
  1540.      *  
  1541.      * If there are more interfaces and one of them meet our requirement
  1542.      * (as reported by callback function), then we need to parse
  1543.      * until the desired interface is found..
  1544.      */
  1546.     /* 
  1547.      * pBfr and bfr are needed in case there are multiple interfaces,
  1548.      * to allow multiple parses.
  1549.      */
  1550.         
  1551.     if ((pIfDescr = (pUSB_INTERFACE_DESCR) 
  1552. usbDescrParseSkip (&pBfr, &actLen, USB_DESCR_INTERFACE)) == NULL)
  1553. {
  1554. KLSI_LOG (KLSI_DBG_INIT, "Could not find Interface Descriptor.n",
  1555.      0, 0, 0, 0, 0, 0);
  1556.      return ERROR;
  1557. }
  1558.     
  1559.      /* Find out the output and input end points ... */
  1561.     if ((pOutEp = findEndpoint (pBfr, actLen, USB_ENDPOINT_OUT)) == NULL)
  1562. {
  1563. KLSI_LOG (KLSI_DBG_INIT, "No Output End Point. n",
  1564.      0, 0, 0, 0, 0, 0);
  1565. return ERROR;
  1566. }
  1568.     if ((pInEp = findEndpoint (pBfr, actLen, USB_ENDPOINT_IN)) == NULL)
  1569. {
  1570. KLSI_LOG (KLSI_DBG_INIT, "No Input End Point. n",
  1571.      0, 0, 0, 0, 0, 0);
  1572. return ERROR;
  1573. }
  1575.     pDevCtrl->maxPower = pCfgDescr->maxPower; 
  1577.     /*
  1578.      * Now, set the configuration.
  1579.      * Note that any ConfigurationSet request will reset the device.
  1580.      * Thus, an explicit device reset is not required 
  1581.      */
  1583.     if (usbdConfigurationSet (klsiHandle, 
  1584.       pNewDev->nodeId, 
  1585.       pCfgDescr->configurationValue, 
  1586.       pCfgDescr->maxPower * USB_POWER_MA_PER_UNIT) 
  1587.    != OK)
  1588. return ERROR;
  1589.  
  1590.     /* Now, Create the Pipes... */
  1592.     if (usbdPipeCreate (klsiHandle, 
  1593. pNewDev->nodeId, 
  1594. pOutEp->endpointAddress, 
  1595. pCfgDescr->configurationValue, 
  1596. pNewDev->interface, 
  1597. USB_XFRTYPE_BULK, 
  1598. USB_DIR_OUT, 
  1599. FROM_LITTLEW (pOutEp->maxPacketSize), 
  1600. 0, 
  1601. 0, 
  1602. &pDevCtrl->outPipeHandle) 
  1603. != OK)
  1604. {
  1605. KLSI_LOG (KLSI_DBG_INIT, "Output Pipe could not be created. n",
  1606.      0, 0, 0, 0, 0, 0);
  1607. return ERROR;
  1608. }
  1609.     
  1610.     if (usbdPipeCreate (klsiHandle, 
  1611. pNewDev->nodeId, 
  1612. pInEp->endpointAddress, 
  1613. pCfgDescr->configurationValue, 
  1614. pNewDev->interface, 
  1615. USB_XFRTYPE_BULK, 
  1616. USB_DIR_IN, 
  1617. FROM_LITTLEW (pInEp->maxPacketSize), 
  1618. 0, 
  1619. 0, 
  1620. &pDevCtrl->inPipeHandle) 
  1621.     != OK)       
  1622. {
  1623. KLSI_LOG (KLSI_DBG_INIT, "Input Pipe could not be created n",
  1624.            0, 0, 0, 0, 0, 0);
  1625. return ERROR;
  1626. }
  1628.     pDevCtrl->inIrpInUse = FALSE;
  1630.     /* 
  1631.      * Read the (Ethernet) Function Descriptor and get the details.
  1632.      * Though this is described as a "descriptor", it is a vendor specific 
  1633.      * command for KLSI and is a control Pipe 0 transaction.
  1634.      */
  1635.    
  1636.     if (usbdDescriptorGet (klsiHandle, 
  1637.    pNewDev->nodeId, 
  1638.    USB_RT_STANDARD | USB_RT_DEVICE, 
  1639.    USB_DESCR_STRING, 
  1640.    1, 
  1641.    0x409, 
  1642.    sizeof (bfr), 
  1643.    bfr, 
  1644.    &actLen) 
  1645. != OK)
  1646. {
  1647. KLSI_LOG (KLSI_DBG_INIT, "Could not GET String Descriptor.n",
  1648.      0, 0, 0, 0, 0, 0);
  1649. return ERROR;
  1650. }
  1652.     /* UNICODE to ASCII conversion and then finally to MAC Address */
  1654.     if (usbdVendorSpecific (klsiHandle, 
  1655.       pNewDev->nodeId, 
  1656.       USB_RT_VENDOR |USB_RT_DEV_TO_HOST, 
  1657.       USB_REQ_KLSI_ETHDESC_GET, 
  1658.       0, 
  1659.       0, 
  1660.       sizeof(bfr), 
  1661.       bfr, 
  1662.       &actLen) 
  1663.     != OK)
  1664. {
  1665. KLSI_LOG (KLSI_DBG_INIT, "Error retrieving Ethernet descriptor. n",
  1666.                   0, 0, 0, 0, 0, 0);
  1667. return ERROR;
  1668. }
  1670. #if 0
  1671.     printf("Eth Desc = "); 
  1672.     for(index=0;index<actLen;index++)
  1673. printf("%x ",bfr[index]);
  1674.     printf("n");
  1675. #endif
  1677.     for (index = 0; index< 6; index++)
  1678. {
  1679. pDevCtrl->macAdrs[index] = bfr[3+index];
  1680. }
  1681. #if 0    
  1682.     printf("MAC Addrs = "); 
  1683.     for(index=0;index<6;index++)
  1684. printf("%x ",pDevCtrl->macAdrs[index]);
  1685.     printf("n");
  1686. #endif
  1688.  
  1689.     /* Set URB Size */
  1691.     if (usbdVendorSpecific (klsiHandle, 
  1692.     pNewDev->nodeId, 
  1693.     USB_RT_VENDOR |USB_RT_HOST_TO_DEV, 
  1694.     USB_REQ_KLSI_SET_URB_SIZE, 
  1695.     64, 
  1696.     0, 
  1697.     0, 
  1698.     NULL, 
  1699.     NULL) 
  1700. != OK)
  1701. {
  1702. KLSI_LOG (KLSI_DBG_INIT, "Error Setting URB Size. n",
  1703.   0, 0, 0, 0, 0, 0);
  1704. return ERROR;
  1705. }
  1707.      
  1708.     if (usbdVendorSpecific (klsiHandle, 
  1709.     pNewDev->nodeId, 
  1710.     USB_RT_VENDOR |USB_RT_HOST_TO_DEV, 
  1711.     USB_REQ_KLSI_SET_SOFS_TO_WAIT, 
  1712.     0x1, 
  1713.     0, 
  1714.     0, 
  1715.     NULL, 
  1716.     NULL) 
  1717.   != OK)
  1718. {
  1719. KLSI_LOG (KLSI_DBG_INIT, "Error setting SOFs n",
  1720.   0, 0, 0, 0, 0, 0);
  1721. return ERROR;
  1722. }
  1723.     
  1724.     /* Set No Multicasting */
  1726.     if (usbdVendorSpecific (klsiHandle, 
  1727.     pNewDev->nodeId, 
  1728.     USB_RT_VENDOR |USB_RT_HOST_TO_DEV, 
  1729.     USB_REQ_KLSI_SET_MCAST_FILTER, 
  1730.     0, 
  1731.     0, 
  1732.     0, 
  1733.     NULL, 
  1734.     NULL) 
  1735.   != OK)
  1736. {
  1737. KLSI_LOG (KLSI_DBG_INIT, "Error setting Multicast Addresses n",
  1738.   0, 0, 0, 0, 0, 0);
  1739. return ERROR;
  1740. }
  1742.     /* Set Only directed Packets to be received */
  1743.     
  1744.     if (usbdVendorSpecific (klsiHandle, 
  1745.     pNewDev->nodeId, 
  1746.     USB_RT_VENDOR |USB_RT_HOST_TO_DEV, 
  1747.     USB_REQ_KLSI_SET_PACKET_FILTER, 
  1748.     0x0004, 
  1749.     0, 
  1750.     0, 
  1751.     NULL, 
  1752.     NULL) 
  1753.  != OK)
  1754. {
  1755. KLSI_LOG (KLSI_DBG_INIT, "Error setting packet bitmap. n",
  1756.      0, 0, 0, 0, 0, 0);
  1757. return ERROR;
  1758. }
  1760.     return OK;
  1762.     }
  1764. /***************************************************************************
  1765. *
  1766. * klsiEndStart - Starts communications over Ethernet via USB (device)
  1767. *
  1768. * Since there is no interrupt available, the device is to be prevented from 
  1769. * communicating in some other way. Here, since the reception is based 
  1770. * on polling and the klsiListenForInput() is called for such polling,
  1771. * the listening can be delayed to any packet coming in  by calling
  1772. * klsiListenForInput(). This way, the traditional "interrupt enabling"   
  1773. * is mimicked. This is for packet reception.
  1774. *
  1775. * For packet transmission, communicateOk flag is used. Data is transmitted 
  1776. * only if this flag is true. This flag will be set to TRUE and will be
  1777. * reset to FALSE in klsiEndStop().
  1778. *
  1779. * RETURNS : OK or ERROR
  1780. */
  1782. STATUS klsiEndStart
  1783.     (
  1784.     KLSI_DEVICE* pDevCtrl         /* Device to be started */
  1785.     )
  1786.     {
  1788.     KLSI_LOG (KLSI_DBG_START, "Entered klsiEndStart.n",
  1789.  0, 0, 0, 0, 0, 0);
  1790.     
  1791.     /*
  1792.      * start listening on the BULK input pipe for any  
  1793.      *  ethernet packet coming in. This is how   
  1794.      * "connecting the interrupt" of the END Model is simulated.
  1795.      */
  1797.     pDevCtrl->communicateOk = TRUE;
  1799.     if (klsiListenForInput (pDevCtrl) != OK)
  1800. {
  1801.         pDevCtrl->communicateOk = FALSE;
  1802.         KLSI_LOG (KLSI_DBG_START, 
  1803.                   "klsiEndStart:..Unable to listen for input...n",
  1804.                   0, 0, 0, 0, 0, 0);
  1805. return ERROR;
  1806. }
  1808.     /* 
  1809.      * The above will effectively preempt any possibility of packet reception.
  1810.      * For preempting such possibility for transmission, the communicateOk 
  1811.      * flag is used. Ideally a semaphore should be used here, but
  1812.      * the use of a flag will suffice.
  1813.      */
  1815.     return OK;
  1817.     }
  1819. /***************************************************************************
  1820. *
  1821. * klsiEndStop - Disables communication over Ethernet via USB (device)
  1822. * 
  1823. * The pipes will be aborted. If there are any pending transfers on these
  1824. * Pipes, USBD will see to it that they are also cancelled. The IRPs for
  1825. * these transfers will return a S_usbHcdLib_IRP_CANCELED error code.
  1826. * It waits for the IRPs to be informed of their Cancelled Status and then
  1827. * the function returns.
  1828. * 
  1829. * RETURNS: OK or ERROR
  1830. */
  1832. STATUS klsiEndStop
  1833.     (
  1834.     KLSI_DEVICE* pDevCtrl     /* Device to be Stopped */
  1835.     )
  1836.     {
  1838.     KLSI_LOG (KLSI_DBG_STOP, "klsiEndStop:..entered.n",
  1839.       0, 0, 0, 0, 0, 0);
  1841.     /* 
  1842.      * Abort the transfers the input and output Pipes.
  1843.      * once such requests are issued, usbd will take care of aborting the 
  1844.      * outstanding transfers, if any, associated with the Pipes.
  1845.      */
  1847.     pDevCtrl->communicateOk = FALSE;
  1848.     klsiDestroyDevice(pDevCtrl);
  1849.     taskDelay(sysClkRateGet()*5);
  1850.     return OK;
  1852.     }
  1854. /***************************************************************************
  1855. * klsiListenForInput - Listens for data on the ethernet (Bulk In Pipe) 
  1856. *
  1857. * Input IRP will be initialized to listen on the BULK input pipe and will
  1858. * be submitted to the usbd.
  1859. *
  1860. * RETURNS : OK or ERROR
  1861. *
  1862. * 
  1863. */
  1864.      
  1865. LOCAL STATUS klsiListenForInput
  1866.     (
  1867.     KLSI_DEVICE* pDevCtrl /* device to receive from */
  1868.     )
  1869.     {
  1871.     pUSB_IRP pIrp = &pDevCtrl->inIrp;
  1874.     if (pDevCtrl == NULL)
  1875. return ERROR;
  1877.     /* Initialize IRP */
  1879.     memset (pIrp, 0, sizeof (*pIrp));
  1881.     pIrp->userPtr = pDevCtrl;
  1882.     pIrp->irpLen = sizeof (*pIrp);
  1883.     pIrp->userCallback = klsiRxCallback;
  1884.     pIrp->timeout = USB_TIMEOUT_DEFAULT;
  1885.     pIrp->transferLen = pDevCtrl->inBfrLen; 
  1886.     pIrp->flags = USB_FLAG_SHORT_OK;
  1888.     pIrp->bfrCount = 1;
  1890.     pIrp->bfrList[0].pid = USB_PID_IN;
  1891.     pIrp->bfrList[0].bfrLen = pDevCtrl->inBfrLen; 
  1892.     pIrp->bfrList[0].pBfr = (pUINT8)pDevCtrl->pInBfrArray[pDevCtrl->rxIndex] - 2;  
  1894.     /* Submit IRP */
  1896.     if (usbdTransfer (klsiHandle, pDevCtrl->inPipeHandle, (pUSB_IRP)pIrp) != OK)
  1897. return ERROR;
  1899.     pDevCtrl->inIrpInUse = TRUE;
  1901.     return OK;
  1902.     }
  1904. /***************************************************************************
  1905. *
  1906. * klsiSend - Initiates data transmission to the device
  1907. *
  1908. * This function initiates transmission on the ethernet.
  1909. *
  1910. * RETURNS: OK or ERROR
  1911. */
  1913. STATUS klsiSend
  1914.     (
  1915.     KLSI_DEVICE* pDevCtrl, /* device to send to */
  1916.     UINT8* pBfr, /* data to send */
  1917.     UINT32 size /* data size */
  1918.     )
  1919.     {
  1921.     pUSB_IRP pIrp;       /* = &pDevCtrl->outIrp; */
  1922.     KLSI_ENET_IRP * pIrpBfr;
  1924.     KLSI_LOG (KLSI_DBG_TX, "klsiSend:..entered. %d bytesn", 
  1925.       size, 0, 0, 0, 0, 0); 
  1927.     if ((pDevCtrl == NULL) || (pBfr == NULL))
  1928. {
  1929. return ERROR;
  1930. }
  1932.     if (size == 0)
  1933. return ERROR;
  1936.     pIrpBfr = (KLSI_ENET_IRP *)(pDevCtrl->pEnetIrp + pDevCtrl->txIrpIndex);
  1937.     pIrp =(pUSB_IRP) &pIrpBfr->outIrp;
  1938.     pIrpBfr->outIrpInUse = TRUE;
  1939.     pDevCtrl->txIrpIndex++;
  1940.     pDevCtrl->txIrpIndex %= pDevCtrl->noOfIrps;
  1942.     /* Initialize IRP */
  1944.     memset (pIrp, 0, sizeof (*pIrp));
  1946.     pIrp->userPtr = pDevCtrl;
  1947.     pIrp->irpLen = sizeof (*pIrp);
  1948.     pIrp->userCallback = klsiTxCallback;
  1949.     pIrp->timeout = USB_TIMEOUT_NONE;
  1950.     pIrp->transferLen = size;
  1952.     pIrp->bfrCount = 1;
  1953.     pIrp->bfrList[0].pid = USB_PID_OUT;
  1954.     pIrp->bfrList[0].pBfr = pBfr;
  1955.     pIrp->bfrList[0].bfrLen = size;
  1957.     /* Submit IRP */
  1959.     KLSI_LOG (KLSI_DBG_TX, "klsiSend:..Sumitting IRP for Trans. %d bytesn", 
  1960.  size, 0, 0, 0, 0, 0); 
  1963.     if (usbdTransfer (klsiHandle, 
  1964. pDevCtrl->outPipeHandle, 
  1965. (pUSB_IRP)pIrp) 
  1966. != OK)
  1967. return ERROR;
  1969.     KLSI_LOG (KLSI_DBG_TX, "klsiSend:..done !!!!!!n", 
  1970.  0, 0, 0, 0, 0, 0); 
  1972. /*    OSS_MUTEX_RELEASE (klsiMutex); */
  1973.  
  1975.     return OK;
  1976.     }
  1978. /***************************************************************************
  1979. *
  1980. * klsiTxCallback - Invoked upon Transmit IRP completion/cancellation
  1981. *
  1982. * RETURNS : N/A
  1983. *
  1984. * 
  1985. */
  1988. LOCAL void klsiTxCallback
  1989.     (
  1990.     pVOID p /* completed IRP */
  1991.     )
  1993.     {
  1994.     pUSB_IRP pIrp = (pUSB_IRP) p;
  1996.     KLSI_ENET_IRP * pIrpBfr;
  1997.     int index = 0;
  1999.     KLSI_DEVICE* pDevCtrl = pIrp->userPtr;
  2001.     /* Output IRP completed */
  2003.     for (index = 0; index < pDevCtrl->noOfIrps; index++)
  2004. {
  2006. pIrpBfr = pDevCtrl->pEnetIrp + index;
  2007. if (pIrp ==(pUSB_IRP) &pIrpBfr->outIrp)
  2008.     {
  2009.     break;
  2010.     }
  2011. }
  2012.    
  2013.     if (index == pDevCtrl->noOfIrps)
  2014. {
  2015. return;
  2016. }
  2017.  
  2018.     KLSI_LOG (KLSI_DBG_TX, "Tx Callback for  %d IRP.n",
  2019.     index, 0, 0, 0, 0, 0);
  2021.     pIrpBfr = pDevCtrl->pEnetIrp + index;
  2022.     pIrpBfr->outIrpInUse = FALSE;
  2025.      
  2026.     free (pIrp->bfrList[0].pBfr);
  2028.     if (pIrp->result != OK)
  2029. {
  2030.         KLSI_LOG (KLSI_DBG_TX, "Tx error %x.n",
  2031.     pIrp->result, 0, 0, 0, 0, 0);
  2033. if (pIrp->result == S_usbHcdLib_STALLED)
  2034.     {
  2035.        if (usbdFeatureClear (klsiHandle, 
  2036.   pDevCtrl->pDev->nodeId,
  2037.   USB_RT_STANDARD | USB_RT_ENDPOINT, 
  2038.   0, 
  2039.   1) == ERROR)
  2040. {
  2041.         KLSI_LOG (KLSI_DBG_TX, "Could not clear STALL.n",
  2042.              pIrp->result, 0, 0, 0, 0, 0);
  2043. }
  2044.     }
  2045.   
  2046.         pDevCtrl->outErrors++; /* Should also Update MIB */
  2047. }
  2048.     else
  2049. {
  2050.             KLSI_LOG (KLSI_DBG_TX, "Tx finished.n",
  2051.       0, 0, 0, 0, 0, 0);
  2052. }
  2054.     }
  2056. /***************************************************************************
  2057. *
  2058. * klsiRxCallback - Invoked when a Packet is received.
  2059. *
  2060. *
  2061. * RETURNS : N/A
  2062. *
  2063. * 
  2064. */
  2066. LOCAL void klsiRxCallback
  2067.     (
  2068.     pVOID p /* completed IRP */
  2069.     )
  2071.     {
  2072.     pUSB_IRP pIrp = (pUSB_IRP) p;
  2073.     KLSI_DEVICE* pDevCtrl = pIrp->userPtr;
  2074.     BOOL irpStalled = FALSE;
  2076.     OSS_MUTEX_TAKE (klsiMutex, OSS_BLOCK);
  2078.     /* Input IRP completed */
  2080.     pDevCtrl->inIrpInUse = FALSE;
  2082.     /*
  2083.      * If the IRP was successful then pass the data back to the client.
  2084.      * Note that the netJobAdd() is not necessary here as the function 
  2085.      * is not getting executed in isr context.
  2086.      * If irp STALL occurs and could not be cleared then we do not submit 
  2087.      * next Irp for listening input.
  2088.      */
  2089.     if (pIrp->result != OK)
  2090. {
  2091.         pDevCtrl->inErrors++; /* Should also update MIB */
  2092.   
  2093. if(pIrp->result == S_usbHcdLib_STALLED)
  2094.     {
  2095.     if(usbdFeatureClear (klsiHandle,
  2096.  pDevCtrl->pDev->nodeId,
  2097.  USB_RT_STANDARD | USB_RT_ENDPOINT, 
  2098.  0, 
  2099.  0) !=OK)
  2100.   {
  2101.         KLSI_LOG (KLSI_DBG_TX, "Irp STALLED ..Could not clearn",
  2102.                   0, 0, 0, 0, 0, 0);
  2103. irpStalled = TRUE;
  2104. }
  2105.     }
  2106. }
  2107.     else
  2108. {
  2109. if( pIrp->bfrList[0].actLen >= 2)
  2110.     {
  2111.        klsiEndRecv (pDevCtrl,(pUINT8)(pIrp->bfrList[0].pBfr+2), 
  2112. pIrp->bfrList[0].actLen-2);  
  2113.     pDevCtrl->rxIndex++;
  2114.     pDevCtrl->rxIndex %= pDevCtrl->noOfInBfrs;    
  2115.     }
  2116. }       
  2118.     /*
  2119.      * Unless the IRP was cancelled,stalled - implying the channel is being
  2120.      * torn down, re-initiate the "in" IRP to listen for more data.
  2121.      */
  2123.     if ((pIrp->result != S_usbHcdLib_IRP_CANCELED) && (irpStalled !=TRUE))
  2124. klsiListenForInput (pDevCtrl);
  2125.     else
  2126.         KLSI_LOG (KLSI_DBG_TX, "Rxcallback....pIrp->result %dn",
  2127.              pIrp->result, 0, 0, 0, 0, 0);
  2129.     OSS_MUTEX_RELEASE (klsiMutex);  
  2131.     }
  2134. /***************************************************************************
  2135. *
  2136. * klsiMCastFilterSet - Sets a Multicast Address Filter for the device
  2137. *
  2138. * Even if the host wishes to change a single multicast filter in the device,
  2139. * it must reprogram the entire list of filters using this function. 
  2140. * <pAddress> shall contain a pointer to this list of multicast addresses
  2141. * and <noOfFilters> shall hold the number of multicast address filters
  2142. * being programmed to the device.
  2143. *
  2144. * RETURNS : OK or ERROR
  2145. */
  2147. STATUS klsiMCastFilterSet
  2148.     (
  2149.     KLSI_DEVICE* pDevCtrl, /* device to add the mcast filters */
  2150.     UINT8* pAddress, /* Mcast address filters list */
  2151.     UINT32 noOfFilters /* no. of filters to add */
  2152.     )
  2153.     {
  2154.     
  2155.     KLSI_LOG (KLSI_DBG_MCAST, "klsiMCasrFilterSet:..entered.n",
  2156.  0, 0, 0, 0, 0, 0);
  2158.     if (pDevCtrl == NULL)
  2159. return ERROR;
  2161.     /* Check if  this many number of Filters are supported by the device */
  2163.     if ((noOfFilters < 0) || 
  2164. (noOfFilters > (pDevCtrl->mCastFilters.noMCastFilters)))
  2165. return ERROR;
  2167.     if (((noOfFilters == 0) && (pAddress != NULL)) ||
  2168. ((noOfFilters > 0) && (pAddress == NULL)))
  2169. return ERROR;
  2170.     
  2171.     /* Set the Filters */
  2173.     if (usbdVendorSpecific (klsiHandle, 
  2174.     pDevCtrl->pDev->nodeId,
  2175.     USB_RT_VENDOR | USB_RT_HOST_TO_DEV, 
  2176.     USB_REQ_KLSI_SET_MCAST_FILTER, 
  2177.     noOfFilters, 
  2178.     0, 
  2179.     noOfFilters * 6, 
  2180.     pAddress, 
  2181.     NULL) != OK)
  2182. {
  2183. return ERROR;
  2184. }
  2186.     return OK;
  2188.     }
  2190. /***************************************************************************
  2191. *
  2192. * klsiPacketFilterSet - Sets a Ethernet Packet Filter for the device
  2193. *
  2194. * This function configures the Ethernet device for reception of various 
  2195. * kinds of ethernet packets. <bitmap> is an inclusive OR of the BITs
  2196. * listed below. Additional Filtering, if needed must be performed in the 
  2197. * host software.
  2198. * 
  2199. * .IP "PACKET_TYPE_MULTICAST"
  2200. * This bit will enable all multicast packets enumerated in the
  2201. * devices multicast address list to be forwarded to the host.
  2202. * .IP "PACKET_TYPE_BROADCAST"
  2203. * This bit enables all broadcast packets to be forwarded to host.
  2204. * .IP "PACKET_TYPE_DIRECTED"
  2205. * This bit enables all normal packets to be forwarded to host.
  2206. * .IP "PACKET_TYPE_ALL_MULTICAST"
  2207. * This bit enables all multi cast packets to be forwarded to host.
  2208. * .IP "PACKET_TYPE_PROMISCOUS"
  2209. * This bit enables all packets to be forwarded to host.
  2210. * 
  2211. * The Rest of the bits in <bitmap> shall be reset to Zero.
  2212. * 
  2213. * RETURNS: OK or ERROR
  2214. */
  2216. STATUS klsiPacketFilterSet
  2217.     (
  2218.     KLSI_DEVICE* pDevCtrl, /* device to set he packet filter */
  2219.     UINT8 bitmap /* packet filter bitmap */
  2220.     )
  2221.     {
  2223.     UINT16 pktFilterBitmap = 0x0000;    
  2225.     KLSI_LOG (KLSI_DBG_MCAST, "klsiPacketFilterSet:..entered.n",
  2226.  0, 0, 0, 0, 0, 0);
  2228.     if (pDevCtrl == NULL)
  2229. return ERROR;
  2231.     bitmap |= PACKET_TYPE_DIRECTED; /* this is always maintained  */
  2233.     pktFilterBitmap |= bitmap;
  2235.     /* Set the Filters */
  2237.     if (usbdVendorSpecific (klsiHandle, 
  2238.     pDevCtrl->pDev->nodeId,
  2239.     USB_RT_VENDOR | USB_RT_HOST_TO_DEV, 
  2240.     USB_REQ_KLSI_SET_PACKET_FILTER, 
  2241.     pktFilterBitmap, 
  2242.     0, 
  2243.     0, 
  2244.     NULL, 
  2245.     NULL) != OK)
  2246. {
  2247. return ERROR;
  2248. }
  2250.     return OK;
  2251.        
  2252.     }   
  2254. /***************************************************************************
  2255. *
  2256. * klsiStatsGet - Gets the statistics from the device
  2257. * 
  2258. * RETURNS : OK or ERROR 
  2259. *
  2260. * 
  2261. */
  2263. STATUS klsiStatsGet
  2264.     (
  2265.     KLSI_DEVICE* pDevCtrl, /* device to retrieve the Statistic */
  2266.     UINT8 feature, /* statistic to get */
  2267.     UINT8* pStat /* place to store the stats */
  2268.     )
  2269.     {
  2271.     KLSI_LOG (KLSI_DBG_MCAST, "Entered klsiStatsGet.n",
  2272.  0, 0, 0, 0, 0, 0);
  2274.     if (pDevCtrl == NULL)
  2275. return ERROR;
  2277.     /* see if this particular statistic is supported by the device */
  2279.     if ((pDevCtrl->stats.bitmap & (0x1 << feature)) == 0)
  2280. return ERROR;
  2283.     if (usbdVendorSpecific (klsiHandle, 
  2284.     pDevCtrl->pDev->nodeId,
  2285.                     USB_RT_VENDOR | USB_RT_DEV_TO_HOST, 
  2286.                     USB_REQ_KLSI_GET_STATS, 
  2287.     feature, 
  2288.                             0, 
  2289.     4, 
  2290.     pStat, 
  2291.     0) != OK)
  2292. {
  2293. return ERROR;
  2294. }
  2296.     /* the driver structure is not updated now */
  2298.     return OK;
  2299.     
  2300.     }   
  2303. /***************************************************************************
  2304. *
  2305. * klsiReset - Resets the USB-ethernet adapter
  2306. *
  2307. * This function resets the Ethernet Adapter. 
  2308. *
  2309. * RETURNS : OK or ERROR
  2310. */
  2312. STATUS klsiReset
  2313.     (
  2314.     KLSI_DEVICE* pDevCtrl /* device to reset */
  2315.     )
  2317.     {
  2319.     KLSI_LOG (KLSI_DBG_RESET, "Entered klsiReset.n",
  2320.  0, 0, 0, 0, 0, 0);
  2322.     if (pDevCtrl == NULL)
  2323. return ERROR;
  2325.     /* SET_CONFIGURATION command shall cause the device to reset */
  2327.     if (usbdConfigurationSet (klsiHandle, 
  2328. pDevCtrl->pDev->nodeId,
  2329. 0, 
  2330. pDevCtrl->maxPower * USB_POWER_MA_PER_UNIT) 
  2331. != OK)
  2332. {
  2333.         KLSI_LOG (KLSI_DBG_RESET, " Could not reset the device. n",
  2334.   0, 0, 0, 0, 0, 0);
  2335. return ERROR;
  2336. }
  2338.     return OK;
  2339.     
  2340.     }  
  2341.   
  2343. /***************************************************************************
  2344. *
  2345. * klsiFindDevice - Searches for a USB ethernet device for indicated <nodeId>
  2346. *
  2347. * RETURNS: pointer to matching device structure, or NULL if device not found
  2348. * 
  2349. */
  2351. USB_KLSI_DEV* klsiFindDevice
  2352.     (
  2353.     USBD_NODE_ID nodeId /* Node Id to find */
  2354.     )
  2356.     {
  2358.     USB_KLSI_DEV * pDev = usbListFirst (&klsiDevList);
  2360.     while (pDev != NULL)
  2361. {
  2362. if (pDev->nodeId == nodeId)
  2363.     break;
  2365. pDev = usbListNext (&pDev->devLink);
  2366. }
  2368.     return pDev;
  2369.     }
  2371. /***************************************************************************
  2372. *
  2373. * klsiEndFindDevice - Searches USB ethernet device 
  2374. * 
  2375. *
  2376. * RETURNS: pointer to matching device structure, or NULL if not found
  2377. * 
  2378. */
  2380. USB_KLSI_DEV* klsiEndFindDevice
  2381.     (
  2382.     UINT16 vendorId, /* Vendor Id to search for */
  2383.     UINT16 productId /* Product Id to search for */
  2384.     )
  2386.     {
  2387.     USB_KLSI_DEV * pDev = usbListFirst (&klsiDevList);
  2389.     while (pDev != NULL)
  2390. {
  2391. if ((pDev->vendorId == vendorId) && (pDev->productId == productId))
  2392.     break;
  2394. pDev = usbListNext (&pDev->devLink);
  2395. }
  2397.     return pDev;
  2398.     }
  2399.   
  2400.      
  2401. /***************************************************************************
  2402. *
  2403. * klsiMacAddressSet - Sets a Ethernet Address for the device
  2404. *
  2405. * This function will do the address setting for the given device.
  2406. *
  2407. * RETURNS : OK or ERROR 
  2408. */
  2410. STATUS klsiMacAddressSet
  2411.     (
  2412.     KLSI_DEVICE* pDevCtrl,  /* Device to set the address for */
  2413.     UINT8 * pAddress     /* The MAC Address to be Set */
  2414.     )
  2415.    
  2416.     {
  2418.     KLSI_LOG (KLSI_DBG_MAC, "Entered klsiMacAddressSet...n",
  2419.  0, 0, 0, 0, 0, 0);
  2421.     if ((pDevCtrl == NULL) || (pAddress == NULL))
  2422. return ERROR;
  2424.     /* Set the MAC Address */
  2426.     if (usbdVendorSpecific (klsiHandle, 
  2427.     pDevCtrl->pDev->nodeId,
  2428.                     USB_RT_VENDOR | USB_RT_HOST_TO_DEV, 
  2429.                     USB_REQ_KLSI_SET_TEMP_MAC, 
  2430.     0, 
  2431.     0, 
  2432.     6, 
  2433.     pAddress,
  2434.                     NULL) != OK)
  2435. {
  2436. return ERROR;
  2437. }
  2439.     return OK;
  2440.     
  2441.     }   
  2442.     
  2443. /***************************************************************************
  2444. *
  2445. * klsiShutdown - Shuts down USB EnetLib
  2446. *
  2447. * <errCode> should be OK or S_klsiLib_xxxx.  This value will be
  2448. * passed to ossStatus() and the return value from ossStatus() is the
  2449. * return value of this function.
  2450. *
  2451. * RETURNS: OK or ERROR
  2452. */
  2454. LOCAL STATUS klsiShutdown
  2455.     (
  2456.     int errCode
  2457.     )
  2459.     {
  2460.    
  2461.     KLSI_DEVICE * pDev;
  2463.     /* Dispose of any open connections. */
  2465.     while ((pDev = usbListFirst (&klsiDevList)) != NULL)
  2466. klsiDestroyDevice (pDev);
  2468.     /*
  2469.      * Release our connection to the USBD.  The USBD automatically 
  2470.      * releases any outstanding dynamic attach requests when a client
  2471.      * unregisters.
  2472.      */
  2474.     if (klsiHandle != NULL)
  2475. {
  2476. usbdClientUnregister (klsiHandle);
  2477. klsiHandle = NULL;
  2478. }
  2480.     /* Release resources. */
  2482.     if (klsiMutex != NULL)
  2483. {
  2484. OSS_MUTEX_DESTROY (klsiMutex);
  2485. klsiMutex = NULL;
  2486. }
  2487.     
  2488.     if (klsiTxMutex != NULL)
  2489. {
  2490. OSS_MUTEX_DESTROY (klsiTxMutex);
  2491. klsiTxMutex = NULL;
  2492. }
  2493.     
  2494.     if (klsiRxMutex != NULL)
  2495. {
  2496. OSS_MUTEX_DESTROY (klsiRxMutex);
  2497. klsiRxMutex = NULL;
  2498. }
  2500.    
  2501.     usbdShutdown();
  2503.     return ossStatus (errCode);
  2504.     }
  2506.      
  2507. /***************************************************************************
  2508. *
  2509. * klsiDestroyDevice - disposes of a KLSI_DEVICE structure
  2510. *
  2511. * Unlinks the indicated KLSI_DEVICE structure and de-allocates
  2512. * resources associated with the channel.
  2513. *
  2514. * RETURNS: N/A
  2515. */
  2517. void klsiDestroyDevice
  2518.     (
  2519.     KLSI_DEVICE* pDevCtrl
  2520.     )
  2521.     {
  2522.     USB_KLSI_DEV *pDev;
  2524.     if (pDevCtrl != NULL)
  2525. {
  2527. pDev = pDevCtrl->pDev;
  2529. /* Unlink the structure. */
  2531. usbListUnlink (&pDev->devLink);
  2532.   
  2533. /* Release pipes and wait for IRPs to be cancelled if necessary. */
  2535. if (pDevCtrl->outPipeHandle != NULL)
  2536.     usbdPipeDestroy (klsiHandle, pDevCtrl->outPipeHandle);
  2538. if (pDevCtrl->inPipeHandle != NULL)
  2539.     usbdPipeDestroy (klsiHandle, pDevCtrl->inPipeHandle);
  2541. /* taskDelay(sysClkRateGet()*2);*/
  2544. while (pDevCtrl->pEnetIrp->outIrpInUse || pDevCtrl->inIrpInUse)
  2545.    OSS_THREAD_SLEEP (1);
  2547.   /*  Release Input buffers*/
  2549. if ( pDevCtrl->pInBfrArray !=NULL)
  2550.     {
  2551.             OSS_FREE(pDevCtrl->pInBfrArray);
  2552.     taskDelay(sysClkRateGet()*1);
  2553.     }
  2554. /*  Release EnetIrp buffers*/
  2555. if ( pDevCtrl->pEnetIrp != NULL)
  2556.     {
  2557.            OSS_FREE(pDevCtrl->pEnetIrp);
  2558.    taskDelay(sysClkRateGet()*1);
  2559.             }
  2561. /* Release structure. */
  2563. if (pDev !=NULL)
  2564.     OSS_FREE (pDev);
  2566. }
  2567.     }
  2570. /**************************************************************************
  2571. *
  2572. * klsiEndLoad - Initialize the driver and device
  2573. *
  2574. * This routine initializes the driver and the device to the operational state.
  2575. * All of the device specific parameters are passed in the initString.
  2576. * 
  2577. * This function first extracts the vendorId and productId of the device 
  2578. * from the initialization string using the klsiEndParse() function. It then 
  2579. * passes these parameters and its control structure to the klsiDevInit()
  2580. * function. klsiDevInit() does most of the device specific initialization
  2581. * and brings the device to the operational state. Please refer to klsiLib.c
  2582. * for more details about usbenetDevInit(). This driver will be attached to MUX
  2583. * and then the memory initialization of the device is carried out using
  2584. * klsiEndMemInit(). 
  2585. *
  2586. * This function doesn't do any thing device specific. Instead, it delegates
  2587. * such initialization to klsiDevInit(). This routine handles the other part
  2588. * of the driver initialization as required by MUX.
  2589. *
  2590. * muxDevLoad() calls this function twice. First time this function is called, 
  2591. * initialization string will be NULL . We are required to fill in the device 
  2592. * name ("usb") in the string and return. When next time this function is called,
  2593. * the initialization string will be proper.
  2594. *
  2595. * <initString> will be of the format :
  2596. * "unit : vendorId : productId : noOfInBfrs : noOfIrps"
  2597. *
  2598. * PARAMETERS
  2599. *
  2600. * .IP <initString>
  2601. * The device initialization string.
  2602. *
  2603. * RETURNS: An END object pointer, or NULL on error.
  2604. */
  2606. END_OBJ * klsiEndLoad
  2607.     (
  2608.     char * initString                             /* initialization string */
  2609.     )
  2610.     {
  2611.     KLSI_DEVICE * pDrvCtrl;                      /* driver structure */
  2613.     UINT16 vendorId;                                /* vendor information */
  2614.     UINT16 productId;                               /* product information */
  2616.     KLSI_LOG (KLSI_DBG_LOAD, "Loading usb end...n", 1, 2, 3, 4, 5, 6);
  2618.     if (initString == NULL)
  2619. return (NULL);
  2620.     
  2621.     if (initString[0] == EOS)
  2622. {
  2624.         /* Fill in the device name and return peacefully */
  2626. bcopy ((char *)KLSI_NAME, (void *)initString, KLSI_NAME_LEN);
  2627. return (0);
  2628. }
  2630.     /* allocate the device structure */
  2632.     pDrvCtrl = (KLSI_DEVICE *)calloc (sizeof (KLSI_DEVICE), 1);
  2635.     if (pDrvCtrl == NULL)
  2636. {
  2637. KLSI_LOG (KLSI_DBG_LOAD, "No Memory!!...n", 1, 2, 3, 4, 5, 6);
  2638. goto errorExit;
  2639. }
  2641.     /* parse the init string, filling in the device structure */
  2643.     if (klsiEndParse (pDrvCtrl, initString, &vendorId, &productId) == ERROR)
  2644. {
  2645. KLSI_LOG (KLSI_DBG_LOAD, "Parse Failed.n", 1, 2, 3, 4, 5, 6);
  2646. goto errorExit;
  2647. }
  2649.     /* Ask the klsiLib to do the necessary initialization. */
  2651.     if (klsiDevInit(pDrvCtrl,vendorId,productId) == ERROR)
  2652. {
  2653. KLSI_LOG (KLSI_DBG_LOAD, "EnetDevInitFailed.n", 
  2654.     1, 2, 3, 4, 5, 6);
  2655. goto errorExit;
  2656. }
  2658.     /* initialize the END and MIB2 parts of the structure */
  2660.     if (END_OBJ_INIT (&pDrvCtrl->endObj, 
  2661.       (DEV_OBJ *)pDrvCtrl, 
  2662.       "usb",
  2663.                       pDrvCtrl->unit, 
  2664.       &klsiEndFuncTable,
  2665.                       KLSI_NAME) == ERROR
  2666.      || END_MIB_INIT (&pDrvCtrl->endObj, 
  2667.       M2_ifType_ethernet_csmacd,
  2668.                       &pDrvCtrl->macAdrs[0], 
  2669.       6, 
  2670.       KLSI_BUFSIZ,
  2671.                       KLSI_SPEED)
  2672.     == ERROR)
  2673. {
  2674. KLSI_LOG (KLSI_DBG_LOAD, "END MACROS FAILED...n", 
  2675. 1, 2, 3, 4, 5, 6);
  2676. goto errorExit;
  2677. }
  2679.     /* Perform memory allocation/distribution */
  2681.     if (klsiEndMemInit (pDrvCtrl) == ERROR)
  2682. {
  2683. KLSI_LOG (KLSI_DBG_LOAD, "endMemInit() Failed...n", 
  2684.     1, 2, 3, 4, 5, 6);
  2686. klsiDestroyDevice(pDrvCtrl);
  2687. goto errorExit;
  2688. }
  2689.  
  2690.     /* set the flags to indicate readiness */
  2692.     END_OBJ_READY (&pDrvCtrl->endObj,
  2693.     IFF_UP | IFF_RUNNING | IFF_NOTRAILERS | IFF_BROADCAST
  2694.     | IFF_MULTICAST);
  2696.     KLSI_LOG (KLSI_DBG_LOAD, "Done loading usb end..n", 
  2697. 1, 2, 3, 4, 5, 6);
  2699.     pDrvCtrl->pDev->connected = TRUE;
  2701.     return (&pDrvCtrl->endObj);
  2703. errorExit:
  2705.     if (pDrvCtrl != NULL)
  2706. {
  2707. free ((char *)pDrvCtrl);
  2708. }
  2710.     return NULL;
  2711.     }
  2714. /***************************************************************************
  2715. *
  2716. * klsiEndParse - parse the init string
  2717. *
  2718. * Parse the input string.  Fill in values in the driver control structure.
  2719. *
  2720. * The muxLib.o module automatically prepends the unit number to the user's
  2721. * initialization string from the BSP (configNet.h).
  2722. * 
  2723. * This function parses the input string and fills in the places pointed
  2724. * to by <pVendorId> and <pProductId>. Unit Number, no of Irps and no of Input 
  2725. * buffers of the string will be stored in the device structure pointed to by 
  2726. * <pDrvCtrl>.
  2727. *
  2728. * .IP <pDrvCtrl>
  2729. * Pointer to the device structure.
  2730. * .IP <initString>
  2731. * Initialization string for the device. It will be of the following format :
  2732. * "unit:vendorId:productId:noOfInbfrs:noOfIrps"
  2733. * Device unit number, a small integer.
  2734. * .IP <pVendorId>
  2735. * Pointer to the place holder of the device vendor id.
  2736. * .IP <pProductId>
  2737. *  Pointer to the place holder of the device product id.
  2738. * .IP <noOfInbfrs>
  2739. * Holds the number of input buffers.
  2740. * .IP <noOfIrps>
  2741. *  Holds the number of output IRP's.
  2742. *
  2743. * RETURNS: OK or ERROR
  2744. * 
  2745. */
  2747. STATUS klsiEndParse
  2748.     (
  2749.     KLSI_DEVICE * pDrvCtrl, /* device pointer */
  2750.     char * initString, /* information string */
  2751.     UINT16 * pVendorId,
  2752.     UINT16 * pProductId
  2753.     )
  2754.     {
  2756.     char * tok;
  2757.     char * pHolder = NULL;
  2758.     
  2759.     /* Parse the initString */
  2761.     /* Unit number. (from muxLib.o) */
  2763.     tok = strtok_r (initString, ":", &pHolder);
  2765.     if (tok == NULL)
  2766. return ERROR;
  2768.     pDrvCtrl->unit = atoi (tok);
  2770.     KLSI_LOG (KLSI_DBG_LOAD, "Parse: Unit : %d..n", 
  2771. pDrvCtrl->unit, 2, 3, 4, 5, 6); 
  2773.     /* Vendor Id. */
  2775.     tok = strtok_r (NULL, ":", &pHolder);
  2777.     if (tok == NULL)
  2778. return ERROR;
  2780.     *pVendorId = atoi (tok);
  2782.     KLSI_LOG (KLSI_DBG_LOAD, "Parse: VendorId : 0x%x..n", 
  2783. *pVendorId, 2, 3, 4, 5, 6); 
  2785.     /* Product Id. */
  2787.     tok = strtok_r (NULL, ":", &pHolder);
  2789.     if (tok == NULL)
  2790. return ERROR;
  2792.     *pProductId = atoi (tok);
  2793.   
  2794.     KLSI_LOG (KLSI_DBG_LOAD, "Parse: ProductId : 0x%x..n", 
  2795. *pProductId, 2, 3, 4, 5, 6); 
  2798.     /* no of in buffers */
  2800.     tok = strtok_r (NULL, ":", &pHolder);
  2802.     if (tok == NULL)
  2803. return ERROR;
  2806.     pDrvCtrl->noOfInBfrs  = atoi (tok);
  2807.   
  2808.     KLSI_LOG (KLSI_DBG_LOAD, "Parse: NoInBfrs : %x..n", 
  2809. pDrvCtrl->noOfInBfrs, 2, 3, 4, 5, 6); 
  2811.     /* no of out IRPs */
  2813.     tok = strtok_r (NULL, ":", &pHolder);
  2815.     if (tok == NULL)
  2816. return ERROR;
  2818.     pDrvCtrl->noOfIrps = atoi (tok);
  2819.   
  2820.     KLSI_LOG (KLSI_DBG_LOAD, "Parse: NoOutIrps : %x..n", 
  2821.  pDrvCtrl->noOfIrps, 2, 3, 4, 5, 6);
  2823.     KLSI_LOG (KLSI_DBG_LOAD, "Parse: Processed all argumentsn", 
  2824. 1, 2, 3, 4, 5, 6);
  2826.     return OK;
  2827.     }
  2830. /***************************************************************************
  2831. *
  2832. * klsiEndSend - the driver send routine
  2833. *
  2834. * This routine takes a M_BLK_ID sends off the data in the M_BLK_ID. The data 
  2835. * contained in the MBlks is copied to a character buffer and the buffer is 
  2836. * handed over  to klsiSend(). The buffer must already have the addressing 
  2837. * information properly installed in it.  This is done by a higher layer.   
  2838. * The device requires that the first two bytes of the data sent to it (for 
  2839. * transmission over ethernet) contain the length of the data. This is added
  2840. * here. 
  2841. *
  2842. * During the course of testing the driver, it is found that the device is 
  2843. * corrupting some bytes of the packet if exact length of the data as handed 
  2844. * over by MUX is sent. This is resulting in packet not being received
  2845. * by the addressed destination, packet checksum errors etc. The remedy is to
  2846. * pad up few bytes to the data packet. This solved the problem.
  2847. *
  2848. * RETURNS: OK or ERROR.
  2849. */
  2851. LOCAL STATUS klsiEndSend
  2852.     (
  2853.     KLSI_DEVICE * pDrvCtrl, /* device ptr */
  2854.     M_BLK_ID     pMblk /* data to send */
  2855.     )
  2856.     {
  2858.     UINT8 *      pBuf;  /* buffer to hold the data */
  2859.     UINT32 noOfBytes;      /* noOfBytes to be transmitted */
  2861. #if 0
  2862.     int i=0;
  2863. #endif
  2865.     KLSI_LOG (KLSI_DBG_TX, "klsiEndSend: Entered.n", 0, 0, 0, 0, 0, 0);  
  2867.  
  2868.     if ((pDrvCtrl == NULL) || (pMblk == NULL))
  2869. return ERROR;
  2871. /*   pBuf = (UINT8 *) malloc(KLSI_OUT_BFR_SIZE);*/
  2872.      pBuf = (UINT8 *) memalign(sizeof(ULONG),KLSI_OUT_BFR_SIZE);
  2873.   
  2874.     
  2876.     if (pBuf == NULL)
  2877. {
  2878. printf(" klsiEndSend : Could not allocate memory n");
  2879. return ERROR;
  2880. }
  2882.     /* copy the MBlk chain to a buffer */
  2884.     noOfBytes = netMblkToBufCopy(pMblk,(char *)pBuf+2,NULL); 
  2887.     KLSI_LOG (KLSI_DBG_LOAD, "klsiEndSend: %d bytes to be sent.n", 
  2888. noOfBytes, 0, 0, 0, 0, 0);
  2890.     if (noOfBytes == 0) 
  2891. return ERROR;
  2893.     /* 
  2894.      * Padding : how much to pad is decided by trial and error.
  2895.      * Note that there is no need to add any extra bytes in the buffer.
  2896.      * since these bytes are not used, they can be any junk 
  2897.      * which is already in the buffer.
  2898.      * We are just interested in the count.
  2899.      */
  2900.     
  2901.     if (noOfBytes < 60)
  2902. noOfBytes = 60;
  2904.     /* (Required by the device) Fill in the Length in the first Two Bytes */
  2906. /*    *(UINT16 *)pBuf = noOfBytes; */
  2908.     pBuf[0] = (UINT8) (noOfBytes&0x00ff); 
  2909.     pBuf[1] = (UINT8) ((noOfBytes >> 8)&0x00ff);
  2911. #if 0
  2912.     for(i=0;i<noOfBytes+2;i++)
  2913. printf("%x ",pBuf[i]);
  2914.     printf("n"); 
  2915. #endif
  2917.     /* Transmit the data */
  2919.     if (klsiSend (pDrvCtrl, pBuf, noOfBytes+2) == ERROR)
  2920. return ERROR;
  2921.  
  2923.     KLSI_LOG (KLSI_DBG_TX, "klsiEndSend: Pkt submitted for tx.n", 
  2924. 0, 0, 0, 0, 0, 0);
  2925.  
  2926.     /* Bump the statistic counter. */
  2928.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);
  2930.     /*
  2931.      * Cleanup.  The driver frees the packet now.
  2932.      */
  2934.     netMblkClChainFree (pMblk);
  2936.     return (OK);
  2937.     }
  2940. /***************************************************************************
  2941. *
  2942. * klsiEndRecv - process the next incoming packet
  2943. *
  2944. * klsiEndRecv is called by the klsiRxCallBack() upon successful execution
  2945. * of an input IRP. This means some proper data is received. This function  
  2946. * will be called with the pointer to be buffer and the length of data.
  2947. * What is done here is to construct an MBlk structure with the data received 
  2948. * and pass it onto the upper layer.
  2949. *
  2950. * RETURNS: N/A.
  2951. * 
  2952. */
  2954. STATUS klsiEndRecv
  2955.     (
  2956.     KLSI_DEVICE *pDrvCtrl, /* device structure */
  2957.     UINT8*  pData,              /* pointer to data buffer */
  2958.     UINT32  len                 /* length of data */
  2959.     )
  2960.     {
  2961.     
  2962.     UCHAR *     pNewCluster;    /* Clsuter to store the data */
  2963.     CL_BLK_ID pClBlk;         /* Control block to "control" the cluster */
  2964.     M_BLK_ID  pMblk;          /* and an MBlk to complete a MBlk contract */   
  2965. #if 0
  2966.     int i=0;
  2967. #endif
  2969.     /* Add one to our unicast data. */
  2971.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_UCAST, +1);
  2973.     pNewCluster = (UCHAR *)pData; 
  2975. #if 0
  2976.      for (i=0;i<len;i++)
  2977. printf("%x ",pNewCluster[i]);
  2978.      printf("n");
  2979. #endif
  2981.     /* Grab a cluster block to marry to the cluster received. */
  2983.     if ((pClBlk = netClBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT)) == NULL)
  2984.         {
  2985.         netClFree (pDrvCtrl->endObj.pNetPool, pNewCluster);
  2986. KLSI_LOG (KLSI_DBG_RX, "Out of Cluster Blocks!n", 
  2987.     1, 2, 3, 4, 5, 6);
  2988. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  2989. goto cleanRXD;
  2990.         }
  2991.     
  2992.     /*
  2993.      * Let's get an M_BLK_ID and marry it to the one in the ring.
  2994.      */
  2996.     if ((pMblk = mBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT, MT_DATA)) 
  2997. == NULL)
  2998.         {
  2999.         netClBlkFree (pDrvCtrl->endObj.pNetPool, pClBlk); 
  3000.         netClFree (pDrvCtrl->endObj.pNetPool, pNewCluster);
  3001. KLSI_LOG (KLSI_DBG_RX, "Out of M Blocks!n", 
  3002.     1, 2, 3, 4, 5, 6);
  3003. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  3004. goto cleanRXD;
  3005.         }
  3007.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_UCAST, +1);
  3008.     
  3009.     /* Join the cluster to the MBlock */
  3011.     netClBlkJoin (pClBlk, (char *)pNewCluster, len, NULL, 0, 0, 0);
  3012.     netMblkClJoin (pMblk, pClBlk);
  3014.     pMblk->mBlkHdr.mLen = len;
  3015.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  3016.     pMblk->mBlkPktHdr.len = len;
  3019.     END_RCV_RTN_CALL(&pDrvCtrl->endObj, pMblk);    
  3021. cleanRXD:
  3023.     return OK;
  3024.     }
  3026. /***************************************************************************
  3027. *
  3028. * klsiEndMemInit - initialize memory for the device.
  3029. *
  3030. * The END's Network memory pool is setup. This code is highly generic and 
  3031. * very simple. The technique described in netBufLib is followed.
  3032. * It is not even needed to make the memory cache DMA coherent. This is because
  3033. * unlike other END drivers, which act right on the top of the hardware,  
  3034. * we are layers above the hardware. 
  3035. *
  3036. * RETURNS: OK or ERROR.
  3037. * 
  3038. */
  3040. STATUS klsiEndMemInit
  3041.     (
  3042.     KLSI_DEVICE * pDrvCtrl /* device to be initialized */
  3043.     )
  3044.     {
  3045.   
  3046.     /*
  3047.      * This is how END netPool is setup using netBufLib(1).
  3048.      * This code is very generic.
  3049.      */
  3050.     
  3051.     if ((pDrvCtrl->endObj.pNetPool = malloc (sizeof (NET_POOL))) == NULL)
  3052.         return (ERROR);
  3054.     klsiMclBlkConfig.mBlkNum = KLSI_M_BULK_NUM;
  3055.     klsiClDescTbl[0].clNum = KLSI_CL_NUMBER;
  3056.     klsiMclBlkConfig.clBlkNum = klsiClDescTbl[0].clNum;
  3058.     /* Calculate the total memory for all the M-Blks and CL-Blks. */
  3060.     klsiMclBlkConfig.memSize = (klsiMclBlkConfig.mBlkNum *
  3061.     (MSIZE + sizeof (long))) +
  3062.       (klsiMclBlkConfig.clBlkNum * 
  3063.     (CL_BLK_SZ + sizeof(long)));
  3065.     if ((klsiMclBlkConfig.memArea = (char *) memalign (sizeof(long),
  3066.                          klsiMclBlkConfig.memSize)) == NULL)
  3067.         return (ERROR);
  3068.     
  3069.     /* Calculate the memory size of all the clusters. */
  3071.     klsiClDescTbl[0].memSize = (klsiClDescTbl[0].clNum *
  3072.     (KLSI_BUFSIZ + 8)) + sizeof(int);
  3074.     /* Allocate the memory for the clusters from cache safe memory. */
  3076.     klsiClDescTbl[0].memArea =
  3077.         (char *) cacheDmaMalloc (klsiClDescTbl[0].memSize);
  3079.     if (klsiClDescTbl[0].memArea == NULL)
  3080.         {
  3081.         KLSI_LOG (KLSI_DBG_LOAD,"klsiEndMemInit:system memory "
  3082.     "unavailablen", 1, 2, 3, 4, 5, 6);
  3083.         return (ERROR);
  3084.         }
  3085.     
  3086.     /* Initialize the memory pool. */
  3088.     if (netPoolInit(pDrvCtrl->endObj.pNetPool, 
  3089.     &klsiMclBlkConfig,
  3090.                     &klsiClDescTbl[0], 
  3091.     klsiClDescTblNumEnt,
  3092.     NULL) == ERROR)
  3093.         {
  3094.         KLSI_LOG (KLSI_DBG_LOAD, "Could not init bufferingn",
  3095. 1, 2, 3, 4, 5, 6);
  3096.         return (ERROR);
  3097.         }
  3100.     if ((pDrvCtrl->pClPoolId = netClPoolIdGet (pDrvCtrl->endObj.pNetPool,
  3101.        ETHERMTU, 
  3102.        FALSE)) 
  3103.     == NULL)
  3104. {
  3105.         KLSI_LOG (KLSI_DBG_LOAD, "netClPoolIdGet() not successful n",
  3106.        1, 2, 3, 4, 5, 6);
  3107. return (ERROR);
  3108.         }
  3110.     KLSI_LOG (KLSI_DBG_LOAD, "Memory setup completen", 
  3111. 1, 2, 3, 4, 5, 6);
  3113.     return OK;
  3114.     }
  3117. /***************************************************************************
  3118. *
  3119. * klsiEndConfig - reconfigure the interface under us.
  3120. *
  3121. * Reconfigure the interface setting promiscuous/ broadcast etc modes, and 
  3122. * changing the multicast interface list.
  3123. *
  3124. * RETURNS: N/A.
  3125. */
  3127. LOCAL STATUS klsiEndConfig
  3128.     (
  3129.     KLSI_DEVICE *pDrvCtrl /* device to be re-configured */
  3130.     )
  3131.     {
  3133.     UINT8 bitmap = 0x00;    
  3134.     MULTI_TABLE* pList = NULL;
  3137.     /* Set the modes asked for. */
  3139.     if (END_FLAGS_GET(&pDrvCtrl->endObj) & IFF_PROMISC)
  3140. {
  3141. KLSI_LOG (KLSI_DBG_IOCTL, "Setting Promiscuous mode on!n",
  3142. 1, 2, 3, 4, 5, 6);
  3143. bitmap |= PACKET_TYPE_PROMISCOUS;
  3144. }
  3146.     if (END_FLAGS_GET(&pDrvCtrl->endObj) & IFF_MULTICAST)
  3147. {
  3148. KLSI_LOG (KLSI_DBG_IOCTL, "Setting Multicast mode On!n",
  3149. 1, 2, 3, 4, 5, 6);
  3150. bitmap |= PACKET_TYPE_MULTICAST;
  3151. }
  3153.     if (END_FLAGS_GET(&pDrvCtrl->endObj) & IFF_ALLMULTI)
  3154. {
  3155. KLSI_LOG (KLSI_DBG_IOCTL, "Setting ALLMULTI mode On!n",
  3156. 1, 2, 3, 4, 5, 6);
  3157. bitmap |= PACKET_TYPE_ALL_MULTICAST;
  3158. }
  3160.     if (END_FLAGS_GET(&pDrvCtrl->endObj) & IFF_BROADCAST)
  3161. {
  3162. KLSI_LOG (KLSI_DBG_IOCTL, "Setting Broadcast mode On!n",
  3163. 1, 2, 3, 4, 5, 6);
  3164. bitmap |= PACKET_TYPE_BROADCAST;
  3165. }
  3167.     /* Setup the packet filter */
  3169.     if (klsiPacketFilterSet (pDrvCtrl, bitmap) == ERROR)
  3170.         return ERROR;
  3171.          
  3172.     
  3173.     /* Set up address filter for multicasting. */
  3175.     if (END_MULTI_LST_CNT(&pDrvCtrl->endObj) > 0)
  3176. {
  3178. /* get the list of address to send to the device */
  3179.  
  3180.   if (etherMultiGet (&pDrvCtrl->endObj.multiList, pList)
  3181.    == ERROR)
  3182.     return ERROR;   
  3184.         /* Set the Filter!!! */
  3186.         if (klsiMCastFilterSet(pDrvCtrl,(pUINT8)pList->pTable,
  3187.     (pList->len) / 6) == ERROR)
  3188.     return ERROR;
  3189. }
  3191.     return OK;
  3192.     }
  3194. /***************************************************************************
  3195. *
  3196. * klsiEndMCastAdd - add a multicast address for the device
  3197. *
  3198. * This routine adds a multicast address to whatever the chip is already 
  3199. * listening for. The USB Ethernet device specifically requires that even 
  3200. * if a small modification (addition or removal) of the filter list is desired,
  3201. * the entire list has to be downloaded to the device. The generic etherMultiLib
  3202. * functions are used and then klsiMCastFilterSet() is called to achieve the
  3203. * functionality.
  3204. *
  3205. * RETURNS: OK or ERROR.
  3206. */
  3208. LOCAL STATUS klsiEndMCastAdd
  3209.     (
  3210.     KLSI_DEVICE *pDrvCtrl, /* device pointer */
  3211.     char* pAddress /* new address to add */
  3212.     )
  3213.     {
  3214.     
  3215.     int error;
  3216.     MULTI_TABLE* pList = NULL;
  3218.     if ((pDrvCtrl == NULL) || (pAddress == NULL))
  3219. return ERROR;
  3221.     /* First, add this address to the local list */
  3222.     
  3223.     if ((error = etherMultiAdd (&pDrvCtrl->endObj.multiList,
  3224. pAddress)) == ERROR)
  3225. return ERROR;
  3226.      
  3227.     /* Then get the list of address to send to the device */
  3228.  
  3229.     if ((error = etherMultiGet (&pDrvCtrl->endObj.multiList, pList))
  3230. == ERROR)
  3231. return ERROR;   
  3233.     /* Set the Filter!!! */
  3235.     if ((error = klsiMCastFilterSet (pDrvCtrl, 
  3236.      (pUINT8)pList->pTable, 
  3237.      (pList->len) / 6))
  3238. == ERROR)
  3239. return ERROR;   
  3241.     return (OK);
  3242.     }
  3244. /***************************************************************************
  3245. *
  3246. * klsiEndMCastDel - delete a multicast address for the device
  3247. *
  3248. * This routine removes a multicast address from whatever the driver
  3249. * listening for. The USB Ethernet device specifically requires that even 
  3250. * if a small modification (addition or removal) of the filter list is desired,
  3251. * the entire list has to be downloaded to the device. The generic etherMultiLib
  3252. * functions are used and then klsiMCastFilterSet() is called to achieve the
  3253. * functionality.
  3254. *
  3255. * RETURNS: OK or ERROR.
  3256. */
  3258. LOCAL STATUS klsiEndMCastDel
  3259.     (
  3260.     KLSI_DEVICE *pDrvCtrl, /* device pointer */
  3261.     char* pAddress /* new address to add */
  3262.     )
  3263.     {
  3264.     int error;
  3265.     MULTI_TABLE* pList = NULL;
  3267.     if ((pDrvCtrl == NULL) || (pAddress == NULL))
  3268. return ERROR;
  3270.     /* First, add this address to the local list */
  3271.     
  3272.     if ((error = etherMultiDel (&pDrvCtrl->endObj.multiList,
  3273. pAddress)) == ERROR)
  3274. return ERROR;
  3275.      
  3276.     /* Then get the list of address to send to the device */
  3277.  
  3278.     if ((error = etherMultiGet (&pDrvCtrl->endObj.multiList, pList))
  3279. == ERROR)
  3280. return ERROR;   
  3282.     if ((error = klsiMCastFilterSet (pDrvCtrl,
  3283.      (pUINT8)pList->pTable, 
  3284.      (pList->len) / 6))
  3285. == ERROR)
  3286. return ERROR;
  3288.     return (OK);
  3289.     }
  3292. /***************************************************************************
  3293. *
  3294. * klsiEndMCastGet - get the multicast address list for the device
  3295. *
  3296. * This routine gets the multicast list of whatever the driver
  3297. * is already listening for.
  3298. *
  3299. * RETURNS: OK or ERROR.
  3300. */
  3302. LOCAL STATUS klsiEndMCastGet
  3303.     (
  3304.     KLSI_DEVICE *pDrvCtrl, /* device pointer */
  3305.     MULTI_TABLE* pTable /* address table to be filled in */
  3306.     )
  3307.     {
  3308.     return (etherMultiGet (&pDrvCtrl->endObj.multiList, pTable));
  3309.     }
  3312. /***************************************************************************
  3313. *
  3314. * klsiEndIoctl - the driver I/O control routine
  3315. *
  3316. * Process an ioctl request.
  3317. *
  3318. * RETURNS: A command specific response, usually OK or ERROR.
  3319. */
  3321. int klsiEndIoctl
  3322.     (
  3323.     KLSI_DEVICE * pDrvCtrl, /* device receiving command */
  3324.     int cmd, /* ioctl command code */
  3325.     caddr_t data /* command argument */
  3326.     )
  3327.     {
  3329.     int error = 0;
  3330.     long value;
  3332.     switch (cmd)
  3333.         {
  3334.         case EIOCSADDR : /* Set Device Address */
  3336.     if (data == NULL)
  3337. return (EINVAL);
  3339.             bcopy ((char *)data, 
  3340.    (char *)END_HADDR (&pDrvCtrl->endObj),
  3341.    END_HADDR_LEN (&pDrvCtrl->endObj));
  3343.     if(klsiMacAddressSet (pDrvCtrl, (UINT8 *)data) == ERROR)
  3344. return ERROR;
  3346.             break;
  3348.         case EIOCGADDR : /* Get Device Address */
  3350.     if (data == NULL)
  3351. return (EINVAL);
  3353.             bcopy ((char *)END_HADDR (&pDrvCtrl->endObj), 
  3354.       (char *)data,
  3355.       END_HADDR_LEN (&pDrvCtrl->endObj));
  3357.             break;
  3360.         case EIOCSFLAGS : /* Set Device Flags */
  3361.   
  3362.     value = (long)data;
  3363.     if (value < 0)
  3364.         {
  3365. value = -(--value);
  3366. END_FLAGS_CLR (&pDrvCtrl->endObj, value);
  3367. }
  3368.     else
  3369. {
  3370. END_FLAGS_SET (&pDrvCtrl->endObj, value);
  3371. }
  3373.     klsiEndConfig (pDrvCtrl);
  3374.             break;
  3377.         case EIOCGFLAGS: /* Get Device Flags */
  3379.     *(int *)data = END_FLAGS_GET(&pDrvCtrl->endObj);
  3380.             break;
  3383. case EIOCPOLLSTART : /* Begin polled operation */
  3385.     return EINVAL; /* Not supported */
  3388. case EIOCPOLLSTOP : /* End polled operation */
  3390.     return EINVAL; /* Not supported */
  3393.         case EIOCGMIB2 : /* return MIB information */
  3395.             if (data == NULL)
  3396.                 return (EINVAL);
  3398.             bcopy ((char *)&pDrvCtrl->endObj.mib2Tbl, 
  3399.    (char *)data,
  3400.    sizeof(pDrvCtrl->endObj.mib2Tbl));
  3402.             break;
  3405.         case EIOCGFBUF : /* return minimum First Buffer for chaining */
  3407.             if (data == NULL)
  3408.                 return (EINVAL);
  3410.             * (int *)data = KLSI_MIN_FBUF;
  3412.             break;
  3415. case EIOCMULTIADD :  /* Add a Multicast Address */
  3417.     if (data == NULL)
  3418. return (EINVAL);
  3420.     if (klsiEndMCastAdd (pDrvCtrl, (char *)data) == ERROR)
  3421. return ERROR;
  3423.     break;
  3426. case EIOCMULTIDEL :  /* Delete a Multicast Address */
  3428.     if (data == NULL)
  3429. return (EINVAL);
  3431.     if (klsiEndMCastDel (pDrvCtrl, (char *)data) == ERROR)
  3432. return ERROR;
  3434.     break;
  3437. case EIOCMULTIGET :  /* Get the Multicast List */
  3439.     if (data == NULL)
  3440. return (EINVAL);
  3442.     if (klsiEndMCastGet (pDrvCtrl, (MULTI_TABLE *)data) == ERROR)
  3443. return ERROR;
  3445.     break;
  3447.        default:
  3448.             error = EINVAL;
  3450.         }
  3452.     return (error);
  3453.     }
  3456. /***************************************************************************
  3457. *
  3458. * klsiEndUnload - unload a driver from the system
  3459. *
  3460. * This function first brings down the device, and then frees any
  3461. * stuff that was allocated by the driver in the load function.
  3462. *
  3463. * RETURNS: OK or ERROR.
  3464. */
  3466. LOCAL STATUS klsiEndUnload
  3467.     (
  3468.     KLSI_DEVICE* pDrvCtrl /* device to be unloaded */
  3469.     )
  3470.     {
  3471.     END_OBJECT_UNLOAD (&pDrvCtrl->endObj);
  3472.    
  3473.     if ((pDrvCtrl->pDev->lockCount == 0) && (!pDrvCtrl->pDev->connected))
  3474. {
  3475.   klsiDestroyDevice (pDrvCtrl);
  3476.      taskDelay(sysClkRateGet() *1);
  3478.      netPoolDelete (pDrvCtrl->endObj.pNetPool);
  3479.      taskDelay(sysClkRateGet() *1);
  3480.     
  3481.      if (cfree((char *)pDrvCtrl)!=OK)
  3482.    {
  3483.     printf(" Error in memory clearing of device Structuren");
  3484.     return (ERROR);
  3485.     }
  3486. }
  3488.     return (OK);
  3489.     }
  3492. /***************************************************************************
  3493. *
  3494. * klsiEndPollRcv - routine to receive a packet in polled mode.
  3495. *
  3496. * This routine is NOT supported
  3497. *
  3498. * RETURNS: ERROR Always
  3499. */
  3501. LOCAL STATUS klsiEndPollRcv
  3502.     (
  3503.     KLSI_DEVICE * pDrvCtrl, /* device to be polled */
  3504.     M_BLK_ID      pMblk /* ptr to buffer */
  3505.     )
  3506.     {
  3507.     
  3508.     KLSI_LOG (KLSI_DBG_POLL_RX, "Poll Recv: NOT SUPPORTED", 
  3509. 1, 2, 3, 4, 5, 6);
  3511.     return ERROR;
  3513.     }
  3515. /***************************************************************************
  3516. *
  3517. * klsiEndPollSend - routine to send a packet in polled mode.
  3518. *
  3519. * This routine is NOT SUPPORTED
  3520. *
  3521. * RETURNS: ERROR always
  3522. */
  3524. LOCAL STATUS klsiEndPollSend
  3525.     (
  3526.     KLSI_DEVICE*  pDrvCtrl, /* device to be polled */
  3527.     M_BLK_ID    pMblk /* packet to send */
  3528.     )
  3529.     {
  3530.     
  3531.     KLSI_LOG (KLSI_DBG_POLL_TX, "Poll Send : NOT SUPPORTED", 
  3532. 1, 2, 3, 4, 5, 6);
  3534.     return ERROR;
  3535.     }
  3537. /***************************************************************************
  3538. *
  3539. * klsiDownloadFirmware - Downloads firmware to the KLSI Chip
  3540. *
  3541. * This routine downloads firmaware to the KLSI chip.  It will not function
  3542. * until this occurs.
  3543. *
  3544. *
  3545. * RETURNS : OK or ERROR
  3546. */
  3548. LOCAL STATUS klsiDownloadFirmware
  3549.     (
  3550.     KLSI_DEVICE * pDevCtrl, /* device to download */
  3551.     UINT8 * pData, /* Firmware */
  3552.     UINT16 len, /* size of firmware */
  3553.     UINT8 interrupt, /* Interrupt to use */
  3554.     UINT8 type
  3555.     )
  3556.     {
  3558.     UINT16 actLen = 0;
  3560.     if (len > KLSI_FIRMWARE_BUF)
  3561. {
  3562. KLSI_LOG (KLSI_DBG_DNLD," Firmware too BIG : %d bytes n", 
  3563.     len, 0, 0, 0, 0, 0);
  3564. return ERROR;
  3565. }    
  3567.     pData[2] = (len & 0xFF) - 7;
  3568.     pData[3] = len >> 8;
  3569.     pData[4] = type;
  3570.     pData[5] = interrupt;
  3572.     if (usbdVendorSpecific (klsiHandle, 
  3573.     pDevCtrl->pDev->nodeId,
  3574.     USB_RT_VENDOR | USB_RT_DEVICE | USB_RT_HOST_TO_DEV, 
  3575.     USB_REQ_KLSI_SCAN, 
  3576.     0, 
  3577.     0, 
  3578.     len, 
  3579.     pData,
  3580.     &actLen) != OK)
  3581. {
  3582. return ERROR;
  3583. }
  3584.     
  3585.     return OK;
  3586.     }        
  3589. /***************************************************************************
  3590. *
  3591. * klsiTriggerFirmware - Triggers firmware of KLSI Chip
  3592. *
  3593. * RETURNS : OK or ERROR
  3594. */
  3596. LOCAL STATUS klsiTriggerFirmware
  3597.     (
  3598.     KLSI_DEVICE * pDevCtrl, /* device to trigger */
  3599.     UINT8 interrupt /* interrupt to use */
  3600.     )
  3601.     {
  3603.     UINT16 actLen = 0;
  3605.     UINT8 triggerBuf[8];
  3607.     triggerBuf[0] = 0xB6;
  3608.     triggerBuf[1] = 0xC3;
  3609.     triggerBuf[2] = 1;
  3610.     triggerBuf[3] = 0;
  3611.     triggerBuf[4] = 6;
  3612.     triggerBuf[5] = 100;
  3613.     triggerBuf[6] = 0;
  3614.     triggerBuf[7] = 0;
  3616.     if (usbdVendorSpecific (klsiHandle, 
  3617.     pDevCtrl->pDev->nodeId,
  3618.     USB_RT_VENDOR | USB_RT_DEVICE | USB_RT_HOST_TO_DEV, 
  3619.     USB_REQ_KLSI_SCAN, 
  3620.     0, 
  3621.     0, 
  3622.     8, 
  3623.     triggerBuf,
  3624.     &actLen) 
  3625. != OK)
  3626. {
  3627. return ERROR;
  3628. }
  3629.     
  3631.     return OK;
  3632.     }        
  3635. /***************************************************************************
  3636. *
  3637. * klsiInit - Initialization for the KLSI Chip
  3638. *
  3639. * This device requires that a piece of "Firmware" be downloaded to the Chip 
  3640. * before it starts functioning as an Ethernet adapter. This function does 
  3641. * the device specific initialization, it basically downloads the firmware 
  3642. * on to the chip. Also sets which Interrupt of the device is to be used and 
  3643. * then reset the device.
  3644. *
  3645. * RETURNS : OK or ERROR
  3646. */
  3648. STATUS klsiInit
  3649.     (
  3650.     KLSI_DEVICE * pDevCtrl
  3651.     )
  3652.     {
  3654.     if (klsiDownloadFirmware (pDevCtrl, 
  3655.       klsiNewCode, 
  3656.       lenKlsiNewCode, 
  3657.       KLSI_INTERRUPT_TO_USE, 
  3658.       2) 
  3659.     == ERROR)
  3660. {
  3661. KLSI_LOG (KLSI_DBG_DNLD, " Couldnot download : NewCode n",
  3662.     0, 0, 0, 0, 0, 0);
  3663. return ERROR;
  3664. }
  3666.     if (klsiDownloadFirmware (pDevCtrl, 
  3667.       klsiNewCodeFix, 
  3668.       lenKlsiNewCodeFix, 
  3669.       KLSI_INTERRUPT_TO_USE, 
  3670.       3) 
  3671.     == ERROR)
  3672. {
  3673. KLSI_LOG (KLSI_DBG_DNLD, " Couldnot download : NewCode Fixn", 
  3674.     0, 0, 0, 0, 0, 0);
  3675. return ERROR;
  3676. }
  3678.     if (klsiTriggerFirmware (pDevCtrl, KLSI_INTERRUPT_TO_USE) == ERROR )
  3679. {
  3680. KLSI_LOG (KLSI_DBG_DNLD, " Couldnot Trigger n", 
  3681.     0, 0, 0, 0, 0, 0);
  3682. return ERROR;
  3683. }
  3685.     if (klsiReset (pDevCtrl) == ERROR)
  3686. {
  3687. KLSI_LOG (KLSI_DBG_DNLD, " Couldnot Reset the device n",
  3688.     0, 0, 0, 0, 0, 0);
  3689. return ERROR;
  3690. }
  3692.     return OK;
  3694.     }    
  3695.      
  3697. /***************************************************************************
  3698. *
  3699. * notifyAttach - Notifies registered callers of attachment/removal
  3700. *
  3701. * RETURNS: N/A
  3702. */
  3704. LOCAL VOID notifyAttach
  3705.     (
  3706.     USBD_NODE_ID nodeId,
  3707.     UINT16 attachCode
  3708.     )
  3710.     {
  3711.     pATTACH_REQUEST pRequest = usbListFirst (&reqList);
  3712.     
  3713.     while (pRequest != NULL)
  3714.     {
  3716.     (*pRequest->callback) (pRequest->callbackArg, 
  3717.                    nodeId, 
  3718.    attachCode);
  3720.     pRequest = usbListNext (&pRequest->reqLink);
  3721.     }
  3722.     }
  3724. /***************************************************************************
  3725. *
  3726. * usbKlsiDynamicAttachRegister - Register KLSI device attach callback.
  3727. *
  3728. * <callback> is a caller-supplied function of the form:
  3729. *
  3730. * .CS
  3731. * typedef (*USB_KLSI_ATTACH_CALLBACK) 
  3732. *     (
  3733. *     pVOID arg,
  3734. *     USBD_NODE_ID nodeId,
  3735. *     UINT16 attachCode
  3736. *     );
  3737. * .CE
  3738. *
  3739. * usbKlsiEnd will invoke <callback> each time a KLSI device
  3740. * is attached to or removed from the system.  <arg> is a caller-defined
  3741. * parameter which will be passed to the <callback> each time it is
  3742. * invoked.  The <callback> will also be passed the nodeID of the device 
  3743. * being created/destroyed and an attach code of USB_KLSI_ATTACH or 
  3744. * USB_KLSI_REMOVE.
  3745. *
  3746. * NOTE: The user callback routine should not invoke any driver function that
  3747. * submits IRPs.  Further processing must be done from a different task context.
  3748. * As the driver routines wait for IRP completion, they cannot be invoked from
  3749. * USBD client task's context created for this driver.
  3750. *
  3751. *
  3752. * RETURNS: OK, or ERROR if unable to register callback
  3753. *
  3754. * ERRNO:
  3755. *   S_usbKlsiLib_BAD_PARAM
  3756. *   S_usbKlsiLib_OUT_OF_MEMORY
  3757. */
  3759. STATUS usbKlsiDynamicAttachRegister
  3760.     (
  3761.     USB_KLSI_ATTACH_CALLBACK callback, /* new callback to be registered */
  3762.     pVOID arg                           /* user-defined arg to callback  */
  3763.     )
  3765.     {
  3766.     pATTACH_REQUEST   pRequest;
  3767.     USB_KLSI_DEV  *       pKlsiDev;
  3768.     int status = OK;
  3771.     /* Validate parameters */
  3773.     if (callback == NULL)
  3774.         return (ossStatus (S_usbKlsiLib_BAD_PARAM));
  3776.     OSS_MUTEX_TAKE (klsiMutex, OSS_BLOCK);
  3778.     /* Create a new request structure to track this callback request. */
  3780.     if ((pRequest = OSS_CALLOC (sizeof (*pRequest))) == NULL)
  3781.         {
  3782.         status = ossStatus (S_usbKlsiLib_OUT_OF_MEMORY);
  3783.         }
  3784.     else
  3785.         {
  3786.         pRequest->callback    = callback;
  3787.         pRequest->callbackArg = arg;
  3789.         usbListLink (&reqList, pRequest, &pRequest->reqLink, LINK_TAIL) ;
  3790.     
  3791.        /* 
  3792.         * Perform an initial notification of all currrently attached
  3793.         * KLSI devices.
  3794.         */
  3796.         pKlsiDev = usbListFirst (&klsiDevList);
  3798.         while (pKlsiDev != NULL)
  3799.     {
  3800.             if (pKlsiDev->connected)
  3801.                 (*callback) (arg, pKlsiDev->nodeId, USB_KLSI_ATTACH);
  3803.     pKlsiDev = usbListNext (&pKlsiDev->devLink);
  3804.     }
  3806.         }
  3808.     OSS_MUTEX_RELEASE (klsiMutex);
  3810.     return (ossStatus (status));
  3811.     }
  3814. /***************************************************************************
  3815. *
  3816. * usbKlsiDynamicAttachUnregister - Unregisters KLSI attach callback.
  3817. *
  3818. * This function cancels a previous request to be dynamically notified for
  3819. * KLSI device attachment and removal.  The <callback> and <arg> paramters 
  3820. * must exactly match those passed in a previous call to 
  3821. * usbKlsiDynamicAttachRegister().
  3822. *
  3823. * RETURNS: OK, or ERROR if unable to unregister callback
  3824. *
  3825. * ERRNO:
  3826. *   S_usbKlsiLib_NOT_REGISTERED
  3827. */
  3829. STATUS usbKlsiDynamicAttachUnregister
  3830.     (
  3831.     USB_KLSI_ATTACH_CALLBACK callback, /* callback to be unregistered  */
  3832.     pVOID arg                          /* user-defined arg to callback */
  3833.     )
  3835.     {
  3836.     pATTACH_REQUEST pRequest;
  3837.     int status = S_usbKlsiLib_NOT_REGISTERED;
  3839.     OSS_MUTEX_TAKE (klsiMutex, OSS_BLOCK);
  3841.     pRequest = usbListFirst (&reqList);
  3843.     while (pRequest != NULL)
  3844.         {
  3845.         if ((callback == pRequest->callback) && (arg == pRequest->callbackArg))
  3846.     {
  3847.     /* We found a matching notification request. */
  3849.     usbListUnlink (&pRequest->reqLink);
  3851.             /* Dispose of structure */
  3853.             OSS_FREE (pRequest);
  3854.     status = OK;
  3856.     break;
  3857.     }
  3858.         pRequest = usbListNext (&pRequest->reqLink);
  3859. }
  3861.     OSS_MUTEX_RELEASE (klsiMutex);
  3863.     return (ossStatus (status));
  3864.     }
  3867. /***************************************************************************
  3868. *
  3869. * usbKlsiDevLock - Marks USB_KLSI_DEV structure as in use.
  3870. *
  3871. * A caller uses usbKlsiDevLock() to notify usbKlsiEnd that
  3872. * it is using the indicated USB_KLSI_DEV structure.  usbKlsiEnd maintains
  3873. * a count of callers using a particular USB_KLSI_DEV structure so that it 
  3874. * knows when it is safe to dispose of a structure when the underlying
  3875. * USB_KLSI_DEV is removed from the system.  So long as the "lock count"
  3876. * is greater than zero, usbKlsiEnd will not dispose of an USB_KLSI_DEV
  3877. * structure.
  3878. *
  3879. * RETURNS: OK, or ERROR if unable to mark USB_KLSI_DEV structure in use.
  3880. */
  3882. STATUS usbKlsiDevLock
  3883.     (
  3884.     USBD_NODE_ID nodeId   /* NodeId of the USB_KLSI_DEV to be marked as in use */
  3885.     )
  3887.     {
  3888.     USB_KLSI_DEV* pKlsiDev = klsiFindDevice (nodeId);
  3890.     if ( pKlsiDev == NULL)
  3891.         return (ERROR);
  3893.     pKlsiDev->lockCount++;
  3895.     return (OK);
  3896.     }
  3899. /***************************************************************************
  3900. *
  3901. * usbKlsiDevUnlock - Marks USB_KLSI_DEV structure as unused.
  3902. *
  3903. * This function releases a lock placed on an USB_KLSI_DEV structure.  When a
  3904. * caller no longer needs an USB_KLSI_DEV structure for which it has previously
  3905. * called usbKlsiDevLock(), then it should call this function to
  3906. * release the lock.
  3907. *
  3908. * RETURNS: OK, or ERROR if unable to mark USB_KLSI_DEV structure unused
  3909. *
  3910. * ERRNO:
  3911. *   S_usbKlsiLib_NOT_LOCKED
  3912. */
  3914. STATUS usbKlsiDevUnlock
  3915.     (
  3916.     USBD_NODE_ID nodeId    /* NodeId of the BLK_DEV to be marked as unused */
  3917.     )
  3919.     {
  3920.     int status = OK;
  3922.     USB_KLSI_DEV *      pKlsiDev = klsiFindDevice (nodeId);
  3923.  
  3924.     if ( pKlsiDev == NULL)
  3925.         return (ERROR);
  3927.     OSS_MUTEX_TAKE (klsiMutex, OSS_BLOCK);
  3929.     if (pKlsiDev->lockCount == 0)
  3930.         {
  3931.         status = S_usbKlsiLib_NOT_LOCKED;
  3932.         }
  3933.     else
  3934.      {
  3935.        /* 
  3936. * If this is the last lock and the underlying KLSI device is
  3937.         * no longer connected, then dispose of the device.
  3938.         */
  3939.      if ((--pKlsiDev->lockCount == 0) && (!pKlsiDev->connected))
  3940. klsiDestroyDevice ((KLSI_DEVICE *)pKlsiDev->pDevStructure);
  3941.      }
  3943.     OSS_MUTEX_RELEASE (klsiMutex);
  3945.     return (ossStatus (status));
  3946.     }