/* osWrap_win.c - DK 2.0 functions to hide os dependent calls */


#ident  "ACI $Id: //depot/sw/branches/ART_V53/sw/src/dk/mdk/common/osWrap_win.c#1 $, $Header: //depot/sw/branches/ART_V53/sw/src/dk/mdk/common/osWrap_win.c#1 $"
static  char *rcsid =  "ACI $Id: //depot/sw/branches/ART_V53/sw/src/dk/mdk/common/osWrap_win.c#1 $, $Header: //depot/sw/branches/ART_V53/sw/src/dk/mdk/common/osWrap_win.c#1 $"; 

/* Copyright (c) 2000 Atheros Communications, Inc., All Rights Reserved */
#ifndef PERL_CORE
 #include <winsock2.h>
#endif
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <stddef.h>
#include <Tlhelp32.h>
#include <io.h>
#include "wlantype.h"
#include "athreg.h"
#include "manlib.h"
#include "mInst.h" 
#include "dk_common.h"


#if defined(PREDATOR_BUILD_____)
#undef WRITE_BUF_SIZE
#define WRITE_BUF_SIZE (1 * 4092)  // 3 pages for faster transfer of large data, like pci writes in  resetDevice
#endif

#define NAME_PREFIX "\\\\.\\pipe\\"
#define SEND_BUF_SIZE		1024
#define inPipe "\\PIPE00"
#define outPipe "\\PIPE01"

#define IN_QUEUE	0
#define OUT_QUEUE	1

extern volatile A_BOOL inSignalHandler;

// Local functions
static int	socketListen(OS_SOCK_INFO    *pOSSock);
static int	socketConnect(char *target_hostname, int target_port_num,
			       A_UINT32 *ip_addr);
A_UINT32 os_com_read(OS_SOCK_INFO *pOSSock, A_UINT8 *buf, A_INT32 *len);
A_UINT32 write_device(OS_SOCK_INFO *pOSSock, A_UINT8 *buf, A_INT32 *len);
A_UINT32 read_device(OS_SOCK_INFO *pOSSock, A_UINT8 *buf, A_INT32 *len);
A_UINT32 os_com_close(OS_SOCK_INFO *pOSSock);
A_UINT32 os_com_open(OS_SOCK_INFO *pOSSock);
extern HANDLE open_device(A_UINT32 device_fn, A_UINT32 devIndex, char*);

static A_UINT8 recvBuffer[MIN_TRANSFER_SIZE];
char lpBuffer[6000];
static A_UINT8 rBuffer[MAX_TRANSFER_SIZE];
static A_UINT32 rBufferIndex;

DWORD getBytesBuffered(HANDLE handle, DWORD queueType);

/*
 * A_STATUS onlyOneRunning( char *progname)
 *
 *  DESCRIPTION: Check to make sure that there are no other programs of either of these
 *      names currently running.
 *
 *  RETURNS: A_ERROR if there is another client, else A_OK.
 *
 */
A_STATUS onlyOneRunning(char *prog1, char *prog2)
{
	HANDLE toolHandle;
	PROCESSENTRY32 lppe;
	int progCnt = 0;

	// Snapshot the process table
	if( (HANDLE)-1 == (toolHandle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)) )
		return A_ERROR;

	// Seach through the process table for the # of occurences of progName
	lppe.dwSize = sizeof(PROCESSENTRY32);
	if(	FALSE == Process32First(toolHandle, &lppe) ) {
		CloseHandle( toolHandle );
		return A_ERROR;
	}
    if((strstr(prog1, lppe.szExeFile) != NULL)  || 
       (strstr(prog2, lppe.szExeFile) != NULL)) {
		progCnt++;
    }
	while( FALSE != Process32Next(toolHandle, &lppe) ) {
        if((strstr(prog1, lppe.szExeFile) != NULL)  || 
           (strstr(prog2, lppe.szExeFile) != NULL)) {
			progCnt++;
        }
	}
	CloseHandle( toolHandle );
	if( progCnt > 2) 
		return A_ERROR;
	return A_OK;
}

A_STATUS osThreadCreate
    (
    void            threadFunc(void * param), 
    void		*param,
	A_CHAR*		threadName,
	A_INT32 	threadPrio,
	A_UINT32		*threadId
    )
{
	HANDLE hThread;	
	DWORD thId;
	
//	_beginthread(threadFunc, 0, param);
	hThread = CreateThread(NULL, 0, (unsigned long(__stdcall *)(void *))(threadFunc), param, 0, &thId);

    if(hThread == NULL) {
		 return A_ERROR;
	}

	if (threadId != NULL) {
		*threadId = (A_UINT32)hThread;
	}

    return A_OK;
}  

void osThreadKill
(
	A_UINT32 threadId
)
{
	HANDLE hThread;	

	hThread = (HANDLE)threadId;
	TerminateThread(hThread,0);
	
	return;
}


/**************************************************************************
* osSockRead - read len bytes into *buf from the socket in pSockInfo
*
* This routine calls recv for socket reading
* 
* RETURNS: length read
*/

A_INT32
osSockRead
(
    OS_SOCK_INFO    *pSockInfo,
    A_UINT8         *buf,
    A_INT32         len
)
{
    int dwRead, i = 0;
	A_INT32 cnt;
	A_UINT8* bufpos; 
	A_INT32 tmp_len;
    	A_UINT32 err;
	A_INT32 total_len;
	A_INT32		bytesRemaining; 
	static A_INT32  bytesRead=0; 
	static A_INT32    cmdlen_read=0, cmdlen_size=0;


#ifdef _DEBUG
    q_uiPrintf("osSockRead: buf=0x%08lx  len=%d\n", (unsigned long) buf, len);
#endif
	if (pSockInfo->port_num != USB_PORT_NUM && inSignalHandler == TRUE) return -1;

	tmp_len = len;
   	bufpos = buf;
	dwRead = 0;
	
    switch(pSockInfo->port_num) {
            case COM1_PORT_NUM:
            case COM2_PORT_NUM:
            case COM3_PORT_NUM:
			case COM4_PORT_NUM:{
                    if ((err=os_com_read(pSockInfo, buf, &tmp_len)) != 0) {
                        uiPrintf("ERROR::osSockRead::Com port read failed with error = %x\n", err);
                        return 0;
                    }
                    dwRead = tmp_len; // return number of bytes read
                break;
	            } // end of case
            case SOCK_PORT_NUM: {
                while (len) {
                    cnt = recv(pSockInfo->sockfd, (char *)bufpos, len, 0);

                    if ((cnt == SOCKET_ERROR) || (!cnt)) break;

                    dwRead += cnt;
                    len  -= cnt;
                    bufpos += cnt;
                }

                len = tmp_len;

                if (dwRead != len) {
                    dwRead = 0;
                }
#ifdef _DEBUG
                else {
                    for (i=0;(i<len)&&(i<16);i++) {
                        q_uiPrintf(" %02X",*((unsigned char *)buf+i));
                        if (3==(i%4)) q_uiPrintf(" ");
                    }
                    q_uiPrintf("\n");
                }
#endif // _DEBUG
                break;
                }
            case USB_PORT_NUM: {
	            if (!cmdlen_read) {
					total_len = MIN_TRANSFER_SIZE;
						pSockInfo->sockfd = pSockInfo->inHandle;
                    	if ((err=read_device(pSockInfo, recvBuffer, &total_len)) != 0) {
                      		uiPrintf("ERROR::osSockRead::USB  read failed with error = %x\n", err);
                      		return 0;
                    	}
#ifdef _DEBUG
		        q_uiPrintf("osSockRead::cmdlen_read=%d:recv_buf_sem set\n", cmdlen_read);
#endif
			memcpy(rBuffer, recvBuffer, MIN_TRANSFER_SIZE);
			memcpy(buf, rBuffer, len);
			rBufferIndex = MIN_TRANSFER_SIZE;
			cmdlen_size = len;
			bytesRead = MIN_TRANSFER_SIZE - len;
		    }
		    else {
	  		  bytesRemaining = len - bytesRead;
#ifdef _DEBUG
			  q_uiPrintf("bytesRemaining=%d\n", bytesRemaining);
#endif
	  		  while(bytesRemaining>0) {
				total_len = MIN_TRANSFER_SIZE;
							pSockInfo->sockfd = pSockInfo->inHandle;
                    		if ((err=read_device(pSockInfo, recvBuffer, &total_len)) != 0) {
                      		   uiPrintf("ERROR::osSockRead::USB  read failed with error = %x\n", err);
                      		   return 0;
                    		}
#ifdef _DEBUG
				q_uiPrintf("osSockRead::cmdlen_read=%d:recv_buf_sem set\n", cmdlen_read);
#endif
				memcpy(rBuffer+rBufferIndex, recvBuffer, MIN_TRANSFER_SIZE);
	    			bytesRead+= MIN_TRANSFER_SIZE;
				rBufferIndex+=MIN_TRANSFER_SIZE;
	    			bytesRemaining = len - bytesRead;
	  		 }
	  		 memcpy(buf, rBuffer+cmdlen_size, len);
		    }
		    cmdlen_read = !cmdlen_read;
		    dwRead = bytesRead;
#ifdef _DEBUG
                    for (i=0;i<len;i++) {
                        q_uiPrintf(" %02X",*((unsigned char *)buf+i));
                        if (3==(i%4)) q_uiPrintf(" ");
                    }
                    q_uiPrintf("\n");
#endif
              		break;
            		}// end of case
    }
#ifdef _DEBUG
    q_uiPrintf(":osSockRead:%d read\n", dwRead);
#endif

    return dwRead;
}

/**************************************************************************
* osSockWrite - write len bytes into the socket, pSockInfo, from *buf
*
* This routine calls a OS specific routine for socket writing
* 
* RETURNS: length read
*/
A_INT32
osSockWrite
    (
    OS_SOCK_INFO    *pSockInfo,
    A_UINT8         *buf,
    A_INT32         len
    )
{
		int	dwWritten, i = 0;
		A_INT32 bytes,cnt;
		A_UINT8* bufpos; 
		A_INT32 tmp_len;
        	A_UINT32 err;
		A_UINT8  *pad_buf;
		A_INT32 numblocks, pad_len, total_len;

//		if (inSignalHandler == TRUE) return 0;
	if (pSockInfo->port_num != USB_PORT_NUM && inSignalHandler == TRUE) return -1;

#ifdef _DEBUG 
    q_uiPrintf("osSockWrite: buf=0x%08lx  len=%d\n", (unsigned long) buf, len);
    for (i=0;(i<len)&&(i<16);i++) {
      q_uiPrintf(" %02X",*((unsigned char *)buf +i));
      if (3==(i%4)) q_uiPrintf(" ");
    }
    q_uiPrintf("\n");
#endif // _DEBUG

    switch(pSockInfo->port_num) {
            case COM1_PORT_NUM:
            case COM2_PORT_NUM:
            case COM3_PORT_NUM: 
			case COM4_PORT_NUM: {
                if ((err=write_device(pSockInfo, buf, &len)) != 0) {
                        uiPrintf("ERROR::osSockWrite::Com port write failed with error = %x\n", err);
                        return 0;
                }
	            dwWritten = len;
                break;
	            } // end of case
            case SOCK_PORT_NUM: {
		        tmp_len = len;
	   	        bufpos = buf;
		        dwWritten = 0;

			
		        while (len) {
			        if (len < SEND_BUF_SIZE) bytes = len;
			        else bytes = SEND_BUF_SIZE;
	    	
			        cnt = send(pSockInfo->sockfd, (char *)bufpos, bytes, 0);
    
			        if (cnt == SOCKET_ERROR) break;
    
			        dwWritten += cnt;
		    	
			        len  -= cnt;
			        bufpos += cnt;
    	        }

		        len = tmp_len;
    
		        if (dwWritten != len) {
			        dwWritten = 0;
		        }

            break;
	        } // end of case
            case USB_PORT_NUM: {
		numblocks = (len/MIN_TRANSFER_SIZE) + ((len%MIN_TRANSFER_SIZE)?1:0);
		total_len = numblocks * MIN_TRANSFER_SIZE;
		pad_buf = (A_UINT8 *)A_MALLOC(total_len * sizeof(A_UINT8));
		pad_len = (numblocks*MIN_TRANSFER_SIZE) - len;
		memcpy(pad_buf, buf, len);
#ifdef _DEBUG
		q_uiPrintf("osSockWrite::numblocks=%d:total_len=%d:pad_len=%d:actual len=%d\n", numblocks, total_len, pad_len, len);
#endif
				pSockInfo->sockfd = pSockInfo->outHandle;
                if ((err=write_device(pSockInfo, pad_buf, &total_len)) != 0) {
                        uiPrintf("ERROR::osSockWrite::USB port write failed with error = %x\n", err);
			A_FREE(pad_buf);
                        return 0;
                }
#ifdef _DEBUG
		q_uiPrintf("osSockWrite::total bytes written = %d:Padded len = %d:Actual len = %d\n", total_len, (numblocks * MIN_TRANSFER_SIZE), len);
#endif
		A_FREE(pad_buf);
		if (total_len == (numblocks * MIN_TRANSFER_SIZE))
	        	dwWritten = len;
		else 
			dwWritten = total_len;
            break;
            } 
    }// end of switch

    return dwWritten;
}

/**************************************************************************
* osSockClose - close socket
*
* Close the handle to the pipe
*
* RETURNS: 0 if error, non 0 if no error
*/
void
osSockClose(OS_SOCK_INFO* pOSSock)
{
	A_UINT32 err;

#ifdef _DEBUG
    q_uiPrintf("osSockClose::hostname=%s\n", pOSSock->hostname);
#endif

    switch(pOSSock->port_num) {
            case COM1_PORT_NUM:
            case COM2_PORT_NUM:
            case COM3_PORT_NUM: 
			case COM4_PORT_NUM: {
                if ((err=os_com_close(pOSSock)) != 0) {
                        uiPrintf("ERROR::osSockClose::Com port close failed with error = %x\n", err);
                        return;
                }
                break;
	            } // end of case
            case SOCK_PORT_NUM: {
	            if (inSignalHandler == TRUE) return;
                closesocket(pOSSock->sockfd);
	            A_FREE(pOSSock);
                break;
	        }
            case USB_PORT_NUM:{
             //   CloseHandle((HANDLE) pOSSock->sockfd);
                CloseHandle((HANDLE)pOSSock->inHandle);
                CloseHandle((HANDLE)pOSSock->outHandle);
                break;
            }
    }
    return;
}





OS_SOCK_INFO*
osSockConnect(char *pname)
{
    char		pname_lcl[256];
    char *		mach_name;
    char *		cp;
    OS_SOCK_INFO *pOSSock;
    int			res;
    A_UINT32 err;
    HANDLE handle;

    strncpy(pname_lcl, pname, sizeof(pname_lcl));
    pname_lcl[sizeof(pname_lcl) - 1] = '\0';
#ifdef _DEBUG
    q_uiPrintf("osSockConnect: pname_lcl = '%s'\n", pname_lcl);
#endif
    mach_name = pname_lcl;
	while (*mach_name == '\\') {