rndis.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978
  1. /* USB RNDIS tethering driver.
  2. *
  3. * Android phones expose their USB tethering link as an RNDIS function: a
  4. * CDC-style control interface with encapsulated RNDIS commands and a data
  5. * interface with bulk IN/OUT endpoints. The phone is a soft MAC; the host
  6. * sends the RNDIS INIT/QUERY/SET messages, then Ethernet frames travel in
  7. * RNDIS packet messages over the bulk endpoints.
  8. *
  9. * QEMU's usb-net device implements the same protocol, so the driver can be
  10. * exercised without a phone (`make run-rndis`). QEMU uses configuration
  11. * value 2 and class 02/02/FF; Android usually uses E0/01/03 (and some
  12. * devices use an EF class). Both are parsed here.
  13. *
  14. * This is not WiFi: the phone's own WiFi/cellular connection is shared with
  15. * the board over USB, and the kernel sees it as a normal netdev.
  16. */
  17. #include "rndis.h"
  18. #include "io.h"
  19. #include "netdev.h"
  20. #include "serial.h"
  21. #include "timer.h"
  22. #include "usb.h"
  23. /* RNDIS message types. */
  24. #define RNDIS_MSG_PACKET 0x00000001u
  25. #define RNDIS_MSG_INIT 0x00000002u
  26. #define RNDIS_MSG_HALT 0x00000003u
  27. #define RNDIS_MSG_QUERY 0x00000004u
  28. #define RNDIS_MSG_SET 0x00000005u
  29. #define RNDIS_MSG_RESET 0x00000006u
  30. #define RNDIS_MSG_INDICATE 0x00000007u
  31. #define RNDIS_MSG_KEEPALIVE 0x00000008u
  32. #define RNDIS_MSG_COMPLETION 0x80000000u
  33. #define RNDIS_MSG_INIT_C (RNDIS_MSG_INIT | RNDIS_MSG_COMPLETION)
  34. #define RNDIS_MSG_QUERY_C (RNDIS_MSG_QUERY | RNDIS_MSG_COMPLETION)
  35. #define RNDIS_MSG_SET_C (RNDIS_MSG_SET | RNDIS_MSG_COMPLETION)
  36. #define RNDIS_MSG_KEEPALIVE_C (RNDIS_MSG_KEEPALIVE | RNDIS_MSG_COMPLETION)
  37. #define RNDIS_STATUS_SUCCESS 0x00000000u
  38. #define RNDIS_STATUS_MEDIA_CONNECT 0x4001000Bu
  39. #define RNDIS_STATUS_MEDIA_DISCONNECT 0x4001000Cu
  40. /* Information objects used during bring-up. */
  41. #define RNDIS_OID_GEN_CURRENT_PACKET_FILTER 0x0001010Eu
  42. #define RNDIS_OID_GEN_MEDIA_CONNECT_STATUS 0x00010114u
  43. #define RNDIS_OID_802_3_PERMANENT_ADDRESS 0x01010101u
  44. #define RNDIS_OID_802_3_CURRENT_ADDRESS 0x01010102u
  45. /* Packet filter bits. A phone's DHCP and ARP traffic needs broadcast and
  46. * directed frames; multicast keeps DNS/mDNS from disappearing. */
  47. #define RNDIS_PACKET_TYPE_DIRECTED 0x00000001u
  48. #define RNDIS_PACKET_TYPE_MULTICAST 0x00000002u
  49. #define RNDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004u
  50. #define RNDIS_PACKET_TYPE_BROADCAST 0x00000008u
  51. #define RNDIS_PACKET_TYPE_PROMISCUOUS 0x00000020u
  52. #define RNDIS_PACKET_FILTER_DEFAULT \
  53. (RNDIS_PACKET_TYPE_DIRECTED | RNDIS_PACKET_TYPE_MULTICAST | \
  54. RNDIS_PACKET_TYPE_ALL_MULTICAST | RNDIS_PACKET_TYPE_BROADCAST | \
  55. RNDIS_PACKET_TYPE_PROMISCUOUS)
  56. #define RNDIS_INIT_MAX_TRANSFER 2048u
  57. #define RNDIS_RX_MAX 2048u
  58. #define RNDIS_RX_ASSEMBLY 4096u
  59. #define RNDIS_TX_MAX 1600u
  60. #define RNDIS_CTRL_MAX 1025u
  61. #define RNDIS_CFG_MAX 1024u
  62. #define RNDIS_CONTROL_TIMEOUT_MS 200u
  63. #define RNDIS_POLL_MS 20u
  64. /* USB interface classes that identify an RNDIS control function. */
  65. #define RNDIS_CLASS_COMM 0x02u
  66. #define RNDIS_SUBCLASS_ACM 0x02u
  67. #define RNDIS_PROTO_VENDOR 0xFFu
  68. #define RNDIS_CLASS_WIRELESS 0xE0u
  69. #define RNDIS_CLASS_MISC 0xEFu
  70. #define RNDIS_CLASS_DATA 0x0Au
  71. struct rndis_dev {
  72. int present;
  73. int ready;
  74. int link;
  75. unsigned int ctrl, addr, mps, port, config;
  76. int low;
  77. unsigned int ctrl_iface, data_iface;
  78. unsigned int ep_in, ep_in_mps;
  79. unsigned int ep_out, ep_out_mps;
  80. unsigned int ep_int, ep_int_mps;
  81. unsigned char mac[6];
  82. unsigned int max_transfer;
  83. unsigned int align;
  84. unsigned int xid;
  85. unsigned int gen;
  86. unsigned int rx_pos, rx_len;
  87. unsigned int rx_frames, tx_frames, rx_errors, tx_errors;
  88. /* Bulk reads always land in raw_buf; rx_buf is the reassembly
  89. * stream. xHCI arms directly into the caller's buffer, so the read
  90. * buffer must stay at a fixed address while a transfer is pending. */
  91. unsigned char rx_buf[RNDIS_RX_ASSEMBLY] __attribute__((aligned(64)));
  92. unsigned char raw_buf[RNDIS_RX_MAX] __attribute__((aligned(64)));
  93. unsigned char tx_buf[RNDIS_TX_MAX] __attribute__((aligned(64)));
  94. unsigned char ctrl_buf[RNDIS_CTRL_MAX] __attribute__((aligned(64)));
  95. };
  96. static struct rndis_dev dev;
  97. static unsigned char cfg_buf[RNDIS_CFG_MAX] __attribute__((aligned(64)));
  98. /* Small part of the device state needed to undo a probe of an unrelated USB
  99. * device. The USB core calls every device probe for every device, so a
  100. * mouse/keyboard probe after a working phone must not clear its state. */
  101. struct rndis_saved {
  102. int present, ready, link;
  103. unsigned int ctrl, addr, mps, port, config;
  104. int low;
  105. unsigned int ctrl_iface, data_iface;
  106. unsigned int ep_in, ep_in_mps, ep_out, ep_out_mps;
  107. unsigned int ep_int, ep_int_mps;
  108. unsigned char mac[6];
  109. unsigned int max_transfer, align, xid, gen;
  110. unsigned int rx_pos, rx_len;
  111. };
  112. static void rndis_save(struct rndis_saved *s)
  113. {
  114. s->present = dev.present;
  115. s->ready = dev.ready;
  116. s->link = dev.link;
  117. s->ctrl = dev.ctrl;
  118. s->addr = dev.addr;
  119. s->mps = dev.mps;
  120. s->port = dev.port;
  121. s->config = dev.config;
  122. s->low = dev.low;
  123. s->ctrl_iface = dev.ctrl_iface;
  124. s->data_iface = dev.data_iface;
  125. s->ep_in = dev.ep_in;
  126. s->ep_in_mps = dev.ep_in_mps;
  127. s->ep_out = dev.ep_out;
  128. s->ep_out_mps = dev.ep_out_mps;
  129. s->ep_int = dev.ep_int;
  130. s->ep_int_mps = dev.ep_int_mps;
  131. {
  132. unsigned int i;
  133. for (i = 0; i < 6; i++)
  134. s->mac[i] = dev.mac[i];
  135. }
  136. s->max_transfer = dev.max_transfer;
  137. s->align = dev.align;
  138. s->xid = dev.xid;
  139. s->gen = dev.gen;
  140. s->rx_pos = dev.rx_pos;
  141. s->rx_len = dev.rx_len;
  142. }
  143. static void rndis_restore(const struct rndis_saved *s)
  144. {
  145. unsigned int i;
  146. dev.present = s->present;
  147. dev.ready = s->ready;
  148. dev.link = s->link;
  149. dev.ctrl = s->ctrl;
  150. dev.addr = s->addr;
  151. dev.mps = s->mps;
  152. dev.port = s->port;
  153. dev.config = s->config;
  154. dev.low = s->low;
  155. dev.ctrl_iface = s->ctrl_iface;
  156. dev.data_iface = s->data_iface;
  157. dev.ep_in = s->ep_in;
  158. dev.ep_in_mps = s->ep_in_mps;
  159. dev.ep_out = s->ep_out;
  160. dev.ep_out_mps = s->ep_out_mps;
  161. dev.ep_int = s->ep_int;
  162. dev.ep_int_mps = s->ep_int_mps;
  163. for (i = 0; i < 6; i++)
  164. dev.mac[i] = s->mac[i];
  165. dev.max_transfer = s->max_transfer;
  166. dev.align = s->align;
  167. dev.xid = s->xid;
  168. dev.gen = s->gen;
  169. dev.rx_pos = s->rx_pos;
  170. dev.rx_len = s->rx_len;
  171. }
  172. /* A failed probe normally restores the previous phone. If the failed probe
  173. * is for another device on the phone's own root port, the phone was
  174. * unplugged and replaced between hotplug polls, so do not resurrect it. */
  175. static void rndis_restore_after_probe(const struct rndis_saved *saved,
  176. unsigned int ctrl, unsigned int port,
  177. unsigned int gen)
  178. {
  179. if (saved->present && saved->port != 0xFFu &&
  180. saved->ctrl == ctrl && saved->port == port) {
  181. dev.present = 0;
  182. dev.ready = 0;
  183. dev.link = 0;
  184. dev.gen = gen;
  185. return;
  186. }
  187. rndis_restore(saved);
  188. }
  189. static unsigned int rd32le(const unsigned char *p)
  190. {
  191. return (unsigned int)p[0] | ((unsigned int)p[1] << 8) |
  192. ((unsigned int)p[2] << 16) | ((unsigned int)p[3] << 24);
  193. }
  194. static unsigned int rd16le(const unsigned char *p)
  195. {
  196. return (unsigned int)p[0] | ((unsigned int)p[1] << 8);
  197. }
  198. static void wr32le(unsigned char *p, unsigned int v)
  199. {
  200. p[0] = (unsigned char)(v & 0xFF);
  201. p[1] = (unsigned char)((v >> 8) & 0xFF);
  202. p[2] = (unsigned char)((v >> 16) & 0xFF);
  203. p[3] = (unsigned char)((v >> 24) & 0xFF);
  204. }
  205. static void rndis_delay(unsigned int ms)
  206. {
  207. unsigned int t0 = get_ticks_ms();
  208. while (get_ticks_ms() - t0 < ms)
  209. ;
  210. }
  211. static void put_mac_serial(void)
  212. {
  213. static const char hex[] = "0123456789ABCDEF";
  214. unsigned int i;
  215. for (i = 0; i < 6; i++) {
  216. if (i)
  217. serial_putc(SERIAL_COM1, ':');
  218. serial_putc(SERIAL_COM1, hex[(dev.mac[i] >> 4) & 0xF]);
  219. serial_putc(SERIAL_COM1, hex[dev.mac[i] & 0xF]);
  220. }
  221. }
  222. static void put_mac_io(void)
  223. {
  224. static const char hex[] = "0123456789ABCDEF";
  225. unsigned int i;
  226. for (i = 0; i < 6; i++) {
  227. if (i)
  228. io_putchar(':');
  229. io_putchar(hex[(dev.mac[i] >> 4) & 0xF]);
  230. io_putchar(hex[dev.mac[i] & 0xF]);
  231. }
  232. }
  233. static int rndis_ctrl_send(const unsigned char *buf, unsigned int len)
  234. {
  235. int r = usb_control_out_data(dev.ctrl, dev.addr, dev.mps, dev.low,
  236. 0x21, 0x00, 0,
  237. (unsigned short)dev.ctrl_iface,
  238. buf, len);
  239. return r < 0 ? -1 : 0;
  240. }
  241. static int rndis_ctrl_poll(unsigned char *buf, unsigned int len)
  242. {
  243. return usb_control_in(dev.ctrl, dev.addr, dev.mps, dev.low,
  244. 0xA1, 0x01, 0,
  245. (unsigned short)dev.ctrl_iface, buf, len);
  246. }
  247. static void rndis_send_keepalive_c(unsigned int xid)
  248. {
  249. unsigned char msg[16];
  250. wr32le(msg + 0, RNDIS_MSG_KEEPALIVE_C);
  251. wr32le(msg + 4, sizeof(msg));
  252. wr32le(msg + 8, xid);
  253. wr32le(msg + 12, RNDIS_STATUS_SUCCESS);
  254. (void)rndis_ctrl_send(msg, sizeof(msg));
  255. }
  256. /* Wait for the completion of the current request. RNDIS queues responses on
  257. * the control channel; the interrupt endpoint only says "a response is
  258. * available" and is deliberately not required here. */
  259. static int rndis_wait(unsigned int expect)
  260. {
  261. unsigned int tries = RNDIS_CONTROL_TIMEOUT_MS / RNDIS_POLL_MS;
  262. while (tries--) {
  263. int n;
  264. if (dev.port != 0xFFu &&
  265. !usb_port_connected(dev.ctrl, dev.port))
  266. return -1;
  267. n = rndis_ctrl_poll(dev.ctrl_buf, RNDIS_CTRL_MAX);
  268. if (n >= 8) {
  269. unsigned int type = rd32le(dev.ctrl_buf);
  270. if (type == expect && n >= 16 &&
  271. rd32le(dev.ctrl_buf + 8) == dev.xid)
  272. return n;
  273. if (type == RNDIS_MSG_INDICATE && n >= 12) {
  274. unsigned int status = rd32le(dev.ctrl_buf + 8);
  275. if (status == RNDIS_STATUS_MEDIA_CONNECT)
  276. dev.link = 1;
  277. else if (status == RNDIS_STATUS_MEDIA_DISCONNECT)
  278. dev.link = 0;
  279. } else if (type == RNDIS_MSG_KEEPALIVE && n >= 12) {
  280. rndis_send_keepalive_c(rd32le(dev.ctrl_buf + 8));
  281. }
  282. }
  283. rndis_delay(RNDIS_POLL_MS);
  284. }
  285. return -1;
  286. }
  287. static void rndis_send_halt(void)
  288. {
  289. unsigned char msg[12];
  290. wr32le(msg + 0, RNDIS_MSG_HALT);
  291. wr32le(msg + 4, sizeof(msg));
  292. wr32le(msg + 8, 0);
  293. (void)rndis_ctrl_send(msg, sizeof(msg));
  294. }
  295. static int rndis_msg_init(void)
  296. {
  297. int n;
  298. unsigned int status, max_transfer, alignment;
  299. dev.xid++;
  300. if (!dev.xid)
  301. dev.xid++;
  302. for (n = 0; n < (int)24; n++)
  303. dev.ctrl_buf[n] = 0;
  304. wr32le(dev.ctrl_buf + 0, RNDIS_MSG_INIT);
  305. wr32le(dev.ctrl_buf + 4, 24);
  306. wr32le(dev.ctrl_buf + 8, dev.xid);
  307. wr32le(dev.ctrl_buf + 12, 1); /* RNDIS 1.0 */
  308. wr32le(dev.ctrl_buf + 16, 0);
  309. wr32le(dev.ctrl_buf + 20, RNDIS_INIT_MAX_TRANSFER);
  310. if (rndis_ctrl_send(dev.ctrl_buf, 24) < 0)
  311. return -1;
  312. n = rndis_wait(RNDIS_MSG_INIT_C);
  313. if (n < 52)
  314. return -1;
  315. status = rd32le(dev.ctrl_buf + 12);
  316. if (status != RNDIS_STATUS_SUCCESS)
  317. return -1;
  318. max_transfer = rd32le(dev.ctrl_buf + 36);
  319. alignment = rd32le(dev.ctrl_buf + 40);
  320. if (alignment > 3)
  321. alignment = 3;
  322. dev.align = 1u << alignment;
  323. dev.max_transfer = max_transfer;
  324. if (max_transfer && max_transfer < 1558u) {
  325. serial_puts(SERIAL_COM1, "rndis: warning: small max transfer ");
  326. serial_putdec(SERIAL_COM1, max_transfer);
  327. serial_puts(SERIAL_COM1, "\n");
  328. }
  329. return 0;
  330. }
  331. static int rndis_query(unsigned int oid, unsigned int in_len,
  332. unsigned char *out, unsigned int out_max,
  333. unsigned int *out_len)
  334. {
  335. unsigned int len = 28 + in_len;
  336. unsigned int off, rlen;
  337. int n;
  338. if (len > RNDIS_CTRL_MAX)
  339. return -1;
  340. dev.xid++;
  341. if (!dev.xid)
  342. dev.xid++;
  343. for (n = 0; n < (int)len; n++)
  344. dev.ctrl_buf[n] = 0;
  345. wr32le(dev.ctrl_buf + 0, RNDIS_MSG_QUERY);
  346. wr32le(dev.ctrl_buf + 4, len);
  347. wr32le(dev.ctrl_buf + 8, dev.xid);
  348. wr32le(dev.ctrl_buf + 12, oid);
  349. wr32le(dev.ctrl_buf + 16, in_len);
  350. wr32le(dev.ctrl_buf + 20, 20);
  351. wr32le(dev.ctrl_buf + 24, 0);
  352. if (rndis_ctrl_send(dev.ctrl_buf, len) < 0)
  353. return -1;
  354. n = rndis_wait(RNDIS_MSG_QUERY_C);
  355. if (n < 24)
  356. return -1;
  357. if (rd32le(dev.ctrl_buf + 12) != RNDIS_STATUS_SUCCESS)
  358. return -1;
  359. rlen = rd32le(dev.ctrl_buf + 16);
  360. off = rd32le(dev.ctrl_buf + 20);
  361. if (rlen > out_max)
  362. return -1;
  363. if (off > (unsigned int)n || rlen > (unsigned int)n - off ||
  364. 8u + off + rlen > (unsigned int)n)
  365. return -1;
  366. {
  367. unsigned int i;
  368. for (i = 0; i < rlen; i++)
  369. out[i] = dev.ctrl_buf[8 + off + i];
  370. }
  371. *out_len = rlen;
  372. return 0;
  373. }
  374. static int rndis_set_filter(void)
  375. {
  376. unsigned int len = 32;
  377. int n;
  378. for (n = 0; n < (int)len; n++)
  379. dev.ctrl_buf[n] = 0;
  380. wr32le(dev.ctrl_buf + 0, RNDIS_MSG_SET);
  381. wr32le(dev.ctrl_buf + 4, len);
  382. dev.xid++;
  383. if (!dev.xid)
  384. dev.xid++;
  385. wr32le(dev.ctrl_buf + 8, dev.xid);
  386. wr32le(dev.ctrl_buf + 12, RNDIS_OID_GEN_CURRENT_PACKET_FILTER);
  387. wr32le(dev.ctrl_buf + 16, 4);
  388. wr32le(dev.ctrl_buf + 20, 20);
  389. wr32le(dev.ctrl_buf + 24, 0);
  390. wr32le(dev.ctrl_buf + 28, RNDIS_PACKET_FILTER_DEFAULT);
  391. if (rndis_ctrl_send(dev.ctrl_buf, len) < 0)
  392. return -1;
  393. n = rndis_wait(RNDIS_MSG_SET_C);
  394. if (n < 16)
  395. return -1;
  396. return rd32le(dev.ctrl_buf + 12) == RNDIS_STATUS_SUCCESS ? 0 : -1;
  397. }
  398. static int rndis_start(void)
  399. {
  400. unsigned char macbuf[16];
  401. unsigned int mac_len = 0;
  402. unsigned int status = 0;
  403. unsigned int status_len = 0;
  404. unsigned int i;
  405. int mac_ok = 0;
  406. if (!dev.present)
  407. return -1;
  408. if (dev.ready)
  409. return 0;
  410. if (rndis_msg_init() < 0)
  411. goto fail;
  412. if (rndis_query(RNDIS_OID_802_3_PERMANENT_ADDRESS, 48,
  413. macbuf, sizeof(macbuf), &mac_len) == 0 && mac_len >= 6)
  414. mac_ok = 1;
  415. else if (rndis_query(RNDIS_OID_802_3_CURRENT_ADDRESS, 48,
  416. macbuf, sizeof(macbuf), &mac_len) == 0 &&
  417. mac_len >= 6)
  418. mac_ok = 1;
  419. if (!mac_ok)
  420. goto fail;
  421. for (i = 0; i < 6; i++)
  422. dev.mac[i] = macbuf[i];
  423. {
  424. unsigned int zero = 1;
  425. for (i = 0; i < 6; i++)
  426. if (dev.mac[i])
  427. zero = 0;
  428. if (zero)
  429. goto fail;
  430. }
  431. /* A phone with tethering switched off may report "disconnected"; keep
  432. * the link usable and let a later DHCP attempt discover the state. */
  433. if (rndis_query(RNDIS_OID_GEN_MEDIA_CONNECT_STATUS, 4,
  434. (unsigned char *)&status, sizeof(status),
  435. &status_len) == 0 && status_len >= 4)
  436. dev.link = (status == 0);
  437. else
  438. dev.link = 1;
  439. if (rndis_set_filter() < 0)
  440. goto fail;
  441. dev.ready = 1;
  442. dev.rx_pos = dev.rx_len = 0;
  443. serial_puts(SERIAL_COM1, "rndis: ready, MAC ");
  444. put_mac_serial();
  445. serial_puts(SERIAL_COM1, dev.link ? ", link up\n" : ", link down\n");
  446. return 0;
  447. fail:
  448. serial_puts(SERIAL_COM1, "rndis: initialization failed\n");
  449. rndis_send_halt();
  450. dev.ready = 0;
  451. dev.link = 0;
  452. return -1;
  453. }
  454. static int rndis_is_control(unsigned int cls, unsigned int sub,
  455. unsigned int proto)
  456. {
  457. return (cls == RNDIS_CLASS_COMM && sub == RNDIS_SUBCLASS_ACM &&
  458. proto == RNDIS_PROTO_VENDOR) ||
  459. (cls == RNDIS_CLASS_WIRELESS && sub == 0x01 && proto == 0x03) ||
  460. (cls == RNDIS_CLASS_MISC && sub == 0x01 && proto == 0x01) ||
  461. (cls == RNDIS_CLASS_MISC && sub == 0x04 && proto == 0x01);
  462. }
  463. struct rndis_cfg {
  464. unsigned int config;
  465. unsigned int ctrl_iface;
  466. unsigned int data_iface;
  467. unsigned int data_alt;
  468. unsigned int ep_in, ep_in_mps;
  469. unsigned int ep_out, ep_out_mps;
  470. unsigned int ep_int, ep_int_mps;
  471. };
  472. static int rndis_parse_config(unsigned int total, struct rndis_cfg *out)
  473. {
  474. unsigned int i = 0;
  475. unsigned int iface = 0, alt = 0, cls = 0;
  476. unsigned int ctrl_iface = 0, data_iface = 0, data_alt = 0;
  477. unsigned int int_ep = 0, int_mps = 0;
  478. unsigned int in_ep = 0, in_mps = 0, in_alt = 0;
  479. unsigned int out_ep = 0, out_mps = 0, out_alt = 0;
  480. int have_ctrl = 0;
  481. int have_data = 0;
  482. while (i + 2 <= total) {
  483. unsigned int blen = cfg_buf[i];
  484. unsigned int type = cfg_buf[i + 1];
  485. if (blen < 2 || i + blen > total)
  486. break;
  487. if (type == 0x04 && blen >= 9) {
  488. iface = cfg_buf[i + 2];
  489. alt = cfg_buf[i + 3];
  490. cls = cfg_buf[i + 5];
  491. if (alt == 0 && !have_ctrl &&
  492. rndis_is_control(cfg_buf[i + 5], cfg_buf[i + 6],
  493. cfg_buf[i + 7])) {
  494. have_ctrl = 1;
  495. ctrl_iface = iface;
  496. }
  497. if (alt == 0 && cls == RNDIS_CLASS_DATA && !have_data) {
  498. data_iface = iface;
  499. have_data = 1;
  500. }
  501. } else if (type == 0x05 && blen >= 7) {
  502. unsigned int epa = cfg_buf[i + 2];
  503. unsigned int attr = cfg_buf[i + 3] & 3u;
  504. unsigned int mps = rd16le(cfg_buf + i + 4) & 0x7FFu;
  505. if (attr == 2 && (cls == RNDIS_CLASS_DATA ||
  506. iface == ctrl_iface)) {
  507. if (cls == RNDIS_CLASS_DATA && !have_data) {
  508. data_iface = iface;
  509. have_data = 1;
  510. }
  511. if (epa & 0x80) {
  512. if (!in_ep) {
  513. in_ep = epa & 0x0F;
  514. in_mps = mps;
  515. in_alt = alt;
  516. }
  517. } else if (!out_ep) {
  518. out_ep = epa & 0x0F;
  519. out_mps = mps;
  520. out_alt = alt;
  521. }
  522. } else if (attr == 3 && (epa & 0x80) &&
  523. iface == ctrl_iface && !int_ep) {
  524. int_ep = epa & 0x0F;
  525. int_mps = mps;
  526. }
  527. }
  528. i += blen;
  529. }
  530. if (!have_ctrl || !in_ep || !out_ep || !cfg_buf[5])
  531. return 0;
  532. if (in_alt != out_alt)
  533. return 0;
  534. if (!have_data)
  535. data_iface = ctrl_iface;
  536. data_alt = in_alt;
  537. out->config = cfg_buf[5];
  538. out->ctrl_iface = ctrl_iface;
  539. out->data_iface = data_iface;
  540. out->data_alt = data_alt;
  541. out->ep_in = in_ep;
  542. out->ep_in_mps = in_mps ? in_mps : 64;
  543. out->ep_out = out_ep;
  544. out->ep_out_mps = out_mps ? out_mps : 64;
  545. out->ep_int = int_ep;
  546. out->ep_int_mps = int_mps;
  547. return 1;
  548. }
  549. static int rndis_read_config(unsigned int index, unsigned int *total_out)
  550. {
  551. unsigned char hdr[9];
  552. unsigned int total;
  553. int n;
  554. n = usb_control_in(dev.ctrl, dev.addr, dev.mps, dev.low,
  555. 0x80, 0x06, (unsigned short)((2u << 8) | index), 0,
  556. hdr, sizeof(hdr));
  557. if (n < 9 || hdr[1] != 0x02)
  558. return -1;
  559. total = rd16le(hdr + 2);
  560. if (total < 9 || total > RNDIS_CFG_MAX)
  561. return -1;
  562. n = usb_control_in(dev.ctrl, dev.addr, dev.mps, dev.low,
  563. 0x80, 0x06, (unsigned short)((2u << 8) | index), 0,
  564. cfg_buf, total);
  565. if (n < 9 || cfg_buf[1] != 0x02)
  566. return -1;
  567. if ((unsigned int)n < total)
  568. total = (unsigned int)n;
  569. *total_out = total;
  570. return 0;
  571. }
  572. static int rndis_choose_config(void)
  573. {
  574. unsigned char desc[18];
  575. unsigned int ncfg, i;
  576. int n;
  577. n = usb_control_in(dev.ctrl, dev.addr, dev.mps, dev.low,
  578. 0x80, 0x06, (unsigned short)(1u << 8), 0,
  579. desc, sizeof(desc));
  580. if (n < 18)
  581. return -1;
  582. ncfg = desc[17];
  583. if (!ncfg)
  584. ncfg = 1;
  585. if (ncfg > 8)
  586. ncfg = 8;
  587. for (i = 0; i < ncfg; i++) {
  588. struct rndis_cfg cfg;
  589. unsigned int total;
  590. if (rndis_read_config(i, &total) < 0)
  591. continue;
  592. if (!rndis_parse_config(total, &cfg))
  593. continue;
  594. if (usb_control_out(dev.ctrl, dev.addr, dev.mps, dev.low,
  595. 0x00, 0x09,
  596. (unsigned short)cfg.config, 0) < 0)
  597. continue;
  598. rndis_delay(10);
  599. if (cfg.data_alt != 0 &&
  600. usb_control_out(dev.ctrl, dev.addr, dev.mps, dev.low,
  601. 0x01, 0x0B,
  602. (unsigned short)cfg.data_alt,
  603. (unsigned short)cfg.data_iface) < 0)
  604. continue;
  605. dev.config = cfg.config;
  606. dev.ctrl_iface = cfg.ctrl_iface;
  607. dev.data_iface = cfg.data_iface;
  608. dev.ep_in = cfg.ep_in;
  609. dev.ep_in_mps = cfg.ep_in_mps;
  610. dev.ep_out = cfg.ep_out;
  611. dev.ep_out_mps = cfg.ep_out_mps;
  612. dev.ep_int = cfg.ep_int;
  613. dev.ep_int_mps = cfg.ep_int_mps;
  614. serial_puts(SERIAL_COM1, "rndis: config ");
  615. serial_putdec(SERIAL_COM1, dev.config);
  616. serial_puts(SERIAL_COM1, ", iface ");
  617. serial_putdec(SERIAL_COM1, dev.ctrl_iface);
  618. serial_puts(SERIAL_COM1, "/");
  619. serial_putdec(SERIAL_COM1, dev.data_iface);
  620. serial_puts(SERIAL_COM1, ", ep ");
  621. serial_putdec(SERIAL_COM1, dev.ep_in);
  622. serial_puts(SERIAL_COM1, "/");
  623. serial_putdec(SERIAL_COM1, dev.ep_out);
  624. serial_puts(SERIAL_COM1, "\n");
  625. return 0;
  626. }
  627. return -1;
  628. }
  629. static void rndis_check(void)
  630. {
  631. if (!dev.present)
  632. return;
  633. if (dev.gen != usb_generation() ||
  634. (dev.port != 0xFFu && !usb_port_connected(dev.ctrl, dev.port))) {
  635. dev.present = 0;
  636. dev.ready = 0;
  637. dev.link = 0;
  638. }
  639. }
  640. static int net_init(void)
  641. {
  642. rndis_check();
  643. if (!dev.present)
  644. return -1;
  645. if (dev.ready)
  646. return 0;
  647. return rndis_start();
  648. }
  649. static void net_get_mac(unsigned char mac[6])
  650. {
  651. unsigned int i;
  652. for (i = 0; i < 6; i++)
  653. mac[i] = dev.mac[i];
  654. }
  655. static int net_rx(unsigned char *buf, unsigned int maxlen)
  656. {
  657. rndis_check();
  658. if (!dev.present || !dev.ready)
  659. return -1;
  660. for (;;) {
  661. /* Parse every complete message in the current chunk. */
  662. while (dev.rx_pos + 44 <= dev.rx_len) {
  663. unsigned int msg_type = rd32le(dev.rx_buf + dev.rx_pos);
  664. unsigned int msg_len = rd32le(dev.rx_buf + dev.rx_pos + 4);
  665. unsigned int data_off, data_len, advance, data_pos, i;
  666. if (msg_type != RNDIS_MSG_PACKET ||
  667. msg_len < 44 || msg_len > RNDIS_RX_MAX) {
  668. dev.rx_pos = dev.rx_len;
  669. dev.rx_errors++;
  670. return -1;
  671. }
  672. /* A message split across bulk transfers: keep the
  673. * tail and append the next transfer. */
  674. if (msg_len > dev.rx_len - dev.rx_pos)
  675. break;
  676. data_off = rd32le(dev.rx_buf + dev.rx_pos + 8);
  677. data_len = rd32le(dev.rx_buf + dev.rx_pos + 12);
  678. advance = msg_len;
  679. if (dev.align > 1)
  680. advance = (advance + dev.align - 1) &
  681. ~(dev.align - 1);
  682. if (data_len > msg_len || data_off > msg_len - data_len ||
  683. msg_len - data_len - data_off < 8) {
  684. dev.rx_pos += advance;
  685. if (dev.rx_pos > dev.rx_len)
  686. dev.rx_pos = dev.rx_len;
  687. dev.rx_errors++;
  688. continue;
  689. }
  690. data_pos = dev.rx_pos + 8 + data_off;
  691. dev.rx_pos += advance;
  692. if (dev.rx_pos > dev.rx_len)
  693. dev.rx_pos = dev.rx_len;
  694. if (data_len > maxlen || data_len < 14) {
  695. dev.rx_errors++;
  696. continue;
  697. }
  698. for (i = 0; i < data_len; i++)
  699. buf[i] = dev.rx_buf[data_pos + i];
  700. dev.rx_frames++;
  701. return (int)data_len;
  702. }
  703. /* Move an incomplete message to the start and append more
  704. * bytes from the next bulk transfer. */
  705. if (dev.rx_pos > 0) {
  706. unsigned int rem;
  707. if (dev.rx_pos > dev.rx_len) {
  708. dev.rx_pos = dev.rx_len = 0;
  709. } else {
  710. rem = dev.rx_len - dev.rx_pos;
  711. {
  712. unsigned int i;
  713. for (i = 0; i < rem; i++)
  714. dev.rx_buf[i] =
  715. dev.rx_buf[dev.rx_pos + i];
  716. }
  717. dev.rx_pos = 0;
  718. dev.rx_len = rem;
  719. }
  720. }
  721. if (dev.rx_len >= sizeof(dev.rx_buf)) {
  722. dev.rx_pos = dev.rx_len = 0;
  723. dev.rx_errors++;
  724. return -1;
  725. }
  726. {
  727. int n = usb_bulk_in(dev.ctrl, dev.addr, dev.ep_in,
  728. dev.ep_in_mps, dev.raw_buf,
  729. sizeof(dev.raw_buf));
  730. unsigned int i;
  731. if (n <= 0)
  732. return -1;
  733. if (dev.rx_len + (unsigned int)n > sizeof(dev.rx_buf)) {
  734. dev.rx_pos = dev.rx_len = 0;
  735. dev.rx_errors++;
  736. return -1;
  737. }
  738. for (i = 0; i < (unsigned int)n; i++)
  739. dev.rx_buf[dev.rx_len + i] = dev.raw_buf[i];
  740. dev.rx_len += (unsigned int)n;
  741. }
  742. }
  743. }
  744. static int net_tx(const unsigned char *buf, unsigned int len)
  745. {
  746. unsigned int i;
  747. rndis_check();
  748. if (!dev.present || !dev.ready || len > 1514)
  749. return -1;
  750. if (dev.max_transfer && 44 + len > dev.max_transfer)
  751. return -1;
  752. for (i = 0; i < 44; i++)
  753. dev.tx_buf[i] = 0;
  754. wr32le(dev.tx_buf + 0, RNDIS_MSG_PACKET);
  755. wr32le(dev.tx_buf + 4, 44 + len);
  756. wr32le(dev.tx_buf + 8, 36); /* offset from the 8-byte prefix */
  757. wr32le(dev.tx_buf + 12, len);
  758. for (i = 0; i < len; i++)
  759. dev.tx_buf[44 + i] = buf[i];
  760. if (usb_bulk_out(dev.ctrl, dev.addr, dev.ep_out, dev.ep_out_mps,
  761. dev.tx_buf, 44 + len) != 0) {
  762. dev.tx_errors++;
  763. return -1;
  764. }
  765. dev.tx_frames++;
  766. return 0;
  767. }
  768. static void net_print_info(void)
  769. {
  770. rndis_check();
  771. io_putstr("Android USB tethering (RNDIS)\n");
  772. io_putstr(" MAC ");
  773. put_mac_io();
  774. io_putstr("\n");
  775. if (!dev.present) {
  776. io_putstr(" not attached\n");
  777. return;
  778. }
  779. if (!dev.ready)
  780. io_putstr(" RNDIS not initialized\n");
  781. else if (dev.link)
  782. io_putstr(" link up (DHCP)\n");
  783. else
  784. io_putstr(" link down (enable USB tethering on the phone)\n");
  785. }
  786. static void net_reset(void)
  787. {
  788. dev.ready = 0;
  789. dev.link = 0;
  790. dev.rx_pos = dev.rx_len = 0;
  791. if (!dev.present)
  792. return;
  793. rndis_send_halt();
  794. if (rndis_choose_config() < 0) {
  795. dev.present = 0;
  796. dev.ready = 0;
  797. dev.link = 0;
  798. return;
  799. }
  800. (void)rndis_start();
  801. }
  802. static void net_stop(void)
  803. {
  804. dev.ready = 0;
  805. dev.link = 0;
  806. dev.rx_pos = dev.rx_len = 0;
  807. }
  808. const struct netdev rndis_netdev = {
  809. "rndis",
  810. "Android USB tethering (RNDIS)",
  811. net_init,
  812. net_get_mac,
  813. net_rx,
  814. net_tx,
  815. net_print_info,
  816. 0,
  817. 0,
  818. net_reset,
  819. 0,
  820. 0,
  821. 0,
  822. 0,
  823. 0,
  824. net_stop,
  825. 0,
  826. };
  827. static int device_probe(unsigned int ctrl, unsigned int addr,
  828. unsigned int mps, int low_speed, unsigned int port,
  829. unsigned int vendor, unsigned int product)
  830. {
  831. struct rndis_saved saved;
  832. unsigned int gen = usb_generation();
  833. int was_ready = dev.ready;
  834. (void)vendor;
  835. (void)product;
  836. if (!usb_bulk_supported(ctrl))
  837. return 0;
  838. /* A probe runs for every USB device, not just ours. Save the current
  839. * phone state and put it back if this device is not an RNDIS
  840. * function. Do not clear an old ready state on a generation change
  841. * here: a full scan may probe a mouse before the phone. */
  842. rndis_save(&saved);
  843. dev.ctrl = ctrl;
  844. dev.addr = addr;
  845. dev.mps = mps;
  846. dev.low = low_speed;
  847. dev.port = port;
  848. dev.config = 0;
  849. dev.ready = 0;
  850. dev.link = 0;
  851. dev.rx_pos = dev.rx_len = 0;
  852. dev.xid = 0;
  853. dev.present = 1;
  854. if (rndis_choose_config() < 0) {
  855. rndis_restore_after_probe(&saved, ctrl, port, gen);
  856. return 0;
  857. }
  858. /* Do not run the RNDIS control handshake for a fresh boot-time probe:
  859. * an Ethernet NIC may be the active link. If the phone was already
  860. * ready before this scan, re-establish it now (a full `lsusb` scan
  861. * resets the device configuration). */
  862. dev.gen = gen;
  863. if (was_ready) {
  864. if (rndis_start() < 0 && saved.present &&
  865. (saved.ctrl != ctrl || saved.port != port ||
  866. saved.addr != addr)) {
  867. rndis_restore(&saved);
  868. return 0;
  869. }
  870. }
  871. netdev_hotplug();
  872. return 1;
  873. }
  874. void rndis_register(void)
  875. {
  876. usb_register_device_probe(device_probe);
  877. }