mbed official / USBHostWANDongle

USB Host WAN Dongle library

Fork of USBHostWANDongle_bleedingedge by Donatien Garnier

USB3GModule/WANDongleInitializer.cpp@27:980fe31c14f7, 2013-09-20 (annotated)

Committer:
ashleymills
Date:
Fri Sep 20 10:40:15 2013 +0000
Revision:
27:980fe31c14f7
Parent:
26:b241a57c465b 
Added support for Ublox LISA U200 module

Who changed what in which revision?

UserRevisionLine numberNew contents of line
donatien 10:08bce4cd973a 1 /* Copyright (c) 2010-2012 mbed.org, MIT License
donatien 3:4394986752db 2 *
donatien 3:4394986752db 3 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
donatien 3:4394986752db 4 * and associated documentation files (the "Software"), to deal in the Software without
donatien 3:4394986752db 5 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
donatien 3:4394986752db 6 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
donatien 3:4394986752db 7 * Software is furnished to do so, subject to the following conditions:
donatien 3:4394986752db 8 *
donatien 3:4394986752db 9 * The above copyright notice and this permission notice shall be included in all copies or
donatien 3:4394986752db 10 * substantial portions of the Software.
donatien 3:4394986752db 11 *
donatien 3:4394986752db 12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
donatien 3:4394986752db 13 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
donatien 3:4394986752db 14 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
donatien 3:4394986752db 15 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
donatien 3:4394986752db 16 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
donatien 3:4394986752db 17 */
donatien 3:4394986752db 18
donatien 10:08bce4cd973a 19 #define __DEBUG__ 0
donatien 3:4394986752db 20 #ifndef __MODULE__
donatien 3:4394986752db 21 #define __MODULE__ "WANDongleInitializer.cpp"
donatien 3:4394986752db 22 #endif
donatien 3:4394986752db 23
donatien 12:a712bad7a979 24 #include "core/dbg.h"
donatien 3:4394986752db 25
donatien 3:4394986752db 26 #include <cstdint>
donatien 3:4394986752db 27 using std::uint16_t;
donatien 3:4394986752db 28
donatien 3:4394986752db 29 #include "WANDongleInitializer.h"
donatien 3:4394986752db 30
donatien 3:4394986752db 31 WANDongleInitializer::WANDongleInitializer(USBHost* pHost) : m_pHost(pHost)
donatien 3:4394986752db 32 {
donatien 3:4394986752db 33
donatien 3:4394986752db 34 }
donatien 3:4394986752db 35
donatien 3:4394986752db 36 WANDongleInitializer** WANDongleInitializer::getInitializers(USBHost* pHost)
donatien 3:4394986752db 37 {
donatien 3:4394986752db 38 static VodafoneK3770Initializer vodafoneK3770(pHost);
donatien 8:0d1ec493842c 39 static VodafoneK3772ZInitializer vodafoneK3772Z(pHost);
ashleymills 26:b241a57c465b 40 static VodafoneK3772Initializer vodafoneK3772(pHost);
ashleymills 20:3abcf818be31 41 static VodafoneK3773Initializer vodafoneK3773(pHost);
ashleymills 27:980fe31c14f7 42 static HuaweiMU509Initializer huaweiMU509(pHost);
ashleymills 27:980fe31c14f7 43 static UbloxLISAU200Initializer ubloxLISAU200(pHost);
ashleymills 21:dcc8c866ccbb 44 const static WANDongleInitializer* list[] = {
ashleymills 21:dcc8c866ccbb 45 &vodafoneK3770,
ashleymills 21:dcc8c866ccbb 46 &vodafoneK3772Z,
ashleymills 25:3184f71557bf 47 &vodafoneK3772,
ashleymills 21:dcc8c866ccbb 48 &vodafoneK3773,
ashleymills 27:980fe31c14f7 49 &huaweiMU509,
ashleymills 27:980fe31c14f7 50 &ubloxLISAU200,
ashleymills 21:dcc8c866ccbb 51 NULL
ashleymills 21:dcc8c866ccbb 52 };
donatien 3:4394986752db 53 return (WANDongleInitializer**)list;
donatien 3:4394986752db 54 }
donatien 3:4394986752db 55
donatien 3:4394986752db 56 //Huawei K3770 (Vodafone)
nherriot 5:3189db174f6b 57 // Switching from mass storage device string is: "55 53 42 43 12 34 56 78 00 00 00 00 00 00 00 11 06 20 00 00 01 00 00 00 00 00 00 00 00 00 00"
donatien 3:4394986752db 58 static uint8_t vodafone_k3770_switch_packet[] = {
donatien 3:4394986752db 59 0x55, 0x53, 0x42, 0x43, 0x12, 0x34, 0x56, 0x78, 0, 0, 0, 0, 0, 0, 0, 0x11, 0x06, 0x20, 0, 0, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
donatien 3:4394986752db 60 };
donatien 3:4394986752db 61
donatien 3:4394986752db 62 VodafoneK3770Initializer::VodafoneK3770Initializer(USBHost* pHost) : WANDongleInitializer(pHost)
donatien 3:4394986752db 63 {
donatien 3:4394986752db 64
donatien 3:4394986752db 65 }
donatien 3:4394986752db 66
donatien 3:4394986752db 67 uint16_t VodafoneK3770Initializer::getMSDVid() { return 0x12D1; }
donatien 3:4394986752db 68 uint16_t VodafoneK3770Initializer::getMSDPid() { return 0x14D1; }
donatien 3:4394986752db 69
donatien 3:4394986752db 70 uint16_t VodafoneK3770Initializer::getSerialVid() { return 0x12D1; }
donatien 3:4394986752db 71 uint16_t VodafoneK3770Initializer::getSerialPid() { return 0x14C9; }
donatien 3:4394986752db 72
donatien 3:4394986752db 73 bool VodafoneK3770Initializer::switchMode(USBDeviceConnected* pDev)
donatien 3:4394986752db 74 {
donatien 3:4394986752db 75 for (int i = 0; i < pDev->getNbInterface(); i++)
donatien 3:4394986752db 76 {
donatien 3:4394986752db 77 if (pDev->getInterface(i)->intf_class == MSD_CLASS)
donatien 3:4394986752db 78 {
donatien 9:c9e9817c398c 79 USBEndpoint* pEp = pDev->getEndpoint(i, BULK_ENDPOINT, OUT);
donatien 3:4394986752db 80 if ( pEp != NULL )
donatien 3:4394986752db 81 {
donatien 3:4394986752db 82 DBG("MSD descriptor found on device %p, intf %d, will now try to switch into serial mode", (void *)pDev, i);
donatien 3:4394986752db 83 m_pHost->bulkWrite(pDev, pEp, vodafone_k3770_switch_packet, 31);
donatien 3:4394986752db 84 return true;
donatien 3:4394986752db 85 }
donatien 3:4394986752db 86 }
donatien 3:4394986752db 87 }
donatien 3:4394986752db 88 return false;
donatien 3:4394986752db 89 }
donatien 3:4394986752db 90
donatien 9:c9e9817c398c 91 USBEndpoint* VodafoneK3770Initializer::getEp(USBDeviceConnected* pDev, int serialPortNumber, bool tx)
donatien 3:4394986752db 92 {
donatien 6:075e36a3463e 93 return pDev->getEndpoint(serialPortNumber, BULK_ENDPOINT, tx?OUT:IN, 0);
donatien 3:4394986752db 94 }
donatien 3:4394986752db 95
donatien 3:4394986752db 96 int VodafoneK3770Initializer::getSerialPortCount()
donatien 3:4394986752db 97 {
donatien 6:075e36a3463e 98 return 2;
donatien 6:075e36a3463e 99 }
donatien 6:075e36a3463e 100
donatien 6:075e36a3463e 101 /*virtual*/ void VodafoneK3770Initializer::setVidPid(uint16_t vid, uint16_t pid)
donatien 6:075e36a3463e 102 {
donatien 6:075e36a3463e 103 if( (vid == getSerialVid() ) && ( pid == getSerialPid() ) )
donatien 6:075e36a3463e 104 {
donatien 6:075e36a3463e 105 m_hasSwitched = true;
donatien 6:075e36a3463e 106 m_currentSerialIntf = 0;
donatien 6:075e36a3463e 107 m_endpointsToFetch = 4;
donatien 6:075e36a3463e 108 }
donatien 6:075e36a3463e 109 else
donatien 6:075e36a3463e 110 {
donatien 6:075e36a3463e 111 m_hasSwitched = false;
donatien 6:075e36a3463e 112 m_endpointsToFetch = 1;
donatien 6:075e36a3463e 113 }
donatien 3:4394986752db 114 }
donatien 3:4394986752db 115
donatien 6:075e36a3463e 116 /*virtual*/ bool VodafoneK3770Initializer::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
donatien 6:075e36a3463e 117 {
donatien 6:075e36a3463e 118 if( m_hasSwitched )
donatien 6:075e36a3463e 119 {
donatien 6:075e36a3463e 120 if( intf_class == 0xFF )
donatien 6:075e36a3463e 121 {
donatien 6:075e36a3463e 122 if( (m_currentSerialIntf == 0) || (m_currentSerialIntf == 4) )
donatien 6:075e36a3463e 123 {
donatien 6:075e36a3463e 124 m_currentSerialIntf++;
donatien 6:075e36a3463e 125 return true;
donatien 6:075e36a3463e 126 }
donatien 6:075e36a3463e 127 m_currentSerialIntf++;
donatien 6:075e36a3463e 128 }
donatien 6:075e36a3463e 129 }
donatien 6:075e36a3463e 130 else
donatien 6:075e36a3463e 131 {
donatien 6:075e36a3463e 132 if( (intf_nb == 0) && (intf_class == MSD_CLASS) )
donatien 6:075e36a3463e 133 {
donatien 6:075e36a3463e 134 return true;
donatien 6:075e36a3463e 135 }
donatien 6:075e36a3463e 136 }
donatien 6:075e36a3463e 137 return false;
donatien 6:075e36a3463e 138 }
donatien 6:075e36a3463e 139
donatien 6:075e36a3463e 140 /*virtual*/ bool VodafoneK3770Initializer::useEndpoint(uint8_t intf_nb, ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir) //Must return true if the endpoint will be used
donatien 6:075e36a3463e 141 {
donatien 6:075e36a3463e 142 if( m_hasSwitched )
donatien 6:075e36a3463e 143 {
donatien 6:075e36a3463e 144 if( (type == BULK_ENDPOINT) && m_endpointsToFetch )
donatien 6:075e36a3463e 145 {
donatien 6:075e36a3463e 146 m_endpointsToFetch--;
donatien 6:075e36a3463e 147 return true;
donatien 6:075e36a3463e 148 }
donatien 6:075e36a3463e 149 }
donatien 6:075e36a3463e 150 else
donatien 6:075e36a3463e 151 {
donatien 6:075e36a3463e 152 if( (type == BULK_ENDPOINT) && (dir == OUT) && m_endpointsToFetch )
donatien 6:075e36a3463e 153 {
donatien 6:075e36a3463e 154 m_endpointsToFetch--;
donatien 6:075e36a3463e 155 return true;
donatien 6:075e36a3463e 156 }
donatien 6:075e36a3463e 157 }
donatien 6:075e36a3463e 158 return false;
donatien 6:075e36a3463e 159 }
donatien 8:0d1ec493842c 160
donatien 8:0d1ec493842c 161 /*virtual*/ WAN_DONGLE_TYPE VodafoneK3770Initializer::getType()
donatien 8:0d1ec493842c 162 {
ashleymills 27:980fe31c14f7 163 return WAN_DONGLE_TYPE_VODAFONE_K3770;
donatien 8:0d1ec493842c 164 }
donatien 8:0d1ec493842c 165
ashleymills 21:dcc8c866ccbb 166 //Huawei MU509 (Module)
donatien 18:7d5242aa7b95 167
ashleymills 27:980fe31c14f7 168 HuaweiMU509Initializer::HuaweiMU509Initializer(USBHost* pHost) : WANDongleInitializer(pHost)
donatien 18:7d5242aa7b95 169 {
donatien 18:7d5242aa7b95 170
donatien 18:7d5242aa7b95 171 }
donatien 18:7d5242aa7b95 172
ashleymills 27:980fe31c14f7 173 uint16_t HuaweiMU509Initializer::getMSDVid() { return 0x12D1; }
ashleymills 27:980fe31c14f7 174 uint16_t HuaweiMU509Initializer::getMSDPid() { return 0x0000; } //No MSD mode (presumably)
ashleymills 21:dcc8c866ccbb 175
ashleymills 27:980fe31c14f7 176 uint16_t HuaweiMU509Initializer::getSerialVid() { return 0x12D1; }
ashleymills 27:980fe31c14f7 177 uint16_t HuaweiMU509Initializer::getSerialPid() { return 0x1001; }
ashleymills 21:dcc8c866ccbb 178
ashleymills 27:980fe31c14f7 179 bool HuaweiMU509Initializer::switchMode(USBDeviceConnected* pDev)
ashleymills 21:dcc8c866ccbb 180 {
donatien 22:bec61bcc9c25 181 return true; //No MSD mode
ashleymills 21:dcc8c866ccbb 182 }
ashleymills 21:dcc8c866ccbb 183
ashleymills 27:980fe31c14f7 184 USBEndpoint* HuaweiMU509Initializer::getEp(USBDeviceConnected* pDev, int serialPortNumber, bool tx)
ashleymills 21:dcc8c866ccbb 185 {
ashleymills 24:f4b676f61906 186 /*
ashleymills 24:f4b676f61906 187 int sPort = serialPortNumber;
ashleymills 24:f4b676f61906 188 if(sPort==1)
ashleymills 24:f4b676f61906 189 sPort = 0;
ashleymills 24:f4b676f61906 190 if(sPort==2)
ashleymills 24:f4b676f61906 191 sPort = 1;
ashleymills 24:f4b676f61906 192 if(sPort==0)
ashleymills 24:f4b676f61906 193 sPort = 2;
ashleymills 24:f4b676f61906 194 return pDev->getEndpoint(sPort, BULK_ENDPOINT, tx?OUT:IN, 0);
ashleymills 24:f4b676f61906 195 */
ashleymills 24:f4b676f61906 196 return pDev->getEndpoint(serialPortNumber, BULK_ENDPOINT, tx?OUT:IN, 0);
ashleymills 24:f4b676f61906 197 //return pDev->getEndpoint((serialPortNumber==1)?0:1, BULK_ENDPOINT, tx?OUT:IN, 0);
ashleymills 21:dcc8c866ccbb 198 }
ashleymills 21:dcc8c866ccbb 199
ashleymills 27:980fe31c14f7 200 int HuaweiMU509Initializer::getSerialPortCount()
ashleymills 21:dcc8c866ccbb 201 {
donatien 22:bec61bcc9c25 202 return 2;
ashleymills 21:dcc8c866ccbb 203 }
ashleymills 21:dcc8c866ccbb 204
ashleymills 27:980fe31c14f7 205 /*virtual*/ void HuaweiMU509Initializer::setVidPid(uint16_t vid, uint16_t pid)
ashleymills 21:dcc8c866ccbb 206 {
donatien 22:bec61bcc9c25 207 m_currentSerialIntf = 0;
donatien 22:bec61bcc9c25 208 m_endpointsToFetch = 4;
ashleymills 21:dcc8c866ccbb 209 }
donatien 18:7d5242aa7b95 210
ashleymills 27:980fe31c14f7 211 /*virtual*/ bool HuaweiMU509Initializer::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
ashleymills 21:dcc8c866ccbb 212 {
donatien 22:bec61bcc9c25 213 if( intf_class == 0xFF )
ashleymills 21:dcc8c866ccbb 214 {
ashleymills 24:f4b676f61906 215 if( (m_currentSerialIntf == 0) || (m_currentSerialIntf == 2) )
ashleymills 21:dcc8c866ccbb 216 {
ashleymills 21:dcc8c866ccbb 217 m_currentSerialIntf++;
ashleymills 21:dcc8c866ccbb 218 return true;
ashleymills 21:dcc8c866ccbb 219 }
donatien 22:bec61bcc9c25 220 m_currentSerialIntf++;
ashleymills 21:dcc8c866ccbb 221 }
ashleymills 21:dcc8c866ccbb 222 return false;
ashleymills 21:dcc8c866ccbb 223 }
donatien 18:7d5242aa7b95 224
ashleymills 27:980fe31c14f7 225 /*virtual*/ bool HuaweiMU509Initializer::useEndpoint(uint8_t intf_nb, ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir) //Must return true if the endpoint will be used
ashleymills 21:dcc8c866ccbb 226 {
donatien 22:bec61bcc9c25 227 if( (type == BULK_ENDPOINT) && m_endpointsToFetch )
ashleymills 21:dcc8c866ccbb 228 {
ashleymills 24:f4b676f61906 229 DBG("new endpoint");
donatien 22:bec61bcc9c25 230 m_endpointsToFetch--;
donatien 22:bec61bcc9c25 231 return true;
ashleymills 21:dcc8c866ccbb 232 }
ashleymills 21:dcc8c866ccbb 233 return false;
ashleymills 21:dcc8c866ccbb 234 }
ashleymills 21:dcc8c866ccbb 235
ashleymills 27:980fe31c14f7 236 /*virtual*/ WAN_DONGLE_TYPE HuaweiMU509Initializer::getType()
ashleymills 21:dcc8c866ccbb 237 {
ashleymills 27:980fe31c14f7 238 return WAN_DONGLE_TYPE_HUAWEI_MU509;
ashleymills 21:dcc8c866ccbb 239 }
ashleymills 21:dcc8c866ccbb 240
ashleymills 20:3abcf818be31 241 //Huawei K3773 (Vodafone)
ashleymills 20:3abcf818be31 242 // Switching from mass storage device string is: "55 53 42 43 12 34 56 78 00 00 00 00 00 00 00 11 06 20 00 00 01 00 00 00 00 00 00 00 00 00 00"
ashleymills 20:3abcf818be31 243 static uint8_t vodafone_k3773_switch_packet[] = {
ashleymills 20:3abcf818be31 244 0x55, 0x53, 0x42, 0x43, 0x12, 0x34, 0x56, 0x78, 0, 0, 0, 0, 0, 0, 0, 0x11, 0x06, 0x20, 0, 0, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
ashleymills 20:3abcf818be31 245 };
ashleymills 20:3abcf818be31 246
ashleymills 20:3abcf818be31 247 VodafoneK3773Initializer::VodafoneK3773Initializer(USBHost* pHost) : WANDongleInitializer(pHost)
ashleymills 20:3abcf818be31 248 {
ashleymills 20:3abcf818be31 249
ashleymills 20:3abcf818be31 250 }
ashleymills 20:3abcf818be31 251
ashleymills 20:3abcf818be31 252 uint16_t VodafoneK3773Initializer::getMSDVid() { return 0x12D1; }
ashleymills 20:3abcf818be31 253 uint16_t VodafoneK3773Initializer::getMSDPid() { return 0x1506; }
ashleymills 20:3abcf818be31 254
ashleymills 20:3abcf818be31 255 uint16_t VodafoneK3773Initializer::getSerialVid() { return 0x12D1; }
ashleymills 20:3abcf818be31 256 uint16_t VodafoneK3773Initializer::getSerialPid() { return 0x1506; }
ashleymills 20:3abcf818be31 257
ashleymills 20:3abcf818be31 258 bool VodafoneK3773Initializer::switchMode(USBDeviceConnected* pDev)
donatien 18:7d5242aa7b95 259 {
donatien 18:7d5242aa7b95 260 for (int i = 0; i < pDev->getNbInterface(); i++)
donatien 18:7d5242aa7b95 261 {
donatien 18:7d5242aa7b95 262 if (pDev->getInterface(i)->intf_class == MSD_CLASS)
donatien 18:7d5242aa7b95 263 {
donatien 18:7d5242aa7b95 264 USBEndpoint* pEp = pDev->getEndpoint(i, BULK_ENDPOINT, OUT);
donatien 18:7d5242aa7b95 265 if ( pEp != NULL )
donatien 18:7d5242aa7b95 266 {
donatien 18:7d5242aa7b95 267 DBG("MSD descriptor found on device %p, intf %d, will now try to switch into serial mode", (void *)pDev, i);
ashleymills 20:3abcf818be31 268 m_pHost->bulkWrite(pDev, pEp, vodafone_k3773_switch_packet, 31);
donatien 18:7d5242aa7b95 269 return true;
donatien 18:7d5242aa7b95 270 }
donatien 18:7d5242aa7b95 271 }
donatien 18:7d5242aa7b95 272 }
donatien 18:7d5242aa7b95 273 return false;
donatien 18:7d5242aa7b95 274 }
donatien 18:7d5242aa7b95 275
ashleymills 20:3abcf818be31 276 USBEndpoint* VodafoneK3773Initializer::getEp(USBDeviceConnected* pDev, int serialPortNumber, bool tx)
donatien 18:7d5242aa7b95 277 {
donatien 18:7d5242aa7b95 278 return pDev->getEndpoint(serialPortNumber, BULK_ENDPOINT, tx?OUT:IN, 0);
donatien 18:7d5242aa7b95 279 }
donatien 18:7d5242aa7b95 280
ashleymills 20:3abcf818be31 281 int VodafoneK3773Initializer::getSerialPortCount()
donatien 18:7d5242aa7b95 282 {
donatien 18:7d5242aa7b95 283 return 2;
donatien 18:7d5242aa7b95 284 }
donatien 18:7d5242aa7b95 285
ashleymills 20:3abcf818be31 286 /*virtual*/ void VodafoneK3773Initializer::setVidPid(uint16_t vid, uint16_t pid)
donatien 18:7d5242aa7b95 287 {
donatien 18:7d5242aa7b95 288 if( (vid == getSerialVid() ) && ( pid == getSerialPid() ) )
donatien 18:7d5242aa7b95 289 {
donatien 18:7d5242aa7b95 290 m_hasSwitched = true;
donatien 18:7d5242aa7b95 291 m_currentSerialIntf = 0;
donatien 18:7d5242aa7b95 292 m_endpointsToFetch = 4;
donatien 18:7d5242aa7b95 293 }
donatien 18:7d5242aa7b95 294 else
donatien 18:7d5242aa7b95 295 {
donatien 18:7d5242aa7b95 296 m_hasSwitched = false;
donatien 18:7d5242aa7b95 297 m_endpointsToFetch = 1;
donatien 18:7d5242aa7b95 298 }
donatien 18:7d5242aa7b95 299 }
donatien 18:7d5242aa7b95 300
ashleymills 20:3abcf818be31 301 /*virtual*/ bool VodafoneK3773Initializer::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
donatien 18:7d5242aa7b95 302 {
donatien 18:7d5242aa7b95 303 if( m_hasSwitched )
donatien 18:7d5242aa7b95 304 {
donatien 18:7d5242aa7b95 305 if( intf_class == 0xFF )
donatien 18:7d5242aa7b95 306 {
ashleymills 20:3abcf818be31 307 if( (m_currentSerialIntf == 0) || (m_currentSerialIntf == 4) )
donatien 18:7d5242aa7b95 308 {
donatien 18:7d5242aa7b95 309 m_currentSerialIntf++;
donatien 18:7d5242aa7b95 310 return true;
donatien 18:7d5242aa7b95 311 }
donatien 18:7d5242aa7b95 312 m_currentSerialIntf++;
donatien 18:7d5242aa7b95 313 }
donatien 18:7d5242aa7b95 314 }
donatien 18:7d5242aa7b95 315 else
donatien 18:7d5242aa7b95 316 {
donatien 18:7d5242aa7b95 317 if( (intf_nb == 0) && (intf_class == MSD_CLASS) )
donatien 18:7d5242aa7b95 318 {
donatien 18:7d5242aa7b95 319 return true;
donatien 18:7d5242aa7b95 320 }
donatien 18:7d5242aa7b95 321 }
donatien 18:7d5242aa7b95 322 return false;
donatien 18:7d5242aa7b95 323 }
donatien 18:7d5242aa7b95 324
ashleymills 20:3abcf818be31 325 /*virtual*/ bool VodafoneK3773Initializer::useEndpoint(uint8_t intf_nb, ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir) //Must return true if the endpoint will be used
donatien 18:7d5242aa7b95 326 {
donatien 18:7d5242aa7b95 327 if( m_hasSwitched )
donatien 18:7d5242aa7b95 328 {
donatien 18:7d5242aa7b95 329 if( (type == BULK_ENDPOINT) && m_endpointsToFetch )
donatien 18:7d5242aa7b95 330 {
donatien 18:7d5242aa7b95 331 m_endpointsToFetch--;
donatien 18:7d5242aa7b95 332 return true;
donatien 18:7d5242aa7b95 333 }
donatien 18:7d5242aa7b95 334 }
donatien 18:7d5242aa7b95 335 else
donatien 18:7d5242aa7b95 336 {
donatien 18:7d5242aa7b95 337 if( (type == BULK_ENDPOINT) && (dir == OUT) && m_endpointsToFetch )
donatien 18:7d5242aa7b95 338 {
donatien 18:7d5242aa7b95 339 m_endpointsToFetch--;
donatien 18:7d5242aa7b95 340 return true;
donatien 18:7d5242aa7b95 341 }
donatien 18:7d5242aa7b95 342 }
donatien 18:7d5242aa7b95 343 return false;
donatien 18:7d5242aa7b95 344 }
donatien 18:7d5242aa7b95 345
ashleymills 20:3abcf818be31 346 /*virtual*/ WAN_DONGLE_TYPE VodafoneK3773Initializer::getType()
donatien 18:7d5242aa7b95 347 {
ashleymills 27:980fe31c14f7 348 return WAN_DONGLE_TYPE_VODAFONE_K3773;
donatien 18:7d5242aa7b95 349 }
donatien 18:7d5242aa7b95 350
donatien 8:0d1ec493842c 351 // NVIDIA (ICERA) /ZTE K3772-Z (Vodafone)
donatien 8:0d1ec493842c 352 // Switching from mass storage device string is: "55 53 42 43 12 34 56 78 00 00 00 00 00 00 06 1b 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00"
donatien 8:0d1ec493842c 353 static uint8_t vodafone_k3772_z_switch_packet[] = {
donatien 8:0d1ec493842c 354 0x55, 0x53, 0x42, 0x43, 0x12, 0x34, 0x56, 0x78, 0, 0, 0, 0, 0, 0, 0x06, 0x1b, 0, 0, 0, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
donatien 8:0d1ec493842c 355 };
donatien 8:0d1ec493842c 356
donatien 8:0d1ec493842c 357 VodafoneK3772ZInitializer::VodafoneK3772ZInitializer(USBHost* pHost) : WANDongleInitializer(pHost)
donatien 8:0d1ec493842c 358 {
donatien 8:0d1ec493842c 359
donatien 8:0d1ec493842c 360 }
donatien 8:0d1ec493842c 361
donatien 8:0d1ec493842c 362 uint16_t VodafoneK3772ZInitializer::getMSDVid() { return 0x19D2; }
donatien 8:0d1ec493842c 363 uint16_t VodafoneK3772ZInitializer::getMSDPid() { return 0x1179; }
donatien 8:0d1ec493842c 364
donatien 8:0d1ec493842c 365 uint16_t VodafoneK3772ZInitializer::getSerialVid() { return 0x19D2; }
donatien 8:0d1ec493842c 366 uint16_t VodafoneK3772ZInitializer::getSerialPid() { return 0x1181; }
donatien 8:0d1ec493842c 367
donatien 8:0d1ec493842c 368 bool VodafoneK3772ZInitializer::switchMode(USBDeviceConnected* pDev)
donatien 8:0d1ec493842c 369 {
donatien 8:0d1ec493842c 370 for (int i = 0; i < pDev->getNbInterface(); i++)
donatien 8:0d1ec493842c 371 {
donatien 8:0d1ec493842c 372 if (pDev->getInterface(i)->intf_class == MSD_CLASS)
donatien 8:0d1ec493842c 373 {
donatien 9:c9e9817c398c 374 USBEndpoint* pEp = pDev->getEndpoint(i, BULK_ENDPOINT, OUT);
donatien 8:0d1ec493842c 375 if ( pEp != NULL )
donatien 8:0d1ec493842c 376 {
donatien 8:0d1ec493842c 377 DBG("MSD descriptor found on device %p, intf %d, will now try to switch into serial mode", (void *)pDev, i);
donatien 8:0d1ec493842c 378 m_pHost->bulkWrite(pDev, pEp, vodafone_k3772_z_switch_packet, 31);
donatien 8:0d1ec493842c 379 return true;
donatien 8:0d1ec493842c 380 }
donatien 8:0d1ec493842c 381 }
donatien 8:0d1ec493842c 382 }
donatien 8:0d1ec493842c 383 return false;
donatien 8:0d1ec493842c 384 }
donatien 8:0d1ec493842c 385
donatien 9:c9e9817c398c 386 USBEndpoint* VodafoneK3772ZInitializer::getEp(USBDeviceConnected* pDev, int serialPortNumber, bool tx)
donatien 8:0d1ec493842c 387 {
donatien 8:0d1ec493842c 388 return pDev->getEndpoint((serialPortNumber==1)?0:1, BULK_ENDPOINT, tx?OUT:IN, 0);
donatien 8:0d1ec493842c 389 }
donatien 8:0d1ec493842c 390
donatien 8:0d1ec493842c 391 int VodafoneK3772ZInitializer::getSerialPortCount()
donatien 8:0d1ec493842c 392 {
donatien 8:0d1ec493842c 393 return 2;
donatien 8:0d1ec493842c 394 }
donatien 8:0d1ec493842c 395
donatien 8:0d1ec493842c 396 /*virtual*/ void VodafoneK3772ZInitializer::setVidPid(uint16_t vid, uint16_t pid)
donatien 8:0d1ec493842c 397 {
donatien 8:0d1ec493842c 398 if( (vid == getSerialVid() ) && ( pid == getSerialPid() ) )
donatien 8:0d1ec493842c 399 {
donatien 8:0d1ec493842c 400 m_hasSwitched = true;
donatien 8:0d1ec493842c 401 m_currentSerialIntf = 0;
donatien 8:0d1ec493842c 402 m_endpointsToFetch = 4;
donatien 8:0d1ec493842c 403 }
donatien 8:0d1ec493842c 404 else
donatien 8:0d1ec493842c 405 {
donatien 8:0d1ec493842c 406 m_hasSwitched = false;
donatien 8:0d1ec493842c 407 m_endpointsToFetch = 1;
donatien 8:0d1ec493842c 408 }
donatien 8:0d1ec493842c 409 }
donatien 8:0d1ec493842c 410
donatien 8:0d1ec493842c 411 /*virtual*/ bool VodafoneK3772ZInitializer::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
donatien 8:0d1ec493842c 412 {
donatien 8:0d1ec493842c 413 if( m_hasSwitched )
donatien 8:0d1ec493842c 414 {
donatien 8:0d1ec493842c 415 DBG("Interface #%d; Class:%02x; SubClass:%02x; Protocol:%02x", intf_nb, intf_class, intf_subclass, intf_protocol);
donatien 8:0d1ec493842c 416 if( intf_class == 0x0A )
donatien 8:0d1ec493842c 417 {
donatien 8:0d1ec493842c 418 if( (m_currentSerialIntf == 0) || (m_currentSerialIntf == 1) )
donatien 8:0d1ec493842c 419 {
donatien 8:0d1ec493842c 420 m_currentSerialIntf++;
donatien 8:0d1ec493842c 421 return true;
donatien 8:0d1ec493842c 422 }
donatien 8:0d1ec493842c 423 m_currentSerialIntf++;
donatien 8:0d1ec493842c 424 }
donatien 8:0d1ec493842c 425 }
donatien 8:0d1ec493842c 426 else
donatien 8:0d1ec493842c 427 {
donatien 8:0d1ec493842c 428 if( (intf_nb == 0) && (intf_class == MSD_CLASS) )
donatien 8:0d1ec493842c 429 {
donatien 8:0d1ec493842c 430 return true;
donatien 8:0d1ec493842c 431 }
donatien 8:0d1ec493842c 432 }
donatien 8:0d1ec493842c 433 return false;
donatien 8:0d1ec493842c 434 }
donatien 8:0d1ec493842c 435
donatien 8:0d1ec493842c 436 /*virtual*/ bool VodafoneK3772ZInitializer::useEndpoint(uint8_t intf_nb, ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir) //Must return true if the endpoint will be used
donatien 8:0d1ec493842c 437 {
donatien 8:0d1ec493842c 438 if( m_hasSwitched )
donatien 8:0d1ec493842c 439 {
donatien 9:c9e9817c398c 440 DBG("USBEndpoint on Inteface #%d; Type:%d; Direction:%d", intf_nb, type, dir);
donatien 8:0d1ec493842c 441 if( (type == BULK_ENDPOINT) && m_endpointsToFetch )
donatien 8:0d1ec493842c 442 {
donatien 8:0d1ec493842c 443 m_endpointsToFetch--;
donatien 8:0d1ec493842c 444 return true;
donatien 8:0d1ec493842c 445 }
donatien 8:0d1ec493842c 446 }
donatien 8:0d1ec493842c 447 else
donatien 8:0d1ec493842c 448 {
donatien 8:0d1ec493842c 449 if( (type == BULK_ENDPOINT) && (dir == OUT) && m_endpointsToFetch )
donatien 8:0d1ec493842c 450 {
donatien 8:0d1ec493842c 451 m_endpointsToFetch--;
donatien 8:0d1ec493842c 452 return true;
donatien 8:0d1ec493842c 453 }
donatien 8:0d1ec493842c 454 }
donatien 8:0d1ec493842c 455 return false;
donatien 8:0d1ec493842c 456 }
donatien 8:0d1ec493842c 457
donatien 8:0d1ec493842c 458
donatien 8:0d1ec493842c 459 /*virtual*/ WAN_DONGLE_TYPE VodafoneK3772ZInitializer::getType()
donatien 8:0d1ec493842c 460 {
ashleymills 27:980fe31c14f7 461 return WAN_DONGLE_TYPE_VODAFONE_K3772Z;
donatien 8:0d1ec493842c 462 }
ashleymills 25:3184f71557bf 463
ashleymills 25:3184f71557bf 464 //Huawei K3772 (Vodafone)
ashleymills 25:3184f71557bf 465 // Switching from mass storage device string is: "55 53 42 43 12 34 56 78 00 02 00 00 80 00 0a 11 06 20 00 00 00 00 00 01 00 00 00 00 00 00 00"
ashleymills 25:3184f71557bf 466 static uint8_t vodafone_k3772_switch_packet[] = {
ashleymills 25:3184f71557bf 467 0x55, 0x53, 0x42, 0x43, 0x12, 0x34, 0x56, 0x78, 0, 0x02, 0, 0, 0x80, 0, 0x0a, 0x11, 0x06, 0x20, 0, 0, 0, 0, 0, 0x01, 0, 0, 0, 0, 0, 0, 0
ashleymills 25:3184f71557bf 468 };
ashleymills 25:3184f71557bf 469
ashleymills 25:3184f71557bf 470
ashleymills 25:3184f71557bf 471 VodafoneK3772Initializer::VodafoneK3772Initializer(USBHost* pHost) : WANDongleInitializer(pHost)
ashleymills 25:3184f71557bf 472 {
ashleymills 25:3184f71557bf 473
ashleymills 25:3184f71557bf 474 }
ashleymills 25:3184f71557bf 475
ashleymills 25:3184f71557bf 476 uint16_t VodafoneK3772Initializer::getMSDVid() { return 0x12D1; }
ashleymills 25:3184f71557bf 477 uint16_t VodafoneK3772Initializer::getMSDPid() { return 0x1526; }
ashleymills 25:3184f71557bf 478
ashleymills 25:3184f71557bf 479 uint16_t VodafoneK3772Initializer::getSerialVid() { return 0x12D1; }
ashleymills 25:3184f71557bf 480 uint16_t VodafoneK3772Initializer::getSerialPid() { return 0x14CF; }
ashleymills 25:3184f71557bf 481
ashleymills 25:3184f71557bf 482 bool VodafoneK3772Initializer::switchMode(USBDeviceConnected* pDev)
ashleymills 25:3184f71557bf 483 {
ashleymills 25:3184f71557bf 484 for (int i = 0; i < pDev->getNbInterface(); i++)
ashleymills 25:3184f71557bf 485 {
ashleymills 25:3184f71557bf 486 if (pDev->getInterface(i)->intf_class == MSD_CLASS)
ashleymills 25:3184f71557bf 487 {
ashleymills 25:3184f71557bf 488 USBEndpoint* pEp = pDev->getEndpoint(i, BULK_ENDPOINT, OUT);
ashleymills 25:3184f71557bf 489 if ( pEp != NULL )
ashleymills 25:3184f71557bf 490 {
ashleymills 25:3184f71557bf 491 DBG("MSD descriptor found on device %p, intf %d, will now try to switch into serial mode", (void *)pDev, i);
ashleymills 25:3184f71557bf 492 m_pHost->bulkWrite(pDev, pEp, vodafone_k3772_switch_packet, 31);
ashleymills 25:3184f71557bf 493 return true;
ashleymills 25:3184f71557bf 494 }
ashleymills 25:3184f71557bf 495 }
ashleymills 25:3184f71557bf 496 }
ashleymills 25:3184f71557bf 497 return false;
ashleymills 25:3184f71557bf 498 }
ashleymills 25:3184f71557bf 499
ashleymills 25:3184f71557bf 500 USBEndpoint* VodafoneK3772Initializer::getEp(USBDeviceConnected* pDev, int serialPortNumber, bool tx)
ashleymills 25:3184f71557bf 501 {
ashleymills 25:3184f71557bf 502 return pDev->getEndpoint(serialPortNumber, BULK_ENDPOINT, tx?OUT:IN, 0);
ashleymills 25:3184f71557bf 503 }
ashleymills 25:3184f71557bf 504
ashleymills 25:3184f71557bf 505 int VodafoneK3772Initializer::getSerialPortCount()
ashleymills 25:3184f71557bf 506 {
ashleymills 25:3184f71557bf 507 return 2;
ashleymills 25:3184f71557bf 508 }
ashleymills 25:3184f71557bf 509
ashleymills 25:3184f71557bf 510 /*virtual*/ void VodafoneK3772Initializer::setVidPid(uint16_t vid, uint16_t pid)
ashleymills 25:3184f71557bf 511 {
ashleymills 25:3184f71557bf 512 if( (vid == getSerialVid() ) && ( pid == getSerialPid() ) )
ashleymills 25:3184f71557bf 513 {
ashleymills 25:3184f71557bf 514 m_hasSwitched = true;
ashleymills 25:3184f71557bf 515 m_currentSerialIntf = 0;
ashleymills 25:3184f71557bf 516 m_endpointsToFetch = 4;
ashleymills 25:3184f71557bf 517 }
ashleymills 25:3184f71557bf 518 else
ashleymills 25:3184f71557bf 519 {
ashleymills 25:3184f71557bf 520 m_hasSwitched = false;
ashleymills 25:3184f71557bf 521 m_endpointsToFetch = 1;
ashleymills 25:3184f71557bf 522 }
ashleymills 25:3184f71557bf 523 }
ashleymills 25:3184f71557bf 524
ashleymills 25:3184f71557bf 525 /*virtual*/ bool VodafoneK3772Initializer::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
ashleymills 25:3184f71557bf 526 {
ashleymills 25:3184f71557bf 527 if( m_hasSwitched )
ashleymills 25:3184f71557bf 528 {
ashleymills 25:3184f71557bf 529 if( intf_class == 0xFF )
ashleymills 25:3184f71557bf 530 {
ashleymills 25:3184f71557bf 531 if( (m_currentSerialIntf == 0) || (m_currentSerialIntf == 2) )
ashleymills 25:3184f71557bf 532 {
ashleymills 25:3184f71557bf 533 m_currentSerialIntf++;
ashleymills 25:3184f71557bf 534 return true;
ashleymills 25:3184f71557bf 535 }
ashleymills 25:3184f71557bf 536 m_currentSerialIntf++;
ashleymills 25:3184f71557bf 537 }
ashleymills 25:3184f71557bf 538 }
ashleymills 25:3184f71557bf 539 else
ashleymills 25:3184f71557bf 540 {
ashleymills 25:3184f71557bf 541 if( (intf_nb == 0) && (intf_class == MSD_CLASS) )
ashleymills 25:3184f71557bf 542 {
ashleymills 25:3184f71557bf 543 return true;
ashleymills 25:3184f71557bf 544 }
ashleymills 25:3184f71557bf 545 }
ashleymills 25:3184f71557bf 546 return false;
ashleymills 25:3184f71557bf 547 }
ashleymills 25:3184f71557bf 548
ashleymills 25:3184f71557bf 549 /*virtual*/ bool VodafoneK3772Initializer::useEndpoint(uint8_t intf_nb, ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir) //Must return true if the endpoint will be used
ashleymills 25:3184f71557bf 550 {
ashleymills 25:3184f71557bf 551 if( m_hasSwitched )
ashleymills 25:3184f71557bf 552 {
ashleymills 25:3184f71557bf 553 if( (type == BULK_ENDPOINT) && m_endpointsToFetch )
ashleymills 25:3184f71557bf 554 {
ashleymills 25:3184f71557bf 555 m_endpointsToFetch--;
ashleymills 25:3184f71557bf 556 return true;
ashleymills 25:3184f71557bf 557 }
ashleymills 25:3184f71557bf 558 }
ashleymills 25:3184f71557bf 559 else
ashleymills 25:3184f71557bf 560 {
ashleymills 25:3184f71557bf 561 if( (type == BULK_ENDPOINT) && (dir == OUT) && m_endpointsToFetch )
ashleymills 25:3184f71557bf 562 {
ashleymills 25:3184f71557bf 563 m_endpointsToFetch--;
ashleymills 25:3184f71557bf 564 return true;
ashleymills 25:3184f71557bf 565 }
ashleymills 25:3184f71557bf 566 }
ashleymills 25:3184f71557bf 567 return false;
ashleymills 25:3184f71557bf 568 }
ashleymills 25:3184f71557bf 569
ashleymills 25:3184f71557bf 570 /*virtual*/ WAN_DONGLE_TYPE VodafoneK3772Initializer::getType()
ashleymills 25:3184f71557bf 571 {
ashleymills 27:980fe31c14f7 572 return WAN_DONGLE_TYPE_VODAFONE_K3772;
ashleymills 27:980fe31c14f7 573 }
ashleymills 27:980fe31c14f7 574
ashleymills 27:980fe31c14f7 575
ashleymills 27:980fe31c14f7 576 //-----------------------------------------------------------------------
ashleymills 27:980fe31c14f7 577 // mamm, u-blox Modem
ashleymills 27:980fe31c14f7 578 //-----------------------------------------------------------------------
ashleymills 27:980fe31c14f7 579
ashleymills 27:980fe31c14f7 580 UbloxLISAU200Initializer::UbloxLISAU200Initializer(USBHost* pHost) : WANDongleInitializer(pHost)
ashleymills 27:980fe31c14f7 581 {
ashleymills 27:980fe31c14f7 582
ashleymills 27:980fe31c14f7 583 }
ashleymills 27:980fe31c14f7 584
ashleymills 27:980fe31c14f7 585 uint16_t UbloxLISAU200Initializer::getMSDVid() { return 0x1546; }
ashleymills 27:980fe31c14f7 586 uint16_t UbloxLISAU200Initializer::getMSDPid() { return 0x0000; }
ashleymills 27:980fe31c14f7 587
ashleymills 27:980fe31c14f7 588 uint16_t UbloxLISAU200Initializer::getSerialVid() { return 0x1546; }
ashleymills 27:980fe31c14f7 589 uint16_t UbloxLISAU200Initializer::getSerialPid() { return 0x1102; }
ashleymills 27:980fe31c14f7 590
ashleymills 27:980fe31c14f7 591 bool UbloxLISAU200Initializer::switchMode(USBDeviceConnected* pDev)
ashleymills 27:980fe31c14f7 592 {
ashleymills 27:980fe31c14f7 593 for (int i = 0; i < pDev->getNbInterface(); i++)
ashleymills 27:980fe31c14f7 594 {
ashleymills 27:980fe31c14f7 595 if (pDev->getInterface(i)->intf_class == MSD_CLASS)
ashleymills 27:980fe31c14f7 596 {
ashleymills 27:980fe31c14f7 597 USBEndpoint* pEp = pDev->getEndpoint(i, BULK_ENDPOINT, OUT);
ashleymills 27:980fe31c14f7 598 if ( pEp != NULL )
ashleymills 27:980fe31c14f7 599 {
ashleymills 27:980fe31c14f7 600 ERR("MSD descriptor found on device %p, intf %d", (void *)pDev, i);
ashleymills 27:980fe31c14f7 601 }
ashleymills 27:980fe31c14f7 602 }
ashleymills 27:980fe31c14f7 603 }
ashleymills 27:980fe31c14f7 604 return false;
ashleymills 27:980fe31c14f7 605 }
ashleymills 27:980fe31c14f7 606
ashleymills 27:980fe31c14f7 607 USBEndpoint* UbloxLISAU200Initializer::getEp(USBDeviceConnected* pDev, int serialPortNumber, bool tx)
ashleymills 27:980fe31c14f7 608 {
ashleymills 27:980fe31c14f7 609 return pDev->getEndpoint(serialPortNumber, BULK_ENDPOINT, tx?OUT:IN, 0);
ashleymills 27:980fe31c14f7 610 }
ashleymills 27:980fe31c14f7 611
ashleymills 27:980fe31c14f7 612 #define UBX_SERIALCOUNT 7
ashleymills 27:980fe31c14f7 613
ashleymills 27:980fe31c14f7 614 int UbloxLISAU200Initializer::getSerialPortCount()
ashleymills 27:980fe31c14f7 615 {
ashleymills 27:980fe31c14f7 616 return UBX_SERIALCOUNT;
ashleymills 27:980fe31c14f7 617 }
ashleymills 27:980fe31c14f7 618
ashleymills 27:980fe31c14f7 619 /*virtual*/ void UbloxLISAU200Initializer::setVidPid(uint16_t vid, uint16_t pid)
ashleymills 27:980fe31c14f7 620 {
ashleymills 27:980fe31c14f7 621 if( (vid == getSerialVid() ) && ( pid == getSerialPid() ) )
ashleymills 27:980fe31c14f7 622 {
ashleymills 27:980fe31c14f7 623 m_hasSwitched = true;
ashleymills 27:980fe31c14f7 624 m_currentSerialIntf = 0;
ashleymills 27:980fe31c14f7 625 m_endpointsToFetch = UBX_SERIALCOUNT*2;
ashleymills 27:980fe31c14f7 626 }
ashleymills 27:980fe31c14f7 627 else
ashleymills 27:980fe31c14f7 628 {
ashleymills 27:980fe31c14f7 629 m_hasSwitched = false;
ashleymills 27:980fe31c14f7 630 m_endpointsToFetch = 1;
ashleymills 27:980fe31c14f7 631 }
ashleymills 27:980fe31c14f7 632 }
ashleymills 27:980fe31c14f7 633
ashleymills 27:980fe31c14f7 634 /*virtual*/ bool UbloxLISAU200Initializer::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
ashleymills 27:980fe31c14f7 635 {
ashleymills 27:980fe31c14f7 636 if( m_hasSwitched )
ashleymills 27:980fe31c14f7 637 {
ashleymills 27:980fe31c14f7 638 DBG("Interface #%d; Class:%02x; SubClass:%02x; Protocol:%02x", intf_nb, intf_class, intf_subclass, intf_protocol);
ashleymills 27:980fe31c14f7 639 if( intf_class == 0x0A )
ashleymills 27:980fe31c14f7 640 {
ashleymills 27:980fe31c14f7 641 if( (m_currentSerialIntf == 0) || (m_currentSerialIntf == 1) )
ashleymills 27:980fe31c14f7 642 {
ashleymills 27:980fe31c14f7 643 m_currentSerialIntf++;
ashleymills 27:980fe31c14f7 644 return true;
ashleymills 27:980fe31c14f7 645 }
ashleymills 27:980fe31c14f7 646 m_currentSerialIntf++;
ashleymills 27:980fe31c14f7 647 }
ashleymills 27:980fe31c14f7 648 }
ashleymills 27:980fe31c14f7 649 else
ashleymills 27:980fe31c14f7 650 {
ashleymills 27:980fe31c14f7 651 if( (intf_nb == 0) && (intf_class == MSD_CLASS) )
ashleymills 27:980fe31c14f7 652 {
ashleymills 27:980fe31c14f7 653 return true;
ashleymills 27:980fe31c14f7 654 }
ashleymills 27:980fe31c14f7 655 }
ashleymills 27:980fe31c14f7 656 return false;
ashleymills 27:980fe31c14f7 657 }
ashleymills 27:980fe31c14f7 658
ashleymills 27:980fe31c14f7 659 /*virtual*/ bool UbloxLISAU200Initializer::useEndpoint(uint8_t intf_nb, ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir) //Must return true if the endpoint will be used
ashleymills 27:980fe31c14f7 660 {
ashleymills 27:980fe31c14f7 661 if( m_hasSwitched )
ashleymills 27:980fe31c14f7 662 {
ashleymills 27:980fe31c14f7 663 DBG("USBEndpoint on Interface #%d; Type:%d; Direction:%d", intf_nb, type, dir);
ashleymills 27:980fe31c14f7 664 if( (type == BULK_ENDPOINT) && m_endpointsToFetch )
ashleymills 27:980fe31c14f7 665 {
ashleymills 27:980fe31c14f7 666 m_endpointsToFetch--;
ashleymills 27:980fe31c14f7 667 return true;
ashleymills 27:980fe31c14f7 668 }
ashleymills 27:980fe31c14f7 669 }
ashleymills 27:980fe31c14f7 670 else
ashleymills 27:980fe31c14f7 671 {
ashleymills 27:980fe31c14f7 672 if( (type == BULK_ENDPOINT) && (dir == OUT) && m_endpointsToFetch )
ashleymills 27:980fe31c14f7 673 {
ashleymills 27:980fe31c14f7 674 m_endpointsToFetch--;
ashleymills 27:980fe31c14f7 675 return true;
ashleymills 27:980fe31c14f7 676 }
ashleymills 27:980fe31c14f7 677 }
ashleymills 27:980fe31c14f7 678 return false;
ashleymills 27:980fe31c14f7 679 }
ashleymills 27:980fe31c14f7 680
ashleymills 27:980fe31c14f7 681 /*virtual*/ WAN_DONGLE_TYPE UbloxLISAU200Initializer::getType()
ashleymills 27:980fe31c14f7 682 {
ashleymills 27:980fe31c14f7 683 return WAN_DONGLE_TYPE_UBLOX_LISAU200;
ashleymills 25:3184f71557bf 684 }