USBHostRSSI.cpp

00001 #include "USBHostRSSI.h"
00002 
00003 USBHostRSSI::USBHostRSSI()
00004 {
00005     host = USBHost::getHostInst();
00006     init();
00007 }
00008 
00009 void USBHostRSSI::init()
00010 {
00011     dev = NULL;
00012     int_in = NULL;
00013     onUpdate = NULL;
00014     dev_connected = false;
00015     bluetooth_device_found = false;
00016     bluetooth_intf = -1;
00017     seq = 0;
00018     
00019 }
00020 
00021 bool USBHostRSSI::connected() {
00022     return dev_connected;
00023 }
00024 
00025 bool USBHostRSSI::connect() {
00026 
00027     if (dev_connected) {
00028         return true;
00029     }
00030     
00031     for (uint8_t i = 0; i < MAX_DEVICE_CONNECTED; i++) {
00032         if ((dev = host->getDevice(i)) != NULL) {
00033             if(host->enumerate(dev, this)) {
00034                 break;
00035             }
00036             if (bluetooth_device_found) {
00037                 int_in = dev->getEndpoint(bluetooth_intf, INTERRUPT_ENDPOINT, IN);
00038                 USB_DBG("int_in=%p", int_in);
00039                 if (!int_in) {
00040                     break;
00041                 }
00042                 USB_INFO("New Bluetooth device: VID:%04x PID:%04x [dev: %p - intf: %d]", dev->getVid(), dev->getPid(), dev, bluetooth_intf);
00043                 int_in->attach(this, &USBHostRSSI::rxHandler);
00044                 int rc = host->interruptRead(dev, int_in, int_buf, sizeof(int_buf), false);
00045                 USB_TEST_ASSERT(rc != USB_TYPE_ERROR);
00046                 rc = cmdSend(HCI_OP_RESET);
00047                 USB_TEST_ASSERT(rc == USB_TYPE_OK);
00048                 dev_connected = true;
00049                 return true;
00050             }
00051         }
00052     }
00053     init();
00054     return false;
00055 }
00056 
00057 void USBHostRSSI::rxHandler() {
00058     event(int_buf, int_in->getLengthTransferred());
00059     if (dev) {
00060         host->interruptRead(dev, int_in, int_buf, sizeof(int_buf), false);
00061     }
00062 }
00063 
00064 /*virtual*/ void USBHostRSSI::setVidPid(uint16_t vid, uint16_t pid)
00065 {
00066     USB_DBG("vid:%04x pid:%04x", vid, pid);
00067     // we don't check VID/PID for mouse driver
00068 }
00069 
00070 /*virtual*/ bool USBHostRSSI::parseInterface(uint8_t intf_nb, uint8_t intf_class, uint8_t intf_subclass, uint8_t intf_protocol) //Must return true if the interface should be parsed
00071 {
00072     USB_DBG("intf: %d class: %02x %02x %02x", intf_nb, intf_class, intf_subclass, intf_protocol);
00073     if (bluetooth_intf == -1 && intf_class == 0xe0) {
00074         bluetooth_intf = intf_nb;
00075         return true;
00076     }
00077     return false;
00078 }
00079 
00080 /*virtual*/ bool USBHostRSSI::useEndpoint(uint8_t intf_nb, ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir) //Must return true if the endpoint will be used
00081 {
00082     USB_DBG("intf_nb=%d type=%d dir=%d", intf_nb, type, dir);
00083 
00084     if (intf_nb == bluetooth_intf) {
00085         if (type == INTERRUPT_ENDPOINT && dir == IN) {
00086             bluetooth_device_found = true;
00087             return true;
00088         }
00089     }
00090     return false;
00091 }
00092 
00093 void USBHostRSSI::event(uint8_t* data, int len) {
00094     CTASSERT(sizeof(BD_ADDR) == 6);
00095     CTASSERT(sizeof(inquiry_with_rssi_info) == 14);
00096     inquiry_with_rssi_info* info;
00097     int max_period_length = 25;
00098     int min_period_length = 20;
00099     int inquiry_length = 15;
00100     USB_TYPE rc;
00101     if (len > 0) {
00102         USB_DBG_HEX(data, len);
00103         hci_event* event = reinterpret_cast<hci_event*>(data);
00104         switch(event->evt) {
00105             case HCI_EV_CMD_COMPLETE:
00106                 switch(event->c.op) {
00107                     case HCI_OP_RESET:
00108                         wait_ms(500);
00109                         rc = cmdSend(HCI_OP_WRITE_INQUIRY_MODE, "B", 0x01); // with RSSI
00110                         USB_TEST_ASSERT(rc == USB_TYPE_OK);
00111                         if (rc != USB_TYPE_OK) {
00112                         }
00113                         break;
00114                     case HCI_OP_WRITE_INQUIRY_MODE:
00115                         rc = cmdSend(HCI_OP_PERIODIC_INQUIRY, "HHBBBBB", 
00116                                             max_period_length, min_period_length, 0x33, 0x8B, 0x9E, inquiry_length, 0);
00117                         USB_TEST_ASSERT(rc == USB_TYPE_OK);
00118                         break;
00119                     default:
00120                         break;
00121                 }
00122                 break;
00123             case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
00124                 //USB_DBG_HEX(buf, r);
00125                 info = reinterpret_cast<inquiry_with_rssi_info*>(event->c.data);
00126                 if (onUpdate) {
00127                     (*onUpdate)(info);
00128                 }
00129                 break;
00130             default:
00131                 break;
00132         }        
00133     }
00134 }
00135 
00136 USB_TYPE USBHostRSSI::cmdSend(uint16_t op)
00137 {
00138    return cmdSendSub(op, NULL, 0);
00139 }
00140 
00141 USB_TYPE USBHostRSSI::cmdSend(uint16_t op, const char* fmt, ...) 
00142 {   
00143     va_list vl;
00144     va_start(vl, fmt);
00145     uint8_t buf[255];
00146     int pos = 0;
00147     char* name;
00148     int name_len;
00149     uint16_t h;
00150     BD_ADDR* bdaddr;
00151     for(int i = 0; fmt[i]; i++) {
00152         switch(fmt[i]) {
00153             case 's':
00154                 name = va_arg(vl, char*);
00155                 name_len = strlen(name)+1;
00156                 memcpy(buf+pos, name, name_len);
00157                 pos += name_len;
00158                 break;
00159             case 'B':
00160                 buf[pos++] = va_arg(vl, int);
00161                 break;
00162             case 'H':
00163                 h = va_arg(vl, int);
00164                 buf[pos++] = h;
00165                 buf[pos++] = h>>8;
00166                 break;
00167             case 'A':
00168                 bdaddr = va_arg(vl, BD_ADDR*);
00169                 memcpy(buf+pos, bdaddr, 6);
00170                 pos += 6;
00171                 break;
00172             default:
00173                 USB_DBG("op=%04X fmt=%s i=%d", op, fmt, i);
00174                 break;
00175         }
00176     }
00177     return cmdSendSub(op, buf, pos);
00178 }
00179 
00180 USB_TYPE USBHostRSSI::cmdSendSub(uint16_t op, const uint8_t* data, int size)
00181 {
00182     uint8_t* buf = new uint8_t[size+3];
00183     buf[0] = op;
00184     buf[1] = op>>8;
00185     buf[2] = size;
00186     if (data) {
00187         memcpy(buf+3, data, size);
00188     }
00189     USB_TYPE rc = host->controlWrite(dev, USB_REQUEST_TYPE_CLASS, 0, 0, 0, buf, size+3);
00190     USB_TEST_ASSERT(rc == USB_TYPE_OK);
00191     delete[] buf;
00192     return rc;
00193 }