visus
/
teensy-cores
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
374 Commits
1 Branch
Tree: 12c5d4972d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '12c5d4972d'
${ noResults }
teensy-cores/usb_serial_hid/usb_api.cpp

916 lines
24KB
Raw Blame History 

  1. /* USB API for Teensy USB Development Board

  2.  * http://www.pjrc.com/teensy/teensyduino.html

  3.  * Copyright (c) 2008 PJRC.COM, LLC

  4.  * 

  5.  * Permission is hereby granted, free of charge, to any person obtaining a copy

  6.  * of this software and associated documentation files (the "Software"), to deal

  7.  * in the Software without restriction, including without limitation the rights

  8.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  9.  * copies of the Software, and to permit persons to whom the Software is

  10.  * furnished to do so, subject to the following conditions:

  11.  * 

  12.  * The above copyright notice and this permission notice shall be included in

  13.  * all copies or substantial portions of the Software.

  14.  * 

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  18.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  20.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  21.  * THE SOFTWARE.

  22.  */

  23. 

  24. #include <avr/io.h>

  25. #include <stdint.h>

  26. #include "usb_common.h"

  27. #include "usb_private.h"

  28. #include "usb_api.h"

  29. #include "wiring.h"

  30. 

  31. // Public Methods //////////////////////////////////////////////////////////////

  32. 

  33. void usb_serial_class::begin(long speed)

  34. {

  35. 	// make sure USB is initialized

  36. 	peek_buf = -1;

  37. 	usb_init();

  38. 	uint16_t begin_wait = (uint16_t)millis();

  39. 	while (1) {

  40. 		// wait for the host to finish enumeration

  41. 		if (usb_configuration) {

  42. 			delay(200);  // a little time for host to load a driver

  43. 			return;

  44. 		}

  45. 		// or for suspend mode (powered without USB)

  46. 		if (usb_suspended) {

  47. 			uint16_t begin_suspend = (uint16_t)millis();

  48. 			while (usb_suspended) {

  49. 				// must remain suspended for a while, because

  50. 				// normal USB enumeration causes brief suspend

  51. 				// states, typically under 0.1 second

  52. 				if ((uint16_t)millis() - begin_suspend > 250) {

  53. 					return;

  54. 				}

  55. 			}

  56. 		}

  57. 		// ... or a timout (powered by a USB power adaptor that

  58. 		// wiggles the data lines to keep a USB device charging)

  59. 		if ((uint16_t)millis() - begin_wait > 2500) return;

  60. 	}

  61. }

  62. 

  63. void usb_serial_class::end()

  64. {

  65. 	usb_shutdown();

  66. 	delay(25);

  67. }

  68. 

  69. // number of bytes available in the receive buffer

  70. int usb_serial_class::available()

  71. {

  72.         uint8_t n=0, i, intr_state;

  73. 

  74.         intr_state = SREG;

  75.         cli();

  76.         if (usb_configuration) {

  77.                 UENUM = CDC_RX_ENDPOINT;

  78.                 n = UEBCLX;

  79. 		if (!n) {

  80. 			i = UEINTX;

  81. 			if (i & (1<<RXOUTI) && !(i & (1<<RWAL))) UEINTX = 0x6B;

  82. 		}

  83.         }

  84.         SREG = intr_state;

  85. 	if (peek_buf >= 0 && n < 255) n++;

  86.         return n;

  87. }

  88. 

  89. int usb_serial_class::peek()

  90. {

  91. 	if (peek_buf < 0) peek_buf = read();

  92. 	return peek_buf;

  93. }

  94. 

  95. // get the next character, or -1 if nothing received

  96. int usb_serial_class::read(void)

  97. {

  98.         uint8_t c, intr_state;

  99. 

  100. 	if (peek_buf >= 0) {

  101. 		c = peek_buf;

  102. 		peek_buf = -1;

  103. 		return c;

  104. 	}

  105.         // interrupts are disabled so these functions can be

  106.         // used from the main program or interrupt context,

  107.         // even both in the same program!

  108.         intr_state = SREG;

  109.         cli();

  110.         if (!usb_configuration) {

  111.                 SREG = intr_state;

  112.                 return -1;

  113.         }

  114.         UENUM = CDC_RX_ENDPOINT;

  115. 	retry:

  116. 	c = UEINTX;

  117.         if (!(c & (1<<RWAL))) {

  118.                 // no data in buffer

  119. 		if (c & (1<<RXOUTI)) {

  120. 			UEINTX = 0x6B;

  121. 			goto retry;

  122. 		}

  123.                 SREG = intr_state;

  124.                 return -1;

  125.         }

  126.         // take one byte out of the buffer

  127.         c = UEDATX;

  128.         // if this drained the buffer, release it

  129.         if (!(UEINTX & (1<<RWAL))) UEINTX = 0x6B;

  130.         SREG = intr_state;

  131.         return c;

  132. }

  133. 

  134. // discard any buffered input

  135. void usb_serial_class::flush()

  136. {

  137.         uint8_t intr_state;

  138. 

  139.         if (usb_configuration) {

  140.                 intr_state = SREG;

  141.                 cli();

  142.                 UENUM = CDC_RX_ENDPOINT;

  143.                 while ((UEINTX & (1<<RWAL))) {

  144.                         UEINTX = 0x6B;

  145.                 }

  146.                 SREG = intr_state;

  147.         }

  148. 	peek_buf = -1;

  149. }

  150. #if 0

  151. // transmit a character.

  152. void usb_serial_class::write(uint8_t c)

  153. {

  154.         uint8_t timeout, intr_state;

  155. 

  156.         // if we're not online (enumerated and configured), error

  157.         if (!usb_configuration) return;

  158.         // interrupts are disabled so these functions can be

  159.         // used from the main program or interrupt context,

  160.         // even both in the same program!

  161.         intr_state = SREG;

  162.         cli();

  163.         UENUM = CDC_TX_ENDPOINT;

  164.         // if we gave up due to timeout before, don't wait again

  165.         if (transmit_previous_timeout) {

  166.                 if (!(UEINTX & (1<<RWAL))) {

  167.                         SREG = intr_state;

  168.                         return;

  169.                 }

  170.                 transmit_previous_timeout = 0;

  171.         }

  172.         // wait for the FIFO to be ready to accept data

  173.         timeout = UDFNUML + TRANSMIT_TIMEOUT;

  174.         while (1) {

  175.                 // are we ready to transmit?

  176.                 if (UEINTX & (1<<RWAL)) break;

  177.                 SREG = intr_state;

  178.                 // have we waited too long?  This happens if the user

  179.                 // is not running an application that is listening

  180.                 if (UDFNUML == timeout) {

  181.                         transmit_previous_timeout = 1;

  182.                         return;

  183.                 }

  184.                 // has the USB gone offline?

  185.                 if (!usb_configuration) return;

  186.                 // get ready to try checking again

  187.                 intr_state = SREG;

  188.                 cli();

  189.                 UENUM = CDC_TX_ENDPOINT;

  190.         }

  191.         // actually write the byte into the FIFO

  192.         UEDATX = c;

  193.         // if this completed a packet, transmit it now!

  194.         if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;

  195.         transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;

  196.         SREG = intr_state;

  197. }

  198. #endif

  199. 

  200. 

  201. // transmit a block of data

  202. size_t usb_serial_class::write(const uint8_t *buffer, uint16_t size)

  203. {

  204. 	uint8_t timeout, intr_state, write_size;

  205. 	size_t count=0;

  206. 

  207. 	// if we're not online (enumerated and configured), error

  208. 	if (!usb_configuration) {

  209. 		setWriteError();

  210. 		goto end;

  211. 	}

  212. 	// interrupts are disabled so these functions can be

  213. 	// used from the main program or interrupt context,

  214. 	// even both in the same program!

  215. 	intr_state = SREG;

  216. 	cli();

  217. 	UENUM = CDC_TX_ENDPOINT;

  218. 	// if we gave up due to timeout before, don't wait again

  219. 	if (transmit_previous_timeout) {

  220. 		if (!(UEINTX & (1<<RWAL))) {

  221. 			SREG = intr_state;

  222. 			setWriteError();

  223. 			goto end;

  224. 		}

  225. 		transmit_previous_timeout = 0;

  226. 	}

  227. 	// each iteration of this loop transmits a packet

  228. 	while (size) {

  229. 		// wait for the FIFO to be ready to accept data

  230. 		timeout = UDFNUML + TRANSMIT_TIMEOUT;

  231. 		while (1) {

  232. 			// are we ready to transmit?

  233. 			if (UEINTX & (1<<RWAL)) break;

  234. 			SREG = intr_state;

  235. 			// have we waited too long?  This happens if the user

  236. 			// is not running an application that is listening

  237. 			if (UDFNUML == timeout) {

  238. 				transmit_previous_timeout = 1;

  239. 				setWriteError();

  240. 				goto end;

  241. 			}

  242. 			// has the USB gone offline?

  243. 			if (!usb_configuration) {

  244. 				setWriteError();

  245. 				goto end;

  246. 			}

  247. 			// get ready to try checking again

  248. 			intr_state = SREG;

  249. 			cli();

  250. 			UENUM = CDC_TX_ENDPOINT;

  251. 		}

  252. 

  253. 		// compute how many bytes will fit into the next packet

  254. 		write_size = CDC_TX_SIZE - UEBCLX;

  255. 		if (write_size > size) write_size = size;

  256. 		size -= write_size;

  257. 		count += write_size;

  258. 

  259. #define ASM_COPY1(src, dest, tmp) "ld " tmp ", " src "\n\t" "st " dest ", " tmp "\n\t"

  260. #define ASM_COPY2(src, dest, tmp) ASM_COPY1(src, dest, tmp) ASM_COPY1(src, dest, tmp)

  261. #define ASM_COPY4(src, dest, tmp) ASM_COPY2(src, dest, tmp) ASM_COPY2(src, dest, tmp)

  262. #define ASM_COPY8(src, dest, tmp) ASM_COPY4(src, dest, tmp) ASM_COPY4(src, dest, tmp)

  263. 

  264. #if 1

  265. 		// write the packet

  266. 		do {

  267. 			uint8_t tmp;

  268. 			asm volatile(

  269. 			"L%=begin:"					"\n\t"

  270. 				"ldi	r30, %4"			"\n\t"

  271. 				"sub	r30, %3"			"\n\t"

  272. 				"cpi	r30, %4"			"\n\t"

  273. 				"brsh	L%=err"				"\n\t"

  274. 				"lsl	r30"				"\n\t"

  275. 				"clr	r31"				"\n\t"

  276. 				"subi	r30, lo8(-(pm(L%=table)))"	"\n\t"

  277. 				"sbci	r31, hi8(-(pm(L%=table)))"	"\n\t"

  278. 				"ijmp"					"\n\t"

  279. 			"L%=err:"					"\n\t"

  280. 				"rjmp	L%=end"				"\n\t"

  281. 			"L%=table:"					"\n\t"

  282. 				#if (CDC_TX_SIZE == 64)

  283. 				ASM_COPY8("Y+", "X", "%1")

  284. 				ASM_COPY8("Y+", "X", "%1")

  285. 				ASM_COPY8("Y+", "X", "%1")

  286. 				ASM_COPY8("Y+", "X", "%1")

  287. 				#endif

  288. 				#if (CDC_TX_SIZE >= 32)

  289. 				ASM_COPY8("Y+", "X", "%1")

  290. 				ASM_COPY8("Y+", "X", "%1")

  291. 				#endif

  292. 				#if (CDC_TX_SIZE >= 16)

  293. 				ASM_COPY8("Y+", "X", "%1")

  294. 				#endif

  295. 				ASM_COPY8("Y+", "X", "%1")

  296. 			"L%=end:"					"\n\t"

  297. 				: "+y" (buffer), "=r" (tmp)

  298. 				: "x" (&UEDATX), "r" (write_size), "M" (CDC_TX_SIZE)

  299. 				: "r30", "r31"

  300. 			);

  301. 		} while (0);

  302. #endif

  303. 		// if this completed a packet, transmit it now!

  304. 		if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;

  305. 		transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;

  306. 	}

  307. 	SREG = intr_state;

  308. end:

  309. 	return count;

  310. }

  311. 

  312. // transmit a string

  313. /*

  314. void usb_serial_class::write(const char *str)

  315. {

  316. 	uint16_t size=0;

  317. 	const char *p=str;

  318. 

  319. 	while (*p++) size++;

  320. 	if (size) write((const uint8_t *)str, size);

  321. }

  322. */

  323. 

  324. // These are Teensy-specific extensions to the Serial object

  325. 

  326. // immediately transmit any buffered output.

  327. // This doesn't actually transmit the data - that is impossible!

  328. // USB devices only transmit when the host allows, so the best

  329. // we can do is release the FIFO buffer for when the host wants it

  330. void usb_serial_class::send_now(void)

  331. {

  332.         uint8_t intr_state;

  333. 

  334.         intr_state = SREG;

  335.         cli();

  336.         if (usb_configuration && transmit_flush_timer) {

  337.                 UENUM = CDC_TX_ENDPOINT;

  338.                 UEINTX = 0x3A;

  339.                 transmit_flush_timer = 0;

  340.         }

  341.         SREG = intr_state;

  342. }

  343. 

  344. uint32_t usb_serial_class::baud(void)

  345. {

  346. 	return *(uint32_t *)cdc_line_coding;

  347. }

  348. 

  349. uint8_t usb_serial_class::stopbits(void)

  350. {

  351. 	return cdc_line_coding[4];

  352. }

  353. 

  354. uint8_t usb_serial_class::paritytype(void)

  355. {

  356. 	return cdc_line_coding[5];

  357. }

  358. 

  359. uint8_t usb_serial_class::numbits(void)

  360. {

  361. 	return cdc_line_coding[6];

  362. }

  363. 

  364. uint8_t usb_serial_class::dtr(void)

  365. {

  366. 	return (cdc_line_rtsdtr & USB_SERIAL_DTR) ? 1 : 0;

  367. }

  368. 

  369. uint8_t usb_serial_class::rts(void)

  370. {

  371. 	return (cdc_line_rtsdtr & USB_SERIAL_RTS) ? 1 : 0;

  372. }

  373. 

  374. usb_serial_class::operator bool()

  375. {

  376. 	if (usb_configuration &&

  377. 	  (cdc_line_rtsdtr & (USB_SERIAL_DTR | USB_SERIAL_RTS))) {

  378. 		return true;

  379. 	}

  380. 	return false;

  381. }

  382. 

  383. 

  384. 

  385. 

  386. // Step #1, decode UTF8 to Unicode code points

  387. //

  388. size_t usb_keyboard_class::write(uint8_t c)

  389. {

  390. 	if (c < 0x80) {

  391. 		// single byte encoded, 0x00 to 0x7F

  392. 		utf8_state = 0;

  393. 		write_unicode(c);

  394. 	} else if (c < 0xC0) {

  395. 		// 2nd, 3rd or 4th byte, 0x80 to 0xBF

  396. 		c &= 0x3F;

  397. 		if (utf8_state == 1) {

  398. 			utf8_state = 0;

  399. 			write_unicode(unicode_wchar | c);

  400. 		} else if (utf8_state == 2) {

  401. 			unicode_wchar |= ((uint16_t)c << 6);

  402. 			utf8_state = 1;

  403. 		}

  404. 	} else if (c < 0xE0) {

  405. 		// begin 2 byte sequence, 0xC2 to 0xDF

  406. 		// or illegal 2 byte sequence, 0xC0 to 0xC1

  407. 		unicode_wchar = (uint16_t)(c & 0x1F) << 6;

  408. 		utf8_state = 1;

  409. 	} else if (c < 0xF0) {

  410. 		// begin 3 byte sequence, 0xE0 to 0xEF

  411. 		unicode_wchar = (uint16_t)(c & 0x0F) << 12;

  412. 		utf8_state = 2;

  413. 	} else {

  414. 		// begin 4 byte sequence (not supported), 0xF0 to 0xF4

  415. 		// or illegal, 0xF5 to 0xFF

  416. 		utf8_state = 255;

  417. 	}

  418. 	return 1;

  419. }

  420. 

  421. 

  422. // Step #2: translate Unicode code point to keystroke sequence

  423. //

  424. KEYCODE_TYPE usb_keyboard_class::unicode_to_keycode(uint16_t cpoint)

  425. {

  426. 	// Unicode code points beyond U+FFFF are not supported

  427. 	// technically this input should probably be called UCS-2

  428. 	if (cpoint < 32) {

  429. 		if (cpoint == 10) return KEY_ENTER & KEYCODE_MASK;

  430. 		if (cpoint == 11) return KEY_TAB & KEYCODE_MASK;

  431. 		return 0;

  432. 	}

  433. 	if (cpoint < 128) {

  434. 		if (sizeof(KEYCODE_TYPE) == 1) {

  435. 			return pgm_read_byte(keycodes_ascii + (cpoint - 0x20));

  436. 		} else if (sizeof(KEYCODE_TYPE) == 2) {

  437. 			return pgm_read_word(keycodes_ascii + (cpoint - 0x20));

  438. 		}

  439. 		return 0;

  440. 	}

  441. 	#ifdef ISO_8859_1_A0

  442. 	if (cpoint <= 0xA0) return 0;

  443. 	if (cpoint < 0x100) {

  444. 		if (sizeof(KEYCODE_TYPE) == 1) {

  445. 			return pgm_read_byte(keycodes_iso_8859_1 + (cpoint - 0xA0));

  446. 		} else if (sizeof(KEYCODE_TYPE) == 2) {

  447. 			return pgm_read_word(keycodes_iso_8859_1 + (cpoint - 0xA0));

  448. 		}

  449. 		return 0;

  450. 	}

  451. 	#endif

  452. 	//#ifdef UNICODE_20AC

  453. 	//if (cpoint == 0x20AC) return UNICODE_20AC & 0x3FFF;

  454. 	//#endif

  455. 	#ifdef KEYCODE_EXTRA00

  456. 	if (cpoint == UNICODE_EXTRA00) return KEYCODE_EXTRA00 & 0x3FFF;

  457. 	#endif

  458. 	#ifdef KEYCODE_EXTRA01

  459. 	if (cpoint == UNICODE_EXTRA01) return KEYCODE_EXTRA01 & 0x3FFF;

  460. 	#endif

  461. 	#ifdef KEYCODE_EXTRA02

  462. 	if (cpoint == UNICODE_EXTRA02) return KEYCODE_EXTRA02 & 0x3FFF;

  463. 	#endif

  464. 	#ifdef KEYCODE_EXTRA03

  465. 	if (cpoint == UNICODE_EXTRA03) return KEYCODE_EXTRA03 & 0x3FFF;

  466. 	#endif

  467. 	#ifdef KEYCODE_EXTRA04

  468. 	if (cpoint == UNICODE_EXTRA04) return KEYCODE_EXTRA04 & 0x3FFF;

  469. 	#endif

  470. 	#ifdef KEYCODE_EXTRA05

  471. 	if (cpoint == UNICODE_EXTRA05) return KEYCODE_EXTRA05 & 0x3FFF;

  472. 	#endif

  473. 	#ifdef KEYCODE_EXTRA06

  474. 	if (cpoint == UNICODE_EXTRA06) return KEYCODE_EXTRA06 & 0x3FFF;

  475. 	#endif

  476. 	#ifdef KEYCODE_EXTRA07

  477. 	if (cpoint == UNICODE_EXTRA07) return KEYCODE_EXTRA07 & 0x3FFF;

  478. 	#endif

  479. 	#ifdef KEYCODE_EXTRA08

  480. 	if (cpoint == UNICODE_EXTRA08) return KEYCODE_EXTRA08 & 0x3FFF;

  481. 	#endif

  482. 	#ifdef KEYCODE_EXTRA09

  483. 	if (cpoint == UNICODE_EXTRA09) return KEYCODE_EXTRA09 & 0x3FFF;

  484. 	#endif

  485. 	return 0;

  486. }

  487. 

  488. // Step #3: execute keystroke sequence

  489. //

  490. void usb_keyboard_class::write_keycode(KEYCODE_TYPE keycode)

  491. {

  492. 	if (!keycode) return;

  493. 	#ifdef DEADKEYS_MASK

  494. 	KEYCODE_TYPE deadkeycode = deadkey_to_keycode(keycode);

  495. 	if (deadkeycode) write_key(deadkeycode);

  496. 	#endif

  497. 	write_key(keycode);

  498. }

  499. 

  500. KEYCODE_TYPE usb_keyboard_class::deadkey_to_keycode(KEYCODE_TYPE keycode)

  501. {

  502. 	#ifdef DEADKEYS_MASK

  503. 	keycode &= DEADKEYS_MASK;

  504. 	if (keycode == 0) return 0;

  505. 	#ifdef ACUTE_ACCENT_BITS

  506. 	if (keycode == ACUTE_ACCENT_BITS) return DEADKEY_ACUTE_ACCENT;

  507. 	#endif

  508. 	#ifdef CEDILLA_BITS

  509. 	if (keycode == CEDILLA_BITS) return DEADKEY_CEDILLA;

  510. 	#endif

  511. 	#ifdef CIRCUMFLEX_BITS

  512. 	if (keycode == CIRCUMFLEX_BITS) return DEADKEY_CIRCUMFLEX;

  513. 	#endif

  514. 	#ifdef DIAERESIS_BITS

  515. 	if (keycode == DIAERESIS_BITS) return DEADKEY_DIAERESIS;

  516. 	#endif

  517. 	#ifdef GRAVE_ACCENT_BITS

  518. 	if (keycode == GRAVE_ACCENT_BITS) return DEADKEY_GRAVE_ACCENT;

  519. 	#endif

  520. 	#ifdef TILDE_BITS

  521. 	if (keycode == TILDE_BITS) return DEADKEY_TILDE;

  522. 	#endif

  523. 	#ifdef RING_ABOVE_BITS

  524. 	if (keycode == RING_ABOVE_BITS) return DEADKEY_RING_ABOVE;

  525. 	#endif

  526. 	#endif // DEADKEYS_MASK

  527. 	return 0;

  528. }

  529. 

  530. // Step #4: do each keystroke

  531. //

  532. void usb_keyboard_class::write_key(KEYCODE_TYPE keycode)

  533. {

  534. 	keyboard_report_data[0] = keycode_to_modifier(keycode);

  535. 	keyboard_report_data[1] = 0;

  536. 	keyboard_report_data[2] = keycode_to_key(keycode);

  537. 	keyboard_report_data[3] = 0;

  538. 	keyboard_report_data[4] = 0;

  539. 	keyboard_report_data[5] = 0;

  540. 	keyboard_report_data[6] = 0;

  541. 	keyboard_report_data[7] = 0;

  542. 	send_now();

  543. 	keyboard_report_data[0] = 0;

  544. 	keyboard_report_data[2] = 0;

  545. 	send_now();

  546. }

  547. 

  548. uint8_t usb_keyboard_class::keycode_to_modifier(KEYCODE_TYPE keycode)

  549. {

  550. 	uint8_t modifier=0;

  551. 

  552. 	#ifdef SHIFT_MASK

  553. 	if (keycode & SHIFT_MASK) modifier |= MODIFIERKEY_SHIFT;

  554. 	#endif

  555. 	#ifdef ALTGR_MASK

  556. 	if (keycode & ALTGR_MASK) modifier |= MODIFIERKEY_RIGHT_ALT;

  557. 	#endif

  558. 	#ifdef RCTRL_MASK

  559. 	if (keycode & RCTRL_MASK) modifier |= MODIFIERKEY_RIGHT_CTRL;

  560. 	#endif

  561. 	return modifier;

  562. }

  563. 

  564. uint8_t usb_keyboard_class::keycode_to_key(KEYCODE_TYPE keycode)

  565. {

  566. 	uint8_t key = keycode & 0x3F;

  567. 	#ifdef KEY_NON_US_100

  568. 	if (key == KEY_NON_US_100) key = 100;

  569. 	#endif

  570. 	return key;

  571. }

  572. 

  573. 

  574. 

  575. void usb_keyboard_class::set_modifier(uint8_t c)

  576. {

  577. 	keyboard_report_data[0] = c;

  578. }

  579. void usb_keyboard_class::set_key1(uint8_t c)

  580. {

  581. 	keyboard_report_data[2] = c;

  582. }

  583. void usb_keyboard_class::set_key2(uint8_t c)

  584. {

  585. 	keyboard_report_data[3] = c;

  586. }

  587. void usb_keyboard_class::set_key3(uint8_t c)

  588. {

  589. 	keyboard_report_data[4] = c;

  590. }

  591. void usb_keyboard_class::set_key4(uint8_t c)

  592. {

  593. 	keyboard_report_data[5] = c;

  594. }

  595. void usb_keyboard_class::set_key5(uint8_t c)

  596. {

  597. 	keyboard_report_data[6] = c;

  598. }

  599. void usb_keyboard_class::set_key6(uint8_t c)

  600. {

  601. 	keyboard_report_data[7] = c;

  602. }

  603. 

  604. 

  605. void usb_keyboard_class::send_now(void)

  606. {

  607.         uint8_t intr_state, timeout;

  608. 

  609.         if (!usb_configuration) return;

  610.         intr_state = SREG;

  611.         cli();

  612.         UENUM = KEYBOARD_ENDPOINT;

  613.         timeout = UDFNUML + 50;

  614.         while (1) {

  615.                 // are we ready to transmit?

  616.                 if (UEINTX & (1<<RWAL)) break;

  617.                 SREG = intr_state;

  618.                 // has the USB gone offline?

  619.                 if (!usb_configuration) return;

  620.                 // have we waited too long?

  621.                 if (UDFNUML == timeout) return;

  622.                 // get ready to try checking again

  623.                 intr_state = SREG;

  624.                 cli();

  625.                 UENUM = KEYBOARD_ENDPOINT;

  626.         }

  627.         UEDATX = keyboard_report_data[0];

  628.         UEDATX = keyboard_report_data[1];

  629.         UEDATX = keyboard_report_data[2];

  630.         UEDATX = keyboard_report_data[3];

  631.         UEDATX = keyboard_report_data[4];

  632.         UEDATX = keyboard_report_data[5];

  633.         UEDATX = keyboard_report_data[6];

  634.         UEDATX = keyboard_report_data[7];

  635.         UEINTX = 0x3A;

  636.         keyboard_idle_count = 0;

  637.         SREG = intr_state;

  638. }

  639. 

  640. 

  641. void usb_keyboard_class::press(uint16_t n)

  642. {

  643. 	uint8_t key, mod, msb, modrestore=0;

  644. 

  645. 	msb = n >> 8;

  646.         if (msb >= 0xC2) {

  647.                 if (msb <= 0xDF) {

  648.                         n = (n & 0x3F) | ((uint16_t)(msb & 0x1F) << 6);

  649.                 } else if (msb == 0xF0) {

  650.                         presskey(n, 0);

  651.                         return;

  652.                 } else if (msb == 0xE0) {

  653.                         presskey(0, n);

  654.                         return;

  655.                 } else if (msb == 0xE2) {

  656.                         //press_system_key(n);

  657.                         return;

  658.                 } else if (msb >= 0xE4 && msb <= 0xE7) {

  659.                         //press_consumer_key(n & 0x3FF);

  660.                         return;

  661.                 } else {

  662.                         return;

  663.                 }

  664.         }

  665. 	KEYCODE_TYPE keycode = unicode_to_keycode(n);

  666. 	if (!keycode) return;

  667. 	#ifdef DEADKEYS_MASK

  668. 	KEYCODE_TYPE deadkeycode = deadkey_to_keycode(keycode);

  669. 	if (deadkeycode) {

  670. 		modrestore = keyboard_report_data[0];

  671. 		if (modrestore) {

  672. 			keyboard_report_data[0] = 0;

  673. 			send_now();

  674. 		}

  675. 		// TODO: test if operating systems recognize

  676. 		// deadkey sequences when other keys are held

  677. 		mod = keycode_to_modifier(deadkeycode);

  678. 		key = keycode_to_key(deadkeycode);

  679. 		presskey(key, mod);

  680. 		releasekey(key, mod);

  681. 	}

  682. 	#endif

  683. 	mod = keycode_to_modifier(keycode);

  684. 	key = keycode_to_key(keycode);

  685. 	presskey(key, mod | modrestore);

  686. }

  687. 

  688. void usb_keyboard_class::release(uint16_t n)

  689. {

  690. 	uint8_t key, mod, msb;

  691. 

  692. 	msb = n >> 8;

  693.         if (msb >= 0xC2) {

  694.                 if (msb <= 0xDF) {

  695.                         n = (n & 0x3F) | ((uint16_t)(msb & 0x1F) << 6);

  696.                 } else if (msb == 0xF0) {

  697.                         releasekey(n, 0);

  698.                         return;

  699.                 } else if (msb == 0xE0) {

  700.                         releasekey(0, n);

  701.                         return;

  702.                 } else if (msb == 0xE2) {

  703.                         //release_system_key(n);

  704.                         return;

  705.                 } else if (msb >= 0xE4 && msb <= 0xE7) {

  706.                         //release_consumer_key(n & 0x3FF);

  707.                         return;

  708.                 } else {

  709.                         return;

  710.                 }

  711.         }

  712. 	KEYCODE_TYPE keycode = unicode_to_keycode(n);

  713. 	if (!keycode) return;

  714. 	mod = keycode_to_modifier(keycode);

  715. 	key = keycode_to_key(keycode);

  716. 	releasekey(key, mod);

  717. }

  718. 

  719. void usb_keyboard_class::presskey(uint8_t key, uint8_t modifier)

  720. {

  721. 	bool send_required = false;

  722. 	uint8_t i;

  723. 

  724. 	if (modifier) {

  725. 		if ((keyboard_report_data[0] & modifier) != modifier) {

  726. 			keyboard_report_data[0] |= modifier;

  727. 			send_required = true;

  728. 		}

  729. 	}

  730. 	if (key) {

  731. 		for (i=2; i < 8; i++) {

  732. 			if (keyboard_report_data[i] == key) goto end;

  733. 		}

  734. 		for (i=2; i < 8; i++) {

  735. 			if (keyboard_report_data[i] == 0) {

  736. 				keyboard_report_data[i] = key;

  737. 				send_required = true;

  738. 				goto end;

  739. 			}

  740. 		}

  741. 	}

  742. 	end:

  743. 	if (send_required) send_now();

  744. }

  745. 

  746. void usb_keyboard_class::releasekey(uint8_t key, uint8_t modifier)

  747. {

  748. 	bool send_required = false;

  749. 	uint8_t i;

  750. 

  751. 	if (modifier) {

  752. 		if ((keyboard_report_data[0] & modifier) != 0) {

  753. 			keyboard_report_data[0] &= ~modifier;

  754. 			send_required = true;

  755. 		}

  756. 	}

  757. 	if (key) {

  758. 		for (i=2; i < 8; i++) {

  759. 			if (keyboard_report_data[i] == key) {

  760. 				keyboard_report_data[i] = 0;

  761. 				send_required = true;

  762. 			}

  763. 		}

  764. 	}

  765. 	if (send_required) send_now();

  766. }

  767. 

  768. void usb_keyboard_class::releaseAll(void)

  769. {

  770. 	uint8_t i, anybits;

  771. 

  772. 	anybits = keyboard_report_data[0];

  773. 	for (i=2; i < 8; i++) {

  774. 		anybits |= keyboard_report_data[i];

  775. 		keyboard_report_data[i] = 0;

  776. 	}

  777. 	if (!anybits) return;

  778. 	keyboard_report_data[0] = 0;

  779. 	send_now();

  780. }

  781. 

  782. 

  783. 

  784. 

  785. 

  786. 

  787. void usb_mouse_class::move(int8_t x, int8_t y, int8_t wheel)

  788. {

  789.         uint8_t intr_state, timeout;

  790. 

  791.         if (!usb_configuration) return;

  792.         if (x == -128) x = -127;

  793.         if (y == -128) y = -127;

  794.         if (wheel == -128) wheel = -127;

  795.         intr_state = SREG;

  796.         cli();

  797.         UENUM = MOUSE_ENDPOINT;

  798.         timeout = UDFNUML + 50;

  799.         while (1) {

  800.                 // are we ready to transmit?

  801.                 if (UEINTX & (1<<RWAL)) break;

  802.                 SREG = intr_state;

  803.                 // has the USB gone offline?

  804.                 if (!usb_configuration) return;

  805.                 // have we waited too long?

  806.                 if (UDFNUML == timeout) return;

  807.                 // get ready to try checking again

  808.                 intr_state = SREG;

  809.                 cli();

  810.                 UENUM = MOUSE_ENDPOINT;

  811.         }

  812.         UEDATX = mouse_buttons;

  813.         UEDATX = x;

  814.         UEDATX = y;

  815.         UEDATX = wheel;

  816.         UEINTX = 0x3A;

  817.         SREG = intr_state;

  818. }

  819. 

  820. void usb_mouse_class::click(uint8_t b)

  821. {

  822.         mouse_buttons = (b & 7);

  823.         move(0, 0);

  824.         mouse_buttons = 0;

  825.         move(0, 0);

  826. }

  827. 

  828. void usb_mouse_class::scroll(int8_t wheel)

  829. {

  830.         move(0, 0, wheel);

  831. }

  832. 

  833. void usb_mouse_class::set_buttons(uint8_t left, uint8_t middle, uint8_t right)

  834. {

  835.         uint8_t mask=0;

  836. 

  837.         if (left) mask |= 1;

  838.         if (middle) mask |= 4;

  839.         if (right) mask |= 2;

  840.         mouse_buttons = mask;

  841.         move(0, 0);

  842. }

  843. 

  844. void usb_mouse_class::press(uint8_t b)

  845. {

  846.         uint8_t prev = mouse_buttons;

  847.         mouse_buttons |= (b & 7);

  848.         if (mouse_buttons != prev) move(0, 0);

  849. }

  850. 

  851. void usb_mouse_class::release(uint8_t b)

  852. {

  853.         uint8_t prev = mouse_buttons;

  854.         mouse_buttons &= ~(b & 7);

  855.         if (mouse_buttons != prev) move(0, 0);

  856. }

  857. 

  858. bool usb_mouse_class::isPressed(uint8_t b)

  859. {

  860.         return ((mouse_buttons & (b & 7)) != 0);

  861. }

  862. 

  863. 

  864. 

  865. void usb_joystick_class::send_now(void)

  866. {

  867.         uint8_t intr_state, timeout;

  868. 

  869.         if (!usb_configuration) return;

  870.         intr_state = SREG;

  871.         cli();

  872.         UENUM = JOYSTICK_ENDPOINT;

  873.         timeout = UDFNUML + 50;

  874.         while (1) {

  875.                 // are we ready to transmit?

  876.                 if (UEINTX & (1<<RWAL)) break;

  877.                 SREG = intr_state;

  878.                 // has the USB gone offline?

  879.                 if (!usb_configuration) return;

  880.                 // have we waited too long?

  881.                 if (UDFNUML == timeout) return;

  882.                 // get ready to try checking again

  883.                 intr_state = SREG;

  884.                 cli();

  885.                 UENUM = JOYSTICK_ENDPOINT;

  886.         }

  887.         UEDATX = joystick_report_data[0];

  888.         UEDATX = joystick_report_data[1];

  889.         UEDATX = joystick_report_data[2];

  890.         UEDATX = joystick_report_data[3];

  891.         UEDATX = joystick_report_data[4];

  892.         UEDATX = joystick_report_data[5];

  893.         UEDATX = joystick_report_data[6];

  894.         UEDATX = joystick_report_data[7];

  895.         UEDATX = joystick_report_data[8];

  896.         UEDATX = joystick_report_data[9];

  897.         UEDATX = joystick_report_data[10];

  898.         UEDATX = joystick_report_data[11];

  899.         UEINTX = 0x3A;

  900.         SREG = intr_state;

  901. }

  902. 

  903. 

  904. 

  905. 

  906. 

  907. 

  908. 

  909. // Preinstantiate Objects //////////////////////////////////////////////////////

  910. 

  911. usb_serial_class        Serial = usb_serial_class();

  912. usb_keyboard_class      Keyboard = usb_keyboard_class();

  913. usb_mouse_class         Mouse = usb_mouse_class();

  914. usb_joystick_class      Joystick = usb_joystick_class();