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