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 Aug 09 12:23:24 2013 +0000
Revision:
8:b48bb4df9319
Parent:
6:d733efcc2c56
Child:
10:5afa438c12fd
issue with enable/disable IRQ through wlan_int.fall - replaced with NVIC_... code.
; Additional code improvements

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