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