1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Device driver for the Cuda and Egret system controllers found on PowerMacs 4 * and 68k Macs. 5 * 6 * The Cuda or Egret is a 6805 microcontroller interfaced to the 6522 VIA. 7 * This MCU controls system power, Parameter RAM, Real Time Clock and the 8 * Apple Desktop Bus (ADB) that connects to the keyboard and mouse. 9 * 10 * Copyright (C) 1996 Paul Mackerras. 11 */ 12 #include <stdarg.h> 13 #include <linux/types.h> 14 #include <linux/errno.h> 15 #include <linux/kernel.h> 16 #include <linux/delay.h> 17 #include <linux/adb.h> 18 #include <linux/cuda.h> 19 #include <linux/spinlock.h> 20 #include <linux/interrupt.h> 21 #ifdef CONFIG_PPC 22 #include <asm/prom.h> 23 #include <asm/machdep.h> 24 #else 25 #include <asm/macintosh.h> 26 #include <asm/macints.h> 27 #include <asm/mac_via.h> 28 #endif 29 #include <asm/io.h> 30 #include <linux/init.h> 31 32 static volatile unsigned char __iomem *via; 33 static DEFINE_SPINLOCK(cuda_lock); 34 35 /* VIA registers - spaced 0x200 bytes apart */ 36 #define RS 0x200 /* skip between registers */ 37 #define B 0 /* B-side data */ 38 #define A RS /* A-side data */ 39 #define DIRB (2*RS) /* B-side direction (1=output) */ 40 #define DIRA (3*RS) /* A-side direction (1=output) */ 41 #define T1CL (4*RS) /* Timer 1 ctr/latch (low 8 bits) */ 42 #define T1CH (5*RS) /* Timer 1 counter (high 8 bits) */ 43 #define T1LL (6*RS) /* Timer 1 latch (low 8 bits) */ 44 #define T1LH (7*RS) /* Timer 1 latch (high 8 bits) */ 45 #define T2CL (8*RS) /* Timer 2 ctr/latch (low 8 bits) */ 46 #define T2CH (9*RS) /* Timer 2 counter (high 8 bits) */ 47 #define SR (10*RS) /* Shift register */ 48 #define ACR (11*RS) /* Auxiliary control register */ 49 #define PCR (12*RS) /* Peripheral control register */ 50 #define IFR (13*RS) /* Interrupt flag register */ 51 #define IER (14*RS) /* Interrupt enable register */ 52 #define ANH (15*RS) /* A-side data, no handshake */ 53 54 /* 55 * When the Cuda design replaced the Egret, some signal names and 56 * logic sense changed. They all serve the same purposes, however. 57 * 58 * VIA pin | Egret pin 59 * ----------------+------------------------------------------ 60 * PB3 (input) | Transceiver session (active low) 61 * PB4 (output) | VIA full (active high) 62 * PB5 (output) | System session (active high) 63 * 64 * VIA pin | Cuda pin 65 * ----------------+------------------------------------------ 66 * PB3 (input) | Transfer request (active low) 67 * PB4 (output) | Byte acknowledge (active low) 68 * PB5 (output) | Transfer in progress (active low) 69 */ 70 71 /* Bits in Port B data register */ 72 #define TREQ 0x08 /* Transfer request */ 73 #define TACK 0x10 /* Transfer acknowledge */ 74 #define TIP 0x20 /* Transfer in progress */ 75 76 /* Bits in ACR */ 77 #define SR_CTRL 0x1c /* Shift register control bits */ 78 #define SR_EXT 0x0c /* Shift on external clock */ 79 #define SR_OUT 0x10 /* Shift out if 1 */ 80 81 /* Bits in IFR and IER */ 82 #define IER_SET 0x80 /* set bits in IER */ 83 #define IER_CLR 0 /* clear bits in IER */ 84 #define SR_INT 0x04 /* Shift register full/empty */ 85 86 /* Duration of byte acknowledgement pulse (us) */ 87 #define EGRET_TACK_ASSERTED_DELAY 300 88 #define EGRET_TACK_NEGATED_DELAY 400 89 90 /* Interval from interrupt to start of session (us) */ 91 #define EGRET_SESSION_DELAY 450 92 93 #ifdef CONFIG_PPC 94 #define mcu_is_egret false 95 #else 96 static bool mcu_is_egret; 97 #endif 98 99 static inline bool TREQ_asserted(u8 portb) 100 { 101 return !(portb & TREQ); 102 } 103 104 static inline void assert_TIP(void) 105 { 106 if (mcu_is_egret) { 107 udelay(EGRET_SESSION_DELAY); 108 out_8(&via[B], in_8(&via[B]) | TIP); 109 } else 110 out_8(&via[B], in_8(&via[B]) & ~TIP); 111 } 112 113 static inline void assert_TIP_and_TACK(void) 114 { 115 if (mcu_is_egret) { 116 udelay(EGRET_SESSION_DELAY); 117 out_8(&via[B], in_8(&via[B]) | TIP | TACK); 118 } else 119 out_8(&via[B], in_8(&via[B]) & ~(TIP | TACK)); 120 } 121 122 static inline void assert_TACK(void) 123 { 124 if (mcu_is_egret) { 125 udelay(EGRET_TACK_NEGATED_DELAY); 126 out_8(&via[B], in_8(&via[B]) | TACK); 127 } else 128 out_8(&via[B], in_8(&via[B]) & ~TACK); 129 } 130 131 static inline void toggle_TACK(void) 132 { 133 out_8(&via[B], in_8(&via[B]) ^ TACK); 134 } 135 136 static inline void negate_TACK(void) 137 { 138 if (mcu_is_egret) { 139 udelay(EGRET_TACK_ASSERTED_DELAY); 140 out_8(&via[B], in_8(&via[B]) & ~TACK); 141 } else 142 out_8(&via[B], in_8(&via[B]) | TACK); 143 } 144 145 static inline void negate_TIP_and_TACK(void) 146 { 147 if (mcu_is_egret) { 148 udelay(EGRET_TACK_ASSERTED_DELAY); 149 out_8(&via[B], in_8(&via[B]) & ~(TIP | TACK)); 150 } else 151 out_8(&via[B], in_8(&via[B]) | TIP | TACK); 152 } 153 154 static enum cuda_state { 155 idle, 156 sent_first_byte, 157 sending, 158 reading, 159 read_done, 160 awaiting_reply 161 } cuda_state; 162 163 static struct adb_request *current_req; 164 static struct adb_request *last_req; 165 static unsigned char cuda_rbuf[16]; 166 static unsigned char *reply_ptr; 167 static int reading_reply; 168 static int data_index; 169 static int cuda_irq; 170 #ifdef CONFIG_PPC 171 static struct device_node *vias; 172 #endif 173 static int cuda_fully_inited; 174 175 #ifdef CONFIG_ADB 176 static int cuda_probe(void); 177 static int cuda_send_request(struct adb_request *req, int sync); 178 static int cuda_adb_autopoll(int devs); 179 static int cuda_reset_adb_bus(void); 180 #endif /* CONFIG_ADB */ 181 182 static int cuda_init_via(void); 183 static void cuda_start(void); 184 static irqreturn_t cuda_interrupt(int irq, void *arg); 185 static void cuda_input(unsigned char *buf, int nb); 186 void cuda_poll(void); 187 static int cuda_write(struct adb_request *req); 188 189 int cuda_request(struct adb_request *req, 190 void (*done)(struct adb_request *), int nbytes, ...); 191 192 #ifdef CONFIG_ADB 193 struct adb_driver via_cuda_driver = { 194 .name = "CUDA", 195 .probe = cuda_probe, 196 .send_request = cuda_send_request, 197 .autopoll = cuda_adb_autopoll, 198 .poll = cuda_poll, 199 .reset_bus = cuda_reset_adb_bus, 200 }; 201 #endif /* CONFIG_ADB */ 202 203 #ifdef CONFIG_MAC 204 int __init find_via_cuda(void) 205 { 206 struct adb_request req; 207 int err; 208 209 if (macintosh_config->adb_type != MAC_ADB_CUDA && 210 macintosh_config->adb_type != MAC_ADB_EGRET) 211 return 0; 212 213 via = via1; 214 cuda_state = idle; 215 mcu_is_egret = macintosh_config->adb_type == MAC_ADB_EGRET; 216 217 err = cuda_init_via(); 218 if (err) { 219 printk(KERN_ERR "cuda_init_via() failed\n"); 220 via = NULL; 221 return 0; 222 } 223 224 /* enable autopoll */ 225 cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, 1); 226 while (!req.complete) 227 cuda_poll(); 228 229 return 1; 230 } 231 #else 232 int __init find_via_cuda(void) 233 { 234 struct adb_request req; 235 phys_addr_t taddr; 236 const u32 *reg; 237 int err; 238 239 if (vias != 0) 240 return 1; 241 vias = of_find_node_by_name(NULL, "via-cuda"); 242 if (vias == 0) 243 return 0; 244 245 reg = of_get_property(vias, "reg", NULL); 246 if (reg == NULL) { 247 printk(KERN_ERR "via-cuda: No \"reg\" property !\n"); 248 goto fail; 249 } 250 taddr = of_translate_address(vias, reg); 251 if (taddr == 0) { 252 printk(KERN_ERR "via-cuda: Can't translate address !\n"); 253 goto fail; 254 } 255 via = ioremap(taddr, 0x2000); 256 if (via == NULL) { 257 printk(KERN_ERR "via-cuda: Can't map address !\n"); 258 goto fail; 259 } 260 261 cuda_state = idle; 262 sys_ctrler = SYS_CTRLER_CUDA; 263 264 err = cuda_init_via(); 265 if (err) { 266 printk(KERN_ERR "cuda_init_via() failed\n"); 267 via = NULL; 268 return 0; 269 } 270 271 /* Clear and enable interrupts, but only on PPC. On 68K it's done */ 272 /* for us by the main VIA driver in arch/m68k/mac/via.c */ 273 274 out_8(&via[IFR], 0x7f); /* clear interrupts by writing 1s */ 275 out_8(&via[IER], IER_SET|SR_INT); /* enable interrupt from SR */ 276 277 /* enable autopoll */ 278 cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, 1); 279 while (!req.complete) 280 cuda_poll(); 281 282 return 1; 283 284 fail: 285 of_node_put(vias); 286 vias = NULL; 287 return 0; 288 } 289 #endif /* !defined CONFIG_MAC */ 290 291 static int __init via_cuda_start(void) 292 { 293 if (via == NULL) 294 return -ENODEV; 295 296 #ifdef CONFIG_MAC 297 cuda_irq = IRQ_MAC_ADB; 298 #else 299 cuda_irq = irq_of_parse_and_map(vias, 0); 300 if (!cuda_irq) { 301 printk(KERN_ERR "via-cuda: can't map interrupts for %pOF\n", 302 vias); 303 return -ENODEV; 304 } 305 #endif 306 307 if (request_irq(cuda_irq, cuda_interrupt, 0, "ADB", cuda_interrupt)) { 308 printk(KERN_ERR "via-cuda: can't request irq %d\n", cuda_irq); 309 return -EAGAIN; 310 } 311 312 pr_info("Macintosh Cuda and Egret driver.\n"); 313 314 cuda_fully_inited = 1; 315 return 0; 316 } 317 318 device_initcall(via_cuda_start); 319 320 #ifdef CONFIG_ADB 321 static int 322 cuda_probe(void) 323 { 324 #ifdef CONFIG_PPC 325 if (sys_ctrler != SYS_CTRLER_CUDA) 326 return -ENODEV; 327 #else 328 if (macintosh_config->adb_type != MAC_ADB_CUDA && 329 macintosh_config->adb_type != MAC_ADB_EGRET) 330 return -ENODEV; 331 #endif 332 if (via == NULL) 333 return -ENODEV; 334 return 0; 335 } 336 #endif /* CONFIG_ADB */ 337 338 static int __init sync_egret(void) 339 { 340 if (TREQ_asserted(in_8(&via[B]))) { 341 /* Complete the inbound transfer */ 342 assert_TIP_and_TACK(); 343 while (1) { 344 negate_TACK(); 345 mdelay(1); 346 (void)in_8(&via[SR]); 347 assert_TACK(); 348 if (!TREQ_asserted(in_8(&via[B]))) 349 break; 350 } 351 negate_TIP_and_TACK(); 352 } else if (in_8(&via[B]) & TIP) { 353 /* Terminate the outbound transfer */ 354 negate_TACK(); 355 assert_TACK(); 356 mdelay(1); 357 negate_TIP_and_TACK(); 358 } 359 /* Clear shift register interrupt */ 360 if (in_8(&via[IFR]) & SR_INT) 361 (void)in_8(&via[SR]); 362 return 0; 363 } 364 365 #define WAIT_FOR(cond, what) \ 366 do { \ 367 int x; \ 368 for (x = 1000; !(cond); --x) { \ 369 if (x == 0) { \ 370 pr_err("Timeout waiting for " what "\n"); \ 371 return -ENXIO; \ 372 } \ 373 udelay(100); \ 374 } \ 375 } while (0) 376 377 static int 378 __init cuda_init_via(void) 379 { 380 #ifdef CONFIG_PPC 381 out_8(&via[IER], 0x7f); /* disable interrupts from VIA */ 382 (void)in_8(&via[IER]); 383 #else 384 out_8(&via[IER], SR_INT); /* disable SR interrupt from VIA */ 385 #endif 386 387 out_8(&via[DIRB], (in_8(&via[DIRB]) | TACK | TIP) & ~TREQ); /* TACK & TIP out */ 388 out_8(&via[ACR], (in_8(&via[ACR]) & ~SR_CTRL) | SR_EXT); /* SR data in */ 389 (void)in_8(&via[SR]); /* clear any left-over data */ 390 391 if (mcu_is_egret) 392 return sync_egret(); 393 394 negate_TIP_and_TACK(); 395 396 /* delay 4ms and then clear any pending interrupt */ 397 mdelay(4); 398 (void)in_8(&via[SR]); 399 out_8(&via[IFR], SR_INT); 400 401 /* sync with the CUDA - assert TACK without TIP */ 402 assert_TACK(); 403 404 /* wait for the CUDA to assert TREQ in response */ 405 WAIT_FOR(TREQ_asserted(in_8(&via[B])), "CUDA response to sync"); 406 407 /* wait for the interrupt and then clear it */ 408 WAIT_FOR(in_8(&via[IFR]) & SR_INT, "CUDA response to sync (2)"); 409 (void)in_8(&via[SR]); 410 out_8(&via[IFR], SR_INT); 411 412 /* finish the sync by negating TACK */ 413 negate_TACK(); 414 415 /* wait for the CUDA to negate TREQ and the corresponding interrupt */ 416 WAIT_FOR(!TREQ_asserted(in_8(&via[B])), "CUDA response to sync (3)"); 417 WAIT_FOR(in_8(&via[IFR]) & SR_INT, "CUDA response to sync (4)"); 418 (void)in_8(&via[SR]); 419 out_8(&via[IFR], SR_INT); 420 421 return 0; 422 } 423 424 #ifdef CONFIG_ADB 425 /* Send an ADB command */ 426 static int 427 cuda_send_request(struct adb_request *req, int sync) 428 { 429 int i; 430 431 if ((via == NULL) || !cuda_fully_inited) { 432 req->complete = 1; 433 return -ENXIO; 434 } 435 436 req->reply_expected = 1; 437 438 i = cuda_write(req); 439 if (i) 440 return i; 441 442 if (sync) { 443 while (!req->complete) 444 cuda_poll(); 445 } 446 return 0; 447 } 448 449 450 /* Enable/disable autopolling */ 451 static int 452 cuda_adb_autopoll(int devs) 453 { 454 struct adb_request req; 455 456 if ((via == NULL) || !cuda_fully_inited) 457 return -ENXIO; 458 459 cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, (devs? 1: 0)); 460 while (!req.complete) 461 cuda_poll(); 462 return 0; 463 } 464 465 /* Reset adb bus - how do we do this?? */ 466 static int 467 cuda_reset_adb_bus(void) 468 { 469 struct adb_request req; 470 471 if ((via == NULL) || !cuda_fully_inited) 472 return -ENXIO; 473 474 cuda_request(&req, NULL, 2, ADB_PACKET, 0); /* maybe? */ 475 while (!req.complete) 476 cuda_poll(); 477 return 0; 478 } 479 #endif /* CONFIG_ADB */ 480 481 /* Construct and send a cuda request */ 482 int 483 cuda_request(struct adb_request *req, void (*done)(struct adb_request *), 484 int nbytes, ...) 485 { 486 va_list list; 487 int i; 488 489 if (via == NULL) { 490 req->complete = 1; 491 return -ENXIO; 492 } 493 494 req->nbytes = nbytes; 495 req->done = done; 496 va_start(list, nbytes); 497 for (i = 0; i < nbytes; ++i) 498 req->data[i] = va_arg(list, int); 499 va_end(list); 500 req->reply_expected = 1; 501 return cuda_write(req); 502 } 503 EXPORT_SYMBOL(cuda_request); 504 505 static int 506 cuda_write(struct adb_request *req) 507 { 508 unsigned long flags; 509 510 if (req->nbytes < 2 || req->data[0] > CUDA_PACKET) { 511 req->complete = 1; 512 return -EINVAL; 513 } 514 req->next = NULL; 515 req->sent = 0; 516 req->complete = 0; 517 req->reply_len = 0; 518 519 spin_lock_irqsave(&cuda_lock, flags); 520 if (current_req != 0) { 521 last_req->next = req; 522 last_req = req; 523 } else { 524 current_req = req; 525 last_req = req; 526 if (cuda_state == idle) 527 cuda_start(); 528 } 529 spin_unlock_irqrestore(&cuda_lock, flags); 530 531 return 0; 532 } 533 534 static void 535 cuda_start(void) 536 { 537 /* assert cuda_state == idle */ 538 if (current_req == NULL) 539 return; 540 data_index = 0; 541 if (TREQ_asserted(in_8(&via[B]))) 542 return; /* a byte is coming in from the CUDA */ 543 544 /* set the shift register to shift out and send a byte */ 545 out_8(&via[ACR], in_8(&via[ACR]) | SR_OUT); 546 out_8(&via[SR], current_req->data[data_index++]); 547 if (mcu_is_egret) 548 assert_TIP_and_TACK(); 549 else 550 assert_TIP(); 551 cuda_state = sent_first_byte; 552 } 553 554 void 555 cuda_poll(void) 556 { 557 cuda_interrupt(0, NULL); 558 } 559 EXPORT_SYMBOL(cuda_poll); 560 561 #define ARRAY_FULL(a, p) ((p) - (a) == ARRAY_SIZE(a)) 562 563 static irqreturn_t 564 cuda_interrupt(int irq, void *arg) 565 { 566 unsigned long flags; 567 u8 status; 568 struct adb_request *req = NULL; 569 unsigned char ibuf[16]; 570 int ibuf_len = 0; 571 int complete = 0; 572 bool full; 573 574 spin_lock_irqsave(&cuda_lock, flags); 575 576 /* On powermacs, this handler is registered for the VIA IRQ. But they use 577 * just the shift register IRQ -- other VIA interrupt sources are disabled. 578 * On m68k macs, the VIA IRQ sources are dispatched individually. Unless 579 * we are polling, the shift register IRQ flag has already been cleared. 580 */ 581 582 #ifdef CONFIG_MAC 583 if (!arg) 584 #endif 585 { 586 if ((in_8(&via[IFR]) & SR_INT) == 0) { 587 spin_unlock_irqrestore(&cuda_lock, flags); 588 return IRQ_NONE; 589 } else { 590 out_8(&via[IFR], SR_INT); 591 } 592 } 593 594 status = in_8(&via[B]) & (TIP | TACK | TREQ); 595 596 switch (cuda_state) { 597 case idle: 598 /* System controller has unsolicited data for us */ 599 (void)in_8(&via[SR]); 600 idle_state: 601 assert_TIP(); 602 cuda_state = reading; 603 reply_ptr = cuda_rbuf; 604 reading_reply = 0; 605 break; 606 607 case awaiting_reply: 608 /* System controller has reply data for us */ 609 (void)in_8(&via[SR]); 610 assert_TIP(); 611 cuda_state = reading; 612 reply_ptr = current_req->reply; 613 reading_reply = 1; 614 break; 615 616 case sent_first_byte: 617 if (TREQ_asserted(status)) { 618 /* collision */ 619 out_8(&via[ACR], in_8(&via[ACR]) & ~SR_OUT); 620 (void)in_8(&via[SR]); 621 negate_TIP_and_TACK(); 622 cuda_state = idle; 623 /* Egret does not raise an "aborted" interrupt */ 624 if (mcu_is_egret) 625 goto idle_state; 626 } else { 627 out_8(&via[SR], current_req->data[data_index++]); 628 toggle_TACK(); 629 if (mcu_is_egret) 630 assert_TACK(); 631 cuda_state = sending; 632 } 633 break; 634 635 case sending: 636 req = current_req; 637 if (data_index >= req->nbytes) { 638 out_8(&via[ACR], in_8(&via[ACR]) & ~SR_OUT); 639 (void)in_8(&via[SR]); 640 negate_TIP_and_TACK(); 641 req->sent = 1; 642 if (req->reply_expected) { 643 cuda_state = awaiting_reply; 644 } else { 645 current_req = req->next; 646 complete = 1; 647 /* not sure about this */ 648 cuda_state = idle; 649 cuda_start(); 650 } 651 } else { 652 out_8(&via[SR], req->data[data_index++]); 653 toggle_TACK(); 654 if (mcu_is_egret) 655 assert_TACK(); 656 } 657 break; 658 659 case reading: 660 full = reading_reply ? ARRAY_FULL(current_req->reply, reply_ptr) 661 : ARRAY_FULL(cuda_rbuf, reply_ptr); 662 if (full) 663 (void)in_8(&via[SR]); 664 else 665 *reply_ptr++ = in_8(&via[SR]); 666 if (!TREQ_asserted(status) || full) { 667 if (mcu_is_egret) 668 assert_TACK(); 669 /* that's all folks */ 670 negate_TIP_and_TACK(); 671 cuda_state = read_done; 672 /* Egret does not raise a "read done" interrupt */ 673 if (mcu_is_egret) 674 goto read_done_state; 675 } else { 676 toggle_TACK(); 677 if (mcu_is_egret) 678 negate_TACK(); 679 } 680 break; 681 682 case read_done: 683 (void)in_8(&via[SR]); 684 read_done_state: 685 if (reading_reply) { 686 req = current_req; 687 req->reply_len = reply_ptr - req->reply; 688 if (req->data[0] == ADB_PACKET) { 689 /* Have to adjust the reply from ADB commands */ 690 if (req->reply_len <= 2 || (req->reply[1] & 2) != 0) { 691 /* the 0x2 bit indicates no response */ 692 req->reply_len = 0; 693 } else { 694 /* leave just the command and result bytes in the reply */ 695 req->reply_len -= 2; 696 memmove(req->reply, req->reply + 2, req->reply_len); 697 } 698 } 699 current_req = req->next; 700 complete = 1; 701 reading_reply = 0; 702 } else { 703 /* This is tricky. We must break the spinlock to call 704 * cuda_input. However, doing so means we might get 705 * re-entered from another CPU getting an interrupt 706 * or calling cuda_poll(). I ended up using the stack 707 * (it's only for 16 bytes) and moving the actual 708 * call to cuda_input to outside of the lock. 709 */ 710 ibuf_len = reply_ptr - cuda_rbuf; 711 memcpy(ibuf, cuda_rbuf, ibuf_len); 712 } 713 reply_ptr = cuda_rbuf; 714 cuda_state = idle; 715 cuda_start(); 716 if (cuda_state == idle && TREQ_asserted(in_8(&via[B]))) { 717 assert_TIP(); 718 cuda_state = reading; 719 } 720 break; 721 722 default: 723 pr_err("cuda_interrupt: unknown cuda_state %d?\n", cuda_state); 724 } 725 spin_unlock_irqrestore(&cuda_lock, flags); 726 if (complete && req) { 727 void (*done)(struct adb_request *) = req->done; 728 mb(); 729 req->complete = 1; 730 /* Here, we assume that if the request has a done member, the 731 * struct request will survive to setting req->complete to 1 732 */ 733 if (done) 734 (*done)(req); 735 } 736 if (ibuf_len) 737 cuda_input(ibuf, ibuf_len); 738 return IRQ_HANDLED; 739 } 740 741 static void 742 cuda_input(unsigned char *buf, int nb) 743 { 744 switch (buf[0]) { 745 case ADB_PACKET: 746 #ifdef CONFIG_XMON 747 if (nb == 5 && buf[2] == 0x2c) { 748 extern int xmon_wants_key, xmon_adb_keycode; 749 if (xmon_wants_key) { 750 xmon_adb_keycode = buf[3]; 751 return; 752 } 753 } 754 #endif /* CONFIG_XMON */ 755 #ifdef CONFIG_ADB 756 adb_input(buf+2, nb-2, buf[1] & 0x40); 757 #endif /* CONFIG_ADB */ 758 break; 759 760 case TIMER_PACKET: 761 /* Egret sends these periodically. Might be useful as a 'heartbeat' 762 * to trigger a recovery for the VIA shift register errata. 763 */ 764 break; 765 766 default: 767 print_hex_dump(KERN_INFO, "cuda_input: ", DUMP_PREFIX_NONE, 32, 1, 768 buf, nb, false); 769 } 770 } 771 772 /* Offset between Unix time (1970-based) and Mac time (1904-based) */ 773 #define RTC_OFFSET 2082844800 774 775 time64_t cuda_get_time(void) 776 { 777 struct adb_request req; 778 u32 now; 779 780 if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME) < 0) 781 return 0; 782 while (!req.complete) 783 cuda_poll(); 784 if (req.reply_len != 7) 785 pr_err("%s: got %d byte reply\n", __func__, req.reply_len); 786 now = (req.reply[3] << 24) + (req.reply[4] << 16) + 787 (req.reply[5] << 8) + req.reply[6]; 788 return (time64_t)now - RTC_OFFSET; 789 } 790 791 int cuda_set_rtc_time(struct rtc_time *tm) 792 { 793 u32 now; 794 struct adb_request req; 795 796 now = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET); 797 if (cuda_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME, 798 now >> 24, now >> 16, now >> 8, now) < 0) 799 return -ENXIO; 800 while (!req.complete) 801 cuda_poll(); 802 if ((req.reply_len != 3) && (req.reply_len != 7)) 803 pr_err("%s: got %d byte reply\n", __func__, req.reply_len); 804 return 0; 805 } 806