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:
Mon Jul 15 14:19:46 2013 +0000
Revision:
4:d8255a5aad46
Parent:
1:bbcaf0b2f367
Child:
6:d733efcc2c56
Full clean up (comments, Doxygen, code)

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