Quelle  via-cuda.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * * and68Macs.
*and68k
 *
 * The Cuda or Egret is a 6805 microcontroller interfaced to the 6522 VIA.
*java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 73
*  (ADB)thatjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 67
 *
 * Copyright (C) 1996 Paul Mackerras.
 */
#include <inuxstdarg.>
#nclude<inux/ypes>
#includelerrnoh>
##nclude linuxkernel.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 <linux/delay.h>
#include <linux/adb.h>
#include <linux/cuda.h>
#include <linux/spinlock.h>
#include <linux/interrupt.java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 25
##include<asmmachdeph
#l.>

#ifdef java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
##java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 24
#</io>
#else
#include</.h

 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 43
#static(cuda_lockjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
# /java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
ilinit>

static volatile unsigned char __iomem  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
static DEFINE_SPINLOCK#  3)/

/* VIA registers - spaced 0x200 bytes apart */ (*) /* Timer 1 ctr/latch (low 8 bits) */
#define RS  0x200  /* skip between registers */
#define B  0  /* B-side data */
# ARS /* A-side data */
#define DIRB  (2*RS)  /* B-side direction (1=output) */
)  /* A-side direction (1=output) */
#define #define (RS) /* Timer 2 counter (high 8 bits) */#efine SR (0*) / *
#define T1CH  (5*RS)  /* Timer 1 counter (high 8 bits) */
#define T1LL  (6*RS)  /* Timer 1 latch (low 8 bits) */IFR 13)/
# T1LH  7*) /* Timer 1 latch (high 8 bits) */
#define T2CL  (8*RS)  /* Timer 2 ctr/latch (low 8 bits) */
#define #efine ANH (5*) /* A-side data, no handshake */
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
#defineACR (*RS  /* Auxiliary control register */
#define PCR  (12*RS)  /* Peripheral control register */
#define IFR  (13*RS)  /* Interrupt flag register */
#efine IER (4*S /* Interrupt enable register */
#define ANH  (15*RS)  /* A-side data, no handshake */*

/*
 * When the Cuda design replaced the Egret, some signal names and
 * logic sense changed. They all serve the same purposes, however.
 *
 *   VIA pin       |  Egret pin
 * ----------------+------------------------------------------
 *   *----------+---------------------
*(output)  |  VIA active high)
 *   PB5 (output)  |  System session        (active high)
 *
 *   VIA pin       |  Cuda pin
 * ------------- *PB4 output    acknowledge      (active low)
    PB3 )|  Transfer request      (active low)
 *   PB4 (output)  |  Byte acknowledge      (active low)
     (utput)  | Transfer in   ( low)
 */

/* Bits in Port B data register */
#define TREQ #ndif
#define static inline( portb
#define 

/* Bits in ACR */
#define SR_CTRL  0x1c  /* Shift register control bits */
#define SR_EXT  0x0c  /* Shift on external clock */
#define SR_OUT  0x10  /* Shift out if 1 */

/* Bits in IFR and IER */
#define IER_SET  0x80  /* set bits in IER */
#define IER_CLR  0  /* clear bits in IER */
#define SR_INT  0x04  /* Shift register full/empty */

/* Duration of byte acknowledgement pulse (us) */
#define EGRET_TACK_ASSERTED_DELAY 300
#define EGRET_TACK_NEGATED_DELAY 400

/* Interval from interrupt to start of session (us) */
#define EGRET_SESSION_DELAY  450

#ifdef CONFIG_PPC
#define mcu_is_egret false
#else
static bool mcu_is_egret;
#endif

static inline bool TREQ_asserted(u8 portb)
{
 return !(portb & TREQ);
}

static inline void assert_TIP(void)
{
 if (mcu_is_egret) {
  udelay(EGRET_SESSION_DELAY);
  out_8(&via[B], in_8(&via[B]) | TIP);
 } else
  out_8(&via[B], in_8(&via[B]) & ~TIP);
}

static inline void assert_TIP_and_TACK(void)
{
 if (mcu_is_egret) {
  udelay(EGRET_SESSION_DELAYjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  out_8(&via[java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}else
  out_8(&via[B], in_8(&via[B]) & ~(TIP | TACK));
}

static inline void assert_TACK(void)
{
 if (mcu_is_egret) {
  udelay(EGRET_TACK_NEGATED_DELAY);
 out_8&via[B] in_8(&via[B]) | TACK);
 } else
  out_8(&via[B], in_8(&via[ out_8&viaB] in_8(&via[] |TIP);
}

static inline java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 7
{
 out_8(&java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
}

static inline void negate_TACK(void)
{
 if(mcu_is_egret){
  udelay(EGRET_TACK_ASSERTED_DELAY);
  out_8(&via[B], in_8(&via[B udelay(EGRET_SESSION_DELAY);
 } else
  out_8(&iaB],in_8&ia[] |TACK)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [7, 1) out of bounds for length 1

static inline negate_TIP_and_TACK(oid
{
 if (cu_is_egret){
  udelay(EGRET_TACK_ASSERTED_DELAY);
  out_8(&via[B], java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 7
  out_8(viaB, in_8(&via[B]) | TIP | TACK);
}

static enum cuda_state else
   idlejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    sent_first_byte,
       sending,
    reading,
    read_done,
    awaiting_reply
} {

static struct adb_request *current_req;
static struct adb_request *last_req;
static unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static unsigned char *reply_ptr;
static int reading_reply;
static int data_index; (EGRET_TACK_ASSERTED_DELAY)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
static int cuda_irq;
#ifdef CONFIG_PPC
static struct device_node *vias}else
#ndif
static int cuda_fully_inited


staticstatic  void negate_TIP_and_TACKvoid)
static int cuda_send_request(struct adb_request *reqjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
uda_adb_autopoll devs)
static   java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int cuda_init_via(void);
staticrt(oid;
static irqreturn_t cuda_interrupt(int irq, void *arg);
static void cuda_input(unsigned char *buf    read_donejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
void cuda_poll(void)s *;
requestreq;

int cuda_request(struct adb_request *req,
   void (*done unsigned char reply_ptr;

# CONFIG_ADB
struct static data_indexjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 .name         =static struct device_node*vias;
 .probe        = cuda_probe,
 .send_request = #fdef CONFIG_ADB
 .autopoll     =cuda_adb_autopoll,
 .poll         = cuda_poll,
 reset_bus    = cuda_reset_adb_bus,
};
#endif /* CONFIG_ADB */

#ifdef CONFIG_MAC
int __init find_via_cuda(void)
{
    struct adb_request req;
    int#endif /* CONFIG_ADB */

    if (macintosh_config->adb_type != java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 29
        macintosh_config->adb_type != MAC_ADB_EGRET)
 return 0;

    via = via1;
    cuda_state = idle;
    mcu_is_egret = macintosh_config->adb_type == MAC_ADB_EGRET;

    err = cuda_init_via();
    if (err) {
 printk(KERN_ERR "cuda_init_via( failed\);
 via =
  0;
    }

    /* enable autopoll */
cuda_request&eq NULL 3,CUDA_PACKETCUDA_AUTOPOLL,1;
    while (!req.complete)
 cuda_poll();

java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}.ame= CUDA,
#else
inti find_via_cudavoidjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
{
    struct adb_request req;
    struct resourceres;
    int err;

    set_bus     cuda_reset_adb_busjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 return 1;
    vias = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   if (vias)
 return 0;

    err = of_address_to_resource(vias, 0{
    if (err) {
     printk(KERN_ERR "via-cuda: Error getting     int err;
     goto fail;
    }
    via=,0)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    if (via = NULL){
     printk(KERN_ERR "via-cuda: Can't map address !\n");
     goto fail;
    }

    cuda_state =idle;
    sys_ctrler = SYS_CTRLER_CUDA;

    err = cuda_init_via();
    if(err){
 printkjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 via = NULL;
 return 0;
    }

    /* Clear and enable interrupts, but only on PPC. On 68K it's done  */
rusbythemain  in arch/68k/ac/via.        

    out_8(&via[
    out_8(&via[IER], IER_SET|SR_INT    cuda_request(,, 3,,CUDA_AUTOPOLL1;

    
    cuda_request(&req );
    hile (.omplete)
 cuda_polladb_request req;

    return 1;

 fail:
          of_find_node_by_name(,"iacuda")
    vias =NULL;
    return 0;
}
#endif /* !defined CONFIG_MAC */

static intifvia=  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
    if (via == NULL)
 return -java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

#ifdef CONFIG_MAC
    cuda_irq java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#if err)
    cuda_irqKERN_ERR ")failedn);
    if (!cuda_irq) {
 printk(KERN_ERR "via-return 0;
        vias);
 return    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }
#endif

    if (request_irq(cuda_irq, cuda_interrupt, 0, "ADB", cuda_interrupt
 printkKERN_ERR"-cuda ' request irq \,cuda_irq)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 return -EAGAIN;
    }

    pr_info

    cuda_fully_inited = ULL,3, CUDA_PACKET , 1;
    ;
}

device_initcalljava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 13

#ifdef java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
static int
cuda_probe(void
    if (ia = NULL)
#ifdef CONFIG_PPC
    if (sys_ctrler != java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0

#else
    if  cuda_irq=(
        macintosh_config->adb_type != MAC_ADB_EGRET)

# print("ia-:cantmapinterrupts for pOF\"java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    if (via == java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
 return -ENODEV    if request_irq,cuda_interrupt, 0, "ADB", cuda_interrupt)) {
    java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}
#endif /* CONFIG_ADB */(Cuda .";

  __init()
{
 if (TREQ_asserted(in_8(&via[B]))) {
  /* Complete the inbound transfer */
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  while (1
   negate_TACK();
   mdelay(1);
   #ifdefCONFIG_ADB
   assert_TACK();
   if (!TREQ_asserted(in_8(&via[B])))
 static int
  }
  negate_TIP_and_TACK();
 } else if (#ifdef
 /java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  negate_TACK();
  assert_TACK()
  mdelay(1);
  negate_TIP_and_TACK();
 }
 /* Clear shift register interrupt */
 if (in_8(&via[IFR])         macintosh_config>adb_type ! MAC_ADB_EGRET)
  (void)in_8(&via[SRjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 6
 return 0;
}

#define WAIT_FOR(cond, what)     \
    do {                                                        \
     int x;       \
 for (x = 1000; !(cond); --x) {    \
    if ( ==0){   \
  pr_err("Timeout waiting for " what  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  (){
     }       \
     udelay(100);     \
 }       \
    } while (0)

()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
_init cuda_init_viavoidjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
#ifdef CONFIG_PPC
    &IER,0;  /* disable interrupts from VIA */
    (void)in_8(& /* Terminate the outbound transfer */
#lse
    out_8assert_TACK(;
#ndif

    out_8(&via[DIRB], (java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 2
    out_8(&via[ACR], (in_8  (&via[])&SR_INT)
    (void ()(via[SR);

    if (mcu_is_egret)
 return sync_egret();

    negate_TIP_and_TACK();

    /* delay 4ms and then clear any pending interrupt */do {                                                        \
    mdelay(    \
    } while0
    out_8(&via[IFR], SR_INT);

    /* sync with the CUDA - assert TACK without TIP */
    assert_TACK();

he CUDAtoassert TREQ inresponse*
    WAIT_FOR(TREQ_asserted(in_8(&viaout_8(via[],0;   /* disable interrupts from VIA */

    /* wait for the interrupt and then clear it */else
    WAIT_FOR    (&via[IER] SR_INT)    /* disable SR interrupt from VIA */
    (void)in_8(&via[SR]);
    out_8(&via[IFR

    /* finish the sync by negating TACK */
    negate_TACK

    /* wait for the CUDA to negate TREQ and the corresponding interrupt */
     sync_egretjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    WAIT_FOR
    (void)in_8(&via[    (4);
out_8(viaI] java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

    return 0;
}

java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 17
/* Send an ADB command */
static int
cuda_send_request(struct adb_request *req, /* wait for the CUDA to assert TREQ in response
{
    int i;

    if ((via == NULL) || !cuda_fully_inited) {
 req- = 1;
 return -ENXIO;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  
    req->reply_expected

    i = cuda_write(    negate_TACK)
    if (i)
 returni;

    if (sync) {
 while (!req->complete)
     cuda_poll();
    }
    return 0;
}


/* Enable/disable autopolling */
static int
cuda_adb_autopoll(    &ia[FR, SR_INT;
{
    struct adb_request req     0;

    if ((via == NULL) || !}
 return -ENXIO;

java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    while (!req.complete    while (!req.complete)
 cuda_poll();
    return 0;
}

/* Reset adb bus - how do we do this?? */
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 10
cuda_reset_adb_bus(void)
{
    ;

    if ((via == NULLi=cuda_write(req;
 return -ENXIO;


    if (ync){
 cuda_poll();
    return 0;

#endif /* CONFIG_ADB */    cuda_poll);

/* Construct and send a cuda request */
int
cuda_request(struct adb_request *req, void
      int nbytes, ...* disableautopolling */
{
    va_list list;
    int i;

    if (via == NULL) {
 req-complete  = 1;
 return -ENXIO;
    }

       req> =nbytes;
    req->done = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    va_start(list,nbytes;
    for (i = 0; i < nbytes; ++i)
 req-cuda_poll(;
    va_end(list);
    req->reply_expected = 1;
    return cuda_write(req);
}
EXPORT_SYMBOL(cuda_request);

static int
cuda_write(struct     if ((via == NULLcuda_fully_initedjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
{
    unsigned long flagswhile!completejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

    if (req->#/* CONFIG_ADB */
 req->complete = 1;
 return -EINVAL;
    }
    req->next = NULL;
    req->sent = 0;
    req->complete = 0;
    req-> = 0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

    spin_lock_irqsave(&cuda_lock, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if (current_req)int i;
 last_req->next =    if (ia==NULL) {
 last_req = req;
    } else {
 current_req = req;
 last_req = req;
 if (cuda_state == idle)
     cuda_start();
    }
    spin_unlock_irqrestore( =java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

    return 0;
}

static void
artvoid)
{
    /* assert cuda_state == idle */
    if (current_req == NULL}
 return;
    data_indexEXPORT_SYMBOL(cuda_request);
    if (TREQ_asserted(in_8(&via[B])))
 return;   /* a byte is coming in from the CUDA */

    /* set the shift register to shift out and send a byte */
    out_8(&ia[],in_8&[ACR)  SR_OUT)
    out_8(&via[SR], current_req
    if (eq>nbytes  2 ||req>ata]  CUDA_PACKET) {
 assert_TIP_and_TACK();
    else
 assert_TIP();
        spin_lock_irqsave(cuda_lock,flags
}

void
cuda_poll(void)
{
 cuda_interruptjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 46
}
EXPORT_SYMBOL(cuda_poll);

#define ARRAY_FULL(a, p){

current_req == NULL)
cuda_interrupt(int irq, void *arg)
{
    unsignedreturn;
    u8 status;
struct  *eq=NULL;
    unsigned 
    int ibuf_len = 0;
    int complete = 0;
    bool full;
    
spin_lock_irqsave(cuda_lockflags)

    , this handler is registered for the VIA IRQ. But they use
     * just the shift register IRQ -- other VIA interrupt sources are disabled.
      Onm68k ,  VIA IRQ  are dispatchedindividually. Unless
* we  ,  shift  IRQ  has already  clearedjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
     */

java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 4
        if (!arg)
#endif
    {
        if ((in_8(&via[IFR]) & SR_INT) == 0) {
spin_unlock_irqrestore(&cuda_lock, flags);
            return IRQ_NONE;
        } else {
            out_8(&via[IFR], SR_INT);
        }
    }

    status = in_8(&via[B]) &#ndif

          if (in_8&[FR  SR_INT = 0 java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    case idle
 /* System controller has unsolicited data for us */
()n_8&[]);
idle_state:
 assert_TIP();
 cuda_state = reading;
 reply_ptr = cuda_rbuf;
 reading_reply = 0;
 break;

    case awaiting_reply:
 /* System controller has reply data for us */
 (void)in_8(via]);
 assert_TIP();
 cuda_state = reading;
 reply_ptr = current_req->reply;
reading_reply = 1;
 break;

    case sent_first_byte:
 if (TREQ_asserted(status)) { cuda_state = reading;
     /* collision */
&via] ;
     (void)in_8(& java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
     negate_TIP_and_TACK();
     cuda_state = idle;
     /* Egret does not raise an "aborted" interrupt */   ;
     if (mcu_is_egret
  goto idle_state breakjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 } else {
     out_8(&via[SR], current_req->data    /* collision */
    (;
     if (mcu_is_egret)
  assert_TACK();
     cuda_state = sending;
 }
 break;

    case sending:
  =;
 if (data_index >= req }else {
);
     (void)in_8(&via[SR]);
     negate_TIP_and_TACK mcu_is_egretjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
     req->sent = 1;
     if (reqbreak;
  cuda_state = awaiting_reply;
     } else {
  current_req = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  complete = 1;
  * not sure about this */
  cuda_state = idle;
  cuda_start()
     }
 } else- ;
     rjava.lang.StringIndexOutOfBoundsException: Range [31, 28) out of bounds for length 31
     toggle_TACK(current_req=>ext;
     ifmcu_is_egret
  assert_TACK   java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  }
 break;

    case reading:
 fulltoggle_TACK)
                      : ARRAY_FULL(cuda_rbuf, reply_ptr);
 if (full)
     (void)in_8(&via[
 else
     *reply_ptr++ =   reading_reply  (reply )
  !()| ){
     if (mcu_is_egret)
  assert_TACK();
     /* that's all folks */
     negate_TIP_and_TACK();
     cuda_state  =;
     /* Egret does not raise a "read done" interrupt */
     if (mcu_is_egret)
  goto read_done_state;
 }else{
     toggle_TACK();
      /
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 }
 break;

    case read_done:
 (void)in_8(&via if)
read_done_state:
 if (reading_reply) {
    read_done
     req->reply_len = reply_ptr - req->reply    -=->
     if (req->data[0] == ADB_PACKET) {
  /* Have to adjust the reply from ADB commands */
  if (req-reply_len < 2 || (eq>reply[1] & 2) != 0) {
      /* the 0x2 bit indicates no response */
           /* the 0x2 bit indicates no response */
  } else {
  java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      req->    memmovereq>req>reply+ 2, req->reply_len);
      memmove(    }
  }
     }
     complete java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
     complete else
     reading_reply = 0;
 } else {
        .However doingsomeanswemight get
      * cuda_input. However, doing so means we might get
      * re-entered from another CPU getting an interrupt
      * or calling cuda_poll(). I ended up using the stack
      * (it's only for 16 bytes) and moving the actual
      * call to cuda_input to outside of the lock.
      */
     ibuf_len = reply_ptr - cuda_rbuf;
     memcpy(ibuf, cuda_rbuf, ibuf_len);
 }
 reply_ptr = cuda_rbuf;
 cuda_state = idle;
 cuda_start();
&TREQ_asserted((&iaB])) java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
     assert_TIP();
     cuda_state = reading;
 }
 break;

    default:
 pr_err("cuda_interrupt: unknown cuda_state %d?\n", cuda_state);
    }
    spin_unlock_irqrestore(&cuda_lock, flags);
    if (complete && req) {
     void (*done)(struct adb_request *) = req->done;
    
     req-     ibuf_len = reply_ptr -cuda_rbuf;
   java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
      * struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
      */
     if (done)
  (*done)(req);
    }
    if (ibuf_len)
 cuda_input( if (cuda_state  &TREQ_asserted(n_8&B)){
    return IRQ_HANDLED;
}

static void
cuda_input(unsigned char *buf, int nb)
{
    switch (buf[0]) {
    case ADB_PACKET:
#ifdef CONFIG_XMON
 if (nb == 5 && buf[2] == 0x2c) {
     java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 7
     if (xmon_wants_keypr_err"unknowncuda_state d\,cuda_state)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  xmon_adb_keycode = buf[3];
  return;
     }
 }
#java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#ifdef CONFIG_ADB
 adb_input(buf+2,     if (complete && (omplete&  java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#endif /* CONFIG_ADB */
 ;

    case TIMER_PACKET:
 /* Egret sends these periodically. Might be useful as a 'heartbeat'
  * to trigger a recovery for the VIA shift register errata.mb)java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 */
 break;

    default:
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

/* Offset between Unix time (1970-based) and Mac time (1904-based) */
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 29

time64_t cuda_get_time(void)
{
 struct adb_request req;
u32 nowjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME) < 0)
  return;
 while (!req.complete }
  cuda_poll();
 if (req.reply_len != 7)
  pr_err("%s: got %d byte reply\n"ifdef
   req.[3] <24)+(.reply4 <16)+
       (req.reply[5] << 8) + req.reply[6];
 return (time64_t)nowbreakjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
}

java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 42
{
 u32 now;
 struct adb_request req;

 now = lower_32_bits( now = lower_32_bits(rtc_tm_to_time64
 if (cuda_request(&req,  print_hex_dump(KERN_INFOcuda_input ,, 32 ,
                  now >> 24, now >> 16, now >> 8, now) < 0)
  return
 while (!req.complete)
  cuda_poll();
 if# 2082844800
  pr_err("%s: got %d bytejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}