Driver for CC3000 Wi-Fi module

Dependencies:   NVIC_set_all_priorities

Dependents:   CC3000_Simple_Socket Wi-Go_IOT_Demo

Information

The current code has been reworked to a full object oriented application and contains an mbed socket compatible API.

CC3000 Wi-Fi module library

Info

This is the low level driver for TI's SimpleLink CC3000 device.
Port from Avnet's Wi-Go KEIL code (based on TI's CC3000 code).
Special thanks to Jim Carver from Avnet for providing the Wi-Go board and for his assistance.

Differences with TI's original code

The code functionality stays exactly the same.
In order to make it easier to use the code, following changes were made :

  • Addition of a tool to shift all IRQ priorities to a lower level since it is very important to keep the SPI handler at the highest system priority, the WLAN interrupt the second highest and all other system interrupts at a lower priority, so their handlers can be preempted by the CC3000 interrupts.
  • Addition of low level I/O controls and conditional compiler controls in cc3000_common.h.
  • CC3000 initialisation, pin declarations, SPI and WLAN irq priorities are set in Init_HostDriver , we need to call this function at the start of the main function.
  • The SPI and HCI code are joined into one file.
  • The include list has been rearranged - Only #include "wlan.h" is needed in the user API.
  • Part of the CC3000's user eeprom memory is used to store additional info (52 bytes in NVMEM_USER_FILE_1):
# bytesDescriptionInfo
1First time config parameterUseful when connecting
2Firmware updater versionused with the Firmware update tool
2Service Pack versionused with the Firmware update tool
3Driver Versionused with the Firmware update tool
3Firmware Versionused with the Firmware update tool
1CIK validation (Client Interface Key)
40CIK data (Client Interface Key)used with the exosite

Using the Library

A user API is needed to access the CC3000 functions.
Examples:

Using the library with other processors

cc3000_common.cpp loads the irq tool for all targets:
All current mbed targets are supported by this library.

#include "NVIC_set_all_priorities.h"


All low level settings that need to change are available in cc3000_common.h

//*****************************************************************************
//              PIN CONTROLS & COMPILE CONTROLS
//*****************************************************************************
// Compiler control
#define CC3000_UNENCRYPTED_SMART_CONFIG   // No encryption
//#define CC3000_TINY_DRIVER                // Driver for small memory model CPUs

//Interrupt controls
#define NVIC_ALL_IRQ        NVIC_set_all_irq_priorities(3);         // Set ALL interrupt priorities to level 3
#define NVIC_SPI_IRQ        NVIC_SetPriority(SPI0_IRQn, 0x0);       // Wi-Fi SPI interrupt must be higher priority than SysTick
#define NVIC_PORT_IRQ       NVIC_SetPriority(PORTA_IRQn, 0x1);
#define NVIC_SYSTICK_IRQ    NVIC_SetPriority(SysTick_IRQn, 0x2);    // SysTick set to lower priority than Wi-Fi SPI bus interrupt
//#define NVIC_ADC_IRQ        NVIC_SetPriority(ADC0_IRQn, 0x3);       // ADC is the lowest of all

// Wlan controls
#define WLAN_ISF_PCR        PORTA->PCR[16]
#define WLAN_ISF_ISFR       PORTA->ISFR
#define WLAN_ISF_MASK       (1<<16)

#define WLAN_ASSERT_CS      wlan_cs = 0;   //CS : active low
#define WLAN_DEASSERT_CS    wlan_cs = 1;

#define WLAN_ASSERT_EN      wlan_en = 1;   //EN : active high
#define WLAN_DEASSERT_EN    wlan_en = 0;

#define WLAN_READ_IRQ       wlan_int

#define WLAN_ENABLE_IRQ     wlan_int.fall(&WLAN_IRQHandler);
#define WLAN_DISABLE_IRQ    wlan_int.fall(NULL);

#define WLAN_IRQ_PIN_CREATE         InterruptIn wlan_int (PTA16);
#define WLAN_EN_PIN_CREATE          DigitalOut  wlan_en  (PTA13);
#define WLAN_CS_PIN_CREATE          DigitalOut  wlan_cs  (PTD0);
#define WLAN_SPI_PORT_CREATE        SPI wlan(PTD2, PTD3, PTC5); // mosi, miso, sclk

#define WLAN_SPI_PORT_INIT          wlan.format(8,1);
#define WLAN_SPI_SET_FREQ           wlan.frequency(12000000);
#define WLAN_SPI_SET_IRQ_HANDLER    wlan_int.fall(&WLAN_IRQHandler);

#define WLAN_SPI_WRITE              wlan.write(*data++);
#define WLAN_SPI_READ               wlan.write(0x03);          // !! DO NOT MODIFY the 0x03 parameter (CC3000 will not respond).

API documentation

Due to a little problem with the links on the mbed site, the API documentation is not directly accessible (will be solved in a next release).
Currently, it is only accessible by adding modules.html to the API doc link: http://mbed.org/users/frankvnk/code/CC3000_Hostdriver/docs/tip/modules.html

Committer:
frankvnk
Date:
Fri Nov 29 13:20:07 2013 +0000
Revision:
13:e1ab6b5ab826
Parent:
10:5afa438c12fd
update CC3000_MAXIMAL_RX_SIZE

Who changed what in which revision?

UserRevisionLine numberNew contents of line
frankvnk 0:c44f0314d6ec 1 /*****************************************************************************
frankvnk 0:c44f0314d6ec 2 *
frankvnk 0:c44f0314d6ec 3 * socket.c - CC3000 Host Driver Implementation.
frankvnk 0:c44f0314d6ec 4 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
frankvnk 0:c44f0314d6ec 5 *
frankvnk 0:c44f0314d6ec 6 * Redistribution and use in source and binary forms, with or without
frankvnk 0:c44f0314d6ec 7 * modification, are permitted provided that the following conditions
frankvnk 0:c44f0314d6ec 8 * are met:
frankvnk 0:c44f0314d6ec 9 *
frankvnk 0:c44f0314d6ec 10 * Redistributions of source code must retain the above copyright
frankvnk 0:c44f0314d6ec 11 * notice, this list of conditions and the following disclaimer.
frankvnk 0:c44f0314d6ec 12 *
frankvnk 0:c44f0314d6ec 13 * Redistributions in binary form must reproduce the above copyright
frankvnk 0:c44f0314d6ec 14 * notice, this list of conditions and the following disclaimer in the
frankvnk 0:c44f0314d6ec 15 * documentation and/or other materials provided with the
frankvnk 0:c44f0314d6ec 16 * distribution.
frankvnk 0:c44f0314d6ec 17 *
frankvnk 0:c44f0314d6ec 18 * Neither the name of Texas Instruments Incorporated nor the names of
frankvnk 0:c44f0314d6ec 19 * its contributors may be used to endorse or promote products derived
frankvnk 0:c44f0314d6ec 20 * from this software without specific prior written permission.
frankvnk 0:c44f0314d6ec 21 *
frankvnk 0:c44f0314d6ec 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
frankvnk 0:c44f0314d6ec 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
frankvnk 0:c44f0314d6ec 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
frankvnk 0:c44f0314d6ec 25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
frankvnk 0:c44f0314d6ec 26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
frankvnk 0:c44f0314d6ec 27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
frankvnk 0:c44f0314d6ec 28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
frankvnk 0:c44f0314d6ec 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
frankvnk 0:c44f0314d6ec 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
frankvnk 0:c44f0314d6ec 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
frankvnk 0:c44f0314d6ec 32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
frankvnk 0:c44f0314d6ec 33 *
frankvnk 0:c44f0314d6ec 34 *****************************************************************************/
frankvnk 0:c44f0314d6ec 35
frankvnk 0:c44f0314d6ec 36 #include "socket.h"
frankvnk 0:c44f0314d6ec 37
frankvnk 0:c44f0314d6ec 38 int HostFlowControlConsumeBuff(int sd)
frankvnk 0:c44f0314d6ec 39 {
frankvnk 0:c44f0314d6ec 40 #ifndef SEND_NON_BLOCKING
frankvnk 0:c44f0314d6ec 41 /* wait in busy loop */
frankvnk 0:c44f0314d6ec 42 do
frankvnk 0:c44f0314d6ec 43 {
frankvnk 4:d8255a5aad46 44 // When the last transmission failed, return the last failure reason.
frankvnk 0:c44f0314d6ec 45 // Note that the buffer will not be allocated in this case
frankvnk 0:c44f0314d6ec 46 if (tSLInformation.slTransmitDataError != 0)
frankvnk 0:c44f0314d6ec 47 {
frankvnk 0:c44f0314d6ec 48 errno = tSLInformation.slTransmitDataError;
frankvnk 0:c44f0314d6ec 49 tSLInformation.slTransmitDataError = 0;
frankvnk 0:c44f0314d6ec 50 return errno;
frankvnk 0:c44f0314d6ec 51 }
frankvnk 0:c44f0314d6ec 52
frankvnk 0:c44f0314d6ec 53 if(SOCKET_STATUS_ACTIVE != get_socket_active_status(sd))
frankvnk 0:c44f0314d6ec 54 return -1;
frankvnk 0:c44f0314d6ec 55 } while(0 == tSLInformation.usNumberOfFreeBuffers);
frankvnk 0:c44f0314d6ec 56
frankvnk 0:c44f0314d6ec 57 tSLInformation.usNumberOfFreeBuffers--;
frankvnk 0:c44f0314d6ec 58
frankvnk 0:c44f0314d6ec 59 return 0;
frankvnk 0:c44f0314d6ec 60 #else
frankvnk 0:c44f0314d6ec 61
frankvnk 4:d8255a5aad46 62 // When the last transmission failed, return the last failure reason.
frankvnk 0:c44f0314d6ec 63 // Note that the buffer will not be allocated in this case
frankvnk 0:c44f0314d6ec 64 if (tSLInformation.slTransmitDataError != 0)
frankvnk 0:c44f0314d6ec 65 {
frankvnk 0:c44f0314d6ec 66 errno = tSLInformation.slTransmitDataError;
frankvnk 0:c44f0314d6ec 67 tSLInformation.slTransmitDataError = 0;
frankvnk 0:c44f0314d6ec 68 return errno;
frankvnk 0:c44f0314d6ec 69 }
frankvnk 0:c44f0314d6ec 70 if(SOCKET_STATUS_ACTIVE != get_socket_active_status(sd))
frankvnk 0:c44f0314d6ec 71 return -1;
frankvnk 0:c44f0314d6ec 72
frankvnk 4:d8255a5aad46 73 // If there are no available buffers, return -2. It is recommended to use
frankvnk 0:c44f0314d6ec 74 // select or receive to see if there is any buffer occupied with received data
frankvnk 0:c44f0314d6ec 75 // If so, call receive() to release the buffer.
frankvnk 0:c44f0314d6ec 76 if(0 == tSLInformation.usNumberOfFreeBuffers)
frankvnk 0:c44f0314d6ec 77 {
frankvnk 0:c44f0314d6ec 78 return -2;
frankvnk 0:c44f0314d6ec 79 }
frankvnk 0:c44f0314d6ec 80 else
frankvnk 0:c44f0314d6ec 81 {
frankvnk 0:c44f0314d6ec 82 tSLInformation.usNumberOfFreeBuffers--;
frankvnk 0:c44f0314d6ec 83 return 0;
frankvnk 0:c44f0314d6ec 84 }
frankvnk 0:c44f0314d6ec 85 #endif
frankvnk 0:c44f0314d6ec 86 }
frankvnk 0:c44f0314d6ec 87
frankvnk 0:c44f0314d6ec 88
frankvnk 0:c44f0314d6ec 89 int socket(long domain, long type, long protocol)
frankvnk 0:c44f0314d6ec 90 {
frankvnk 0:c44f0314d6ec 91 long ret;
frankvnk 0:c44f0314d6ec 92 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 93
frankvnk 0:c44f0314d6ec 94 ret = EFAIL;
frankvnk 0:c44f0314d6ec 95 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 96 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 97
frankvnk 0:c44f0314d6ec 98 // Fill in HCI packet structure
frankvnk 0:c44f0314d6ec 99 args = UINT32_TO_STREAM(args, domain);
frankvnk 0:c44f0314d6ec 100 args = UINT32_TO_STREAM(args, type);
frankvnk 0:c44f0314d6ec 101 args = UINT32_TO_STREAM(args, protocol);
frankvnk 0:c44f0314d6ec 102
frankvnk 0:c44f0314d6ec 103 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 104 hci_command_send(HCI_CMND_SOCKET, ptr, SOCKET_OPEN_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 105
frankvnk 0:c44f0314d6ec 106 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 107 SimpleLinkWaitEvent(HCI_CMND_SOCKET, &ret);
frankvnk 0:c44f0314d6ec 108
frankvnk 0:c44f0314d6ec 109 // Process the event
frankvnk 0:c44f0314d6ec 110 errno = ret;
frankvnk 0:c44f0314d6ec 111
frankvnk 0:c44f0314d6ec 112 set_socket_active_status(ret, SOCKET_STATUS_ACTIVE);
frankvnk 0:c44f0314d6ec 113
frankvnk 0:c44f0314d6ec 114 return(ret);
frankvnk 0:c44f0314d6ec 115 }
frankvnk 0:c44f0314d6ec 116
frankvnk 0:c44f0314d6ec 117
frankvnk 0:c44f0314d6ec 118 long closesocket(long sd)
frankvnk 0:c44f0314d6ec 119 {
frankvnk 0:c44f0314d6ec 120 long ret;
frankvnk 0:c44f0314d6ec 121 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 122
frankvnk 10:5afa438c12fd 123 //Wait until all buffers are released
frankvnk 10:5afa438c12fd 124 while(tSLInformation.usNumberOfFreeBuffers != SOCKET_MAX_FREE_BUFFERS);
frankvnk 10:5afa438c12fd 125
frankvnk 0:c44f0314d6ec 126 ret = EFAIL;
frankvnk 0:c44f0314d6ec 127 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 128 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 129
frankvnk 0:c44f0314d6ec 130 // Fill in HCI packet structure
frankvnk 0:c44f0314d6ec 131 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 132
frankvnk 0:c44f0314d6ec 133 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 134 hci_command_send(HCI_CMND_CLOSE_SOCKET, ptr, SOCKET_CLOSE_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 135
frankvnk 0:c44f0314d6ec 136 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 137 SimpleLinkWaitEvent(HCI_CMND_CLOSE_SOCKET, &ret);
frankvnk 0:c44f0314d6ec 138 errno = ret;
frankvnk 0:c44f0314d6ec 139
frankvnk 4:d8255a5aad46 140 // since 'close' call may result in either OK (and then it closed) or error, mark this socket as invalid
frankvnk 0:c44f0314d6ec 141 set_socket_active_status(sd, SOCKET_STATUS_INACTIVE);
frankvnk 0:c44f0314d6ec 142
frankvnk 0:c44f0314d6ec 143 return(ret);
frankvnk 0:c44f0314d6ec 144 }
frankvnk 0:c44f0314d6ec 145
frankvnk 0:c44f0314d6ec 146
frankvnk 0:c44f0314d6ec 147 long accept(long sd, sockaddr *addr, socklen_t *addrlen)
frankvnk 0:c44f0314d6ec 148 {
frankvnk 0:c44f0314d6ec 149 long ret;
frankvnk 0:c44f0314d6ec 150 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 151 tBsdReturnParams tAcceptReturnArguments;
frankvnk 0:c44f0314d6ec 152
frankvnk 0:c44f0314d6ec 153 ret = EFAIL;
frankvnk 0:c44f0314d6ec 154 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 155 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 156
frankvnk 0:c44f0314d6ec 157 // Fill in temporary command buffer
frankvnk 0:c44f0314d6ec 158 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 159
frankvnk 0:c44f0314d6ec 160 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 161 hci_command_send(HCI_CMND_ACCEPT, ptr, SOCKET_ACCEPT_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 162
frankvnk 0:c44f0314d6ec 163 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 164 SimpleLinkWaitEvent(HCI_CMND_ACCEPT, &tAcceptReturnArguments);
frankvnk 0:c44f0314d6ec 165
frankvnk 0:c44f0314d6ec 166
frankvnk 0:c44f0314d6ec 167 // need specify return parameters!!!
frankvnk 0:c44f0314d6ec 168 memcpy(addr, &tAcceptReturnArguments.tSocketAddress, ASIC_ADDR_LEN);
frankvnk 0:c44f0314d6ec 169 *addrlen = ASIC_ADDR_LEN;
frankvnk 0:c44f0314d6ec 170 errno = tAcceptReturnArguments.iStatus;
frankvnk 0:c44f0314d6ec 171 ret = errno;
frankvnk 0:c44f0314d6ec 172
frankvnk 0:c44f0314d6ec 173 // if succeeded, iStatus = new socket descriptor. otherwise - error number
frankvnk 0:c44f0314d6ec 174 if(M_IS_VALID_SD(ret))
frankvnk 0:c44f0314d6ec 175 {
frankvnk 0:c44f0314d6ec 176 set_socket_active_status(ret, SOCKET_STATUS_ACTIVE);
frankvnk 0:c44f0314d6ec 177 }
frankvnk 0:c44f0314d6ec 178 else
frankvnk 0:c44f0314d6ec 179 {
frankvnk 0:c44f0314d6ec 180 set_socket_active_status(sd, SOCKET_STATUS_INACTIVE);
frankvnk 0:c44f0314d6ec 181 }
frankvnk 0:c44f0314d6ec 182
frankvnk 0:c44f0314d6ec 183 return(ret);
frankvnk 0:c44f0314d6ec 184 }
frankvnk 0:c44f0314d6ec 185
frankvnk 0:c44f0314d6ec 186
frankvnk 0:c44f0314d6ec 187 long bind(long sd, const sockaddr *addr, long addrlen)
frankvnk 0:c44f0314d6ec 188 {
frankvnk 0:c44f0314d6ec 189 long ret;
frankvnk 0:c44f0314d6ec 190 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 191
frankvnk 0:c44f0314d6ec 192 ret = EFAIL;
frankvnk 0:c44f0314d6ec 193 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 194 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 195
frankvnk 0:c44f0314d6ec 196 addrlen = ASIC_ADDR_LEN;
frankvnk 0:c44f0314d6ec 197
frankvnk 0:c44f0314d6ec 198 // Fill in temporary command buffer
frankvnk 0:c44f0314d6ec 199 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 200 args = UINT32_TO_STREAM(args, 0x00000008);
frankvnk 0:c44f0314d6ec 201 args = UINT32_TO_STREAM(args, addrlen);
frankvnk 0:c44f0314d6ec 202 ARRAY_TO_STREAM(args, ((unsigned char *)addr), addrlen);
frankvnk 0:c44f0314d6ec 203
frankvnk 0:c44f0314d6ec 204 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 205 hci_command_send(HCI_CMND_BIND, ptr, SOCKET_BIND_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 206
frankvnk 0:c44f0314d6ec 207 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 208 SimpleLinkWaitEvent(HCI_CMND_BIND, &ret);
frankvnk 0:c44f0314d6ec 209
frankvnk 0:c44f0314d6ec 210 errno = ret;
frankvnk 0:c44f0314d6ec 211
frankvnk 0:c44f0314d6ec 212 return(ret);
frankvnk 0:c44f0314d6ec 213 }
frankvnk 0:c44f0314d6ec 214
frankvnk 0:c44f0314d6ec 215
frankvnk 0:c44f0314d6ec 216 long listen(long sd, long backlog)
frankvnk 0:c44f0314d6ec 217 {
frankvnk 0:c44f0314d6ec 218 long ret;
frankvnk 0:c44f0314d6ec 219 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 220
frankvnk 0:c44f0314d6ec 221 ret = EFAIL;
frankvnk 0:c44f0314d6ec 222 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 223 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 224
frankvnk 0:c44f0314d6ec 225 // Fill in temporary command buffer
frankvnk 0:c44f0314d6ec 226 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 227 args = UINT32_TO_STREAM(args, backlog);
frankvnk 0:c44f0314d6ec 228
frankvnk 0:c44f0314d6ec 229 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 230 hci_command_send(HCI_CMND_LISTEN, ptr, SOCKET_LISTEN_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 231
frankvnk 0:c44f0314d6ec 232 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 233 SimpleLinkWaitEvent(HCI_CMND_LISTEN, &ret);
frankvnk 0:c44f0314d6ec 234 errno = ret;
frankvnk 0:c44f0314d6ec 235
frankvnk 0:c44f0314d6ec 236 return(ret);
frankvnk 0:c44f0314d6ec 237 }
frankvnk 0:c44f0314d6ec 238
frankvnk 4:d8255a5aad46 239
frankvnk 0:c44f0314d6ec 240 #ifndef CC3000_TINY_DRIVER
frankvnk 0:c44f0314d6ec 241 int gethostbyname(char * hostname, unsigned short usNameLen, unsigned long* out_ip_addr)
frankvnk 0:c44f0314d6ec 242 {
frankvnk 0:c44f0314d6ec 243 tBsdGethostbynameParams ret;
frankvnk 0:c44f0314d6ec 244 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 245
frankvnk 0:c44f0314d6ec 246 errno = EFAIL;
frankvnk 0:c44f0314d6ec 247
frankvnk 0:c44f0314d6ec 248 if (usNameLen > HOSTNAME_MAX_LENGTH)
frankvnk 0:c44f0314d6ec 249 {
frankvnk 0:c44f0314d6ec 250 return errno;
frankvnk 0:c44f0314d6ec 251 }
frankvnk 0:c44f0314d6ec 252
frankvnk 0:c44f0314d6ec 253 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 254 args = (ptr + SIMPLE_LINK_HCI_CMND_TRANSPORT_HEADER_SIZE);
frankvnk 0:c44f0314d6ec 255
frankvnk 0:c44f0314d6ec 256 // Fill in HCI packet structure
frankvnk 0:c44f0314d6ec 257 args = UINT32_TO_STREAM(args, 8);
frankvnk 0:c44f0314d6ec 258 args = UINT32_TO_STREAM(args, usNameLen);
frankvnk 0:c44f0314d6ec 259 ARRAY_TO_STREAM(args, hostname, usNameLen);
frankvnk 0:c44f0314d6ec 260
frankvnk 0:c44f0314d6ec 261 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 262 hci_command_send(HCI_CMND_GETHOSTNAME, ptr, SOCKET_GET_HOST_BY_NAME_PARAMS_LEN + usNameLen - 1);
frankvnk 0:c44f0314d6ec 263
frankvnk 0:c44f0314d6ec 264 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 265 SimpleLinkWaitEvent(HCI_EVNT_BSD_GETHOSTBYNAME, &ret);
frankvnk 0:c44f0314d6ec 266
frankvnk 0:c44f0314d6ec 267 errno = ret.retVal;
frankvnk 0:c44f0314d6ec 268
frankvnk 0:c44f0314d6ec 269 (*((long*)out_ip_addr)) = ret.outputAddress;
frankvnk 0:c44f0314d6ec 270
frankvnk 0:c44f0314d6ec 271 return (errno);
frankvnk 0:c44f0314d6ec 272
frankvnk 0:c44f0314d6ec 273 }
frankvnk 0:c44f0314d6ec 274 #endif
frankvnk 0:c44f0314d6ec 275
frankvnk 0:c44f0314d6ec 276
frankvnk 0:c44f0314d6ec 277 long connect(long sd, const sockaddr *addr, long addrlen)
frankvnk 0:c44f0314d6ec 278 {
frankvnk 0:c44f0314d6ec 279 long int ret;
frankvnk 0:c44f0314d6ec 280 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 281
frankvnk 0:c44f0314d6ec 282 ret = EFAIL;
frankvnk 0:c44f0314d6ec 283 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 284 args = (ptr + SIMPLE_LINK_HCI_CMND_TRANSPORT_HEADER_SIZE);
frankvnk 0:c44f0314d6ec 285 addrlen = 8;
frankvnk 0:c44f0314d6ec 286
frankvnk 0:c44f0314d6ec 287 // Fill in temporary command buffer
frankvnk 0:c44f0314d6ec 288 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 289 args = UINT32_TO_STREAM(args, 0x00000008);
frankvnk 0:c44f0314d6ec 290 args = UINT32_TO_STREAM(args, addrlen);
frankvnk 0:c44f0314d6ec 291 ARRAY_TO_STREAM(args, ((unsigned char *)addr), addrlen);
frankvnk 0:c44f0314d6ec 292
frankvnk 0:c44f0314d6ec 293 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 294 hci_command_send(HCI_CMND_CONNECT, ptr, SOCKET_CONNECT_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 295
frankvnk 0:c44f0314d6ec 296 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 297 SimpleLinkWaitEvent(HCI_CMND_CONNECT, &ret);
frankvnk 0:c44f0314d6ec 298
frankvnk 0:c44f0314d6ec 299 errno = ret;
frankvnk 0:c44f0314d6ec 300
frankvnk 0:c44f0314d6ec 301 return((long)ret);
frankvnk 0:c44f0314d6ec 302 }
frankvnk 0:c44f0314d6ec 303
frankvnk 0:c44f0314d6ec 304
frankvnk 0:c44f0314d6ec 305 int select(long nfds, fd_set *readsds, fd_set *writesds, fd_set *exceptsds, struct timeval *timeout)
frankvnk 0:c44f0314d6ec 306 {
frankvnk 0:c44f0314d6ec 307 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 308 tBsdSelectRecvParams tParams;
frankvnk 0:c44f0314d6ec 309 unsigned long is_blocking;
frankvnk 0:c44f0314d6ec 310
frankvnk 0:c44f0314d6ec 311 if( timeout == NULL)
frankvnk 0:c44f0314d6ec 312 {
frankvnk 0:c44f0314d6ec 313 is_blocking = 1; /* blocking , infinity timeout */
frankvnk 0:c44f0314d6ec 314 }
frankvnk 0:c44f0314d6ec 315 else
frankvnk 0:c44f0314d6ec 316 {
frankvnk 0:c44f0314d6ec 317 is_blocking = 0; /* no blocking, timeout */
frankvnk 0:c44f0314d6ec 318 }
frankvnk 0:c44f0314d6ec 319
frankvnk 0:c44f0314d6ec 320 // Fill in HCI packet structure
frankvnk 0:c44f0314d6ec 321 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 322 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 323
frankvnk 0:c44f0314d6ec 324 // Fill in temporary command buffer
frankvnk 0:c44f0314d6ec 325 args = UINT32_TO_STREAM(args, nfds);
frankvnk 0:c44f0314d6ec 326 args = UINT32_TO_STREAM(args, 0x00000014);
frankvnk 0:c44f0314d6ec 327 args = UINT32_TO_STREAM(args, 0x00000014);
frankvnk 0:c44f0314d6ec 328 args = UINT32_TO_STREAM(args, 0x00000014);
frankvnk 0:c44f0314d6ec 329 args = UINT32_TO_STREAM(args, 0x00000014);
frankvnk 0:c44f0314d6ec 330 args = UINT32_TO_STREAM(args, is_blocking);
frankvnk 0:c44f0314d6ec 331 args = UINT32_TO_STREAM(args, ((readsds) ? *(unsigned long*)readsds : 0));
frankvnk 0:c44f0314d6ec 332 args = UINT32_TO_STREAM(args, ((writesds) ? *(unsigned long*)writesds : 0));
frankvnk 0:c44f0314d6ec 333 args = UINT32_TO_STREAM(args, ((exceptsds) ? *(unsigned long*)exceptsds : 0));
frankvnk 0:c44f0314d6ec 334
frankvnk 0:c44f0314d6ec 335 if (timeout)
frankvnk 0:c44f0314d6ec 336 {
frankvnk 0:c44f0314d6ec 337 if ( 0 == timeout->tv_sec && timeout->tv_usec < SELECT_TIMEOUT_MIN_MICRO_SECONDS)
frankvnk 0:c44f0314d6ec 338 {
frankvnk 0:c44f0314d6ec 339 timeout->tv_usec = SELECT_TIMEOUT_MIN_MICRO_SECONDS;
frankvnk 0:c44f0314d6ec 340 }
frankvnk 0:c44f0314d6ec 341 args = UINT32_TO_STREAM(args, timeout->tv_sec);
frankvnk 0:c44f0314d6ec 342 args = UINT32_TO_STREAM(args, timeout->tv_usec);
frankvnk 0:c44f0314d6ec 343 }
frankvnk 0:c44f0314d6ec 344
frankvnk 0:c44f0314d6ec 345 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 346 hci_command_send(HCI_CMND_BSD_SELECT, ptr, SOCKET_SELECT_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 347
frankvnk 0:c44f0314d6ec 348 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 349 SimpleLinkWaitEvent(HCI_EVNT_SELECT, &tParams);
frankvnk 0:c44f0314d6ec 350
frankvnk 0:c44f0314d6ec 351 // Update actually read FD
frankvnk 0:c44f0314d6ec 352 if (tParams.iStatus >= 0)
frankvnk 0:c44f0314d6ec 353 {
frankvnk 0:c44f0314d6ec 354 if (readsds)
frankvnk 0:c44f0314d6ec 355 {
frankvnk 0:c44f0314d6ec 356 memcpy(readsds, &tParams.uiRdfd, sizeof(tParams.uiRdfd));
frankvnk 0:c44f0314d6ec 357 }
frankvnk 0:c44f0314d6ec 358
frankvnk 0:c44f0314d6ec 359 if (writesds)
frankvnk 0:c44f0314d6ec 360 {
frankvnk 0:c44f0314d6ec 361 memcpy(writesds, &tParams.uiWrfd, sizeof(tParams.uiWrfd));
frankvnk 0:c44f0314d6ec 362 }
frankvnk 0:c44f0314d6ec 363
frankvnk 0:c44f0314d6ec 364 if (exceptsds)
frankvnk 0:c44f0314d6ec 365 {
frankvnk 0:c44f0314d6ec 366 memcpy(exceptsds, &tParams.uiExfd, sizeof(tParams.uiExfd));
frankvnk 0:c44f0314d6ec 367 }
frankvnk 0:c44f0314d6ec 368
frankvnk 0:c44f0314d6ec 369 return(tParams.iStatus);
frankvnk 0:c44f0314d6ec 370
frankvnk 0:c44f0314d6ec 371 }
frankvnk 0:c44f0314d6ec 372 else
frankvnk 0:c44f0314d6ec 373 {
frankvnk 0:c44f0314d6ec 374 errno = tParams.iStatus;
frankvnk 0:c44f0314d6ec 375 return(-1);
frankvnk 0:c44f0314d6ec 376 }
frankvnk 0:c44f0314d6ec 377 }
frankvnk 0:c44f0314d6ec 378
frankvnk 0:c44f0314d6ec 379
frankvnk 0:c44f0314d6ec 380 #ifndef CC3000_TINY_DRIVER
frankvnk 0:c44f0314d6ec 381 int setsockopt(long sd, long level, long optname, const void *optval, socklen_t optlen)
frankvnk 0:c44f0314d6ec 382 {
frankvnk 0:c44f0314d6ec 383 int ret;
frankvnk 0:c44f0314d6ec 384 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 385
frankvnk 0:c44f0314d6ec 386 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 387 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 388
frankvnk 0:c44f0314d6ec 389 // Fill in temporary command buffer
frankvnk 0:c44f0314d6ec 390 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 391 args = UINT32_TO_STREAM(args, level);
frankvnk 0:c44f0314d6ec 392 args = UINT32_TO_STREAM(args, optname);
frankvnk 0:c44f0314d6ec 393 args = UINT32_TO_STREAM(args, 0x00000008);
frankvnk 0:c44f0314d6ec 394 args = UINT32_TO_STREAM(args, optlen);
frankvnk 0:c44f0314d6ec 395 ARRAY_TO_STREAM(args, ((unsigned char *)optval), optlen);
frankvnk 0:c44f0314d6ec 396
frankvnk 0:c44f0314d6ec 397 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 398 hci_command_send(HCI_CMND_SETSOCKOPT, ptr, SOCKET_SET_SOCK_OPT_PARAMS_LEN + optlen);
frankvnk 0:c44f0314d6ec 399
frankvnk 0:c44f0314d6ec 400 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 401 SimpleLinkWaitEvent(HCI_CMND_SETSOCKOPT, &ret);
frankvnk 0:c44f0314d6ec 402
frankvnk 0:c44f0314d6ec 403 if (ret >= 0)
frankvnk 0:c44f0314d6ec 404 {
frankvnk 0:c44f0314d6ec 405 return (0);
frankvnk 0:c44f0314d6ec 406 }
frankvnk 0:c44f0314d6ec 407 else
frankvnk 0:c44f0314d6ec 408 {
frankvnk 0:c44f0314d6ec 409 errno = ret;
frankvnk 8:b48bb4df9319 410 return ret;
frankvnk 0:c44f0314d6ec 411 }
frankvnk 0:c44f0314d6ec 412 }
frankvnk 0:c44f0314d6ec 413 #endif
frankvnk 0:c44f0314d6ec 414
frankvnk 0:c44f0314d6ec 415
frankvnk 8:b48bb4df9319 416 int getsockopt (long sd, long level, long optname, void *optval, socklen_t *optlen)
frankvnk 0:c44f0314d6ec 417 {
frankvnk 0:c44f0314d6ec 418 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 419 tBsdGetSockOptReturnParams tRetParams;
frankvnk 0:c44f0314d6ec 420
frankvnk 0:c44f0314d6ec 421 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 422 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 423
frankvnk 0:c44f0314d6ec 424 // Fill in temporary command buffer
frankvnk 0:c44f0314d6ec 425 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 426 args = UINT32_TO_STREAM(args, level);
frankvnk 0:c44f0314d6ec 427 args = UINT32_TO_STREAM(args, optname);
frankvnk 0:c44f0314d6ec 428
frankvnk 0:c44f0314d6ec 429 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 430 hci_command_send(HCI_CMND_GETSOCKOPT, ptr, SOCKET_GET_SOCK_OPT_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 431
frankvnk 0:c44f0314d6ec 432 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 433 SimpleLinkWaitEvent(HCI_CMND_GETSOCKOPT, &tRetParams);
frankvnk 0:c44f0314d6ec 434
frankvnk 0:c44f0314d6ec 435 if (((signed char)tRetParams.iStatus) >= 0)
frankvnk 0:c44f0314d6ec 436 {
frankvnk 0:c44f0314d6ec 437 *optlen = 4;
frankvnk 0:c44f0314d6ec 438 memcpy(optval, tRetParams.ucOptValue, 4);
frankvnk 0:c44f0314d6ec 439 return (0);
frankvnk 0:c44f0314d6ec 440 }
frankvnk 0:c44f0314d6ec 441 else
frankvnk 0:c44f0314d6ec 442 {
frankvnk 0:c44f0314d6ec 443 errno = tRetParams.iStatus;
frankvnk 8:b48bb4df9319 444 return errno;
frankvnk 0:c44f0314d6ec 445 }
frankvnk 0:c44f0314d6ec 446 }
frankvnk 0:c44f0314d6ec 447
frankvnk 4:d8255a5aad46 448
frankvnk 0:c44f0314d6ec 449 int simple_link_recv(long sd, void *buf, long len, long flags, sockaddr *from, socklen_t *fromlen, long opcode)
frankvnk 0:c44f0314d6ec 450 {
frankvnk 0:c44f0314d6ec 451 unsigned char *ptr, *args;
frankvnk 0:c44f0314d6ec 452 tBsdReadReturnParams tSocketReadEvent;
frankvnk 0:c44f0314d6ec 453
frankvnk 0:c44f0314d6ec 454 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 455 args = (ptr + HEADERS_SIZE_CMD);
frankvnk 0:c44f0314d6ec 456
frankvnk 0:c44f0314d6ec 457 // Fill in HCI packet structure
frankvnk 0:c44f0314d6ec 458 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 459 args = UINT32_TO_STREAM(args, len);
frankvnk 0:c44f0314d6ec 460 args = UINT32_TO_STREAM(args, flags);
frankvnk 0:c44f0314d6ec 461
frankvnk 0:c44f0314d6ec 462 // Generate the read command, and wait for the
frankvnk 0:c44f0314d6ec 463 hci_command_send(opcode, ptr, SOCKET_RECV_FROM_PARAMS_LEN);
frankvnk 0:c44f0314d6ec 464
frankvnk 0:c44f0314d6ec 465 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 466 SimpleLinkWaitEvent(opcode, &tSocketReadEvent);
frankvnk 0:c44f0314d6ec 467
frankvnk 0:c44f0314d6ec 468 // In case the number of bytes is more then zero - read data
frankvnk 0:c44f0314d6ec 469 if (tSocketReadEvent.iNumberOfBytes > 0)
frankvnk 0:c44f0314d6ec 470 {
frankvnk 0:c44f0314d6ec 471 // Wait for the data in a synchronous way. Here we assume that the bug is
frankvnk 0:c44f0314d6ec 472 // big enough to store also parameters of receive from too....
frankvnk 0:c44f0314d6ec 473 SimpleLinkWaitData((unsigned char *)buf, (unsigned char *)from, (unsigned char *)fromlen);
frankvnk 0:c44f0314d6ec 474 }
frankvnk 0:c44f0314d6ec 475
frankvnk 0:c44f0314d6ec 476 errno = tSocketReadEvent.iNumberOfBytes;
frankvnk 0:c44f0314d6ec 477
frankvnk 0:c44f0314d6ec 478 return(tSocketReadEvent.iNumberOfBytes);
frankvnk 0:c44f0314d6ec 479 }
frankvnk 0:c44f0314d6ec 480
frankvnk 0:c44f0314d6ec 481
frankvnk 0:c44f0314d6ec 482 int recv(long sd, void *buf, long len, long flags)
frankvnk 0:c44f0314d6ec 483 {
frankvnk 0:c44f0314d6ec 484 return(simple_link_recv(sd, buf, len, flags, NULL, NULL, HCI_CMND_RECV));
frankvnk 0:c44f0314d6ec 485 }
frankvnk 0:c44f0314d6ec 486
frankvnk 4:d8255a5aad46 487
frankvnk 0:c44f0314d6ec 488 int recvfrom(long sd, void *buf, long len, long flags, sockaddr *from, socklen_t *fromlen)
frankvnk 0:c44f0314d6ec 489 {
frankvnk 0:c44f0314d6ec 490 return(simple_link_recv(sd, buf, len, flags, from, fromlen, HCI_CMND_RECVFROM));
frankvnk 0:c44f0314d6ec 491 }
frankvnk 0:c44f0314d6ec 492
frankvnk 4:d8255a5aad46 493
frankvnk 0:c44f0314d6ec 494 int simple_link_send(long sd, const void *buf, long len, long flags, const sockaddr *to, long tolen, long opcode)
frankvnk 0:c44f0314d6ec 495 {
frankvnk 0:c44f0314d6ec 496 unsigned char uArgSize = 0x00, addrlen = 0x00;
frankvnk 0:c44f0314d6ec 497 unsigned char *ptr, *pDataPtr = NULL, *args;
frankvnk 0:c44f0314d6ec 498 unsigned long addr_offset = 0x00;
frankvnk 0:c44f0314d6ec 499 int res;
frankvnk 1:bbcaf0b2f367 500 tBsdReadReturnParams tSocketSendEvent;
frankvnk 0:c44f0314d6ec 501
frankvnk 0:c44f0314d6ec 502 // Check the bsd_arguments
frankvnk 0:c44f0314d6ec 503 if (0 != (res = HostFlowControlConsumeBuff(sd)))
frankvnk 0:c44f0314d6ec 504 {
frankvnk 0:c44f0314d6ec 505 return res;
frankvnk 0:c44f0314d6ec 506 }
frankvnk 0:c44f0314d6ec 507
frankvnk 0:c44f0314d6ec 508 //Update the number of sent packets
frankvnk 0:c44f0314d6ec 509 tSLInformation.NumberOfSentPackets++;
frankvnk 0:c44f0314d6ec 510
frankvnk 0:c44f0314d6ec 511 // Allocate a buffer and construct a packet and send it over spi
frankvnk 0:c44f0314d6ec 512 ptr = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 513 args = (ptr + HEADERS_SIZE_DATA);
frankvnk 0:c44f0314d6ec 514
frankvnk 0:c44f0314d6ec 515 // Update the offset of data and parameters according to the command
frankvnk 0:c44f0314d6ec 516 switch(opcode)
frankvnk 0:c44f0314d6ec 517 {
frankvnk 0:c44f0314d6ec 518 case HCI_CMND_SENDTO:
frankvnk 0:c44f0314d6ec 519 {
frankvnk 0:c44f0314d6ec 520 addr_offset = len + sizeof(len) + sizeof(len);
frankvnk 0:c44f0314d6ec 521 addrlen = 8;
frankvnk 0:c44f0314d6ec 522 uArgSize = SOCKET_SENDTO_PARAMS_LEN;
frankvnk 0:c44f0314d6ec 523 pDataPtr = ptr + HEADERS_SIZE_DATA + SOCKET_SENDTO_PARAMS_LEN;
frankvnk 0:c44f0314d6ec 524 break;
frankvnk 0:c44f0314d6ec 525 }
frankvnk 0:c44f0314d6ec 526
frankvnk 0:c44f0314d6ec 527 case HCI_CMND_SEND:
frankvnk 0:c44f0314d6ec 528 {
frankvnk 0:c44f0314d6ec 529 tolen = 0;
frankvnk 0:c44f0314d6ec 530 to = NULL;
frankvnk 0:c44f0314d6ec 531 uArgSize = HCI_CMND_SEND_ARG_LENGTH;
frankvnk 0:c44f0314d6ec 532 pDataPtr = ptr + HEADERS_SIZE_DATA + HCI_CMND_SEND_ARG_LENGTH;
frankvnk 0:c44f0314d6ec 533 break;
frankvnk 0:c44f0314d6ec 534 }
frankvnk 0:c44f0314d6ec 535
frankvnk 0:c44f0314d6ec 536 default:
frankvnk 0:c44f0314d6ec 537 {
frankvnk 0:c44f0314d6ec 538 break;
frankvnk 0:c44f0314d6ec 539 }
frankvnk 0:c44f0314d6ec 540 }
frankvnk 0:c44f0314d6ec 541
frankvnk 0:c44f0314d6ec 542 // Fill in temporary command buffer
frankvnk 0:c44f0314d6ec 543 args = UINT32_TO_STREAM(args, sd);
frankvnk 0:c44f0314d6ec 544 args = UINT32_TO_STREAM(args, uArgSize - sizeof(sd));
frankvnk 0:c44f0314d6ec 545 args = UINT32_TO_STREAM(args, len);
frankvnk 0:c44f0314d6ec 546 args = UINT32_TO_STREAM(args, flags);
frankvnk 0:c44f0314d6ec 547
frankvnk 0:c44f0314d6ec 548 if (opcode == HCI_CMND_SENDTO)
frankvnk 0:c44f0314d6ec 549 {
frankvnk 0:c44f0314d6ec 550 args = UINT32_TO_STREAM(args, addr_offset);
frankvnk 0:c44f0314d6ec 551 args = UINT32_TO_STREAM(args, addrlen);
frankvnk 0:c44f0314d6ec 552 }
frankvnk 0:c44f0314d6ec 553
frankvnk 0:c44f0314d6ec 554 // Copy the data received from user into the TX Buffer
frankvnk 0:c44f0314d6ec 555 ARRAY_TO_STREAM(pDataPtr, ((unsigned char *)buf), len);
frankvnk 0:c44f0314d6ec 556
frankvnk 0:c44f0314d6ec 557 // In case we are using SendTo, copy the to parameters
frankvnk 0:c44f0314d6ec 558 if (opcode == HCI_CMND_SENDTO)
frankvnk 0:c44f0314d6ec 559 {
frankvnk 0:c44f0314d6ec 560 ARRAY_TO_STREAM(pDataPtr, ((unsigned char *)to), tolen);
frankvnk 0:c44f0314d6ec 561 }
frankvnk 0:c44f0314d6ec 562
frankvnk 0:c44f0314d6ec 563 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 564 hci_data_send(opcode, ptr, uArgSize, len,(unsigned char*)to, tolen);
frankvnk 1:bbcaf0b2f367 565 if (opcode == HCI_CMND_SENDTO)
frankvnk 1:bbcaf0b2f367 566 SimpleLinkWaitEvent(HCI_EVNT_SENDTO, &tSocketSendEvent);
frankvnk 1:bbcaf0b2f367 567 else
frankvnk 1:bbcaf0b2f367 568 SimpleLinkWaitEvent(HCI_EVNT_SEND, &tSocketSendEvent);
frankvnk 0:c44f0314d6ec 569
frankvnk 8:b48bb4df9319 570 return (len);
frankvnk 0:c44f0314d6ec 571 }
frankvnk 0:c44f0314d6ec 572
frankvnk 0:c44f0314d6ec 573
frankvnk 0:c44f0314d6ec 574 int send(long sd, const void *buf, long len, long flags)
frankvnk 0:c44f0314d6ec 575 {
frankvnk 0:c44f0314d6ec 576 return(simple_link_send(sd, buf, len, flags, NULL, 0, HCI_CMND_SEND));
frankvnk 0:c44f0314d6ec 577 }
frankvnk 0:c44f0314d6ec 578
frankvnk 0:c44f0314d6ec 579
frankvnk 0:c44f0314d6ec 580 int sendto(long sd, const void *buf, long len, long flags, const sockaddr *to, socklen_t tolen)
frankvnk 0:c44f0314d6ec 581 {
frankvnk 0:c44f0314d6ec 582 return(simple_link_send(sd, buf, len, flags, to, tolen, HCI_CMND_SENDTO));
frankvnk 0:c44f0314d6ec 583 }
frankvnk 0:c44f0314d6ec 584
frankvnk 0:c44f0314d6ec 585
frankvnk 0:c44f0314d6ec 586 int mdnsAdvertiser(unsigned short mdnsEnabled, char * deviceServiceName, unsigned short deviceServiceNameLength)
frankvnk 0:c44f0314d6ec 587 {
frankvnk 0:c44f0314d6ec 588 int ret;
frankvnk 0:c44f0314d6ec 589 unsigned char *pTxBuffer, *pArgs;
frankvnk 0:c44f0314d6ec 590
frankvnk 0:c44f0314d6ec 591 if (deviceServiceNameLength > MDNS_DEVICE_SERVICE_MAX_LENGTH)
frankvnk 0:c44f0314d6ec 592 {
frankvnk 0:c44f0314d6ec 593 return EFAIL;
frankvnk 0:c44f0314d6ec 594 }
frankvnk 0:c44f0314d6ec 595
frankvnk 0:c44f0314d6ec 596 pTxBuffer = tSLInformation.pucTxCommandBuffer;
frankvnk 0:c44f0314d6ec 597 pArgs = (pTxBuffer + SIMPLE_LINK_HCI_CMND_TRANSPORT_HEADER_SIZE);
frankvnk 0:c44f0314d6ec 598
frankvnk 0:c44f0314d6ec 599 // Fill in HCI packet structure
frankvnk 0:c44f0314d6ec 600 pArgs = UINT32_TO_STREAM(pArgs, mdnsEnabled);
frankvnk 0:c44f0314d6ec 601 pArgs = UINT32_TO_STREAM(pArgs, 8);
frankvnk 0:c44f0314d6ec 602 pArgs = UINT32_TO_STREAM(pArgs, deviceServiceNameLength);
frankvnk 0:c44f0314d6ec 603 ARRAY_TO_STREAM(pArgs, deviceServiceName, deviceServiceNameLength);
frankvnk 0:c44f0314d6ec 604
frankvnk 0:c44f0314d6ec 605 // Initiate a HCI command
frankvnk 0:c44f0314d6ec 606 hci_command_send(HCI_CMND_MDNS_ADVERTISE, pTxBuffer, SOCKET_MDNS_ADVERTISE_PARAMS_LEN + deviceServiceNameLength);
frankvnk 0:c44f0314d6ec 607
frankvnk 0:c44f0314d6ec 608 // Since we are in blocking state - wait for event complete
frankvnk 0:c44f0314d6ec 609 SimpleLinkWaitEvent(HCI_EVNT_MDNS_ADVERTISE, &ret);
frankvnk 0:c44f0314d6ec 610
frankvnk 0:c44f0314d6ec 611 return ret;
frankvnk 0:c44f0314d6ec 612
frankvnk 0:c44f0314d6ec 613 }
frankvnk 0:c44f0314d6ec 614
frankvnk 6:d733efcc2c56 615
frankvnk 6:d733efcc2c56 616
frankvnk 6:d733efcc2c56 617