hci/src/hci_hal_mct.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2014 Google, Inc.
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 #define LOG_TAG "bt_hci_mct"
  20
  21 #include <assert.h>
  22 #include <errno.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25
  26 #include "bt_vendor_lib.h"
  27 #include "hci_hal.h"
  28 #include "osi/include/eager_reader.h"
  29 #include "osi/include/log.h"
  30 #include "osi/include/osi.h"
  31 #include "osi/include/reactor.h"
  32 #include "vendor.h"
  33
  34 #define HCI_HAL_SERIAL_BUFFER_SIZE 1026
  35
  36 // Our interface and modules we import
  37 static const hci_hal_t interface;
  38 static const hci_hal_callbacks_t *callbacks;
  39 static const vendor_t *vendor;
  40
  41 static thread_t *thread; // Not owned by us
  42
  43 static int uart_fds[CH_MAX];
  44 static eager_reader_t *event_stream;
  45 static eager_reader_t *acl_stream;
  46
  47 static uint16_t transmit_data_on(int fd, uint8_t *data, uint16_t length);
  48 static void event_event_stream_has_bytes(eager_reader_t *reader, void *context);
  49 static void event_acl_stream_has_bytes(eager_reader_t *reader, void *context);
  50
  51 // Interface functions
  52
  53 static bool hal_init(const hci_hal_callbacks_t *upper_callbacks, thread_t *upper_thread) {
  54   assert(upper_callbacks != NULL);
  55   assert(upper_thread != NULL);
  56
  57   callbacks = upper_callbacks;
  58   thread = upper_thread;
  59   return true;
  60 }
  61
  62 static bool hal_open() {
  63   LOG_INFO(LOG_TAG, "%s", __func__);
  64   // TODO(zachoverflow): close if already open / or don't reopen (maybe at the hci layer level)
  65
  66   int number_of_ports = vendor->send_command(VENDOR_OPEN_USERIAL, &uart_fds);
  67
  68   if (number_of_ports != 2 && number_of_ports != 4) {
  69     LOG_ERROR(LOG_TAG, "%s opened the wrong number of ports: got %d, expected 2 or 4.", __func__, number_of_ports);
  70     goto error;
  71   }
  72
  73   LOG_INFO(LOG_TAG, "%s got uart fds: CMD=%d, EVT=%d, ACL_OUT=%d, ACL_IN=%d",
  74       __func__, uart_fds[CH_CMD], uart_fds[CH_EVT], uart_fds[CH_ACL_OUT], uart_fds[CH_ACL_IN]);
  75
  76   if (uart_fds[CH_CMD] == INVALID_FD) {
  77     LOG_ERROR(LOG_TAG, "%s unable to open the command uart serial port.", __func__);
  78     goto error;
  79   }
  80
  81   if (uart_fds[CH_EVT] == INVALID_FD) {
  82     LOG_ERROR(LOG_TAG, "%s unable to open the event uart serial port.", __func__);
  83     goto error;
  84   }
  85
  86   if (uart_fds[CH_ACL_OUT] == INVALID_FD) {
  87     LOG_ERROR(LOG_TAG, "%s unable to open the acl-out uart serial port.", __func__);
  88     goto error;
  89   }
  90
  91   if (uart_fds[CH_ACL_IN] == INVALID_FD) {
  92     LOG_ERROR(LOG_TAG, "%s unable to open the acl-in uart serial port.", __func__);
  93     goto error;
  94   }
  95
  96   event_stream = eager_reader_new(uart_fds[CH_EVT], &allocator_malloc, HCI_HAL_SERIAL_BUFFER_SIZE, SIZE_MAX, "hci_mct");
  97   if (!event_stream) {
  98     LOG_ERROR(LOG_TAG, "%s unable to create eager reader for the event uart serial port.", __func__);
  99     goto error;
 100   }
 101
 102   acl_stream = eager_reader_new(uart_fds[CH_ACL_IN], &allocator_malloc, HCI_HAL_SERIAL_BUFFER_SIZE, SIZE_MAX, "hci_mct");
 103   if (!acl_stream) {
 104     LOG_ERROR(LOG_TAG, "%s unable to create eager reader for the acl-in uart serial port.", __func__);
 105     goto error;
 106   }
 107
 108   eager_reader_register(event_stream, thread_get_reactor(thread), event_event_stream_has_bytes, NULL);
 109   eager_reader_register(acl_stream, thread_get_reactor(thread), event_acl_stream_has_bytes, NULL);
 110
 111   return true;
 112
 113 error:;
 114   interface.close();
 115   return false;
 116 }
 117
 118 static void hal_close() {
 119   LOG_INFO(LOG_TAG, "%s", __func__);
 120
 121   eager_reader_free(event_stream);
 122   eager_reader_free(acl_stream);
 123   vendor->send_command(VENDOR_CLOSE_USERIAL, NULL);
 124
 125   for (int i = 0; i < CH_MAX; i++)
 126     uart_fds[i] = INVALID_FD;
 127 }
 128
 129 static size_t read_data(serial_data_type_t type, uint8_t *buffer, size_t max_size) {
 130   if (type == DATA_TYPE_ACL) {
 131     return eager_reader_read(acl_stream, buffer, max_size);
 132   } else if (type == DATA_TYPE_EVENT) {
 133     return eager_reader_read(event_stream, buffer, max_size);
 134   }
 135
 136   LOG_ERROR(LOG_TAG, "%s invalid data type: %d", __func__, type);
 137   return 0;
 138 }
 139
 140 static void packet_finished(UNUSED_ATTR serial_data_type_t type) {
 141   // not needed by this protocol
 142 }
 143
 144 static uint16_t transmit_data(serial_data_type_t type, uint8_t *data, uint16_t length) {
 145   if (type == DATA_TYPE_ACL) {
 146     return transmit_data_on(uart_fds[CH_ACL_OUT], data, length);
 147   } else if (type == DATA_TYPE_COMMAND) {
 148     return transmit_data_on(uart_fds[CH_CMD], data, length);
 149   }
 150
 151   LOG_ERROR(LOG_TAG, "%s invalid data type: %d", __func__, type);
 152   return 0;
 153 }
 154
 155 // Internal functions
 156
 157 static uint16_t transmit_data_on(int fd, uint8_t *data, uint16_t length) {
 158   assert(data != NULL);
 159   assert(length > 0);
 160
 161   uint16_t transmitted_length = 0;
 162   while (length > 0) {
 163     ssize_t ret;
 164     OSI_NO_INTR(ret = write(fd, data + transmitted_length, length));
 165     switch (ret) {
 166       case -1:
 167         LOG_ERROR(LOG_TAG, "In %s, error writing to the serial port with fd %d: %s", __func__, fd, strerror(errno));
 168         return transmitted_length;
 169       case 0:
 170         // If we wrote nothing, don't loop more because we
 171         // can't go to infinity or beyond
 172         return transmitted_length;
 173       default:
 174         transmitted_length += ret;
 175         length -= ret;
 176         break;
 177     }
 178   }
 179
 180   return transmitted_length;
 181 }
 182
 183 static void event_event_stream_has_bytes(UNUSED_ATTR eager_reader_t *reader, UNUSED_ATTR void *context) {
 184   callbacks->data_ready(DATA_TYPE_EVENT);
 185 }
 186
 187 static void event_acl_stream_has_bytes(UNUSED_ATTR eager_reader_t *reader, UNUSED_ATTR void *context) {
 188   // No real concept of incoming SCO typed data, just ACL
 189   callbacks->data_ready(DATA_TYPE_ACL);
 190 }
 191
 192 static const hci_hal_t interface = {
 193   hal_init,
 194
 195   hal_open,
 196   hal_close,
 197
 198   read_data,
 199   packet_finished,
 200   transmit_data,
 201 };
 202
 203 const hci_hal_t *hci_hal_mct_get_interface() {
 204   vendor = vendor_get_interface();
 205   return &interface;
 206 }
 207
 208 const hci_hal_t *hci_hal_mct_get_test_interface(vendor_t *vendor_interface) {
 209   vendor = vendor_interface;
 210   return &interface;
 211 }