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 <asm/semaphore.h> 44 45#define PREFIX "HP SDC MLC: " 46 47static hil_mlc hp_sdc_mlc; 48 49MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>"); 50MODULE_DESCRIPTION("Glue for onboard HIL MLC in HP-PARISC machines"); 51MODULE_LICENSE("Dual BSD/GPL"); 52 53struct 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 ******************************/ 61static 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 "Unkown 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 143static 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 182static 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 225static 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 down_trylock(&mlc->csem); 300 } 301 enqueue: 302 hp_sdc_enqueue_transaction(&priv->trans); 303} 304 305static int __init hp_sdc_mlc_init(void) 306{ 307 hil_mlc *mlc = &hp_sdc_mlc; 308 309 printk(KERN_INFO PREFIX "Registering the System Domain Controller's HIL MLC.\n"); 310 311 hp_sdc_mlc_priv.emtestmode = 0; 312 hp_sdc_mlc_priv.trans.seq = hp_sdc_mlc_priv.tseq; 313 hp_sdc_mlc_priv.trans.act.semaphore = &mlc->osem; 314 hp_sdc_mlc_priv.got5x = 0; 315 316 mlc->cts = &hp_sdc_mlc_cts; 317 mlc->in = &hp_sdc_mlc_in; 318 mlc->out = &hp_sdc_mlc_out; 319 mlc->priv = &hp_sdc_mlc_priv; 320 321 if (hil_mlc_register(mlc)) { 322 printk(KERN_WARNING PREFIX "Failed to register MLC structure with hil_mlc\n"); 323 goto err0; 324 } 325 326 if (hp_sdc_request_hil_irq(&hp_sdc_mlc_isr)) { 327 printk(KERN_WARNING PREFIX "Request for raw HIL ISR hook denied\n"); 328 goto err1; 329 } 330 return 0; 331 err1: 332 if (hil_mlc_unregister(mlc)) 333 printk(KERN_ERR PREFIX "Failed to unregister MLC structure with hil_mlc.\n" 334 "This is bad. Could cause an oops.\n"); 335 err0: 336 return -EBUSY; 337} 338 339static void __exit hp_sdc_mlc_exit(void) 340{ 341 hil_mlc *mlc = &hp_sdc_mlc; 342 343 if (hp_sdc_release_hil_irq(&hp_sdc_mlc_isr)) 344 printk(KERN_ERR PREFIX "Failed to release the raw HIL ISR hook.\n" 345 "This is bad. Could cause an oops.\n"); 346 347 if (hil_mlc_unregister(mlc)) 348 printk(KERN_ERR PREFIX "Failed to unregister MLC structure with hil_mlc.\n" 349 "This is bad. Could cause an oops.\n"); 350} 351 352module_init(hp_sdc_mlc_init); 353module_exit(hp_sdc_mlc_exit); 354