← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-n900/saucy

« back to all changes in this revision

Viewing changes to drivers/input/serio/hp_sdc_mlc.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Poirier
  • Date: 2011-02-18 09:43:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110218094331-eyubsja4f9k0yhmq
Tags: 2.6.35-1.1
Initial release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/input/serio/hp_sdc_mlc.c
 
1
/*
 
2
 * Access to HP-HIL MLC through HP System Device Controller.
 
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
 * HP-HIL Technical Reference Manual.  Hewlett Packard Product No. 45918A
 
31
 * System Device Controller Microprocessor Firmware Theory of Operation
 
32
 *      for Part Number 1820-4784 Revision B.  Dwg No. A-1820-4784-2
 
33
 *
 
34
 */
 
35
 
 
36
#include <linux/hil_mlc.h>
 
37
#include <linux/hp_sdc.h>
 
38
#include <linux/errno.h>
 
39
#include <linux/kernel.h>
 
40
#include <linux/module.h>
 
41
#include <linux/init.h>
 
42
#include <linux/string.h>
 
43
#include <linux/semaphore.h>
 
44
 
 
45
#define PREFIX "HP SDC MLC: "
 
46
 
 
47
static hil_mlc hp_sdc_mlc;
 
48
 
 
49
MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>");
 
50
MODULE_DESCRIPTION("Glue for onboard HIL MLC in HP-PARISC machines");
 
51
MODULE_LICENSE("Dual BSD/GPL");
 
52
 
 
53
static struct hp_sdc_mlc_priv_s {
 
54
        int emtestmode;
 
55
        hp_sdc_transaction trans;
 
56
        u8 tseq[16];
 
57
        int got5x;
 
58
} hp_sdc_mlc_priv;
 
59
 
 
60
/************************* Interrupt context ******************************/
 
61
static void hp_sdc_mlc_isr (int irq, void *dev_id,
 
62
                            uint8_t status, uint8_t data)
 
63
{
 
64
        int idx;
 
65
        hil_mlc *mlc = &hp_sdc_mlc;
 
66
 
 
67
        write_lock(&mlc->lock);
 
68
        if (mlc->icount < 0) {
 
69
                printk(KERN_WARNING PREFIX "HIL Overflow!\n");
 
70
                up(&mlc->isem);
 
71
                goto out;
 
72
        }
 
73
        idx = 15 - mlc->icount;
 
74
        if ((status & HP_SDC_STATUS_IRQMASK) == HP_SDC_STATUS_HILDATA) {
 
75
                mlc->ipacket[idx] |= data | HIL_ERR_INT;
 
76
                mlc->icount--;
 
77
                if (hp_sdc_mlc_priv.got5x || !idx)
 
78
                        goto check;
 
79
                if ((mlc->ipacket[idx - 1] & HIL_PKT_ADDR_MASK) !=
 
80
                    (mlc->ipacket[idx] & HIL_PKT_ADDR_MASK)) {
 
81
                        mlc->ipacket[idx] &= ~HIL_PKT_ADDR_MASK;
 
82
                        mlc->ipacket[idx] |= (mlc->ipacket[idx - 1]
 
83
                                                & HIL_PKT_ADDR_MASK);
 
84
                }
 
85
                goto check;
 
86
        }
 
87
        /* We know status is 5X */
 
88
        if (data & HP_SDC_HIL_ISERR)
 
89
                goto err;
 
90
        mlc->ipacket[idx] =
 
91
                (data & HP_SDC_HIL_R1MASK) << HIL_PKT_ADDR_SHIFT;
 
92
        hp_sdc_mlc_priv.got5x = 1;
 
93
        goto out;
 
94
 
 
95
 check:
 
96
        hp_sdc_mlc_priv.got5x = 0;
 
97
        if (mlc->imatch == 0)
 
98
                goto done;
 
99
        if ((mlc->imatch == (HIL_ERR_INT | HIL_PKT_CMD | HIL_CMD_POL))
 
100
            && (mlc->ipacket[idx] == (mlc->imatch | idx)))
 
101
                goto done;
 
102
        if (mlc->ipacket[idx] == mlc->imatch)
 
103
                goto done;
 
104
        goto out;
 
105
 
 
106
 err:
 
107
        printk(KERN_DEBUG PREFIX "err code %x\n", data);
 
108
 
 
109
        switch (data) {
 
110
        case HP_SDC_HIL_RC_DONE:
 
111
                printk(KERN_WARNING PREFIX "Bastard SDC reconfigured loop!\n");
 
112
                break;
 
113
 
 
114
        case HP_SDC_HIL_ERR:
 
115
                mlc->ipacket[idx] |= HIL_ERR_INT | HIL_ERR_PERR |
 
116
                                        HIL_ERR_FERR | HIL_ERR_FOF;
 
117
                break;
 
118
 
 
119
        case HP_SDC_HIL_TO:
 
120
                mlc->ipacket[idx] |= HIL_ERR_INT | HIL_ERR_LERR;
 
121
                break;
 
122
 
 
123
        case HP_SDC_HIL_RC:
 
124
                printk(KERN_WARNING PREFIX "Bastard SDC decided to reconfigure loop!\n");
 
125
                break;
 
126
 
 
127
        default:
 
128
                printk(KERN_WARNING PREFIX "Unknown HIL Error status (%x)!\n", data);
 
129
                break;
 
130
        }
 
131
 
 
132
        /* No more data will be coming due to an error. */
 
133
 done:
 
134
        tasklet_schedule(mlc->tasklet);
 
135
        up(&mlc->isem);
 
136
 out:
 
137
        write_unlock(&mlc->lock);
 
138
}
 
139
 
 
140
 
 
141
/******************** Tasklet or userspace context functions ****************/
 
142
 
 
143
static int hp_sdc_mlc_in(hil_mlc *mlc, suseconds_t timeout)
 
144
{
 
145
        struct hp_sdc_mlc_priv_s *priv;
 
146
        int rc = 2;
 
147
 
 
148
        priv = mlc->priv;
 
149
 
 
150
        /* Try to down the semaphore */
 
151
        if (down_trylock(&mlc->isem)) {
 
152
                struct timeval tv;
 
153
                if (priv->emtestmode) {
 
154
                        mlc->ipacket[0] =
 
155
                                HIL_ERR_INT | (mlc->opacket &
 
156
                                               (HIL_PKT_CMD |
 
157
                                                HIL_PKT_ADDR_MASK |
 
158
                                                HIL_PKT_DATA_MASK));
 
159
                        mlc->icount = 14;
 
160
                        /* printk(KERN_DEBUG PREFIX ">[%x]\n", mlc->ipacket[0]); */
 
161
                        goto wasup;
 
162
                }
 
163
                do_gettimeofday(&tv);
 
164
                tv.tv_usec += USEC_PER_SEC * (tv.tv_sec - mlc->instart.tv_sec);
 
165
                if (tv.tv_usec - mlc->instart.tv_usec > mlc->intimeout) {
 
166
                        /*      printk("!%i %i",
 
167
                                tv.tv_usec - mlc->instart.tv_usec,
 
168
                                mlc->intimeout);
 
169
                         */
 
170
                        rc = 1;
 
171
                        up(&mlc->isem);
 
172
                }
 
173
                goto done;
 
174
        }
 
175
 wasup:
 
176
        up(&mlc->isem);
 
177
        rc = 0;
 
178
 done:
 
179
        return rc;
 
180
}
 
181
 
 
182
static int hp_sdc_mlc_cts(hil_mlc *mlc)
 
183
{
 
184
        struct hp_sdc_mlc_priv_s *priv;
 
185
 
 
186
        priv = mlc->priv;
 
187
 
 
188
        /* Try to down the semaphores -- they should be up. */
 
189
        BUG_ON(down_trylock(&mlc->isem));
 
190
        BUG_ON(down_trylock(&mlc->osem));
 
191
 
 
192
        up(&mlc->isem);
 
193
        up(&mlc->osem);
 
194
 
 
195
        if (down_trylock(&mlc->csem)) {
 
196
                if (priv->trans.act.semaphore != &mlc->csem)
 
197
                        goto poll;
 
198
                else
 
199
                        goto busy;
 
200
        }
 
201
 
 
202
        if (!(priv->tseq[4] & HP_SDC_USE_LOOP))
 
203
                goto done;
 
204
 
 
205
 poll:
 
206
        priv->trans.act.semaphore = &mlc->csem;
 
207
        priv->trans.actidx = 0;
 
208
        priv->trans.idx = 1;
 
209
        priv->trans.endidx = 5;
 
210
        priv->tseq[0] =
 
211
                HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN | HP_SDC_ACT_SEMAPHORE;
 
212
        priv->tseq[1] = HP_SDC_CMD_READ_USE;
 
213
        priv->tseq[2] = 1;
 
214
        priv->tseq[3] = 0;
 
215
        priv->tseq[4] = 0;
 
216
        __hp_sdc_enqueue_transaction(&priv->trans);
 
217
 busy:
 
218
        return 1;
 
219
 done:
 
220
        priv->trans.act.semaphore = &mlc->osem;
 
221
        up(&mlc->csem);
 
222
        return 0;
 
223
}
 
224
 
 
225
static void hp_sdc_mlc_out(hil_mlc *mlc)
 
226
{
 
227
        struct hp_sdc_mlc_priv_s *priv;
 
228
 
 
229
        priv = mlc->priv;
 
230
 
 
231
        /* Try to down the semaphore -- it should be up. */
 
232
        BUG_ON(down_trylock(&mlc->osem));
 
233
 
 
234
        if (mlc->opacket & HIL_DO_ALTER_CTRL)
 
235
                goto do_control;
 
236
 
 
237
 do_data:
 
238
        if (priv->emtestmode) {
 
239
                up(&mlc->osem);
 
240
                return;
 
241
        }
 
242
        /* Shouldn't be sending commands when loop may be busy */
 
243
        BUG_ON(down_trylock(&mlc->csem));
 
244
        up(&mlc->csem);
 
245
 
 
246
        priv->trans.actidx = 0;
 
247
        priv->trans.idx = 1;
 
248
        priv->trans.act.semaphore = &mlc->osem;
 
249
        priv->trans.endidx = 6;
 
250
        priv->tseq[0] =
 
251
                HP_SDC_ACT_DATAREG | HP_SDC_ACT_POSTCMD | HP_SDC_ACT_SEMAPHORE;
 
252
        priv->tseq[1] = 0x7;
 
253
        priv->tseq[2] =
 
254
                (mlc->opacket &
 
255
                 (HIL_PKT_ADDR_MASK | HIL_PKT_CMD))
 
256
                   >> HIL_PKT_ADDR_SHIFT;
 
257
        priv->tseq[3] =
 
258
                (mlc->opacket & HIL_PKT_DATA_MASK)
 
259
                  >> HIL_PKT_DATA_SHIFT;
 
260
        priv->tseq[4] = 0;  /* No timeout */
 
261
        if (priv->tseq[3] == HIL_CMD_DHR)
 
262
                priv->tseq[4] = 1;
 
263
        priv->tseq[5] = HP_SDC_CMD_DO_HIL;
 
264
        goto enqueue;
 
265
 
 
266
 do_control:
 
267
        priv->emtestmode = mlc->opacket & HIL_CTRL_TEST;
 
268
 
 
269
        /* we cannot emulate this, it should not be used. */
 
270
        BUG_ON((mlc->opacket & (HIL_CTRL_APE | HIL_CTRL_IPF)) == HIL_CTRL_APE);
 
271
 
 
272
        if ((mlc->opacket & HIL_CTRL_ONLY) == HIL_CTRL_ONLY)
 
273
                goto control_only;
 
274
 
 
275
        /* Should not send command/data after engaging APE */
 
276
        BUG_ON(mlc->opacket & HIL_CTRL_APE);
 
277
 
 
278
        /* Disengaging APE this way would not be valid either since
 
279
         * the loop must be allowed to idle.
 
280
         *
 
281
         * So, it works out that we really never actually send control
 
282
         * and data when using SDC, we just send the data.
 
283
         */
 
284
        goto do_data;
 
285
 
 
286
 control_only:
 
287
        priv->trans.actidx = 0;
 
288
        priv->trans.idx = 1;
 
289
        priv->trans.act.semaphore = &mlc->osem;
 
290
        priv->trans.endidx = 4;
 
291
        priv->tseq[0] =
 
292
          HP_SDC_ACT_PRECMD | HP_SDC_ACT_DATAOUT | HP_SDC_ACT_SEMAPHORE;
 
293
        priv->tseq[1] = HP_SDC_CMD_SET_LPC;
 
294
        priv->tseq[2] = 1;
 
295
        /* priv->tseq[3] = (mlc->ddc + 1) | HP_SDC_LPS_ACSUCC; */
 
296
        priv->tseq[3] = 0;
 
297
        if (mlc->opacket & HIL_CTRL_APE) {
 
298
                priv->tseq[3] |= HP_SDC_LPC_APE_IPF;
 
299
                BUG_ON(down_trylock(&mlc->csem));
 
300
        }
 
301
 enqueue:
 
302
        hp_sdc_enqueue_transaction(&priv->trans);
 
303
}
 
304
 
 
305
static int __init hp_sdc_mlc_init(void)
 
306
{
 
307
        hil_mlc *mlc = &hp_sdc_mlc;
 
308
 
 
309
#ifdef __mc68000__
 
310
        if (!MACH_IS_HP300)
 
311
                return -ENODEV;
 
312
#endif
 
313
 
 
314
        printk(KERN_INFO PREFIX "Registering the System Domain Controller's HIL MLC.\n");
 
315
 
 
316
        hp_sdc_mlc_priv.emtestmode = 0;
 
317
        hp_sdc_mlc_priv.trans.seq = hp_sdc_mlc_priv.tseq;
 
318
        hp_sdc_mlc_priv.trans.act.semaphore = &mlc->osem;
 
319
        hp_sdc_mlc_priv.got5x = 0;
 
320
 
 
321
        mlc->cts = &hp_sdc_mlc_cts;
 
322
        mlc->in = &hp_sdc_mlc_in;
 
323
        mlc->out = &hp_sdc_mlc_out;
 
324
        mlc->priv = &hp_sdc_mlc_priv;
 
325
 
 
326
        if (hil_mlc_register(mlc)) {
 
327
                printk(KERN_WARNING PREFIX "Failed to register MLC structure with hil_mlc\n");
 
328
                goto err0;
 
329
        }
 
330
 
 
331
        if (hp_sdc_request_hil_irq(&hp_sdc_mlc_isr)) {
 
332
                printk(KERN_WARNING PREFIX "Request for raw HIL ISR hook denied\n");
 
333
                goto err1;
 
334
        }
 
335
        return 0;
 
336
 err1:
 
337
        if (hil_mlc_unregister(mlc))
 
338
                printk(KERN_ERR PREFIX "Failed to unregister MLC structure with hil_mlc.\n"
 
339
                        "This is bad.  Could cause an oops.\n");
 
340
 err0:
 
341
        return -EBUSY;
 
342
}
 
343
 
 
344
static void __exit hp_sdc_mlc_exit(void)
 
345
{
 
346
        hil_mlc *mlc = &hp_sdc_mlc;
 
347
 
 
348
        if (hp_sdc_release_hil_irq(&hp_sdc_mlc_isr))
 
349
                printk(KERN_ERR PREFIX "Failed to release the raw HIL ISR hook.\n"
 
350
                        "This is bad.  Could cause an oops.\n");
 
351
 
 
352
        if (hil_mlc_unregister(mlc))
 
353
                printk(KERN_ERR PREFIX "Failed to unregister MLC structure with hil_mlc.\n"
 
354
                        "This is bad.  Could cause an oops.\n");
 
355
}
 
356
 
 
357
module_init(hp_sdc_mlc_init);
 
358
module_exit(hp_sdc_mlc_exit);