Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[linux-2.6] / drivers / input / serio / hp_sdc.c
1 /*
2  * HP i8042-based System Device Controller driver.
3  *
4  * Copyright (c) 2001 Brian S. Julin
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions, and the following disclaimer,
12  *    without modification.
13  * 2. The name of the author may not be used to endorse or promote products
14  *    derived from this software without specific prior written permission.
15  *
16  * Alternatively, this software may be distributed under the terms of the
17  * GNU General Public License ("GPL").
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
23  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  *
29  * References:
30  * System Device Controller Microprocessor Firmware Theory of Operation
31  *      for Part Number 1820-4784 Revision B.  Dwg No. A-1820-4784-2
32  * Helge Deller's original hilkbd.c port for PA-RISC.
33  *
34  *
35  * Driver theory of operation:
36  *
37  * hp_sdc_put does all writing to the SDC.  ISR can run on a different
38  * CPU than hp_sdc_put, but only one CPU runs hp_sdc_put at a time
39  * (it cannot really benefit from SMP anyway.)  A tasket fit this perfectly.
40  *
41  * All data coming back from the SDC is sent via interrupt and can be read
42  * fully in the ISR, so there are no latency/throughput problems there.
43  * The problem is with output, due to the slow clock speed of the SDC
44  * compared to the CPU.  This should not be too horrible most of the time,
45  * but if used with HIL devices that support the multibyte transfer command,
46  * keeping outbound throughput flowing at the 6500KBps that the HIL is
47  * capable of is more than can be done at HZ=100.
48  *
49  * Busy polling for IBF clear wastes CPU cycles and bus cycles.  hp_sdc.ibf
50  * is set to 0 when the IBF flag in the status register has cleared.  ISR
51  * may do this, and may also access the parts of queued transactions related
52  * to reading data back from the SDC, but otherwise will not touch the
53  * hp_sdc state. Whenever a register is written hp_sdc.ibf is set to 1.
54  *
55  * The i8042 write index and the values in the 4-byte input buffer
56  * starting at 0x70 are kept track of in hp_sdc.wi, and .r7[], respectively,
57  * to minimize the amount of IO needed to the SDC.  However these values
58  * do not need to be locked since they are only ever accessed by hp_sdc_put.
59  *
60  * A timer task schedules the tasklet once per second just to make
61  * sure it doesn't freeze up and to allow for bad reads to time out.
62  */
63
64 #include <linux/hp_sdc.h>
65 #include <linux/errno.h>
66 #include <linux/init.h>
67 #include <linux/module.h>
68 #include <linux/ioport.h>
69 #include <linux/time.h>
70 #include <linux/slab.h>
71 #include <linux/hil.h>
72 #include <asm/io.h>
73 #include <asm/system.h>
74
75 /* Machine-specific abstraction */
76
77 #if defined(__hppa__)
78 # include <asm/parisc-device.h>
79 # define sdc_readb(p)           gsc_readb(p)
80 # define sdc_writeb(v,p)        gsc_writeb((v),(p))
81 #elif defined(__mc68000__)
82 # include <asm/uaccess.h>
83 # define sdc_readb(p)           in_8(p)
84 # define sdc_writeb(v,p)        out_8((p),(v))
85 #else
86 # error "HIL is not supported on this platform"
87 #endif
88
89 #define PREFIX "HP SDC: "
90
91 MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>");
92 MODULE_DESCRIPTION("HP i8042-based SDC Driver");
93 MODULE_LICENSE("Dual BSD/GPL");
94
95 EXPORT_SYMBOL(hp_sdc_request_timer_irq);
96 EXPORT_SYMBOL(hp_sdc_request_hil_irq);
97 EXPORT_SYMBOL(hp_sdc_request_cooked_irq);
98
99 EXPORT_SYMBOL(hp_sdc_release_timer_irq);
100 EXPORT_SYMBOL(hp_sdc_release_hil_irq);
101 EXPORT_SYMBOL(hp_sdc_release_cooked_irq);
102
103 EXPORT_SYMBOL(__hp_sdc_enqueue_transaction);
104 EXPORT_SYMBOL(hp_sdc_enqueue_transaction);
105 EXPORT_SYMBOL(hp_sdc_dequeue_transaction);
106
107 static hp_i8042_sdc     hp_sdc; /* All driver state is kept in here. */
108
109 /*************** primitives for use in any context *********************/
110 static inline uint8_t hp_sdc_status_in8(void)
111 {
112         uint8_t status;
113         unsigned long flags;
114
115         write_lock_irqsave(&hp_sdc.ibf_lock, flags);
116         status = sdc_readb(hp_sdc.status_io);
117         if (!(status & HP_SDC_STATUS_IBF))
118                 hp_sdc.ibf = 0;
119         write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
120
121         return status;
122 }
123
124 static inline uint8_t hp_sdc_data_in8(void)
125 {
126         return sdc_readb(hp_sdc.data_io);
127 }
128
129 static inline void hp_sdc_status_out8(uint8_t val)
130 {
131         unsigned long flags;
132
133         write_lock_irqsave(&hp_sdc.ibf_lock, flags);
134         hp_sdc.ibf = 1;
135         if ((val & 0xf0) == 0xe0)
136                 hp_sdc.wi = 0xff;
137         sdc_writeb(val, hp_sdc.status_io);
138         write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
139 }
140
141 static inline void hp_sdc_data_out8(uint8_t val)
142 {
143         unsigned long flags;
144
145         write_lock_irqsave(&hp_sdc.ibf_lock, flags);
146         hp_sdc.ibf = 1;
147         sdc_writeb(val, hp_sdc.data_io);
148         write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
149 }
150
151 /*      Care must be taken to only invoke hp_sdc_spin_ibf when
152  *      absolutely needed, or in rarely invoked subroutines.
153  *      Not only does it waste CPU cycles, it also wastes bus cycles.
154  */
155 static inline void hp_sdc_spin_ibf(void)
156 {
157         unsigned long flags;
158         rwlock_t *lock;
159
160         lock = &hp_sdc.ibf_lock;
161
162         read_lock_irqsave(lock, flags);
163         if (!hp_sdc.ibf) {
164                 read_unlock_irqrestore(lock, flags);
165                 return;
166         }
167         read_unlock(lock);
168         write_lock(lock);
169         while (sdc_readb(hp_sdc.status_io) & HP_SDC_STATUS_IBF)
170                 { }
171         hp_sdc.ibf = 0;
172         write_unlock_irqrestore(lock, flags);
173 }
174
175
176 /************************ Interrupt context functions ************************/
177 static void hp_sdc_take(int irq, void *dev_id, uint8_t status, uint8_t data)
178 {
179         hp_sdc_transaction *curr;
180
181         read_lock(&hp_sdc.rtq_lock);
182         if (hp_sdc.rcurr < 0) {
183                 read_unlock(&hp_sdc.rtq_lock);
184                 return;
185         }
186         curr = hp_sdc.tq[hp_sdc.rcurr];
187         read_unlock(&hp_sdc.rtq_lock);
188
189         curr->seq[curr->idx++] = status;
190         curr->seq[curr->idx++] = data;
191         hp_sdc.rqty -= 2;
192         do_gettimeofday(&hp_sdc.rtv);
193
194         if (hp_sdc.rqty <= 0) {
195                 /* All data has been gathered. */
196                 if (curr->seq[curr->actidx] & HP_SDC_ACT_SEMAPHORE)
197                         if (curr->act.semaphore)
198                                 up(curr->act.semaphore);
199
200                 if (curr->seq[curr->actidx] & HP_SDC_ACT_CALLBACK)
201                         if (curr->act.irqhook)
202                                 curr->act.irqhook(irq, dev_id, status, data);
203
204                 curr->actidx = curr->idx;
205                 curr->idx++;
206                 /* Return control of this transaction */
207                 write_lock(&hp_sdc.rtq_lock);
208                 hp_sdc.rcurr = -1;
209                 hp_sdc.rqty = 0;
210                 write_unlock(&hp_sdc.rtq_lock);
211                 tasklet_schedule(&hp_sdc.task);
212         }
213 }
214
215 static irqreturn_t hp_sdc_isr(int irq, void *dev_id)
216 {
217         uint8_t status, data;
218
219         status = hp_sdc_status_in8();
220         /* Read data unconditionally to advance i8042. */
221         data =   hp_sdc_data_in8();
222
223         /* For now we are ignoring these until we get the SDC to behave. */
224         if (((status & 0xf1) == 0x51) && data == 0x82)
225                 return IRQ_HANDLED;
226
227         switch (status & HP_SDC_STATUS_IRQMASK) {
228         case 0: /* This case is not documented. */
229                 break;
230
231         case HP_SDC_STATUS_USERTIMER:
232         case HP_SDC_STATUS_PERIODIC:
233         case HP_SDC_STATUS_TIMER:
234                 read_lock(&hp_sdc.hook_lock);
235                 if (hp_sdc.timer != NULL)
236                         hp_sdc.timer(irq, dev_id, status, data);
237                 read_unlock(&hp_sdc.hook_lock);
238                 break;
239
240         case HP_SDC_STATUS_REG:
241                 hp_sdc_take(irq, dev_id, status, data);
242                 break;
243
244         case HP_SDC_STATUS_HILCMD:
245         case HP_SDC_STATUS_HILDATA:
246                 read_lock(&hp_sdc.hook_lock);
247                 if (hp_sdc.hil != NULL)
248                         hp_sdc.hil(irq, dev_id, status, data);
249                 read_unlock(&hp_sdc.hook_lock);
250                 break;
251
252         case HP_SDC_STATUS_PUP:
253                 read_lock(&hp_sdc.hook_lock);
254                 if (hp_sdc.pup != NULL)
255                         hp_sdc.pup(irq, dev_id, status, data);
256                 else
257                         printk(KERN_INFO PREFIX "HP SDC reports successful PUP.\n");
258                 read_unlock(&hp_sdc.hook_lock);
259                 break;
260
261         default:
262                 read_lock(&hp_sdc.hook_lock);
263                 if (hp_sdc.cooked != NULL)
264                         hp_sdc.cooked(irq, dev_id, status, data);
265                 read_unlock(&hp_sdc.hook_lock);
266                 break;
267         }
268
269         return IRQ_HANDLED;
270 }
271
272
273 static irqreturn_t hp_sdc_nmisr(int irq, void *dev_id)
274 {
275         int status;
276
277         status = hp_sdc_status_in8();
278         printk(KERN_WARNING PREFIX "NMI !\n");
279
280 #if 0
281         if (status & HP_SDC_NMISTATUS_FHS) {
282                 read_lock(&hp_sdc.hook_lock);
283                 if (hp_sdc.timer != NULL)
284                         hp_sdc.timer(irq, dev_id, status, 0);
285                 read_unlock(&hp_sdc.hook_lock);
286         } else {
287                 /* TODO: pass this on to the HIL handler, or do SAK here? */
288                 printk(KERN_WARNING PREFIX "HIL NMI\n");
289         }
290 #endif
291
292         return IRQ_HANDLED;
293 }
294
295
296 /***************** Kernel (tasklet) context functions ****************/
297
298 unsigned long hp_sdc_put(void);
299
300 static void hp_sdc_tasklet(unsigned long foo)
301 {
302         write_lock_irq(&hp_sdc.rtq_lock);
303
304         if (hp_sdc.rcurr >= 0) {
305                 struct timeval tv;
306
307                 do_gettimeofday(&tv);
308                 if (tv.tv_sec > hp_sdc.rtv.tv_sec)
309                         tv.tv_usec += USEC_PER_SEC;
310
311                 if (tv.tv_usec - hp_sdc.rtv.tv_usec > HP_SDC_MAX_REG_DELAY) {
312                         hp_sdc_transaction *curr;
313                         uint8_t tmp;
314
315                         curr = hp_sdc.tq[hp_sdc.rcurr];
316                         /* If this turns out to be a normal failure mode
317                          * we'll need to figure out a way to communicate
318                          * it back to the application. and be less verbose.
319                          */
320                         printk(KERN_WARNING PREFIX "read timeout (%ius)!\n",
321                                tv.tv_usec - hp_sdc.rtv.tv_usec);
322                         curr->idx += hp_sdc.rqty;
323                         hp_sdc.rqty = 0;
324                         tmp = curr->seq[curr->actidx];
325                         curr->seq[curr->actidx] |= HP_SDC_ACT_DEAD;
326                         if (tmp & HP_SDC_ACT_SEMAPHORE)
327                                 if (curr->act.semaphore)
328                                         up(curr->act.semaphore);
329
330                         if (tmp & HP_SDC_ACT_CALLBACK) {
331                                 /* Note this means that irqhooks may be called
332                                  * in tasklet/bh context.
333                                  */
334                                 if (curr->act.irqhook)
335                                         curr->act.irqhook(0, NULL, 0, 0);
336                         }
337
338                         curr->actidx = curr->idx;
339                         curr->idx++;
340                         hp_sdc.rcurr = -1;
341                 }
342         }
343         write_unlock_irq(&hp_sdc.rtq_lock);
344         hp_sdc_put();
345 }
346
347 unsigned long hp_sdc_put(void)
348 {
349         hp_sdc_transaction *curr;
350         uint8_t act;
351         int idx, curridx;
352
353         int limit = 0;
354
355         write_lock(&hp_sdc.lock);
356
357         /* If i8042 buffers are full, we cannot do anything that
358            requires output, so we skip to the administrativa. */
359         if (hp_sdc.ibf) {
360                 hp_sdc_status_in8();
361                 if (hp_sdc.ibf)
362                         goto finish;
363         }
364
365  anew:
366         /* See if we are in the middle of a sequence. */
367         if (hp_sdc.wcurr < 0)
368                 hp_sdc.wcurr = 0;
369         read_lock_irq(&hp_sdc.rtq_lock);
370         if (hp_sdc.rcurr == hp_sdc.wcurr)
371                 hp_sdc.wcurr++;
372         read_unlock_irq(&hp_sdc.rtq_lock);
373         if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
374                 hp_sdc.wcurr = 0;
375         curridx = hp_sdc.wcurr;
376
377         if (hp_sdc.tq[curridx] != NULL)
378                 goto start;
379
380         while (++curridx != hp_sdc.wcurr) {
381                 if (curridx >= HP_SDC_QUEUE_LEN) {
382                         curridx = -1; /* Wrap to top */
383                         continue;
384                 }
385                 read_lock_irq(&hp_sdc.rtq_lock);
386                 if (hp_sdc.rcurr == curridx) {
387                         read_unlock_irq(&hp_sdc.rtq_lock);
388                         continue;
389                 }
390                 read_unlock_irq(&hp_sdc.rtq_lock);
391                 if (hp_sdc.tq[curridx] != NULL)
392                         break; /* Found one. */
393         }
394         if (curridx == hp_sdc.wcurr) { /* There's nothing queued to do. */
395                 curridx = -1;
396         }
397         hp_sdc.wcurr = curridx;
398
399  start:
400
401         /* Check to see if the interrupt mask needs to be set. */
402         if (hp_sdc.set_im) {
403                 hp_sdc_status_out8(hp_sdc.im | HP_SDC_CMD_SET_IM);
404                 hp_sdc.set_im = 0;
405                 goto finish;
406         }
407
408         if (hp_sdc.wcurr == -1)
409                 goto done;
410
411         curr = hp_sdc.tq[curridx];
412         idx = curr->actidx;
413
414         if (curr->actidx >= curr->endidx) {
415                 hp_sdc.tq[curridx] = NULL;
416                 /* Interleave outbound data between the transactions. */
417                 hp_sdc.wcurr++;
418                 if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
419                         hp_sdc.wcurr = 0;
420                 goto finish;
421         }
422
423         act = curr->seq[idx];
424         idx++;
425
426         if (curr->idx >= curr->endidx) {
427                 if (act & HP_SDC_ACT_DEALLOC)
428                         kfree(curr);
429                 hp_sdc.tq[curridx] = NULL;
430                 /* Interleave outbound data between the transactions. */
431                 hp_sdc.wcurr++;
432                 if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
433                         hp_sdc.wcurr = 0;
434                 goto finish;
435         }
436
437         while (act & HP_SDC_ACT_PRECMD) {
438                 if (curr->idx != idx) {
439                         idx++;
440                         act &= ~HP_SDC_ACT_PRECMD;
441                         break;
442                 }
443                 hp_sdc_status_out8(curr->seq[idx]);
444                 curr->idx++;
445                 /* act finished? */
446                 if ((act & HP_SDC_ACT_DURING) == HP_SDC_ACT_PRECMD)
447                         goto actdone;
448                 /* skip quantity field if data-out sequence follows. */
449                 if (act & HP_SDC_ACT_DATAOUT)
450                         curr->idx++;
451                 goto finish;
452         }
453         if (act & HP_SDC_ACT_DATAOUT) {
454                 int qty;
455
456                 qty = curr->seq[idx];
457                 idx++;
458                 if (curr->idx - idx < qty) {
459                         hp_sdc_data_out8(curr->seq[curr->idx]);
460                         curr->idx++;
461                         /* act finished? */
462                         if (curr->idx - idx >= qty &&
463                             (act & HP_SDC_ACT_DURING) == HP_SDC_ACT_DATAOUT)
464                                 goto actdone;
465                         goto finish;
466                 }
467                 idx += qty;
468                 act &= ~HP_SDC_ACT_DATAOUT;
469         } else
470             while (act & HP_SDC_ACT_DATAREG) {
471                 int mask;
472                 uint8_t w7[4];
473
474                 mask = curr->seq[idx];
475                 if (idx != curr->idx) {
476                         idx++;
477                         idx += !!(mask & 1);
478                         idx += !!(mask & 2);
479                         idx += !!(mask & 4);
480                         idx += !!(mask & 8);
481                         act &= ~HP_SDC_ACT_DATAREG;
482                         break;
483                 }
484
485                 w7[0] = (mask & 1) ? curr->seq[++idx] : hp_sdc.r7[0];
486                 w7[1] = (mask & 2) ? curr->seq[++idx] : hp_sdc.r7[1];
487                 w7[2] = (mask & 4) ? curr->seq[++idx] : hp_sdc.r7[2];
488                 w7[3] = (mask & 8) ? curr->seq[++idx] : hp_sdc.r7[3];
489
490                 if (hp_sdc.wi > 0x73 || hp_sdc.wi < 0x70 ||
491                     w7[hp_sdc.wi - 0x70] == hp_sdc.r7[hp_sdc.wi - 0x70]) {
492                         int i = 0;
493
494                         /* Need to point the write index register */
495                         while (i < 4 && w7[i] == hp_sdc.r7[i])
496                                 i++;
497
498                         if (i < 4) {
499                                 hp_sdc_status_out8(HP_SDC_CMD_SET_D0 + i);
500                                 hp_sdc.wi = 0x70 + i;
501                                 goto finish;
502                         }
503
504                         idx++;
505                         if ((act & HP_SDC_ACT_DURING) == HP_SDC_ACT_DATAREG)
506                                 goto actdone;
507
508                         curr->idx = idx;
509                         act &= ~HP_SDC_ACT_DATAREG;
510                         break;
511                 }
512
513                 hp_sdc_data_out8(w7[hp_sdc.wi - 0x70]);
514                 hp_sdc.r7[hp_sdc.wi - 0x70] = w7[hp_sdc.wi - 0x70];
515                 hp_sdc.wi++; /* write index register autoincrements */
516                 {
517                         int i = 0;
518
519                         while ((i < 4) && w7[i] == hp_sdc.r7[i])
520                                 i++;
521                         if (i >= 4) {
522                                 curr->idx = idx + 1;
523                                 if ((act & HP_SDC_ACT_DURING) ==
524                                     HP_SDC_ACT_DATAREG)
525                                         goto actdone;
526                         }
527                 }
528                 goto finish;
529         }
530         /* We don't go any further in the command if there is a pending read,
531            because we don't want interleaved results. */
532         read_lock_irq(&hp_sdc.rtq_lock);
533         if (hp_sdc.rcurr >= 0) {
534                 read_unlock_irq(&hp_sdc.rtq_lock);
535                 goto finish;
536         }
537         read_unlock_irq(&hp_sdc.rtq_lock);
538
539
540         if (act & HP_SDC_ACT_POSTCMD) {
541                 uint8_t postcmd;
542
543                 /* curr->idx should == idx at this point. */
544                 postcmd = curr->seq[idx];
545                 curr->idx++;
546                 if (act & HP_SDC_ACT_DATAIN) {
547
548                         /* Start a new read */
549                         hp_sdc.rqty = curr->seq[curr->idx];
550                         do_gettimeofday(&hp_sdc.rtv);
551                         curr->idx++;
552                         /* Still need to lock here in case of spurious irq. */
553                         write_lock_irq(&hp_sdc.rtq_lock);
554                         hp_sdc.rcurr = curridx;
555                         write_unlock_irq(&hp_sdc.rtq_lock);
556                         hp_sdc_status_out8(postcmd);
557                         goto finish;
558                 }
559                 hp_sdc_status_out8(postcmd);
560                 goto actdone;
561         }
562
563  actdone:
564         if (act & HP_SDC_ACT_SEMAPHORE)
565                 up(curr->act.semaphore);
566         else if (act & HP_SDC_ACT_CALLBACK)
567                 curr->act.irqhook(0,NULL,0,0);
568
569         if (curr->idx >= curr->endidx) { /* This transaction is over. */
570                 if (act & HP_SDC_ACT_DEALLOC)
571                         kfree(curr);
572                 hp_sdc.tq[curridx] = NULL;
573         } else {
574                 curr->actidx = idx + 1;
575                 curr->idx = idx + 2;
576         }
577         /* Interleave outbound data between the transactions. */
578         hp_sdc.wcurr++;
579         if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
580                 hp_sdc.wcurr = 0;
581
582  finish:
583         /* If by some quirk IBF has cleared and our ISR has run to
584            see that that has happened, do it all again. */
585         if (!hp_sdc.ibf && limit++ < 20)
586                 goto anew;
587
588  done:
589         if (hp_sdc.wcurr >= 0)
590                 tasklet_schedule(&hp_sdc.task);
591         write_unlock(&hp_sdc.lock);
592
593         return 0;
594 }
595
596 /******* Functions called in either user or kernel context ****/
597 int __hp_sdc_enqueue_transaction(hp_sdc_transaction *this)
598 {
599         int i;
600
601         if (this == NULL) {
602                 BUG();
603                 return -EINVAL;
604         }
605
606         /* Can't have same transaction on queue twice */
607         for (i = 0; i < HP_SDC_QUEUE_LEN; i++)
608                 if (hp_sdc.tq[i] == this)
609                         goto fail;
610
611         this->actidx = 0;
612         this->idx = 1;
613
614         /* Search for empty slot */
615         for (i = 0; i < HP_SDC_QUEUE_LEN; i++)
616                 if (hp_sdc.tq[i] == NULL) {
617                         hp_sdc.tq[i] = this;
618                         tasklet_schedule(&hp_sdc.task);
619                         return 0;
620                 }
621
622         printk(KERN_WARNING PREFIX "No free slot to add transaction.\n");
623         return -EBUSY;
624
625  fail:
626         printk(KERN_WARNING PREFIX "Transaction add failed: transaction already queued?\n");
627         return -EINVAL;
628 }
629
630 int hp_sdc_enqueue_transaction(hp_sdc_transaction *this) {
631         unsigned long flags;
632         int ret;
633
634         write_lock_irqsave(&hp_sdc.lock, flags);
635         ret = __hp_sdc_enqueue_transaction(this);
636         write_unlock_irqrestore(&hp_sdc.lock,flags);
637
638         return ret;
639 }
640
641 int hp_sdc_dequeue_transaction(hp_sdc_transaction *this)
642 {
643         unsigned long flags;
644         int i;
645
646         write_lock_irqsave(&hp_sdc.lock, flags);
647
648         /* TODO: don't remove it if it's not done. */
649
650         for (i = 0; i < HP_SDC_QUEUE_LEN; i++)
651                 if (hp_sdc.tq[i] == this)
652                         hp_sdc.tq[i] = NULL;
653
654         write_unlock_irqrestore(&hp_sdc.lock, flags);
655         return 0;
656 }
657
658
659
660 /********************** User context functions **************************/
661 int hp_sdc_request_timer_irq(hp_sdc_irqhook *callback)
662 {
663         if (callback == NULL || hp_sdc.dev == NULL)
664                 return -EINVAL;
665
666         write_lock_irq(&hp_sdc.hook_lock);
667         if (hp_sdc.timer != NULL) {
668                 write_unlock_irq(&hp_sdc.hook_lock);
669                 return -EBUSY;
670         }
671
672         hp_sdc.timer = callback;
673         /* Enable interrupts from the timers */
674         hp_sdc.im &= ~HP_SDC_IM_FH;
675         hp_sdc.im &= ~HP_SDC_IM_PT;
676         hp_sdc.im &= ~HP_SDC_IM_TIMERS;
677         hp_sdc.set_im = 1;
678         write_unlock_irq(&hp_sdc.hook_lock);
679
680         tasklet_schedule(&hp_sdc.task);
681
682         return 0;
683 }
684
685 int hp_sdc_request_hil_irq(hp_sdc_irqhook *callback)
686 {
687         if (callback == NULL || hp_sdc.dev == NULL)
688                 return -EINVAL;
689
690         write_lock_irq(&hp_sdc.hook_lock);
691         if (hp_sdc.hil != NULL) {
692                 write_unlock_irq(&hp_sdc.hook_lock);
693                 return -EBUSY;
694         }
695
696         hp_sdc.hil = callback;
697         hp_sdc.im &= ~(HP_SDC_IM_HIL | HP_SDC_IM_RESET);
698         hp_sdc.set_im = 1;
699         write_unlock_irq(&hp_sdc.hook_lock);
700
701         tasklet_schedule(&hp_sdc.task);
702
703         return 0;
704 }
705
706 int hp_sdc_request_cooked_irq(hp_sdc_irqhook *callback)
707 {
708         if (callback == NULL || hp_sdc.dev == NULL)
709                 return -EINVAL;
710
711         write_lock_irq(&hp_sdc.hook_lock);
712         if (hp_sdc.cooked != NULL) {
713                 write_unlock_irq(&hp_sdc.hook_lock);
714                 return -EBUSY;
715         }
716
717         /* Enable interrupts from the HIL MLC */
718         hp_sdc.cooked = callback;
719         hp_sdc.im &= ~(HP_SDC_IM_HIL | HP_SDC_IM_RESET);
720         hp_sdc.set_im = 1;
721         write_unlock_irq(&hp_sdc.hook_lock);
722
723         tasklet_schedule(&hp_sdc.task);
724
725         return 0;
726 }
727
728 int hp_sdc_release_timer_irq(hp_sdc_irqhook *callback)
729 {
730         write_lock_irq(&hp_sdc.hook_lock);
731         if ((callback != hp_sdc.timer) ||
732             (hp_sdc.timer == NULL)) {
733                 write_unlock_irq(&hp_sdc.hook_lock);
734                 return -EINVAL;
735         }
736
737         /* Disable interrupts from the timers */
738         hp_sdc.timer = NULL;
739         hp_sdc.im |= HP_SDC_IM_TIMERS;
740         hp_sdc.im |= HP_SDC_IM_FH;
741         hp_sdc.im |= HP_SDC_IM_PT;
742         hp_sdc.set_im = 1;
743         write_unlock_irq(&hp_sdc.hook_lock);
744         tasklet_schedule(&hp_sdc.task);
745
746         return 0;
747 }
748
749 int hp_sdc_release_hil_irq(hp_sdc_irqhook *callback)
750 {
751         write_lock_irq(&hp_sdc.hook_lock);
752         if ((callback != hp_sdc.hil) ||
753             (hp_sdc.hil == NULL)) {
754                 write_unlock_irq(&hp_sdc.hook_lock);
755                 return -EINVAL;
756         }
757
758         hp_sdc.hil = NULL;
759         /* Disable interrupts from HIL only if there is no cooked driver. */
760         if(hp_sdc.cooked == NULL) {
761                 hp_sdc.im |= (HP_SDC_IM_HIL | HP_SDC_IM_RESET);
762                 hp_sdc.set_im = 1;
763         }
764         write_unlock_irq(&hp_sdc.hook_lock);
765         tasklet_schedule(&hp_sdc.task);
766
767         return 0;
768 }
769
770 int hp_sdc_release_cooked_irq(hp_sdc_irqhook *callback)
771 {
772         write_lock_irq(&hp_sdc.hook_lock);
773         if ((callback != hp_sdc.cooked) ||
774             (hp_sdc.cooked == NULL)) {
775                 write_unlock_irq(&hp_sdc.hook_lock);
776                 return -EINVAL;
777         }
778
779         hp_sdc.cooked = NULL;
780         /* Disable interrupts from HIL only if there is no raw HIL driver. */
781         if(hp_sdc.hil == NULL) {
782                 hp_sdc.im |= (HP_SDC_IM_HIL | HP_SDC_IM_RESET);
783                 hp_sdc.set_im = 1;
784         }
785         write_unlock_irq(&hp_sdc.hook_lock);
786         tasklet_schedule(&hp_sdc.task);
787
788         return 0;
789 }
790
791 /************************* Keepalive timer task *********************/
792
793 void hp_sdc_kicker (unsigned long data)
794 {
795         tasklet_schedule(&hp_sdc.task);
796         /* Re-insert the periodic task. */
797         mod_timer(&hp_sdc.kicker, jiffies + HZ);
798 }
799
800 /************************** Module Initialization ***************************/
801
802 #if defined(__hppa__)
803
804 static const struct parisc_device_id hp_sdc_tbl[] = {
805         {
806                 .hw_type =      HPHW_FIO,
807                 .hversion_rev = HVERSION_REV_ANY_ID,
808                 .hversion =     HVERSION_ANY_ID,
809                 .sversion =     0x73,
810          },
811         { 0, }
812 };
813
814 MODULE_DEVICE_TABLE(parisc, hp_sdc_tbl);
815
816 static int __init hp_sdc_init_hppa(struct parisc_device *d);
817
818 static struct parisc_driver hp_sdc_driver = {
819         .name =         "hp_sdc",
820         .id_table =     hp_sdc_tbl,
821         .probe =        hp_sdc_init_hppa,
822 };
823
824 #endif /* __hppa__ */
825
826 static int __init hp_sdc_init(void)
827 {
828         char *errstr;
829         hp_sdc_transaction t_sync;
830         uint8_t ts_sync[6];
831         struct semaphore s_sync;
832
833         rwlock_init(&hp_sdc.lock);
834         rwlock_init(&hp_sdc.ibf_lock);
835         rwlock_init(&hp_sdc.rtq_lock);
836         rwlock_init(&hp_sdc.hook_lock);
837
838         hp_sdc.timer            = NULL;
839         hp_sdc.hil              = NULL;
840         hp_sdc.pup              = NULL;
841         hp_sdc.cooked           = NULL;
842         hp_sdc.im               = HP_SDC_IM_MASK;  /* Mask maskable irqs */
843         hp_sdc.set_im           = 1;
844         hp_sdc.wi               = 0xff;
845         hp_sdc.r7[0]            = 0xff;
846         hp_sdc.r7[1]            = 0xff;
847         hp_sdc.r7[2]            = 0xff;
848         hp_sdc.r7[3]            = 0xff;
849         hp_sdc.ibf              = 1;
850
851         memset(&hp_sdc.tq, 0, sizeof(hp_sdc.tq));
852
853         hp_sdc.wcurr            = -1;
854         hp_sdc.rcurr            = -1;
855         hp_sdc.rqty             = 0;
856
857         hp_sdc.dev_err = -ENODEV;
858
859         errstr = "IO not found for";
860         if (!hp_sdc.base_io)
861                 goto err0;
862
863         errstr = "IRQ not found for";
864         if (!hp_sdc.irq)
865                 goto err0;
866
867         hp_sdc.dev_err = -EBUSY;
868
869 #if defined(__hppa__)
870         errstr = "IO not available for";
871         if (request_region(hp_sdc.data_io, 2, hp_sdc_driver.name))
872                 goto err0;
873 #endif
874
875         errstr = "IRQ not available for";
876         if (request_irq(hp_sdc.irq, &hp_sdc_isr, IRQF_SHARED|IRQF_SAMPLE_RANDOM,
877                         "HP SDC", &hp_sdc))
878                 goto err1;
879
880         errstr = "NMI not available for";
881         if (request_irq(hp_sdc.nmi, &hp_sdc_nmisr, IRQF_SHARED,
882                         "HP SDC NMI", &hp_sdc))
883                 goto err2;
884
885         printk(KERN_INFO PREFIX "HP SDC at 0x%p, IRQ %d (NMI IRQ %d)\n",
886                (void *)hp_sdc.base_io, hp_sdc.irq, hp_sdc.nmi);
887
888         hp_sdc_status_in8();
889         hp_sdc_data_in8();
890
891         tasklet_init(&hp_sdc.task, hp_sdc_tasklet, 0);
892
893         /* Sync the output buffer registers, thus scheduling hp_sdc_tasklet. */
894         t_sync.actidx   = 0;
895         t_sync.idx      = 1;
896         t_sync.endidx   = 6;
897         t_sync.seq      = ts_sync;
898         ts_sync[0]      = HP_SDC_ACT_DATAREG | HP_SDC_ACT_SEMAPHORE;
899         ts_sync[1]      = 0x0f;
900         ts_sync[2] = ts_sync[3] = ts_sync[4] = ts_sync[5] = 0;
901         t_sync.act.semaphore = &s_sync;
902         init_MUTEX_LOCKED(&s_sync);
903         hp_sdc_enqueue_transaction(&t_sync);
904         down(&s_sync); /* Wait for t_sync to complete */
905
906         /* Create the keepalive task */
907         init_timer(&hp_sdc.kicker);
908         hp_sdc.kicker.expires = jiffies + HZ;
909         hp_sdc.kicker.function = &hp_sdc_kicker;
910         add_timer(&hp_sdc.kicker);
911
912         hp_sdc.dev_err = 0;
913         return 0;
914  err2:
915         free_irq(hp_sdc.irq, &hp_sdc);
916  err1:
917         release_region(hp_sdc.data_io, 2);
918  err0:
919         printk(KERN_WARNING PREFIX ": %s SDC IO=0x%p IRQ=0x%x NMI=0x%x\n",
920                 errstr, (void *)hp_sdc.base_io, hp_sdc.irq, hp_sdc.nmi);
921         hp_sdc.dev = NULL;
922
923         return hp_sdc.dev_err;
924 }
925
926 #if defined(__hppa__)
927
928 static int __init hp_sdc_init_hppa(struct parisc_device *d)
929 {
930         if (!d)
931                 return 1;
932         if (hp_sdc.dev != NULL)
933                 return 1;       /* We only expect one SDC */
934
935         hp_sdc.dev              = d;
936         hp_sdc.irq              = d->irq;
937         hp_sdc.nmi              = d->aux_irq;
938         hp_sdc.base_io          = d->hpa.start;
939         hp_sdc.data_io          = d->hpa.start + 0x800;
940         hp_sdc.status_io        = d->hpa.start + 0x801;
941
942         return hp_sdc_init();
943 }
944
945 #endif /* __hppa__ */
946
947 static void hp_sdc_exit(void)
948 {
949         write_lock_irq(&hp_sdc.lock);
950
951         /* Turn off all maskable "sub-function" irq's. */
952         hp_sdc_spin_ibf();
953         sdc_writeb(HP_SDC_CMD_SET_IM | HP_SDC_IM_MASK, hp_sdc.status_io);
954
955         /* Wait until we know this has been processed by the i8042 */
956         hp_sdc_spin_ibf();
957
958         free_irq(hp_sdc.nmi, &hp_sdc);
959         free_irq(hp_sdc.irq, &hp_sdc);
960         write_unlock_irq(&hp_sdc.lock);
961
962         del_timer(&hp_sdc.kicker);
963
964         tasklet_kill(&hp_sdc.task);
965
966 #if defined(__hppa__)
967         if (unregister_parisc_driver(&hp_sdc_driver))
968                 printk(KERN_WARNING PREFIX "Error unregistering HP SDC");
969 #endif
970 }
971
972 static int __init hp_sdc_register(void)
973 {
974         hp_sdc_transaction tq_init;
975         uint8_t tq_init_seq[5];
976         struct semaphore tq_init_sem;
977 #if defined(__mc68000__)
978         mm_segment_t fs;
979         unsigned char i;
980 #endif
981
982         hp_sdc.dev = NULL;
983         hp_sdc.dev_err = 0;
984 #if defined(__hppa__)
985         if (register_parisc_driver(&hp_sdc_driver)) {
986                 printk(KERN_WARNING PREFIX "Error registering SDC with system bus tree.\n");
987                 return -ENODEV;
988         }
989 #elif defined(__mc68000__)
990         if (!MACH_IS_HP300)
991             return -ENODEV;
992
993         hp_sdc.irq       = 1;
994         hp_sdc.nmi       = 7;
995         hp_sdc.base_io   = (unsigned long) 0xf0428000;
996         hp_sdc.data_io   = (unsigned long) hp_sdc.base_io + 1;
997         hp_sdc.status_io = (unsigned long) hp_sdc.base_io + 3;
998         fs = get_fs();
999         set_fs(KERNEL_DS);
1000         if (!get_user(i, (unsigned char *)hp_sdc.data_io))
1001                 hp_sdc.dev = (void *)1;
1002         set_fs(fs);
1003         hp_sdc.dev_err   = hp_sdc_init();
1004 #endif
1005         if (hp_sdc.dev == NULL) {
1006                 printk(KERN_WARNING PREFIX "No SDC found.\n");
1007                 return hp_sdc.dev_err;
1008         }
1009
1010         init_MUTEX_LOCKED(&tq_init_sem);
1011
1012         tq_init.actidx          = 0;
1013         tq_init.idx             = 1;
1014         tq_init.endidx          = 5;
1015         tq_init.seq             = tq_init_seq;
1016         tq_init.act.semaphore   = &tq_init_sem;
1017
1018         tq_init_seq[0] =
1019                 HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN | HP_SDC_ACT_SEMAPHORE;
1020         tq_init_seq[1] = HP_SDC_CMD_READ_KCC;
1021         tq_init_seq[2] = 1;
1022         tq_init_seq[3] = 0;
1023         tq_init_seq[4] = 0;
1024
1025         hp_sdc_enqueue_transaction(&tq_init);
1026
1027         down(&tq_init_sem);
1028         up(&tq_init_sem);
1029
1030         if ((tq_init_seq[0] & HP_SDC_ACT_DEAD) == HP_SDC_ACT_DEAD) {
1031                 printk(KERN_WARNING PREFIX "Error reading config byte.\n");
1032                 hp_sdc_exit();
1033                 return -ENODEV;
1034         }
1035         hp_sdc.r11 = tq_init_seq[4];
1036         if (hp_sdc.r11 & HP_SDC_CFG_NEW) {
1037                 const char *str;
1038                 printk(KERN_INFO PREFIX "New style SDC\n");
1039                 tq_init_seq[1] = HP_SDC_CMD_READ_XTD;
1040                 tq_init.actidx          = 0;
1041                 tq_init.idx             = 1;
1042                 down(&tq_init_sem);
1043                 hp_sdc_enqueue_transaction(&tq_init);
1044                 down(&tq_init_sem);
1045                 up(&tq_init_sem);
1046                 if ((tq_init_seq[0] & HP_SDC_ACT_DEAD) == HP_SDC_ACT_DEAD) {
1047                         printk(KERN_WARNING PREFIX "Error reading extended config byte.\n");
1048                         return -ENODEV;
1049                 }
1050                 hp_sdc.r7e = tq_init_seq[4];
1051                 HP_SDC_XTD_REV_STRINGS(hp_sdc.r7e & HP_SDC_XTD_REV, str)
1052                 printk(KERN_INFO PREFIX "Revision: %s\n", str);
1053                 if (hp_sdc.r7e & HP_SDC_XTD_BEEPER)
1054                         printk(KERN_INFO PREFIX "TI SN76494 beeper present\n");
1055                 if (hp_sdc.r7e & HP_SDC_XTD_BBRTC)
1056                         printk(KERN_INFO PREFIX "OKI MSM-58321 BBRTC present\n");
1057                 printk(KERN_INFO PREFIX "Spunking the self test register to force PUP "
1058                        "on next firmware reset.\n");
1059                 tq_init_seq[0] = HP_SDC_ACT_PRECMD |
1060                         HP_SDC_ACT_DATAOUT | HP_SDC_ACT_SEMAPHORE;
1061                 tq_init_seq[1] = HP_SDC_CMD_SET_STR;
1062                 tq_init_seq[2] = 1;
1063                 tq_init_seq[3] = 0;
1064                 tq_init.actidx          = 0;
1065                 tq_init.idx             = 1;
1066                 tq_init.endidx          = 4;
1067                 down(&tq_init_sem);
1068                 hp_sdc_enqueue_transaction(&tq_init);
1069                 down(&tq_init_sem);
1070                 up(&tq_init_sem);
1071         } else
1072                 printk(KERN_INFO PREFIX "Old style SDC (1820-%s).\n",
1073                        (hp_sdc.r11 & HP_SDC_CFG_REV) ? "3300" : "2564/3087");
1074
1075         return 0;
1076 }
1077
1078 module_init(hp_sdc_register);
1079 module_exit(hp_sdc_exit);
1080
1081 /* Timing notes:  These measurements taken on my 64MHz 7100-LC (715/64)
1082  *                                              cycles cycles-adj    time
1083  * between two consecutive mfctl(16)'s:              4        n/a    63ns
1084  * hp_sdc_spin_ibf when idle:                      119        115   1.7us
1085  * gsc_writeb status register:                      83         79   1.2us
1086  * IBF to clear after sending SET_IM:             6204       6006    93us
1087  * IBF to clear after sending LOAD_RT:            4467       4352    68us
1088  * IBF to clear after sending two LOAD_RTs:      18974      18859   295us
1089  * READ_T1, read status/data, IRQ, call handler: 35564        n/a   556us
1090  * cmd to ~IBF READ_T1 2nd time right after:   5158403        n/a    81ms
1091  * between IRQ received and ~IBF for above:    2578877        n/a    40ms
1092  *
1093  * Performance stats after a run of this module configuring HIL and
1094  * receiving a few mouse events:
1095  *
1096  * status in8  282508 cycles 7128 calls
1097  * status out8   8404 cycles  341 calls
1098  * data out8     1734 cycles   78 calls
1099  * isr         174324 cycles  617 calls (includes take)
1100  * take          1241 cycles    2 calls
1101  * put        1411504 cycles 6937 calls
1102  * task       1655209 cycles 6937 calls (includes put)
1103  *
1104  */