Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
6188e10d | 43 | #include <linux/semaphore.h> |
1da177e4 LT |
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 | ||
fa14f7e8 | 53 | static struct hp_sdc_mlc_priv_s { |
1da177e4 LT |
54 | int emtestmode; |
55 | hp_sdc_transaction trans; | |
56 | u8 tseq[16]; | |
57 | int got5x; | |
58 | } hp_sdc_mlc_priv; | |
59 | ||
60 | /************************* Interrupt context ******************************/ | |
ffd51f46 HD |
61 | static void hp_sdc_mlc_isr (int irq, void *dev_id, |
62 | uint8_t status, uint8_t data) | |
63 | { | |
64 | int idx; | |
1da177e4 LT |
65 | hil_mlc *mlc = &hp_sdc_mlc; |
66 | ||
ffd51f46 | 67 | write_lock(&mlc->lock); |
1da177e4 LT |
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--; | |
ffd51f46 HD |
77 | if (hp_sdc_mlc_priv.got5x || !idx) |
78 | goto check; | |
79 | if ((mlc->ipacket[idx - 1] & HIL_PKT_ADDR_MASK) != | |
1da177e4 LT |
80 | (mlc->ipacket[idx] & HIL_PKT_ADDR_MASK)) { |
81 | mlc->ipacket[idx] &= ~HIL_PKT_ADDR_MASK; | |
ffd51f46 HD |
82 | mlc->ipacket[idx] |= (mlc->ipacket[idx - 1] |
83 | & HIL_PKT_ADDR_MASK); | |
1da177e4 LT |
84 | } |
85 | goto check; | |
86 | } | |
87 | /* We know status is 5X */ | |
ffd51f46 HD |
88 | if (data & HP_SDC_HIL_ISERR) |
89 | goto err; | |
90 | mlc->ipacket[idx] = | |
1da177e4 LT |
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; | |
ffd51f46 HD |
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; | |
1da177e4 LT |
104 | goto out; |
105 | ||
ffd51f46 | 106 | err: |
1da177e4 | 107 | printk(KERN_DEBUG PREFIX "err code %x\n", data); |
ffd51f46 | 108 | |
1da177e4 LT |
109 | switch (data) { |
110 | case HP_SDC_HIL_RC_DONE: | |
111 | printk(KERN_WARNING PREFIX "Bastard SDC reconfigured loop!\n"); | |
112 | break; | |
ffd51f46 | 113 | |
1da177e4 | 114 | case HP_SDC_HIL_ERR: |
ffd51f46 HD |
115 | mlc->ipacket[idx] |= HIL_ERR_INT | HIL_ERR_PERR | |
116 | HIL_ERR_FERR | HIL_ERR_FOF; | |
1da177e4 | 117 | break; |
ffd51f46 | 118 | |
1da177e4 LT |
119 | case HP_SDC_HIL_TO: |
120 | mlc->ipacket[idx] |= HIL_ERR_INT | HIL_ERR_LERR; | |
121 | break; | |
ffd51f46 | 122 | |
1da177e4 LT |
123 | case HP_SDC_HIL_RC: |
124 | printk(KERN_WARNING PREFIX "Bastard SDC decided to reconfigure loop!\n"); | |
125 | break; | |
ffd51f46 | 126 | |
1da177e4 | 127 | default: |
af901ca1 | 128 | printk(KERN_WARNING PREFIX "Unknown HIL Error status (%x)!\n", data); |
1da177e4 LT |
129 | break; |
130 | } | |
ffd51f46 | 131 | |
1da177e4 LT |
132 | /* No more data will be coming due to an error. */ |
133 | done: | |
134 | tasklet_schedule(mlc->tasklet); | |
ffd51f46 | 135 | up(&mlc->isem); |
1da177e4 | 136 | out: |
ffd51f46 | 137 | write_unlock(&mlc->lock); |
1da177e4 LT |
138 | } |
139 | ||
140 | ||
141 | /******************** Tasklet or userspace context functions ****************/ | |
142 | ||
ffd51f46 HD |
143 | static int hp_sdc_mlc_in(hil_mlc *mlc, suseconds_t timeout) |
144 | { | |
1da177e4 LT |
145 | struct hp_sdc_mlc_priv_s *priv; |
146 | int rc = 2; | |
147 | ||
148 | priv = mlc->priv; | |
149 | ||
1da177e4 | 150 | /* Try to down the semaphore */ |
ffd51f46 | 151 | if (down_trylock(&mlc->isem)) { |
1da177e4 LT |
152 | struct timeval tv; |
153 | if (priv->emtestmode) { | |
ffd51f46 HD |
154 | mlc->ipacket[0] = |
155 | HIL_ERR_INT | (mlc->opacket & | |
156 | (HIL_PKT_CMD | | |
157 | HIL_PKT_ADDR_MASK | | |
1da177e4 LT |
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); | |
ffd51f46 | 164 | tv.tv_usec += USEC_PER_SEC * (tv.tv_sec - mlc->instart.tv_sec); |
1da177e4 | 165 | if (tv.tv_usec - mlc->instart.tv_usec > mlc->intimeout) { |
ffd51f46 HD |
166 | /* printk("!%i %i", |
167 | tv.tv_usec - mlc->instart.tv_usec, | |
168 | mlc->intimeout); | |
169 | */ | |
1da177e4 | 170 | rc = 1; |
ffd51f46 | 171 | up(&mlc->isem); |
1da177e4 LT |
172 | } |
173 | goto done; | |
174 | } | |
175 | wasup: | |
ffd51f46 | 176 | up(&mlc->isem); |
1da177e4 | 177 | rc = 0; |
1da177e4 | 178 | done: |
1da177e4 LT |
179 | return rc; |
180 | } | |
181 | ||
ffd51f46 HD |
182 | static int hp_sdc_mlc_cts(hil_mlc *mlc) |
183 | { | |
1da177e4 | 184 | struct hp_sdc_mlc_priv_s *priv; |
1da177e4 | 185 | |
ffd51f46 | 186 | priv = mlc->priv; |
1da177e4 | 187 | |
1da177e4 | 188 | /* Try to down the semaphores -- they should be up. */ |
ffd51f46 HD |
189 | BUG_ON(down_trylock(&mlc->isem)); |
190 | BUG_ON(down_trylock(&mlc->osem)); | |
1da177e4 | 191 | |
ffd51f46 HD |
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; | |
1da177e4 | 200 | } |
ffd51f46 HD |
201 | |
202 | if (!(priv->tseq[4] & HP_SDC_USE_LOOP)) | |
203 | goto done; | |
1da177e4 LT |
204 | |
205 | poll: | |
ffd51f46 | 206 | priv->trans.act.semaphore = &mlc->csem; |
1da177e4 LT |
207 | priv->trans.actidx = 0; |
208 | priv->trans.idx = 1; | |
209 | priv->trans.endidx = 5; | |
ffd51f46 | 210 | priv->tseq[0] = |
1da177e4 LT |
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; | |
9575499d | 216 | __hp_sdc_enqueue_transaction(&priv->trans); |
1da177e4 | 217 | busy: |
1da177e4 LT |
218 | return 1; |
219 | done: | |
ffd51f46 HD |
220 | priv->trans.act.semaphore = &mlc->osem; |
221 | up(&mlc->csem); | |
1da177e4 LT |
222 | return 0; |
223 | } | |
224 | ||
ffd51f46 HD |
225 | static void hp_sdc_mlc_out(hil_mlc *mlc) |
226 | { | |
1da177e4 | 227 | struct hp_sdc_mlc_priv_s *priv; |
1da177e4 LT |
228 | |
229 | priv = mlc->priv; | |
230 | ||
1da177e4 | 231 | /* Try to down the semaphore -- it should be up. */ |
ffd51f46 | 232 | BUG_ON(down_trylock(&mlc->osem)); |
1da177e4 | 233 | |
ffd51f46 HD |
234 | if (mlc->opacket & HIL_DO_ALTER_CTRL) |
235 | goto do_control; | |
1da177e4 LT |
236 | |
237 | do_data: | |
238 | if (priv->emtestmode) { | |
ffd51f46 | 239 | up(&mlc->osem); |
9575499d | 240 | return; |
1da177e4 LT |
241 | } |
242 | /* Shouldn't be sending commands when loop may be busy */ | |
ffd51f46 HD |
243 | BUG_ON(down_trylock(&mlc->csem)); |
244 | up(&mlc->csem); | |
1da177e4 LT |
245 | |
246 | priv->trans.actidx = 0; | |
247 | priv->trans.idx = 1; | |
ffd51f46 | 248 | priv->trans.act.semaphore = &mlc->osem; |
1da177e4 | 249 | priv->trans.endidx = 6; |
ffd51f46 | 250 | priv->tseq[0] = |
1da177e4 LT |
251 | HP_SDC_ACT_DATAREG | HP_SDC_ACT_POSTCMD | HP_SDC_ACT_SEMAPHORE; |
252 | priv->tseq[1] = 0x7; | |
ffd51f46 HD |
253 | priv->tseq[2] = |
254 | (mlc->opacket & | |
1da177e4 LT |
255 | (HIL_PKT_ADDR_MASK | HIL_PKT_CMD)) |
256 | >> HIL_PKT_ADDR_SHIFT; | |
ffd51f46 HD |
257 | priv->tseq[3] = |
258 | (mlc->opacket & HIL_PKT_DATA_MASK) | |
1da177e4 LT |
259 | >> HIL_PKT_DATA_SHIFT; |
260 | priv->tseq[4] = 0; /* No timeout */ | |
ffd51f46 HD |
261 | if (priv->tseq[3] == HIL_CMD_DHR) |
262 | priv->tseq[4] = 1; | |
1da177e4 LT |
263 | priv->tseq[5] = HP_SDC_CMD_DO_HIL; |
264 | goto enqueue; | |
265 | ||
266 | do_control: | |
267 | priv->emtestmode = mlc->opacket & HIL_CTRL_TEST; | |
ffd51f46 | 268 | |
fddaaae1 ES |
269 | /* we cannot emulate this, it should not be used. */ |
270 | BUG_ON((mlc->opacket & (HIL_CTRL_APE | HIL_CTRL_IPF)) == HIL_CTRL_APE); | |
ffd51f46 HD |
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 | |
1da177e4 LT |
279 | * the loop must be allowed to idle. |
280 | * | |
ffd51f46 HD |
281 | * So, it works out that we really never actually send control |
282 | * and data when using SDC, we just send the data. | |
1da177e4 LT |
283 | */ |
284 | goto do_data; | |
285 | ||
286 | control_only: | |
287 | priv->trans.actidx = 0; | |
288 | priv->trans.idx = 1; | |
ffd51f46 | 289 | priv->trans.act.semaphore = &mlc->osem; |
1da177e4 | 290 | priv->trans.endidx = 4; |
ffd51f46 | 291 | priv->tseq[0] = |
1da177e4 LT |
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; | |
ffd51f46 | 295 | /* priv->tseq[3] = (mlc->ddc + 1) | HP_SDC_LPS_ACSUCC; */ |
1da177e4 LT |
296 | priv->tseq[3] = 0; |
297 | if (mlc->opacket & HIL_CTRL_APE) { | |
298 | priv->tseq[3] |= HP_SDC_LPC_APE_IPF; | |
c6fe6b07 | 299 | BUG_ON(down_trylock(&mlc->csem)); |
ffd51f46 | 300 | } |
1da177e4 | 301 | enqueue: |
ffd51f46 | 302 | hp_sdc_enqueue_transaction(&priv->trans); |
1da177e4 LT |
303 | } |
304 | ||
305 | static int __init hp_sdc_mlc_init(void) | |
306 | { | |
307 | hil_mlc *mlc = &hp_sdc_mlc; | |
39de5210 | 308 | int err; |
1da177e4 | 309 | |
eb98630b GU |
310 | #ifdef __mc68000__ |
311 | if (!MACH_IS_HP300) | |
312 | return -ENODEV; | |
313 | #endif | |
314 | ||
1da177e4 LT |
315 | printk(KERN_INFO PREFIX "Registering the System Domain Controller's HIL MLC.\n"); |
316 | ||
317 | hp_sdc_mlc_priv.emtestmode = 0; | |
318 | hp_sdc_mlc_priv.trans.seq = hp_sdc_mlc_priv.tseq; | |
ffd51f46 | 319 | hp_sdc_mlc_priv.trans.act.semaphore = &mlc->osem; |
1da177e4 LT |
320 | hp_sdc_mlc_priv.got5x = 0; |
321 | ||
ffd51f46 HD |
322 | mlc->cts = &hp_sdc_mlc_cts; |
323 | mlc->in = &hp_sdc_mlc_in; | |
324 | mlc->out = &hp_sdc_mlc_out; | |
325 | mlc->priv = &hp_sdc_mlc_priv; | |
3acaf540 | 326 | |
39de5210 JJ |
327 | err = hil_mlc_register(mlc); |
328 | if (err) { | |
1da177e4 | 329 | printk(KERN_WARNING PREFIX "Failed to register MLC structure with hil_mlc\n"); |
39de5210 | 330 | return err; |
1da177e4 | 331 | } |
1da177e4 LT |
332 | |
333 | if (hp_sdc_request_hil_irq(&hp_sdc_mlc_isr)) { | |
334 | printk(KERN_WARNING PREFIX "Request for raw HIL ISR hook denied\n"); | |
39de5210 JJ |
335 | if (hil_mlc_unregister(mlc)) |
336 | printk(KERN_ERR PREFIX "Failed to unregister MLC structure with hil_mlc.\n" | |
337 | "This is bad. Could cause an oops.\n"); | |
338 | return -EBUSY; | |
1da177e4 | 339 | } |
39de5210 | 340 | |
1da177e4 | 341 | return 0; |
1da177e4 LT |
342 | } |
343 | ||
344 | static void __exit hp_sdc_mlc_exit(void) | |
345 | { | |
346 | hil_mlc *mlc = &hp_sdc_mlc; | |
ffd51f46 HD |
347 | |
348 | if (hp_sdc_release_hil_irq(&hp_sdc_mlc_isr)) | |
1da177e4 LT |
349 | printk(KERN_ERR PREFIX "Failed to release the raw HIL ISR hook.\n" |
350 | "This is bad. Could cause an oops.\n"); | |
ffd51f46 HD |
351 | |
352 | if (hil_mlc_unregister(mlc)) | |
1da177e4 LT |
353 | printk(KERN_ERR PREFIX "Failed to unregister MLC structure with hil_mlc.\n" |
354 | "This is bad. Could cause an oops.\n"); | |
1da177e4 LT |
355 | } |
356 | ||
357 | module_init(hp_sdc_mlc_init); | |
358 | module_exit(hp_sdc_mlc_exit); |