|
|
@@ -34,27 +34,27 @@
|
|
|
*
|
|
|
* Driver theory of operation:
|
|
|
*
|
|
|
- * hp_sdc_put does all writing to the SDC. ISR can run on a different
|
|
|
- * CPU than hp_sdc_put, but only one CPU runs hp_sdc_put at a time
|
|
|
+ * hp_sdc_put does all writing to the SDC. ISR can run on a different
|
|
|
+ * CPU than hp_sdc_put, but only one CPU runs hp_sdc_put at a time
|
|
|
* (it cannot really benefit from SMP anyway.) A tasket fit this perfectly.
|
|
|
*
|
|
|
- * All data coming back from the SDC is sent via interrupt and can be read
|
|
|
- * fully in the ISR, so there are no latency/throughput problems there.
|
|
|
- * The problem is with output, due to the slow clock speed of the SDC
|
|
|
- * compared to the CPU. This should not be too horrible most of the time,
|
|
|
- * but if used with HIL devices that support the multibyte transfer command,
|
|
|
- * keeping outbound throughput flowing at the 6500KBps that the HIL is
|
|
|
+ * All data coming back from the SDC is sent via interrupt and can be read
|
|
|
+ * fully in the ISR, so there are no latency/throughput problems there.
|
|
|
+ * The problem is with output, due to the slow clock speed of the SDC
|
|
|
+ * compared to the CPU. This should not be too horrible most of the time,
|
|
|
+ * but if used with HIL devices that support the multibyte transfer command,
|
|
|
+ * keeping outbound throughput flowing at the 6500KBps that the HIL is
|
|
|
* capable of is more than can be done at HZ=100.
|
|
|
*
|
|
|
- * Busy polling for IBF clear wastes CPU cycles and bus cycles. hp_sdc.ibf
|
|
|
- * is set to 0 when the IBF flag in the status register has cleared. ISR
|
|
|
- * may do this, and may also access the parts of queued transactions related
|
|
|
- * to reading data back from the SDC, but otherwise will not touch the
|
|
|
+ * Busy polling for IBF clear wastes CPU cycles and bus cycles. hp_sdc.ibf
|
|
|
+ * is set to 0 when the IBF flag in the status register has cleared. ISR
|
|
|
+ * may do this, and may also access the parts of queued transactions related
|
|
|
+ * to reading data back from the SDC, but otherwise will not touch the
|
|
|
* hp_sdc state. Whenever a register is written hp_sdc.ibf is set to 1.
|
|
|
*
|
|
|
* The i8042 write index and the values in the 4-byte input buffer
|
|
|
* starting at 0x70 are kept track of in hp_sdc.wi, and .r7[], respectively,
|
|
|
- * to minimize the amount of IO needed to the SDC. However these values
|
|
|
+ * to minimize the amount of IO needed to the SDC. However these values
|
|
|
* do not need to be locked since they are only ever accessed by hp_sdc_put.
|
|
|
*
|
|
|
* A timer task schedules the tasklet once per second just to make
|
|
|
@@ -106,33 +106,39 @@ EXPORT_SYMBOL(hp_sdc_dequeue_transaction);
|
|
|
static hp_i8042_sdc hp_sdc; /* All driver state is kept in here. */
|
|
|
|
|
|
/*************** primitives for use in any context *********************/
|
|
|
-static inline uint8_t hp_sdc_status_in8 (void) {
|
|
|
+static inline uint8_t hp_sdc_status_in8(void)
|
|
|
+{
|
|
|
uint8_t status;
|
|
|
unsigned long flags;
|
|
|
|
|
|
write_lock_irqsave(&hp_sdc.ibf_lock, flags);
|
|
|
status = sdc_readb(hp_sdc.status_io);
|
|
|
- if (!(status & HP_SDC_STATUS_IBF)) hp_sdc.ibf = 0;
|
|
|
+ if (!(status & HP_SDC_STATUS_IBF))
|
|
|
+ hp_sdc.ibf = 0;
|
|
|
write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
|
|
|
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
-static inline uint8_t hp_sdc_data_in8 (void) {
|
|
|
- return sdc_readb(hp_sdc.data_io);
|
|
|
+static inline uint8_t hp_sdc_data_in8(void)
|
|
|
+{
|
|
|
+ return sdc_readb(hp_sdc.data_io);
|
|
|
}
|
|
|
|
|
|
-static inline void hp_sdc_status_out8 (uint8_t val) {
|
|
|
+static inline void hp_sdc_status_out8(uint8_t val)
|
|
|
+{
|
|
|
unsigned long flags;
|
|
|
|
|
|
write_lock_irqsave(&hp_sdc.ibf_lock, flags);
|
|
|
hp_sdc.ibf = 1;
|
|
|
- if ((val & 0xf0) == 0xe0) hp_sdc.wi = 0xff;
|
|
|
+ if ((val & 0xf0) == 0xe0)
|
|
|
+ hp_sdc.wi = 0xff;
|
|
|
sdc_writeb(val, hp_sdc.status_io);
|
|
|
write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
|
|
|
}
|
|
|
|
|
|
-static inline void hp_sdc_data_out8 (uint8_t val) {
|
|
|
+static inline void hp_sdc_data_out8(uint8_t val)
|
|
|
+{
|
|
|
unsigned long flags;
|
|
|
|
|
|
write_lock_irqsave(&hp_sdc.ibf_lock, flags);
|
|
|
@@ -141,11 +147,12 @@ static inline void hp_sdc_data_out8 (uint8_t val) {
|
|
|
write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
|
|
|
}
|
|
|
|
|
|
-/* Care must be taken to only invoke hp_sdc_spin_ibf when
|
|
|
- * absolutely needed, or in rarely invoked subroutines.
|
|
|
- * Not only does it waste CPU cycles, it also wastes bus cycles.
|
|
|
+/* Care must be taken to only invoke hp_sdc_spin_ibf when
|
|
|
+ * absolutely needed, or in rarely invoked subroutines.
|
|
|
+ * Not only does it waste CPU cycles, it also wastes bus cycles.
|
|
|
*/
|
|
|
-static inline void hp_sdc_spin_ibf(void) {
|
|
|
+static inline void hp_sdc_spin_ibf(void)
|
|
|
+{
|
|
|
unsigned long flags;
|
|
|
rwlock_t *lock;
|
|
|
|
|
|
@@ -158,19 +165,21 @@ static inline void hp_sdc_spin_ibf(void) {
|
|
|
}
|
|
|
read_unlock(lock);
|
|
|
write_lock(lock);
|
|
|
- while (sdc_readb(hp_sdc.status_io) & HP_SDC_STATUS_IBF) {};
|
|
|
+ while (sdc_readb(hp_sdc.status_io) & HP_SDC_STATUS_IBF)
|
|
|
+ { }
|
|
|
hp_sdc.ibf = 0;
|
|
|
write_unlock_irqrestore(lock, flags);
|
|
|
}
|
|
|
|
|
|
|
|
|
/************************ Interrupt context functions ************************/
|
|
|
-static void hp_sdc_take (int irq, void *dev_id, uint8_t status, uint8_t data) {
|
|
|
+static void hp_sdc_take(int irq, void *dev_id, uint8_t status, uint8_t data)
|
|
|
+{
|
|
|
hp_sdc_transaction *curr;
|
|
|
|
|
|
read_lock(&hp_sdc.rtq_lock);
|
|
|
if (hp_sdc.rcurr < 0) {
|
|
|
- read_unlock(&hp_sdc.rtq_lock);
|
|
|
+ read_unlock(&hp_sdc.rtq_lock);
|
|
|
return;
|
|
|
}
|
|
|
curr = hp_sdc.tq[hp_sdc.rcurr];
|
|
|
@@ -183,25 +192,27 @@ static void hp_sdc_take (int irq, void *dev_id, uint8_t status, uint8_t data) {
|
|
|
|
|
|
if (hp_sdc.rqty <= 0) {
|
|
|
/* All data has been gathered. */
|
|
|
- if(curr->seq[curr->actidx] & HP_SDC_ACT_SEMAPHORE) {
|
|
|
- if (curr->act.semaphore) up(curr->act.semaphore);
|
|
|
- }
|
|
|
- if(curr->seq[curr->actidx] & HP_SDC_ACT_CALLBACK) {
|
|
|
+ if (curr->seq[curr->actidx] & HP_SDC_ACT_SEMAPHORE)
|
|
|
+ if (curr->act.semaphore)
|
|
|
+ up(curr->act.semaphore);
|
|
|
+
|
|
|
+ if (curr->seq[curr->actidx] & HP_SDC_ACT_CALLBACK)
|
|
|
if (curr->act.irqhook)
|
|
|
curr->act.irqhook(irq, dev_id, status, data);
|
|
|
- }
|
|
|
+
|
|
|
curr->actidx = curr->idx;
|
|
|
curr->idx++;
|
|
|
/* Return control of this transaction */
|
|
|
write_lock(&hp_sdc.rtq_lock);
|
|
|
- hp_sdc.rcurr = -1;
|
|
|
+ hp_sdc.rcurr = -1;
|
|
|
hp_sdc.rqty = 0;
|
|
|
write_unlock(&hp_sdc.rtq_lock);
|
|
|
tasklet_schedule(&hp_sdc.task);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-static irqreturn_t hp_sdc_isr(int irq, void *dev_id) {
|
|
|
+static irqreturn_t hp_sdc_isr(int irq, void *dev_id)
|
|
|
+{
|
|
|
uint8_t status, data;
|
|
|
|
|
|
status = hp_sdc_status_in8();
|
|
|
@@ -209,67 +220,74 @@ static irqreturn_t hp_sdc_isr(int irq, void *dev_id) {
|
|
|
data = hp_sdc_data_in8();
|
|
|
|
|
|
/* For now we are ignoring these until we get the SDC to behave. */
|
|
|
- if (((status & 0xf1) == 0x51) && data == 0x82) {
|
|
|
- return IRQ_HANDLED;
|
|
|
- }
|
|
|
+ if (((status & 0xf1) == 0x51) && data == 0x82)
|
|
|
+ return IRQ_HANDLED;
|
|
|
|
|
|
- switch(status & HP_SDC_STATUS_IRQMASK) {
|
|
|
- case 0: /* This case is not documented. */
|
|
|
+ switch (status & HP_SDC_STATUS_IRQMASK) {
|
|
|
+ case 0: /* This case is not documented. */
|
|
|
break;
|
|
|
- case HP_SDC_STATUS_USERTIMER:
|
|
|
- case HP_SDC_STATUS_PERIODIC:
|
|
|
- case HP_SDC_STATUS_TIMER:
|
|
|
+
|
|
|
+ case HP_SDC_STATUS_USERTIMER:
|
|
|
+ case HP_SDC_STATUS_PERIODIC:
|
|
|
+ case HP_SDC_STATUS_TIMER:
|
|
|
read_lock(&hp_sdc.hook_lock);
|
|
|
- if (hp_sdc.timer != NULL)
|
|
|
+ if (hp_sdc.timer != NULL)
|
|
|
hp_sdc.timer(irq, dev_id, status, data);
|
|
|
read_unlock(&hp_sdc.hook_lock);
|
|
|
break;
|
|
|
- case HP_SDC_STATUS_REG:
|
|
|
+
|
|
|
+ case HP_SDC_STATUS_REG:
|
|
|
hp_sdc_take(irq, dev_id, status, data);
|
|
|
break;
|
|
|
- case HP_SDC_STATUS_HILCMD:
|
|
|
- case HP_SDC_STATUS_HILDATA:
|
|
|
+
|
|
|
+ case HP_SDC_STATUS_HILCMD:
|
|
|
+ case HP_SDC_STATUS_HILDATA:
|
|
|
read_lock(&hp_sdc.hook_lock);
|
|
|
if (hp_sdc.hil != NULL)
|
|
|
hp_sdc.hil(irq, dev_id, status, data);
|
|
|
read_unlock(&hp_sdc.hook_lock);
|
|
|
break;
|
|
|
- case HP_SDC_STATUS_PUP:
|
|
|
+
|
|
|
+ case HP_SDC_STATUS_PUP:
|
|
|
read_lock(&hp_sdc.hook_lock);
|
|
|
if (hp_sdc.pup != NULL)
|
|
|
hp_sdc.pup(irq, dev_id, status, data);
|
|
|
- else printk(KERN_INFO PREFIX "HP SDC reports successful PUP.\n");
|
|
|
+ else
|
|
|
+ printk(KERN_INFO PREFIX "HP SDC reports successful PUP.\n");
|
|
|
read_unlock(&hp_sdc.hook_lock);
|
|
|
break;
|
|
|
- default:
|
|
|
+
|
|
|
+ default:
|
|
|
read_lock(&hp_sdc.hook_lock);
|
|
|
if (hp_sdc.cooked != NULL)
|
|
|
hp_sdc.cooked(irq, dev_id, status, data);
|
|
|
read_unlock(&hp_sdc.hook_lock);
|
|
|
break;
|
|
|
}
|
|
|
+
|
|
|
return IRQ_HANDLED;
|
|
|
}
|
|
|
|
|
|
|
|
|
-static irqreturn_t hp_sdc_nmisr(int irq, void *dev_id) {
|
|
|
+static irqreturn_t hp_sdc_nmisr(int irq, void *dev_id)
|
|
|
+{
|
|
|
int status;
|
|
|
-
|
|
|
+
|
|
|
status = hp_sdc_status_in8();
|
|
|
printk(KERN_WARNING PREFIX "NMI !\n");
|
|
|
|
|
|
-#if 0
|
|
|
+#if 0
|
|
|
if (status & HP_SDC_NMISTATUS_FHS) {
|
|
|
read_lock(&hp_sdc.hook_lock);
|
|
|
- if (hp_sdc.timer != NULL)
|
|
|
+ if (hp_sdc.timer != NULL)
|
|
|
hp_sdc.timer(irq, dev_id, status, 0);
|
|
|
read_unlock(&hp_sdc.hook_lock);
|
|
|
- }
|
|
|
- else {
|
|
|
+ } else {
|
|
|
/* TODO: pass this on to the HIL handler, or do SAK here? */
|
|
|
printk(KERN_WARNING PREFIX "HIL NMI\n");
|
|
|
}
|
|
|
#endif
|
|
|
+
|
|
|
return IRQ_HANDLED;
|
|
|
}
|
|
|
|
|
|
@@ -278,13 +296,17 @@ static irqreturn_t hp_sdc_nmisr(int irq, void *dev_id) {
|
|
|
|
|
|
unsigned long hp_sdc_put(void);
|
|
|
|
|
|
-static void hp_sdc_tasklet(unsigned long foo) {
|
|
|
-
|
|
|
+static void hp_sdc_tasklet(unsigned long foo)
|
|
|
+{
|
|
|
write_lock_irq(&hp_sdc.rtq_lock);
|
|
|
+
|
|
|
if (hp_sdc.rcurr >= 0) {
|
|
|
struct timeval tv;
|
|
|
+
|
|
|
do_gettimeofday(&tv);
|
|
|
- if (tv.tv_sec > hp_sdc.rtv.tv_sec) tv.tv_usec += 1000000;
|
|
|
+ if (tv.tv_sec > hp_sdc.rtv.tv_sec)
|
|
|
+ tv.tv_usec += USEC_PER_SEC;
|
|
|
+
|
|
|
if (tv.tv_usec - hp_sdc.rtv.tv_usec > HP_SDC_MAX_REG_DELAY) {
|
|
|
hp_sdc_transaction *curr;
|
|
|
uint8_t tmp;
|
|
|
@@ -300,27 +322,29 @@ static void hp_sdc_tasklet(unsigned long foo) {
|
|
|
hp_sdc.rqty = 0;
|
|
|
tmp = curr->seq[curr->actidx];
|
|
|
curr->seq[curr->actidx] |= HP_SDC_ACT_DEAD;
|
|
|
- if(tmp & HP_SDC_ACT_SEMAPHORE) {
|
|
|
- if (curr->act.semaphore)
|
|
|
+ if (tmp & HP_SDC_ACT_SEMAPHORE)
|
|
|
+ if (curr->act.semaphore)
|
|
|
up(curr->act.semaphore);
|
|
|
- }
|
|
|
- if(tmp & HP_SDC_ACT_CALLBACK) {
|
|
|
+
|
|
|
+ if (tmp & HP_SDC_ACT_CALLBACK) {
|
|
|
/* Note this means that irqhooks may be called
|
|
|
* in tasklet/bh context.
|
|
|
*/
|
|
|
- if (curr->act.irqhook)
|
|
|
+ if (curr->act.irqhook)
|
|
|
curr->act.irqhook(0, NULL, 0, 0);
|
|
|
}
|
|
|
+
|
|
|
curr->actidx = curr->idx;
|
|
|
curr->idx++;
|
|
|
- hp_sdc.rcurr = -1;
|
|
|
+ hp_sdc.rcurr = -1;
|
|
|
}
|
|
|
}
|
|
|
write_unlock_irq(&hp_sdc.rtq_lock);
|
|
|
hp_sdc_put();
|
|
|
}
|
|
|
|
|
|
-unsigned long hp_sdc_put(void) {
|
|
|
+unsigned long hp_sdc_put(void)
|
|
|
+{
|
|
|
hp_sdc_transaction *curr;
|
|
|
uint8_t act;
|
|
|
int idx, curridx;
|
|
|
@@ -333,19 +357,24 @@ unsigned long hp_sdc_put(void) {
|
|
|
requires output, so we skip to the administrativa. */
|
|
|
if (hp_sdc.ibf) {
|
|
|
hp_sdc_status_in8();
|
|
|
- if (hp_sdc.ibf) goto finish;
|
|
|
+ if (hp_sdc.ibf)
|
|
|
+ goto finish;
|
|
|
}
|
|
|
|
|
|
anew:
|
|
|
/* See if we are in the middle of a sequence. */
|
|
|
- if (hp_sdc.wcurr < 0) hp_sdc.wcurr = 0;
|
|
|
+ if (hp_sdc.wcurr < 0)
|
|
|
+ hp_sdc.wcurr = 0;
|
|
|
read_lock_irq(&hp_sdc.rtq_lock);
|
|
|
- if (hp_sdc.rcurr == hp_sdc.wcurr) hp_sdc.wcurr++;
|
|
|
+ if (hp_sdc.rcurr == hp_sdc.wcurr)
|
|
|
+ hp_sdc.wcurr++;
|
|
|
read_unlock_irq(&hp_sdc.rtq_lock);
|
|
|
- if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN) hp_sdc.wcurr = 0;
|
|
|
+ if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
|
|
|
+ hp_sdc.wcurr = 0;
|
|
|
curridx = hp_sdc.wcurr;
|
|
|
|
|
|
- if (hp_sdc.tq[curridx] != NULL) goto start;
|
|
|
+ if (hp_sdc.tq[curridx] != NULL)
|
|
|
+ goto start;
|
|
|
|
|
|
while (++curridx != hp_sdc.wcurr) {
|
|
|
if (curridx >= HP_SDC_QUEUE_LEN) {
|
|
|
@@ -358,7 +387,8 @@ unsigned long hp_sdc_put(void) {
|
|
|
continue;
|
|
|
}
|
|
|
read_unlock_irq(&hp_sdc.rtq_lock);
|
|
|
- if (hp_sdc.tq[curridx] != NULL) break; /* Found one. */
|
|
|
+ if (hp_sdc.tq[curridx] != NULL)
|
|
|
+ break; /* Found one. */
|
|
|
}
|
|
|
if (curridx == hp_sdc.wcurr) { /* There's nothing queued to do. */
|
|
|
curridx = -1;
|
|
|
@@ -374,7 +404,8 @@ unsigned long hp_sdc_put(void) {
|
|
|
goto finish;
|
|
|
}
|
|
|
|
|
|
- if (hp_sdc.wcurr == -1) goto done;
|
|
|
+ if (hp_sdc.wcurr == -1)
|
|
|
+ goto done;
|
|
|
|
|
|
curr = hp_sdc.tq[curridx];
|
|
|
idx = curr->actidx;
|
|
|
@@ -383,20 +414,23 @@ unsigned long hp_sdc_put(void) {
|
|
|
hp_sdc.tq[curridx] = NULL;
|
|
|
/* Interleave outbound data between the transactions. */
|
|
|
hp_sdc.wcurr++;
|
|
|
- if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN) hp_sdc.wcurr = 0;
|
|
|
- goto finish;
|
|
|
+ if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
|
|
|
+ hp_sdc.wcurr = 0;
|
|
|
+ goto finish;
|
|
|
}
|
|
|
|
|
|
act = curr->seq[idx];
|
|
|
idx++;
|
|
|
|
|
|
if (curr->idx >= curr->endidx) {
|
|
|
- if (act & HP_SDC_ACT_DEALLOC) kfree(curr);
|
|
|
+ if (act & HP_SDC_ACT_DEALLOC)
|
|
|
+ kfree(curr);
|
|
|
hp_sdc.tq[curridx] = NULL;
|
|
|
/* Interleave outbound data between the transactions. */
|
|
|
hp_sdc.wcurr++;
|
|
|
- if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN) hp_sdc.wcurr = 0;
|
|
|
- goto finish;
|
|
|
+ if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
|
|
|
+ hp_sdc.wcurr = 0;
|
|
|
+ goto finish;
|
|
|
}
|
|
|
|
|
|
while (act & HP_SDC_ACT_PRECMD) {
|
|
|
@@ -409,9 +443,10 @@ unsigned long hp_sdc_put(void) {
|
|
|
curr->idx++;
|
|
|
/* act finished? */
|
|
|
if ((act & HP_SDC_ACT_DURING) == HP_SDC_ACT_PRECMD)
|
|
|
- goto actdone;
|
|
|
+ goto actdone;
|
|
|
/* skip quantity field if data-out sequence follows. */
|
|
|
- if (act & HP_SDC_ACT_DATAOUT) curr->idx++;
|
|
|
+ if (act & HP_SDC_ACT_DATAOUT)
|
|
|
+ curr->idx++;
|
|
|
goto finish;
|
|
|
}
|
|
|
if (act & HP_SDC_ACT_DATAOUT) {
|
|
|
@@ -423,15 +458,15 @@ unsigned long hp_sdc_put(void) {
|
|
|
hp_sdc_data_out8(curr->seq[curr->idx]);
|
|
|
curr->idx++;
|
|
|
/* act finished? */
|
|
|
- if ((curr->idx - idx >= qty) &&
|
|
|
- ((act & HP_SDC_ACT_DURING) == HP_SDC_ACT_DATAOUT))
|
|
|
+ if (curr->idx - idx >= qty &&
|
|
|
+ (act & HP_SDC_ACT_DURING) == HP_SDC_ACT_DATAOUT)
|
|
|
goto actdone;
|
|
|
goto finish;
|
|
|
}
|
|
|
idx += qty;
|
|
|
act &= ~HP_SDC_ACT_DATAOUT;
|
|
|
- }
|
|
|
- else while (act & HP_SDC_ACT_DATAREG) {
|
|
|
+ } else
|
|
|
+ while (act & HP_SDC_ACT_DATAREG) {
|
|
|
int mask;
|
|
|
uint8_t w7[4];
|
|
|
|
|
|
@@ -445,26 +480,30 @@ unsigned long hp_sdc_put(void) {
|
|
|
act &= ~HP_SDC_ACT_DATAREG;
|
|
|
break;
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
w7[0] = (mask & 1) ? curr->seq[++idx] : hp_sdc.r7[0];
|
|
|
w7[1] = (mask & 2) ? curr->seq[++idx] : hp_sdc.r7[1];
|
|
|
w7[2] = (mask & 4) ? curr->seq[++idx] : hp_sdc.r7[2];
|
|
|
w7[3] = (mask & 8) ? curr->seq[++idx] : hp_sdc.r7[3];
|
|
|
-
|
|
|
+
|
|
|
if (hp_sdc.wi > 0x73 || hp_sdc.wi < 0x70 ||
|
|
|
- w7[hp_sdc.wi-0x70] == hp_sdc.r7[hp_sdc.wi-0x70]) {
|
|
|
+ w7[hp_sdc.wi - 0x70] == hp_sdc.r7[hp_sdc.wi - 0x70]) {
|
|
|
int i = 0;
|
|
|
|
|
|
- /* Need to point the write index register */
|
|
|
- while ((i < 4) && w7[i] == hp_sdc.r7[i]) i++;
|
|
|
+ /* Need to point the write index register */
|
|
|
+ while (i < 4 && w7[i] == hp_sdc.r7[i])
|
|
|
+ i++;
|
|
|
+
|
|
|
if (i < 4) {
|
|
|
hp_sdc_status_out8(HP_SDC_CMD_SET_D0 + i);
|
|
|
hp_sdc.wi = 0x70 + i;
|
|
|
goto finish;
|
|
|
}
|
|
|
+
|
|
|
idx++;
|
|
|
if ((act & HP_SDC_ACT_DURING) == HP_SDC_ACT_DATAREG)
|
|
|
goto actdone;
|
|
|
+
|
|
|
curr->idx = idx;
|
|
|
act &= ~HP_SDC_ACT_DATAREG;
|
|
|
break;
|
|
|
@@ -476,12 +515,13 @@ unsigned long hp_sdc_put(void) {
|
|
|
{
|
|
|
int i = 0;
|
|
|
|
|
|
- while ((i < 4) && w7[i] == hp_sdc.r7[i]) i++;
|
|
|
+ while ((i < 4) && w7[i] == hp_sdc.r7[i])
|
|
|
+ i++;
|
|
|
if (i >= 4) {
|
|
|
curr->idx = idx + 1;
|
|
|
- if ((act & HP_SDC_ACT_DURING) ==
|
|
|
+ if ((act & HP_SDC_ACT_DURING) ==
|
|
|
HP_SDC_ACT_DATAREG)
|
|
|
- goto actdone;
|
|
|
+ goto actdone;
|
|
|
}
|
|
|
}
|
|
|
goto finish;
|
|
|
@@ -497,7 +537,7 @@ unsigned long hp_sdc_put(void) {
|
|
|
|
|
|
|
|
|
if (act & HP_SDC_ACT_POSTCMD) {
|
|
|
- uint8_t postcmd;
|
|
|
+ uint8_t postcmd;
|
|
|
|
|
|
/* curr->idx should == idx at this point. */
|
|
|
postcmd = curr->seq[idx];
|
|
|
@@ -505,12 +545,12 @@ unsigned long hp_sdc_put(void) {
|
|
|
if (act & HP_SDC_ACT_DATAIN) {
|
|
|
|
|
|
/* Start a new read */
|
|
|
- hp_sdc.rqty = curr->seq[curr->idx];
|
|
|
+ hp_sdc.rqty = curr->seq[curr->idx];
|
|
|
do_gettimeofday(&hp_sdc.rtv);
|
|
|
curr->idx++;
|
|
|
/* Still need to lock here in case of spurious irq. */
|
|
|
write_lock_irq(&hp_sdc.rtq_lock);
|
|
|
- hp_sdc.rcurr = curridx;
|
|
|
+ hp_sdc.rcurr = curridx;
|
|
|
write_unlock_irq(&hp_sdc.rtq_lock);
|
|
|
hp_sdc_status_out8(postcmd);
|
|
|
goto finish;
|
|
|
@@ -519,64 +559,69 @@ unsigned long hp_sdc_put(void) {
|
|
|
goto actdone;
|
|
|
}
|
|
|
|
|
|
-actdone:
|
|
|
- if (act & HP_SDC_ACT_SEMAPHORE) {
|
|
|
+ actdone:
|
|
|
+ if (act & HP_SDC_ACT_SEMAPHORE)
|
|
|
up(curr->act.semaphore);
|
|
|
- }
|
|
|
- else if (act & HP_SDC_ACT_CALLBACK) {
|
|
|
+ else if (act & HP_SDC_ACT_CALLBACK)
|
|
|
curr->act.irqhook(0,NULL,0,0);
|
|
|
- }
|
|
|
+
|
|
|
if (curr->idx >= curr->endidx) { /* This transaction is over. */
|
|
|
- if (act & HP_SDC_ACT_DEALLOC) kfree(curr);
|
|
|
+ if (act & HP_SDC_ACT_DEALLOC)
|
|
|
+ kfree(curr);
|
|
|
hp_sdc.tq[curridx] = NULL;
|
|
|
- }
|
|
|
- else {
|
|
|
+ } else {
|
|
|
curr->actidx = idx + 1;
|
|
|
curr->idx = idx + 2;
|
|
|
}
|
|
|
/* Interleave outbound data between the transactions. */
|
|
|
hp_sdc.wcurr++;
|
|
|
- if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN) hp_sdc.wcurr = 0;
|
|
|
+ if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
|
|
|
+ hp_sdc.wcurr = 0;
|
|
|
|
|
|
finish:
|
|
|
- /* If by some quirk IBF has cleared and our ISR has run to
|
|
|
+ /* If by some quirk IBF has cleared and our ISR has run to
|
|
|
see that that has happened, do it all again. */
|
|
|
- if (!hp_sdc.ibf && limit++ < 20) goto anew;
|
|
|
+ if (!hp_sdc.ibf && limit++ < 20)
|
|
|
+ goto anew;
|
|
|
|
|
|
done:
|
|
|
- if (hp_sdc.wcurr >= 0) tasklet_schedule(&hp_sdc.task);
|
|
|
+ if (hp_sdc.wcurr >= 0)
|
|
|
+ tasklet_schedule(&hp_sdc.task);
|
|
|
write_unlock(&hp_sdc.lock);
|
|
|
+
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
/******* Functions called in either user or kernel context ****/
|
|
|
-int hp_sdc_enqueue_transaction(hp_sdc_transaction *this) {
|
|
|
+int hp_sdc_enqueue_transaction(hp_sdc_transaction *this)
|
|
|
+{
|
|
|
unsigned long flags;
|
|
|
int i;
|
|
|
|
|
|
if (this == NULL) {
|
|
|
tasklet_schedule(&hp_sdc.task);
|
|
|
return -EINVAL;
|
|
|
- };
|
|
|
+ }
|
|
|
|
|
|
write_lock_irqsave(&hp_sdc.lock, flags);
|
|
|
|
|
|
/* Can't have same transaction on queue twice */
|
|
|
- for (i=0; i < HP_SDC_QUEUE_LEN; i++)
|
|
|
- if (hp_sdc.tq[i] == this) goto fail;
|
|
|
+ for (i = 0; i < HP_SDC_QUEUE_LEN; i++)
|
|
|
+ if (hp_sdc.tq[i] == this)
|
|
|
+ goto fail;
|
|
|
|
|
|
this->actidx = 0;
|
|
|
this->idx = 1;
|
|
|
|
|
|
/* Search for empty slot */
|
|
|
- for (i=0; i < HP_SDC_QUEUE_LEN; i++) {
|
|
|
+ for (i = 0; i < HP_SDC_QUEUE_LEN; i++)
|
|
|
if (hp_sdc.tq[i] == NULL) {
|
|
|
hp_sdc.tq[i] = this;
|
|
|
write_unlock_irqrestore(&hp_sdc.lock, flags);
|
|
|
tasklet_schedule(&hp_sdc.task);
|
|
|
return 0;
|
|
|
}
|
|
|
- }
|
|
|
+
|
|
|
write_unlock_irqrestore(&hp_sdc.lock, flags);
|
|
|
printk(KERN_WARNING PREFIX "No free slot to add transaction.\n");
|
|
|
return -EBUSY;
|
|
|
@@ -587,7 +632,8 @@ int hp_sdc_enqueue_transaction(hp_sdc_transaction *this) {
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
|
|
|
-int hp_sdc_dequeue_transaction(hp_sdc_transaction *this) {
|
|
|
+int hp_sdc_dequeue_transaction(hp_sdc_transaction *this)
|
|
|
+{
|
|
|
unsigned long flags;
|
|
|
int i;
|
|
|
|
|
|
@@ -595,8 +641,9 @@ int hp_sdc_dequeue_transaction(hp_sdc_transaction *this) {
|
|
|
|
|
|
/* TODO: don't remove it if it's not done. */
|
|
|
|
|
|
- for (i=0; i < HP_SDC_QUEUE_LEN; i++)
|
|
|
- if (hp_sdc.tq[i] == this) hp_sdc.tq[i] = NULL;
|
|
|
+ for (i = 0; i < HP_SDC_QUEUE_LEN; i++)
|
|
|
+ if (hp_sdc.tq[i] == this)
|
|
|
+ hp_sdc.tq[i] = NULL;
|
|
|
|
|
|
write_unlock_irqrestore(&hp_sdc.lock, flags);
|
|
|
return 0;
|
|
|
@@ -605,11 +652,11 @@ int hp_sdc_dequeue_transaction(hp_sdc_transaction *this) {
|
|
|
|
|
|
|
|
|
/********************** User context functions **************************/
|
|
|
-int hp_sdc_request_timer_irq(hp_sdc_irqhook *callback) {
|
|
|
-
|
|
|
- if (callback == NULL || hp_sdc.dev == NULL) {
|
|
|
+int hp_sdc_request_timer_irq(hp_sdc_irqhook *callback)
|
|
|
+{
|
|
|
+ if (callback == NULL || hp_sdc.dev == NULL)
|
|
|
return -EINVAL;
|
|
|
- }
|
|
|
+
|
|
|
write_lock_irq(&hp_sdc.hook_lock);
|
|
|
if (hp_sdc.timer != NULL) {
|
|
|
write_unlock_irq(&hp_sdc.hook_lock);
|
|
|
@@ -629,11 +676,11 @@ int hp_sdc_request_timer_irq(hp_sdc_irqhook *callback) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-int hp_sdc_request_hil_irq(hp_sdc_irqhook *callback) {
|
|
|
-
|
|
|
- if (callback == NULL || hp_sdc.dev == NULL) {
|
|
|
+int hp_sdc_request_hil_irq(hp_sdc_irqhook *callback)
|
|
|
+{
|
|
|
+ if (callback == NULL || hp_sdc.dev == NULL)
|
|
|
return -EINVAL;
|
|
|
- }
|
|
|
+
|
|
|
write_lock_irq(&hp_sdc.hook_lock);
|
|
|
if (hp_sdc.hil != NULL) {
|
|
|
write_unlock_irq(&hp_sdc.hook_lock);
|
|
|
@@ -650,11 +697,11 @@ int hp_sdc_request_hil_irq(hp_sdc_irqhook *callback) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-int hp_sdc_request_cooked_irq(hp_sdc_irqhook *callback) {
|
|
|
-
|
|
|
- if (callback == NULL || hp_sdc.dev == NULL) {
|
|
|
+int hp_sdc_request_cooked_irq(hp_sdc_irqhook *callback)
|
|
|
+{
|
|
|
+ if (callback == NULL || hp_sdc.dev == NULL)
|
|
|
return -EINVAL;
|
|
|
- }
|
|
|
+
|
|
|
write_lock_irq(&hp_sdc.hook_lock);
|
|
|
if (hp_sdc.cooked != NULL) {
|
|
|
write_unlock_irq(&hp_sdc.hook_lock);
|
|
|
@@ -672,9 +719,8 @@ int hp_sdc_request_cooked_irq(hp_sdc_irqhook *callback) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-int hp_sdc_release_timer_irq(hp_sdc_irqhook *callback) {
|
|
|
-
|
|
|
-
|
|
|
+int hp_sdc_release_timer_irq(hp_sdc_irqhook *callback)
|
|
|
+{
|
|
|
write_lock_irq(&hp_sdc.hook_lock);
|
|
|
if ((callback != hp_sdc.timer) ||
|
|
|
(hp_sdc.timer == NULL)) {
|
|
|
@@ -694,8 +740,8 @@ int hp_sdc_release_timer_irq(hp_sdc_irqhook *callback) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-int hp_sdc_release_hil_irq(hp_sdc_irqhook *callback) {
|
|
|
-
|
|
|
+int hp_sdc_release_hil_irq(hp_sdc_irqhook *callback)
|
|
|
+{
|
|
|
write_lock_irq(&hp_sdc.hook_lock);
|
|
|
if ((callback != hp_sdc.hil) ||
|
|
|
(hp_sdc.hil == NULL)) {
|
|
|
@@ -715,8 +761,8 @@ int hp_sdc_release_hil_irq(hp_sdc_irqhook *callback) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-int hp_sdc_release_cooked_irq(hp_sdc_irqhook *callback) {
|
|
|
-
|
|
|
+int hp_sdc_release_cooked_irq(hp_sdc_irqhook *callback)
|
|
|
+{
|
|
|
write_lock_irq(&hp_sdc.hook_lock);
|
|
|
if ((callback != hp_sdc.cooked) ||
|
|
|
(hp_sdc.cooked == NULL)) {
|
|
|
@@ -738,7 +784,8 @@ int hp_sdc_release_cooked_irq(hp_sdc_irqhook *callback) {
|
|
|
|
|
|
/************************* Keepalive timer task *********************/
|
|
|
|
|
|
-void hp_sdc_kicker (unsigned long data) {
|
|
|
+void hp_sdc_kicker (unsigned long data)
|
|
|
+{
|
|
|
tasklet_schedule(&hp_sdc.task);
|
|
|
/* Re-insert the periodic task. */
|
|
|
mod_timer(&hp_sdc.kicker, jiffies + HZ);
|
|
|
@@ -750,10 +797,10 @@ void hp_sdc_kicker (unsigned long data) {
|
|
|
|
|
|
static const struct parisc_device_id hp_sdc_tbl[] = {
|
|
|
{
|
|
|
- .hw_type = HPHW_FIO,
|
|
|
+ .hw_type = HPHW_FIO,
|
|
|
.hversion_rev = HVERSION_REV_ANY_ID,
|
|
|
.hversion = HVERSION_ANY_ID,
|
|
|
- .sversion = 0x73,
|
|
|
+ .sversion = 0x73,
|
|
|
},
|
|
|
{ 0, }
|
|
|
};
|
|
|
@@ -772,16 +819,15 @@ static struct parisc_driver hp_sdc_driver = {
|
|
|
|
|
|
static int __init hp_sdc_init(void)
|
|
|
{
|
|
|
- int i;
|
|
|
char *errstr;
|
|
|
hp_sdc_transaction t_sync;
|
|
|
uint8_t ts_sync[6];
|
|
|
struct semaphore s_sync;
|
|
|
|
|
|
- rwlock_init(&hp_sdc.lock);
|
|
|
- rwlock_init(&hp_sdc.ibf_lock);
|
|
|
- rwlock_init(&hp_sdc.rtq_lock);
|
|
|
- rwlock_init(&hp_sdc.hook_lock);
|
|
|
+ rwlock_init(&hp_sdc.lock);
|
|
|
+ rwlock_init(&hp_sdc.ibf_lock);
|
|
|
+ rwlock_init(&hp_sdc.rtq_lock);
|
|
|
+ rwlock_init(&hp_sdc.hook_lock);
|
|
|
|
|
|
hp_sdc.timer = NULL;
|
|
|
hp_sdc.hil = NULL;
|
|
|
@@ -796,7 +842,8 @@ static int __init hp_sdc_init(void)
|
|
|
hp_sdc.r7[3] = 0xff;
|
|
|
hp_sdc.ibf = 1;
|
|
|
|
|
|
- for (i = 0; i < HP_SDC_QUEUE_LEN; i++) hp_sdc.tq[i] = NULL;
|
|
|
+ memset(&hp_sdc.tq, 0, sizeof(hp_sdc.tq));
|
|
|
+
|
|
|
hp_sdc.wcurr = -1;
|
|
|
hp_sdc.rcurr = -1;
|
|
|
hp_sdc.rqty = 0;
|
|
|
@@ -804,27 +851,32 @@ static int __init hp_sdc_init(void)
|
|
|
hp_sdc.dev_err = -ENODEV;
|
|
|
|
|
|
errstr = "IO not found for";
|
|
|
- if (!hp_sdc.base_io) goto err0;
|
|
|
+ if (!hp_sdc.base_io)
|
|
|
+ goto err0;
|
|
|
|
|
|
errstr = "IRQ not found for";
|
|
|
- if (!hp_sdc.irq) goto err0;
|
|
|
+ if (!hp_sdc.irq)
|
|
|
+ goto err0;
|
|
|
|
|
|
hp_sdc.dev_err = -EBUSY;
|
|
|
|
|
|
#if defined(__hppa__)
|
|
|
errstr = "IO not available for";
|
|
|
- if (request_region(hp_sdc.data_io, 2, hp_sdc_driver.name)) goto err0;
|
|
|
-#endif
|
|
|
+ if (request_region(hp_sdc.data_io, 2, hp_sdc_driver.name))
|
|
|
+ goto err0;
|
|
|
+#endif
|
|
|
|
|
|
errstr = "IRQ not available for";
|
|
|
if (request_irq(hp_sdc.irq, &hp_sdc_isr, IRQF_SHARED|IRQF_SAMPLE_RANDOM,
|
|
|
- "HP SDC", &hp_sdc)) goto err1;
|
|
|
+ "HP SDC", &hp_sdc))
|
|
|
+ goto err1;
|
|
|
|
|
|
errstr = "NMI not available for";
|
|
|
if (request_irq(hp_sdc.nmi, &hp_sdc_nmisr, IRQF_SHARED,
|
|
|
- "HP SDC NMI", &hp_sdc)) goto err2;
|
|
|
+ "HP SDC NMI", &hp_sdc))
|
|
|
+ goto err2;
|
|
|
|
|
|
- printk(KERN_INFO PREFIX "HP SDC at 0x%p, IRQ %d (NMI IRQ %d)\n",
|
|
|
+ printk(KERN_INFO PREFIX "HP SDC at 0x%p, IRQ %d (NMI IRQ %d)\n",
|
|
|
(void *)hp_sdc.base_io, hp_sdc.irq, hp_sdc.nmi);
|
|
|
|
|
|
hp_sdc_status_in8();
|
|
|
@@ -858,9 +910,10 @@ static int __init hp_sdc_init(void)
|
|
|
err1:
|
|
|
release_region(hp_sdc.data_io, 2);
|
|
|
err0:
|
|
|
- printk(KERN_WARNING PREFIX ": %s SDC IO=0x%p IRQ=0x%x NMI=0x%x\n",
|
|
|
+ printk(KERN_WARNING PREFIX ": %s SDC IO=0x%p IRQ=0x%x NMI=0x%x\n",
|
|
|
errstr, (void *)hp_sdc.base_io, hp_sdc.irq, hp_sdc.nmi);
|
|
|
hp_sdc.dev = NULL;
|
|
|
+
|
|
|
return hp_sdc.dev_err;
|
|
|
}
|
|
|
|
|
|
@@ -868,8 +921,10 @@ static int __init hp_sdc_init(void)
|
|
|
|
|
|
static int __init hp_sdc_init_hppa(struct parisc_device *d)
|
|
|
{
|
|
|
- if (!d) return 1;
|
|
|
- if (hp_sdc.dev != NULL) return 1; /* We only expect one SDC */
|
|
|
+ if (!d)
|
|
|
+ return 1;
|
|
|
+ if (hp_sdc.dev != NULL)
|
|
|
+ return 1; /* We only expect one SDC */
|
|
|
|
|
|
hp_sdc.dev = d;
|
|
|
hp_sdc.irq = d->irq;
|
|
|
@@ -906,10 +961,8 @@ static void hp_sdc_exit(void)
|
|
|
|
|
|
tasklet_kill(&hp_sdc.task);
|
|
|
|
|
|
-/* release_region(hp_sdc.data_io, 2); */
|
|
|
-
|
|
|
#if defined(__hppa__)
|
|
|
- if (unregister_parisc_driver(&hp_sdc_driver))
|
|
|
+ if (unregister_parisc_driver(&hp_sdc_driver))
|
|
|
printk(KERN_WARNING PREFIX "Error unregistering HP SDC");
|
|
|
#endif
|
|
|
}
|
|
|
@@ -923,7 +976,7 @@ static int __init hp_sdc_register(void)
|
|
|
mm_segment_t fs;
|
|
|
unsigned char i;
|
|
|
#endif
|
|
|
-
|
|
|
+
|
|
|
hp_sdc.dev = NULL;
|
|
|
hp_sdc.dev_err = 0;
|
|
|
#if defined(__hppa__)
|
|
|
@@ -960,8 +1013,8 @@ static int __init hp_sdc_register(void)
|
|
|
tq_init.seq = tq_init_seq;
|
|
|
tq_init.act.semaphore = &tq_init_sem;
|
|
|
|
|
|
- tq_init_seq[0] =
|
|
|
- HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN | HP_SDC_ACT_SEMAPHORE;
|
|
|
+ tq_init_seq[0] =
|
|
|
+ HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN | HP_SDC_ACT_SEMAPHORE;
|
|
|
tq_init_seq[1] = HP_SDC_CMD_READ_KCC;
|
|
|
tq_init_seq[2] = 1;
|
|
|
tq_init_seq[3] = 0;
|
|
|
@@ -979,13 +1032,13 @@ static int __init hp_sdc_register(void)
|
|
|
}
|
|
|
hp_sdc.r11 = tq_init_seq[4];
|
|
|
if (hp_sdc.r11 & HP_SDC_CFG_NEW) {
|
|
|
- char *str;
|
|
|
+ const char *str;
|
|
|
printk(KERN_INFO PREFIX "New style SDC\n");
|
|
|
tq_init_seq[1] = HP_SDC_CMD_READ_XTD;
|
|
|
tq_init.actidx = 0;
|
|
|
tq_init.idx = 1;
|
|
|
down(&tq_init_sem);
|
|
|
- hp_sdc_enqueue_transaction(&tq_init);
|
|
|
+ hp_sdc_enqueue_transaction(&tq_init);
|
|
|
down(&tq_init_sem);
|
|
|
up(&tq_init_sem);
|
|
|
if ((tq_init_seq[0] & HP_SDC_ACT_DEAD) == HP_SDC_ACT_DEAD) {
|
|
|
@@ -995,15 +1048,13 @@ static int __init hp_sdc_register(void)
|
|
|
hp_sdc.r7e = tq_init_seq[4];
|
|
|
HP_SDC_XTD_REV_STRINGS(hp_sdc.r7e & HP_SDC_XTD_REV, str)
|
|
|
printk(KERN_INFO PREFIX "Revision: %s\n", str);
|
|
|
- if (hp_sdc.r7e & HP_SDC_XTD_BEEPER) {
|
|
|
+ if (hp_sdc.r7e & HP_SDC_XTD_BEEPER)
|
|
|
printk(KERN_INFO PREFIX "TI SN76494 beeper present\n");
|
|
|
- }
|
|
|
- if (hp_sdc.r7e & HP_SDC_XTD_BBRTC) {
|
|
|
+ if (hp_sdc.r7e & HP_SDC_XTD_BBRTC)
|
|
|
printk(KERN_INFO PREFIX "OKI MSM-58321 BBRTC present\n");
|
|
|
- }
|
|
|
printk(KERN_INFO PREFIX "Spunking the self test register to force PUP "
|
|
|
"on next firmware reset.\n");
|
|
|
- tq_init_seq[0] = HP_SDC_ACT_PRECMD |
|
|
|
+ tq_init_seq[0] = HP_SDC_ACT_PRECMD |
|
|
|
HP_SDC_ACT_DATAOUT | HP_SDC_ACT_SEMAPHORE;
|
|
|
tq_init_seq[1] = HP_SDC_CMD_SET_STR;
|
|
|
tq_init_seq[2] = 1;
|
|
|
@@ -1012,14 +1063,12 @@ static int __init hp_sdc_register(void)
|
|
|
tq_init.idx = 1;
|
|
|
tq_init.endidx = 4;
|
|
|
down(&tq_init_sem);
|
|
|
- hp_sdc_enqueue_transaction(&tq_init);
|
|
|
+ hp_sdc_enqueue_transaction(&tq_init);
|
|
|
down(&tq_init_sem);
|
|
|
up(&tq_init_sem);
|
|
|
- }
|
|
|
- else {
|
|
|
- printk(KERN_INFO PREFIX "Old style SDC (1820-%s).\n",
|
|
|
+ } else
|
|
|
+ printk(KERN_INFO PREFIX "Old style SDC (1820-%s).\n",
|
|
|
(hp_sdc.r11 & HP_SDC_CFG_REV) ? "3300" : "2564/3087");
|
|
|
- }
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
@@ -1027,13 +1076,13 @@ static int __init hp_sdc_register(void)
|
|
|
module_init(hp_sdc_register);
|
|
|
module_exit(hp_sdc_exit);
|
|
|
|
|
|
-/* Timing notes: These measurements taken on my 64MHz 7100-LC (715/64)
|
|
|
+/* Timing notes: These measurements taken on my 64MHz 7100-LC (715/64)
|
|
|
* cycles cycles-adj time
|
|
|
* between two consecutive mfctl(16)'s: 4 n/a 63ns
|
|
|
* hp_sdc_spin_ibf when idle: 119 115 1.7us
|
|
|
* gsc_writeb status register: 83 79 1.2us
|
|
|
* IBF to clear after sending SET_IM: 6204 6006 93us
|
|
|
- * IBF to clear after sending LOAD_RT: 4467 4352 68us
|
|
|
+ * IBF to clear after sending LOAD_RT: 4467 4352 68us
|
|
|
* IBF to clear after sending two LOAD_RTs: 18974 18859 295us
|
|
|
* READ_T1, read status/data, IRQ, call handler: 35564 n/a 556us
|
|
|
* cmd to ~IBF READ_T1 2nd time right after: 5158403 n/a 81ms
|
Helge Deller