ppb_1284.c (50477) | ppb_1284.c (55939) |
---|---|
1/*- 2 * Copyright (c) 1997 Nicolas Souchu 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 9 unchanged lines hidden (view full) --- 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * | 1/*- 2 * Copyright (c) 1997 Nicolas Souchu 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 9 unchanged lines hidden (view full) --- 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * |
26 * $FreeBSD: head/sys/dev/ppbus/ppb_1284.c 50477 1999-08-28 01:08:13Z peter $ | 26 * $FreeBSD: head/sys/dev/ppbus/ppb_1284.c 55939 2000-01-14 00:18:06Z nsouch $ |
27 * 28 */ 29 30/* 31 * General purpose routines for the IEEE1284-1994 Standard 32 */ 33 34#include "opt_ppb_1284.h" 35 36#include <sys/param.h> 37#include <sys/systm.h> | 27 * 28 */ 29 30/* 31 * General purpose routines for the IEEE1284-1994 Standard 32 */ 33 34#include "opt_ppb_1284.h" 35 36#include <sys/param.h> 37#include <sys/systm.h> |
38#include <sys/bus.h> |
|
38 39#include <machine/clock.h> 40 41#include <dev/ppbus/ppbconf.h> 42#include <dev/ppbus/ppb_1284.h> 43 | 39 40#include <machine/clock.h> 41 42#include <dev/ppbus/ppbconf.h> 43#include <dev/ppbus/ppb_1284.h> 44 |
45#include "ppbus_if.h" 46 47#include <dev/ppbus/ppbio.h> 48 49#define DEVTOSOFTC(dev) ((struct ppb_data *)device_get_softc(dev)) 50 |
|
44/* 45 * do_1284_wait() 46 * 47 * Wait for the peripherial up to 40ms 48 */ 49static int | 51/* 52 * do_1284_wait() 53 * 54 * Wait for the peripherial up to 40ms 55 */ 56static int |
50do_1284_wait(struct ppb_device *dev, char mask, char status) | 57do_1284_wait(device_t bus, char mask, char status) |
51{ | 58{ |
52 return (ppb_poll_device(dev, 4, mask, status, PPB_NOINTR | PPB_POLL)); | 59 return (ppb_poll_bus(bus, 4, mask, status, PPB_NOINTR | PPB_POLL)); |
53} 54 55static int | 60} 61 62static int |
56do_peripheral_wait(struct ppb_device *dev, char mask, char status) | 63do_peripheral_wait(device_t bus, char mask, char status) |
57{ | 64{ |
58 return (ppb_poll_device(dev, 100, mask, status, PPB_NOINTR | PPB_POLL)); | 65 return (ppb_poll_bus(bus, 100, mask, status, PPB_NOINTR | PPB_POLL)); |
59} 60 61#define nibble2char(s) (((s & ~nACK) >> 3) | (~s & nBUSY) >> 4) 62 63/* 64 * ppb_1284_reset_error() 65 * 66 * Unconditionaly reset the error field 67 */ 68static int | 66} 67 68#define nibble2char(s) (((s & ~nACK) >> 3) | (~s & nBUSY) >> 4) 69 70/* 71 * ppb_1284_reset_error() 72 * 73 * Unconditionaly reset the error field 74 */ 75static int |
69ppb_1284_reset_error(struct ppb_device *dev, int state) | 76ppb_1284_reset_error(device_t bus, int state) |
70{ | 77{ |
71 dev->ppb->error = PPB_NO_ERROR; 72 dev->ppb->state = state; | 78 struct ppb_data *ppb = DEVTOSOFTC(bus); |
73 | 79 |
80 ppb->error = PPB_NO_ERROR; 81 ppb->state = state; 82 |
|
74 return (0); 75} 76 77/* 78 * ppb_1284_get_state() 79 * 80 * Get IEEE1284 state 81 */ 82static int | 83 return (0); 84} 85 86/* 87 * ppb_1284_get_state() 88 * 89 * Get IEEE1284 state 90 */ 91static int |
83ppb_1284_get_state(struct ppb_device *dev) | 92ppb_1284_get_state(device_t bus) |
84{ | 93{ |
85 return (dev->ppb->state); | 94 return (DEVTOSOFTC(bus)->state); |
86} 87 88/* 89 * ppb_1284_set_state() 90 * 91 * Change IEEE1284 state if no error occured 92 */ 93static int | 95} 96 97/* 98 * ppb_1284_set_state() 99 * 100 * Change IEEE1284 state if no error occured 101 */ 102static int |
94ppb_1284_set_state(struct ppb_device *dev, int state) | 103ppb_1284_set_state(device_t bus, int state) |
95{ | 104{ |
105 struct ppb_data *ppb = DEVTOSOFTC(bus); 106 |
|
96 /* call ppb_1284_reset_error() if you absolutly want to change 97 * the state from PPB_ERROR to another */ | 107 /* call ppb_1284_reset_error() if you absolutly want to change 108 * the state from PPB_ERROR to another */ |
98 if ((dev->ppb->state != PPB_ERROR) && 99 (dev->ppb->error == PPB_NO_ERROR)) { 100 dev->ppb->state = state; 101 dev->ppb->error = PPB_NO_ERROR; | 109 if ((ppb->state != PPB_ERROR) && 110 (ppb->error == PPB_NO_ERROR)) { 111 ppb->state = state; 112 ppb->error = PPB_NO_ERROR; |
102 } 103 104 return (0); 105} 106 107static int | 113 } 114 115 return (0); 116} 117 118static int |
108ppb_1284_set_error(struct ppb_device *dev, int error, int event) | 119ppb_1284_set_error(device_t bus, int error, int event) |
109{ | 120{ |
121 struct ppb_data *ppb = DEVTOSOFTC(bus); 122 |
|
110 /* do not accumulate errors */ | 123 /* do not accumulate errors */ |
111 if ((dev->ppb->error == PPB_NO_ERROR) && 112 (dev->ppb->state != PPB_ERROR)) { 113 dev->ppb->error = error; 114 dev->ppb->state = PPB_ERROR; | 124 if ((ppb->error == PPB_NO_ERROR) && 125 (ppb->state != PPB_ERROR)) { 126 ppb->error = error; 127 ppb->state = PPB_ERROR; |
115 } 116 117#ifdef DEBUG_1284 118 printf("ppb1284: error=%d status=0x%x event=%d\n", error, | 128 } 129 130#ifdef DEBUG_1284 131 printf("ppb1284: error=%d status=0x%x event=%d\n", error, |
119 ppb_rstr(dev) & 0xff, event); | 132 ppb_rstr(bus) & 0xff, event); |
120#endif 121 122 return (0); 123} 124 125/* 126 * ppb_request_mode() 127 * --- 41 unchanged lines hidden (view full) --- 169} 170 171/* 172 * ppb_peripheral_negociate() 173 * 174 * Negociate the peripheral side 175 */ 176int | 133#endif 134 135 return (0); 136} 137 138/* 139 * ppb_request_mode() 140 * --- 41 unchanged lines hidden (view full) --- 182} 183 184/* 185 * ppb_peripheral_negociate() 186 * 187 * Negociate the peripheral side 188 */ 189int |
177ppb_peripheral_negociate(struct ppb_device *dev, int mode, int options) | 190ppb_peripheral_negociate(device_t bus, int mode, int options) |
178{ 179 int spin, request_mode, error = 0; 180 char r; 181 | 191{ 192 int spin, request_mode, error = 0; 193 char r; 194 |
182 ppb_set_mode(dev, PPB_COMPATIBLE); 183 ppb_1284_set_state(dev, PPB_PERIPHERAL_NEGOCIATION); | 195 ppb_set_mode(bus, PPB_COMPATIBLE); 196 ppb_1284_set_state(bus, PPB_PERIPHERAL_NEGOCIATION); |
184 185 /* compute ext. value */ 186 request_mode = ppb_request_mode(mode, options); 187 188 /* wait host */ 189 spin = 10; | 197 198 /* compute ext. value */ 199 request_mode = ppb_request_mode(mode, options); 200 201 /* wait host */ 202 spin = 10; |
190 while (spin-- && (ppb_rstr(dev) & nBUSY)) | 203 while (spin-- && (ppb_rstr(bus) & nBUSY)) |
191 DELAY(1); 192 193 /* check termination */ | 204 DELAY(1); 205 206 /* check termination */ |
194 if (!(ppb_rstr(dev) & SELECT) || !spin) { | 207 if (!(ppb_rstr(bus) & SELECT) || !spin) { |
195 error = ENODEV; 196 goto error; 197 } 198 199 /* Event 4 - read ext. value */ | 208 error = ENODEV; 209 goto error; 210 } 211 212 /* Event 4 - read ext. value */ |
200 r = ppb_rdtr(dev); | 213 r = ppb_rdtr(bus); |
201 202 /* nibble mode is not supported */ 203 if ((r == (char)request_mode) || 204 (r == NIBBLE_1284_NORMAL)) { 205 206 /* Event 5 - restore direction bit, no data avail */ | 214 215 /* nibble mode is not supported */ 216 if ((r == (char)request_mode) || 217 (r == NIBBLE_1284_NORMAL)) { 218 219 /* Event 5 - restore direction bit, no data avail */ |
207 ppb_wctr(dev, (STROBE | nINIT) & ~(SELECTIN)); | 220 ppb_wctr(bus, (STROBE | nINIT) & ~(SELECTIN)); |
208 DELAY(1); 209 210 /* Event 6 */ | 221 DELAY(1); 222 223 /* Event 6 */ |
211 ppb_wctr(dev, (nINIT) & ~(SELECTIN | STROBE)); | 224 ppb_wctr(bus, (nINIT) & ~(SELECTIN | STROBE)); |
212 213 if (r == NIBBLE_1284_NORMAL) { 214#ifdef DEBUG_1284 215 printf("R"); 216#endif | 225 226 if (r == NIBBLE_1284_NORMAL) { 227#ifdef DEBUG_1284 228 printf("R"); 229#endif |
217 ppb_1284_set_error(dev, PPB_MODE_UNSUPPORTED, 4); | 230 ppb_1284_set_error(bus, PPB_MODE_UNSUPPORTED, 4); |
218 error = EINVAL; 219 goto error; 220 } else { | 231 error = EINVAL; 232 goto error; 233 } else { |
221 ppb_1284_set_state(dev, PPB_PERIPHERAL_IDLE); | 234 ppb_1284_set_state(bus, PPB_PERIPHERAL_IDLE); |
222 switch (r) { 223 case BYTE_1284_NORMAL: | 235 switch (r) { 236 case BYTE_1284_NORMAL: |
224 ppb_set_mode(dev, PPB_BYTE); | 237 ppb_set_mode(bus, PPB_BYTE); |
225 break; 226 default: 227 break; 228 } 229#ifdef DEBUG_1284 230 printf("A"); 231#endif 232 /* negociation succeeds */ 233 } 234 } else { 235 /* Event 5 - mode not supported */ | 238 break; 239 default: 240 break; 241 } 242#ifdef DEBUG_1284 243 printf("A"); 244#endif 245 /* negociation succeeds */ 246 } 247 } else { 248 /* Event 5 - mode not supported */ |
236 ppb_wctr(dev, SELECTIN); | 249 ppb_wctr(bus, SELECTIN); |
237 DELAY(1); 238 239 /* Event 6 */ | 250 DELAY(1); 251 252 /* Event 6 */ |
240 ppb_wctr(dev, (SELECTIN) & ~(STROBE | nINIT)); 241 ppb_1284_set_error(dev, PPB_MODE_UNSUPPORTED, 4); | 253 ppb_wctr(bus, (SELECTIN) & ~(STROBE | nINIT)); 254 ppb_1284_set_error(bus, PPB_MODE_UNSUPPORTED, 4); |
242 243#ifdef DEBUG_1284 244 printf("r"); 245#endif 246 error = EINVAL; 247 goto error; 248 } 249 250 return (0); 251 252error: | 255 256#ifdef DEBUG_1284 257 printf("r"); 258#endif 259 error = EINVAL; 260 goto error; 261 } 262 263 return (0); 264 265error: |
253 ppb_peripheral_terminate(dev, PPB_WAIT); | 266 ppb_peripheral_terminate(bus, PPB_WAIT); |
254 return (error); 255} 256 257/* 258 * ppb_peripheral_terminate() 259 * 260 * Terminate peripheral transfer side 261 * 262 * Always return 0 in compatible mode 263 */ 264int | 267 return (error); 268} 269 270/* 271 * ppb_peripheral_terminate() 272 * 273 * Terminate peripheral transfer side 274 * 275 * Always return 0 in compatible mode 276 */ 277int |
265ppb_peripheral_terminate(struct ppb_device *dev, int how) | 278ppb_peripheral_terminate(device_t bus, int how) |
266{ 267 int error = 0; 268 269#ifdef DEBUG_1284 270 printf("t"); 271#endif 272 | 279{ 280 int error = 0; 281 282#ifdef DEBUG_1284 283 printf("t"); 284#endif 285 |
273 ppb_1284_set_state(dev, PPB_PERIPHERAL_TERMINATION); | 286 ppb_1284_set_state(bus, PPB_PERIPHERAL_TERMINATION); |
274 275 /* Event 22 - wait up to host response time (1s) */ | 287 288 /* Event 22 - wait up to host response time (1s) */ |
276 if ((error = do_peripheral_wait(dev, SELECT | nBUSY, 0))) { 277 ppb_1284_set_error(dev, PPB_TIMEOUT, 22); | 289 if ((error = do_peripheral_wait(bus, SELECT | nBUSY, 0))) { 290 ppb_1284_set_error(bus, PPB_TIMEOUT, 22); |
278 goto error; 279 } 280 281 /* Event 24 */ | 291 goto error; 292 } 293 294 /* Event 24 */ |
282 ppb_wctr(dev, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); | 295 ppb_wctr(bus, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); |
283 284 /* Event 25 - wait up to host response time (1s) */ | 296 297 /* Event 25 - wait up to host response time (1s) */ |
285 if ((error = do_peripheral_wait(dev, nBUSY, nBUSY))) { 286 ppb_1284_set_error(dev, PPB_TIMEOUT, 25); | 298 if ((error = do_peripheral_wait(bus, nBUSY, nBUSY))) { 299 ppb_1284_set_error(bus, PPB_TIMEOUT, 25); |
287 goto error; 288 } 289 290 /* Event 26 */ | 300 goto error; 301 } 302 303 /* Event 26 */ |
291 ppb_wctr(dev, (SELECTIN | nINIT | STROBE) & ~(AUTOFEED)); | 304 ppb_wctr(bus, (SELECTIN | nINIT | STROBE) & ~(AUTOFEED)); |
292 DELAY(1); 293 /* Event 27 */ | 305 DELAY(1); 306 /* Event 27 */ |
294 ppb_wctr(dev, (SELECTIN | nINIT) & ~(STROBE | AUTOFEED)); | 307 ppb_wctr(bus, (SELECTIN | nINIT) & ~(STROBE | AUTOFEED)); |
295 296 /* Event 28 - wait up to host response time (1s) */ | 308 309 /* Event 28 - wait up to host response time (1s) */ |
297 if ((error = do_peripheral_wait(dev, nBUSY, 0))) { 298 ppb_1284_set_error(dev, PPB_TIMEOUT, 28); | 310 if ((error = do_peripheral_wait(bus, nBUSY, 0))) { 311 ppb_1284_set_error(bus, PPB_TIMEOUT, 28); |
299 goto error; 300 } 301 302error: | 312 goto error; 313 } 314 315error: |
303 ppb_set_mode(dev, PPB_COMPATIBLE); 304 ppb_1284_set_state(dev, PPB_FORWARD_IDLE); | 316 ppb_set_mode(bus, PPB_COMPATIBLE); 317 ppb_1284_set_state(bus, PPB_FORWARD_IDLE); |
305 306 return (0); 307} 308 309/* 310 * byte_peripheral_outbyte() 311 * 312 * Write 1 byte in BYTE mode 313 */ 314static int | 318 319 return (0); 320} 321 322/* 323 * byte_peripheral_outbyte() 324 * 325 * Write 1 byte in BYTE mode 326 */ 327static int |
315byte_peripheral_outbyte(struct ppb_device *dev, char *buffer, int last) | 328byte_peripheral_outbyte(device_t bus, char *buffer, int last) |
316{ 317 int error = 0; 318 319 /* Event 7 */ | 329{ 330 int error = 0; 331 332 /* Event 7 */ |
320 if ((error = do_1284_wait(dev, nBUSY, nBUSY))) { 321 ppb_1284_set_error(dev, PPB_TIMEOUT, 7); | 333 if ((error = do_1284_wait(bus, nBUSY, nBUSY))) { 334 ppb_1284_set_error(bus, PPB_TIMEOUT, 7); |
322 goto error; 323 } 324 325 /* check termination */ | 335 goto error; 336 } 337 338 /* check termination */ |
326 if (!(ppb_rstr(dev) & SELECT)) { 327 ppb_peripheral_terminate(dev, PPB_WAIT); | 339 if (!(ppb_rstr(bus) & SELECT)) { 340 ppb_peripheral_terminate(bus, PPB_WAIT); |
328 goto error; 329 } 330 331 /* Event 15 - put byte on data lines */ 332#ifdef DEBUG_1284 333 printf("B"); 334#endif | 341 goto error; 342 } 343 344 /* Event 15 - put byte on data lines */ 345#ifdef DEBUG_1284 346 printf("B"); 347#endif |
335 ppb_wdtr(dev, *buffer); | 348 ppb_wdtr(bus, *buffer); |
336 337 /* Event 9 */ | 349 350 /* Event 9 */ |
338 ppb_wctr(dev, (AUTOFEED | STROBE) & ~(nINIT | SELECTIN)); | 351 ppb_wctr(bus, (AUTOFEED | STROBE) & ~(nINIT | SELECTIN)); |
339 340 /* Event 10 - wait data read */ | 352 353 /* Event 10 - wait data read */ |
341 if ((error = do_peripheral_wait(dev, nBUSY, 0))) { 342 ppb_1284_set_error(dev, PPB_TIMEOUT, 16); | 354 if ((error = do_peripheral_wait(bus, nBUSY, 0))) { 355 ppb_1284_set_error(bus, PPB_TIMEOUT, 16); |
343 goto error; 344 } 345 346 /* Event 11 */ 347 if (!last) { | 356 goto error; 357 } 358 359 /* Event 11 */ 360 if (!last) { |
348 ppb_wctr(dev, (AUTOFEED) & ~(nINIT | STROBE | SELECTIN)); | 361 ppb_wctr(bus, (AUTOFEED) & ~(nINIT | STROBE | SELECTIN)); |
349 } else { | 362 } else { |
350 ppb_wctr(dev, (nINIT) & ~(STROBE | SELECTIN | AUTOFEED)); | 363 ppb_wctr(bus, (nINIT) & ~(STROBE | SELECTIN | AUTOFEED)); |
351 } 352 353#if 0 354 /* Event 16 - wait strobe */ | 364 } 365 366#if 0 367 /* Event 16 - wait strobe */ |
355 if ((error = do_peripheral_wait(dev, nACK | nBUSY, 0))) { 356 ppb_1284_set_error(dev, PPB_TIMEOUT, 16); | 368 if ((error = do_peripheral_wait(bus, nACK | nBUSY, 0))) { 369 ppb_1284_set_error(bus, PPB_TIMEOUT, 16); |
357 goto error; 358 } 359#endif 360 361 /* check termination */ | 370 goto error; 371 } 372#endif 373 374 /* check termination */ |
362 if (!(ppb_rstr(dev) & SELECT)) { 363 ppb_peripheral_terminate(dev, PPB_WAIT); | 375 if (!(ppb_rstr(bus) & SELECT)) { 376 ppb_peripheral_terminate(bus, PPB_WAIT); |
364 goto error; 365 } 366 367error: 368 return (error); 369} 370 371/* 372 * byte_peripheral_write() 373 * 374 * Write n bytes in BYTE mode 375 */ 376int | 377 goto error; 378 } 379 380error: 381 return (error); 382} 383 384/* 385 * byte_peripheral_write() 386 * 387 * Write n bytes in BYTE mode 388 */ 389int |
377byte_peripheral_write(struct ppb_device *dev, char *buffer, int len, int *sent) | 390byte_peripheral_write(device_t bus, char *buffer, int len, int *sent) |
378{ 379 int error = 0, i; 380 char r; 381 | 391{ 392 int error = 0, i; 393 char r; 394 |
382 ppb_1284_set_state(dev, PPB_PERIPHERAL_TRANSFER); | 395 ppb_1284_set_state(bus, PPB_PERIPHERAL_TRANSFER); |
383 384 /* wait forever, the remote host is master and should initiate 385 * termination 386 */ 387 for (i=0; i<len; i++) { 388 /* force remote nFAULT low to release the remote waiting 389 * process, if any 390 */ | 396 397 /* wait forever, the remote host is master and should initiate 398 * termination 399 */ 400 for (i=0; i<len; i++) { 401 /* force remote nFAULT low to release the remote waiting 402 * process, if any 403 */ |
391 r = ppb_rctr(dev); 392 ppb_wctr(dev, r & ~nINIT); | 404 r = ppb_rctr(bus); 405 ppb_wctr(bus, r & ~nINIT); |
393 394#ifdef DEBUG_1284 395 printf("y"); 396#endif 397 /* Event 7 */ | 406 407#ifdef DEBUG_1284 408 printf("y"); 409#endif 410 /* Event 7 */ |
398 error = ppb_poll_device(dev, PPB_FOREVER, nBUSY, nBUSY, | 411 error = ppb_poll_bus(bus, PPB_FOREVER, nBUSY, nBUSY, |
399 PPB_INTR); 400 401 if (error && error != EWOULDBLOCK) 402 goto error; 403 404#ifdef DEBUG_1284 405 printf("b"); 406#endif | 412 PPB_INTR); 413 414 if (error && error != EWOULDBLOCK) 415 goto error; 416 417#ifdef DEBUG_1284 418 printf("b"); 419#endif |
407 if ((error = byte_peripheral_outbyte(dev, buffer+i, (i == len-1)))) | 420 if ((error = byte_peripheral_outbyte(bus, buffer+i, (i == len-1)))) |
408 goto error; 409 } 410error: 411 if (!error) | 421 goto error; 422 } 423error: 424 if (!error) |
412 ppb_1284_set_state(dev, PPB_PERIPHERAL_IDLE); | 425 ppb_1284_set_state(bus, PPB_PERIPHERAL_IDLE); |
413 414 *sent = i; 415 return (error); 416} 417 418/* 419 * byte_1284_inbyte() 420 * 421 * Read 1 byte in BYTE mode 422 */ 423int | 426 427 *sent = i; 428 return (error); 429} 430 431/* 432 * byte_1284_inbyte() 433 * 434 * Read 1 byte in BYTE mode 435 */ 436int |
424byte_1284_inbyte(struct ppb_device *dev, char *buffer) | 437byte_1284_inbyte(device_t bus, char *buffer) |
425{ 426 int error = 0; 427 428 /* Event 7 - ready to take data (nAUTO low) */ | 438{ 439 int error = 0; 440 441 /* Event 7 - ready to take data (nAUTO low) */ |
429 ppb_wctr(dev, (PCD | nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); | 442 ppb_wctr(bus, (PCD | nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); |
430 431 /* Event 9 - peripheral set nAck low */ | 443 444 /* Event 9 - peripheral set nAck low */ |
432 if ((error = do_1284_wait(dev, nACK, 0))) { 433 ppb_1284_set_error(dev, PPB_TIMEOUT, 9); | 445 if ((error = do_1284_wait(bus, nACK, 0))) { 446 ppb_1284_set_error(bus, PPB_TIMEOUT, 9); |
434 goto error; 435 } 436 437 /* read the byte */ | 447 goto error; 448 } 449 450 /* read the byte */ |
438 *buffer = ppb_rdtr(dev); | 451 *buffer = ppb_rdtr(bus); |
439 440 /* Event 10 - data received, can't accept more */ | 452 453 /* Event 10 - data received, can't accept more */ |
441 ppb_wctr(dev, (nINIT) & ~(AUTOFEED | STROBE | SELECTIN)); | 454 ppb_wctr(bus, (nINIT) & ~(AUTOFEED | STROBE | SELECTIN)); |
442 443 /* Event 11 - peripheral ack */ | 455 456 /* Event 11 - peripheral ack */ |
444 if ((error = do_1284_wait(dev, nACK, nACK))) { 445 ppb_1284_set_error(dev, PPB_TIMEOUT, 11); | 457 if ((error = do_1284_wait(bus, nACK, nACK))) { 458 ppb_1284_set_error(bus, PPB_TIMEOUT, 11); |
446 goto error; 447 } 448 449 /* Event 16 - strobe */ | 459 goto error; 460 } 461 462 /* Event 16 - strobe */ |
450 ppb_wctr(dev, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); | 463 ppb_wctr(bus, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); |
451 DELAY(3); | 464 DELAY(3); |
452 ppb_wctr(dev, (nINIT) & ~(AUTOFEED | STROBE | SELECTIN)); | 465 ppb_wctr(bus, (nINIT) & ~(AUTOFEED | STROBE | SELECTIN)); |
453 454error: 455 return (error); 456} 457 458/* 459 * nibble_1284_inbyte() 460 * 461 * Read 1 byte in NIBBLE mode 462 */ 463int | 466 467error: 468 return (error); 469} 470 471/* 472 * nibble_1284_inbyte() 473 * 474 * Read 1 byte in NIBBLE mode 475 */ 476int |
464nibble_1284_inbyte(struct ppb_device *dev, char *buffer) | 477nibble_1284_inbyte(device_t bus, char *buffer) |
465{ 466 char nibble[2]; 467 int i, error; 468 469 for (i = 0; i < 2; i++) { 470 471 /* Event 7 - ready to take data (nAUTO low) */ | 478{ 479 char nibble[2]; 480 int i, error; 481 482 for (i = 0; i < 2; i++) { 483 484 /* Event 7 - ready to take data (nAUTO low) */ |
472 ppb_wctr(dev, (nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); | 485 ppb_wctr(bus, (nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); |
473 474 /* Event 8 - peripheral writes the first nibble */ 475 476 /* Event 9 - peripheral set nAck low */ | 486 487 /* Event 8 - peripheral writes the first nibble */ 488 489 /* Event 9 - peripheral set nAck low */ |
477 if ((error = do_1284_wait(dev, nACK, 0))) { 478 ppb_1284_set_error(dev, PPB_TIMEOUT, 9); | 490 if ((error = do_1284_wait(bus, nACK, 0))) { 491 ppb_1284_set_error(bus, PPB_TIMEOUT, 9); |
479 goto error; 480 } 481 482 /* read nibble */ | 492 goto error; 493 } 494 495 /* read nibble */ |
483 nibble[i] = ppb_rstr(dev); | 496 nibble[i] = ppb_rstr(bus); |
484 485 /* Event 10 - ack, nibble received */ | 497 498 /* Event 10 - ack, nibble received */ |
486 ppb_wctr(dev, nINIT & ~(AUTOFEED | STROBE | SELECTIN)); | 499 ppb_wctr(bus, nINIT & ~(AUTOFEED | STROBE | SELECTIN)); |
487 488 /* Event 11 - wait ack from peripherial */ | 500 501 /* Event 11 - wait ack from peripherial */ |
489 if ((error = do_1284_wait(dev, nACK, nACK))) { 490 ppb_1284_set_error(dev, PPB_TIMEOUT, 11); | 502 if ((error = do_1284_wait(bus, nACK, nACK))) { 503 ppb_1284_set_error(bus, PPB_TIMEOUT, 11); |
491 goto error; 492 } 493 } 494 495 *buffer = ((nibble2char(nibble[1]) << 4) & 0xf0) | 496 (nibble2char(nibble[0]) & 0x0f); 497 498error: 499 return (error); 500} 501 502/* 503 * spp_1284_read() 504 * 505 * Read in IEEE1284 NIBBLE/BYTE mode 506 */ 507int | 504 goto error; 505 } 506 } 507 508 *buffer = ((nibble2char(nibble[1]) << 4) & 0xf0) | 509 (nibble2char(nibble[0]) & 0x0f); 510 511error: 512 return (error); 513} 514 515/* 516 * spp_1284_read() 517 * 518 * Read in IEEE1284 NIBBLE/BYTE mode 519 */ 520int |
508spp_1284_read(struct ppb_device *dev, int mode, char *buffer, int max, int *read) | 521spp_1284_read(device_t bus, int mode, char *buffer, int max, int *read) |
509{ 510 int error = 0, len = 0; 511 int terminate_after_transfer = 1; 512 int state; 513 514 *read = len = 0; 515 | 522{ 523 int error = 0, len = 0; 524 int terminate_after_transfer = 1; 525 int state; 526 527 *read = len = 0; 528 |
516 state = ppb_1284_get_state(dev); | 529 state = ppb_1284_get_state(bus); |
517 518 switch (state) { 519 case PPB_FORWARD_IDLE: | 530 531 switch (state) { 532 case PPB_FORWARD_IDLE: |
520 if ((error = ppb_1284_negociate(dev, mode, 0))) | 533 if ((error = ppb_1284_negociate(bus, mode, 0))) |
521 return (error); 522 break; 523 524 case PPB_REVERSE_IDLE: 525 terminate_after_transfer = 0; 526 break; 527 528 default: | 534 return (error); 535 break; 536 537 case PPB_REVERSE_IDLE: 538 terminate_after_transfer = 0; 539 break; 540 541 default: |
529 ppb_1284_terminate(dev); 530 if ((error = ppb_1284_negociate(dev, mode, 0))) | 542 ppb_1284_terminate(bus); 543 if ((error = ppb_1284_negociate(bus, mode, 0))) |
531 return (error); 532 break; 533 } 534 | 544 return (error); 545 break; 546 } 547 |
535 while ((len < max) && !(ppb_rstr(dev) & (nFAULT))) { | 548 while ((len < max) && !(ppb_rstr(bus) & (nFAULT))) { |
536 | 549 |
537 ppb_1284_set_state(dev, PPB_REVERSE_TRANSFER); | 550 ppb_1284_set_state(bus, PPB_REVERSE_TRANSFER); |
538 539#ifdef DEBUG_1284 540 printf("B"); 541#endif 542 543 switch (mode) { 544 case PPB_NIBBLE: 545 /* read a byte, error means no more data */ | 551 552#ifdef DEBUG_1284 553 printf("B"); 554#endif 555 556 switch (mode) { 557 case PPB_NIBBLE: 558 /* read a byte, error means no more data */ |
546 if (nibble_1284_inbyte(dev, buffer+len)) | 559 if (nibble_1284_inbyte(bus, buffer+len)) |
547 goto end_while; 548 break; 549 case PPB_BYTE: | 560 goto end_while; 561 break; 562 case PPB_BYTE: |
550 if (byte_1284_inbyte(dev, buffer+len)) | 563 if (byte_1284_inbyte(bus, buffer+len)) |
551 goto end_while; 552 break; 553 default: 554 error = EINVAL; 555 goto end_while; 556 } 557 len ++; 558 } 559end_while: 560 561 if (!error) | 564 goto end_while; 565 break; 566 default: 567 error = EINVAL; 568 goto end_while; 569 } 570 len ++; 571 } 572end_while: 573 574 if (!error) |
562 ppb_1284_set_state(dev, PPB_REVERSE_IDLE); | 575 ppb_1284_set_state(bus, PPB_REVERSE_IDLE); |
563 564 *read = len; 565 566 if (terminate_after_transfer || error) | 576 577 *read = len; 578 579 if (terminate_after_transfer || error) |
567 ppb_1284_terminate(dev); | 580 ppb_1284_terminate(bus); |
568 569 return (error); 570} 571 572/* 573 * ppb_1284_read_id() 574 * 575 */ 576int | 581 582 return (error); 583} 584 585/* 586 * ppb_1284_read_id() 587 * 588 */ 589int |
577ppb_1284_read_id(struct ppb_device *dev, int mode, char *buffer, | 590ppb_1284_read_id(device_t bus, int mode, char *buffer, |
578 int max, int *read) 579{ 580 int error = 0; 581 582 /* fill the buffer with 0s */ 583 bzero(buffer, max); 584 585 switch (mode) { 586 case PPB_NIBBLE: 587 case PPB_ECP: | 591 int max, int *read) 592{ 593 int error = 0; 594 595 /* fill the buffer with 0s */ 596 bzero(buffer, max); 597 598 switch (mode) { 599 case PPB_NIBBLE: 600 case PPB_ECP: |
588 if ((error = ppb_1284_negociate(dev, PPB_NIBBLE, PPB_REQUEST_ID))) | 601 if ((error = ppb_1284_negociate(bus, PPB_NIBBLE, PPB_REQUEST_ID))) |
589 return (error); | 602 return (error); |
590 error = spp_1284_read(dev, PPB_NIBBLE, buffer, max, read); | 603 error = spp_1284_read(bus, PPB_NIBBLE, buffer, max, read); |
591 break; 592 case PPB_BYTE: | 604 break; 605 case PPB_BYTE: |
593 if ((error = ppb_1284_negociate(dev, PPB_BYTE, PPB_REQUEST_ID))) | 606 if ((error = ppb_1284_negociate(bus, PPB_BYTE, PPB_REQUEST_ID))) |
594 return (error); | 607 return (error); |
595 error = spp_1284_read(dev, PPB_BYTE, buffer, max, read); | 608 error = spp_1284_read(bus, PPB_BYTE, buffer, max, read); |
596 break; 597 default: 598 panic("%s: unsupported mode %d\n", __FUNCTION__, mode); 599 } 600 | 609 break; 610 default: 611 panic("%s: unsupported mode %d\n", __FUNCTION__, mode); 612 } 613 |
601 ppb_1284_terminate(dev); | 614 ppb_1284_terminate(bus); |
602 return (error); 603} 604 605/* 606 * ppb_1284_read() 607 * 608 * IEEE1284 read 609 */ 610int | 615 return (error); 616} 617 618/* 619 * ppb_1284_read() 620 * 621 * IEEE1284 read 622 */ 623int |
611ppb_1284_read(struct ppb_device *dev, int mode, char *buffer, | 624ppb_1284_read(device_t bus, int mode, char *buffer, |
612 int max, int *read) 613{ 614 int error = 0; 615 616 switch (mode) { 617 case PPB_NIBBLE: 618 case PPB_BYTE: | 625 int max, int *read) 626{ 627 int error = 0; 628 629 switch (mode) { 630 case PPB_NIBBLE: 631 case PPB_BYTE: |
619 error = spp_1284_read(dev, mode, buffer, max, read); | 632 error = spp_1284_read(bus, mode, buffer, max, read); |
620 break; 621 default: 622 return (EINVAL); 623 } 624 625 return (error); 626} 627 628/* 629 * ppb_1284_negociate() 630 * 631 * IEEE1284 negociation phase 632 * 633 * Normal nibble mode or request device id mode (see ppb_1284.h) 634 * 635 * After negociation, nFAULT is low if data is available 636 */ 637int | 633 break; 634 default: 635 return (EINVAL); 636 } 637 638 return (error); 639} 640 641/* 642 * ppb_1284_negociate() 643 * 644 * IEEE1284 negociation phase 645 * 646 * Normal nibble mode or request device id mode (see ppb_1284.h) 647 * 648 * After negociation, nFAULT is low if data is available 649 */ 650int |
638ppb_1284_negociate(struct ppb_device *dev, int mode, int options) | 651ppb_1284_negociate(device_t bus, int mode, int options) |
639{ 640 int error; 641 int request_mode; 642 643#ifdef DEBUG_1284 644 printf("n"); 645#endif 646 | 652{ 653 int error; 654 int request_mode; 655 656#ifdef DEBUG_1284 657 printf("n"); 658#endif 659 |
647 if (ppb_1284_get_state(dev) >= PPB_PERIPHERAL_NEGOCIATION) 648 ppb_peripheral_terminate(dev, PPB_WAIT); | 660 if (ppb_1284_get_state(bus) >= PPB_PERIPHERAL_NEGOCIATION) 661 ppb_peripheral_terminate(bus, PPB_WAIT); |
649 | 662 |
650 if (ppb_1284_get_state(dev) != PPB_FORWARD_IDLE) 651 ppb_1284_terminate(dev); | 663 if (ppb_1284_get_state(bus) != PPB_FORWARD_IDLE) 664 ppb_1284_terminate(bus); |
652 653#ifdef DEBUG_1284 654 printf("%d", mode); 655#endif 656 657 /* ensure the host is in compatible mode */ | 665 666#ifdef DEBUG_1284 667 printf("%d", mode); 668#endif 669 670 /* ensure the host is in compatible mode */ |
658 ppb_set_mode(dev, PPB_COMPATIBLE); | 671 ppb_set_mode(bus, PPB_COMPATIBLE); |
659 660 /* reset error to catch the actual negociation error */ | 672 673 /* reset error to catch the actual negociation error */ |
661 ppb_1284_reset_error(dev, PPB_FORWARD_IDLE); | 674 ppb_1284_reset_error(bus, PPB_FORWARD_IDLE); |
662 663 /* calculate ext. value */ 664 request_mode = ppb_request_mode(mode, options); 665 666 /* default state */ | 675 676 /* calculate ext. value */ 677 request_mode = ppb_request_mode(mode, options); 678 679 /* default state */ |
667 ppb_wctr(dev, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); | 680 ppb_wctr(bus, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); |
668 DELAY(1); 669 670 /* enter negociation phase */ | 681 DELAY(1); 682 683 /* enter negociation phase */ |
671 ppb_1284_set_state(dev, PPB_NEGOCIATION); | 684 ppb_1284_set_state(bus, PPB_NEGOCIATION); |
672 673 /* Event 0 - put the exten. value on the data lines */ | 685 686 /* Event 0 - put the exten. value on the data lines */ |
674 ppb_wdtr(dev, request_mode); | 687 ppb_wdtr(bus, request_mode); |
675 676#ifdef PERIPH_1284 677 /* request remote host attention */ | 688 689#ifdef PERIPH_1284 690 /* request remote host attention */ |
678 ppb_wctr(dev, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); | 691 ppb_wctr(bus, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); |
679 DELAY(1); | 692 DELAY(1); |
680 ppb_wctr(dev, (nINIT) & ~(STROBE | AUTOFEED | SELECTIN)); | 693 ppb_wctr(bus, (nINIT) & ~(STROBE | AUTOFEED | SELECTIN)); |
681#else 682 DELAY(1); 683 684#endif /* !PERIPH_1284 */ 685 686 /* Event 1 - enter IEEE1284 mode */ | 694#else 695 DELAY(1); 696 697#endif /* !PERIPH_1284 */ 698 699 /* Event 1 - enter IEEE1284 mode */ |
687 ppb_wctr(dev, (nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); | 700 ppb_wctr(bus, (nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); |
688 689#ifdef PERIPH_1284 690 /* ignore the PError line, wait a bit more, remote host's 691 * interrupts don't respond fast enough */ | 701 702#ifdef PERIPH_1284 703 /* ignore the PError line, wait a bit more, remote host's 704 * interrupts don't respond fast enough */ |
692 if (ppb_poll_device(dev, 40, nACK | SELECT | nFAULT, | 705 if (ppb_poll_bus(bus, 40, nACK | SELECT | nFAULT, |
693 SELECT | nFAULT, PPB_NOINTR | PPB_POLL)) { | 706 SELECT | nFAULT, PPB_NOINTR | PPB_POLL)) { |
694 ppb_1284_set_error(dev, PPB_NOT_IEEE1284, 2); | 707 ppb_1284_set_error(bus, PPB_NOT_IEEE1284, 2); |
695 error = ENODEV; 696 goto error; 697 } 698#else 699 /* Event 2 - trying IEEE1284 dialog */ | 708 error = ENODEV; 709 goto error; 710 } 711#else 712 /* Event 2 - trying IEEE1284 dialog */ |
700 if (do_1284_wait(dev, nACK | PERROR | SELECT | nFAULT, | 713 if (do_1284_wait(bus, nACK | PERROR | SELECT | nFAULT, |
701 PERROR | SELECT | nFAULT)) { | 714 PERROR | SELECT | nFAULT)) { |
702 ppb_1284_set_error(dev, PPB_NOT_IEEE1284, 2); | 715 ppb_1284_set_error(bus, PPB_NOT_IEEE1284, 2); |
703 error = ENODEV; 704 goto error; 705 } 706#endif /* !PERIPH_1284 */ 707 708 /* Event 3 - latch the ext. value to the peripheral */ | 716 error = ENODEV; 717 goto error; 718 } 719#endif /* !PERIPH_1284 */ 720 721 /* Event 3 - latch the ext. value to the peripheral */ |
709 ppb_wctr(dev, (nINIT | STROBE | AUTOFEED) & ~SELECTIN); | 722 ppb_wctr(bus, (nINIT | STROBE | AUTOFEED) & ~SELECTIN); |
710 DELAY(1); 711 712 /* Event 4 - IEEE1284 device recognized */ | 723 DELAY(1); 724 725 /* Event 4 - IEEE1284 device recognized */ |
713 ppb_wctr(dev, nINIT & ~(SELECTIN | AUTOFEED | STROBE)); | 726 ppb_wctr(bus, nINIT & ~(SELECTIN | AUTOFEED | STROBE)); |
714 715 /* Event 6 - waiting for status lines */ | 727 728 /* Event 6 - waiting for status lines */ |
716 if (do_1284_wait(dev, nACK, nACK)) { 717 ppb_1284_set_error(dev, PPB_TIMEOUT, 6); | 729 if (do_1284_wait(bus, nACK, nACK)) { 730 ppb_1284_set_error(bus, PPB_TIMEOUT, 6); |
718 error = EBUSY; 719 goto error; 720 } 721 722 /* Event 7 - quering result consider nACK not to misunderstand 723 * a remote computer terminate sequence */ 724 if (options & PPB_EXTENSIBILITY_LINK) { 725 726 /* XXX not fully supported yet */ | 731 error = EBUSY; 732 goto error; 733 } 734 735 /* Event 7 - quering result consider nACK not to misunderstand 736 * a remote computer terminate sequence */ 737 if (options & PPB_EXTENSIBILITY_LINK) { 738 739 /* XXX not fully supported yet */ |
727 ppb_1284_terminate(dev); | 740 ppb_1284_terminate(bus); |
728 return (0); 729 730 } 731 if (request_mode == NIBBLE_1284_NORMAL) { | 741 return (0); 742 743 } 744 if (request_mode == NIBBLE_1284_NORMAL) { |
732 if (do_1284_wait(dev, nACK | SELECT, nACK)) { 733 ppb_1284_set_error(dev, PPB_MODE_UNSUPPORTED, 7); | 745 if (do_1284_wait(bus, nACK | SELECT, nACK)) { 746 ppb_1284_set_error(bus, PPB_MODE_UNSUPPORTED, 7); |
734 error = ENODEV; 735 goto error; 736 } 737 } else { | 747 error = ENODEV; 748 goto error; 749 } 750 } else { |
738 if (do_1284_wait(dev, nACK | SELECT, SELECT | nACK)) { 739 ppb_1284_set_error(dev, PPB_MODE_UNSUPPORTED, 7); | 751 if (do_1284_wait(bus, nACK | SELECT, SELECT | nACK)) { 752 ppb_1284_set_error(bus, PPB_MODE_UNSUPPORTED, 7); |
740 error = ENODEV; 741 goto error; 742 } 743 } 744 745 switch (mode) { 746 case PPB_NIBBLE: 747 case PPB_PS2: 748 /* enter reverse idle phase */ | 753 error = ENODEV; 754 goto error; 755 } 756 } 757 758 switch (mode) { 759 case PPB_NIBBLE: 760 case PPB_PS2: 761 /* enter reverse idle phase */ |
749 ppb_1284_set_state(dev, PPB_REVERSE_IDLE); | 762 ppb_1284_set_state(bus, PPB_REVERSE_IDLE); |
750 break; 751 case PPB_ECP: 752 /* negociation ok, now setup the communication */ | 763 break; 764 case PPB_ECP: 765 /* negociation ok, now setup the communication */ |
753 ppb_1284_set_state(dev, PPB_SETUP); 754 ppb_wctr(dev, (nINIT | AUTOFEED) & ~(SELECTIN | STROBE)); | 766 ppb_1284_set_state(bus, PPB_SETUP); 767 ppb_wctr(bus, (nINIT | AUTOFEED) & ~(SELECTIN | STROBE)); |
755 756#ifdef PERIPH_1284 757 /* ignore PError line */ | 768 769#ifdef PERIPH_1284 770 /* ignore PError line */ |
758 if (do_1284_wait(dev, nACK | SELECT | nBUSY, | 771 if (do_1284_wait(bus, nACK | SELECT | nBUSY, |
759 nACK | SELECT | nBUSY)) { | 772 nACK | SELECT | nBUSY)) { |
760 ppb_1284_set_error(dev, PPB_TIMEOUT, 30); | 773 ppb_1284_set_error(bus, PPB_TIMEOUT, 30); |
761 error = ENODEV; 762 goto error; 763 } 764#else | 774 error = ENODEV; 775 goto error; 776 } 777#else |
765 if (do_1284_wait(dev, nACK | SELECT | PERROR | nBUSY, | 778 if (do_1284_wait(bus, nACK | SELECT | PERROR | nBUSY, |
766 nACK | SELECT | PERROR | nBUSY)) { | 779 nACK | SELECT | PERROR | nBUSY)) { |
767 ppb_1284_set_error(dev, PPB_TIMEOUT, 30); | 780 ppb_1284_set_error(bus, PPB_TIMEOUT, 30); |
768 error = ENODEV; 769 goto error; 770 } 771#endif /* !PERIPH_1284 */ 772 773 /* ok, the host enters the ForwardIdle state */ | 781 error = ENODEV; 782 goto error; 783 } 784#endif /* !PERIPH_1284 */ 785 786 /* ok, the host enters the ForwardIdle state */ |
774 ppb_1284_set_state(dev, PPB_ECP_FORWARD_IDLE); | 787 ppb_1284_set_state(bus, PPB_ECP_FORWARD_IDLE); |
775 break; 776 case PPB_EPP: | 788 break; 789 case PPB_EPP: |
777 ppb_1284_set_state(dev, PPB_EPP_IDLE); | 790 ppb_1284_set_state(bus, PPB_EPP_IDLE); |
778 break; 779 780 default: 781 panic("%s: unknown mode (%d)!", __FUNCTION__, mode); 782 } | 791 break; 792 793 default: 794 panic("%s: unknown mode (%d)!", __FUNCTION__, mode); 795 } |
783 ppb_set_mode(dev, mode); | 796 ppb_set_mode(bus, mode); |
784 785 return (0); 786 787error: | 797 798 return (0); 799 800error: |
788 ppb_1284_terminate(dev); | 801 ppb_1284_terminate(bus); |
789 790 return (error); 791} 792 793/* 794 * ppb_1284_terminate() 795 * 796 * IEEE1284 termination phase, return code should ignored since the host 797 * is _always_ in compatible mode after ppb_1284_terminate() 798 */ 799int | 802 803 return (error); 804} 805 806/* 807 * ppb_1284_terminate() 808 * 809 * IEEE1284 termination phase, return code should ignored since the host 810 * is _always_ in compatible mode after ppb_1284_terminate() 811 */ 812int |
800ppb_1284_terminate(struct ppb_device *dev) | 813ppb_1284_terminate(device_t bus) |
801{ 802 803#ifdef DEBUG_1284 804 printf("T"); 805#endif 806 807 /* do not reset error here to keep the error that 808 * may occured before the ppb_1284_terminate() call */ | 814{ 815 816#ifdef DEBUG_1284 817 printf("T"); 818#endif 819 820 /* do not reset error here to keep the error that 821 * may occured before the ppb_1284_terminate() call */ |
809 ppb_1284_set_state(dev, PPB_TERMINATION); | 822 ppb_1284_set_state(bus, PPB_TERMINATION); |
810 811#ifdef PERIPH_1284 812 /* request remote host attention */ | 823 824#ifdef PERIPH_1284 825 /* request remote host attention */ |
813 ppb_wctr(dev, (nINIT | STROBE | SELECTIN) & ~(AUTOFEED)); | 826 ppb_wctr(bus, (nINIT | STROBE | SELECTIN) & ~(AUTOFEED)); |
814 DELAY(1); 815#endif /* PERIPH_1284 */ 816 817 /* Event 22 - set nSelectin low and nAutoFeed high */ | 827 DELAY(1); 828#endif /* PERIPH_1284 */ 829 830 /* Event 22 - set nSelectin low and nAutoFeed high */ |
818 ppb_wctr(dev, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); | 831 ppb_wctr(bus, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); |
819 820 /* Event 24 - waiting for peripheral, Xflag ignored */ | 832 833 /* Event 24 - waiting for peripheral, Xflag ignored */ |
821 if (do_1284_wait(dev, nACK | nBUSY | nFAULT, nFAULT)) { 822 ppb_1284_set_error(dev, PPB_TIMEOUT, 24); | 834 if (do_1284_wait(bus, nACK | nBUSY | nFAULT, nFAULT)) { 835 ppb_1284_set_error(bus, PPB_TIMEOUT, 24); |
823 goto error; 824 } 825 826 /* Event 25 - set nAutoFd low */ | 836 goto error; 837 } 838 839 /* Event 25 - set nAutoFd low */ |
827 ppb_wctr(dev, (nINIT | SELECTIN | AUTOFEED) & ~STROBE); | 840 ppb_wctr(bus, (nINIT | SELECTIN | AUTOFEED) & ~STROBE); |
828 829 /* Event 26 - compatible mode status is set */ 830 831 /* Event 27 - peripheral set nAck high */ | 841 842 /* Event 26 - compatible mode status is set */ 843 844 /* Event 27 - peripheral set nAck high */ |
832 if (do_1284_wait(dev, nACK, nACK)) { 833 ppb_1284_set_error(dev, PPB_TIMEOUT, 27); | 845 if (do_1284_wait(bus, nACK, nACK)) { 846 ppb_1284_set_error(bus, PPB_TIMEOUT, 27); |
834 } 835 836 /* Event 28 - end termination, return to idle phase */ | 847 } 848 849 /* Event 28 - end termination, return to idle phase */ |
837 ppb_wctr(dev, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); | 850 ppb_wctr(bus, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); |
838 839error: 840 /* return to compatible mode */ | 851 852error: 853 /* return to compatible mode */ |
841 ppb_set_mode(dev, PPB_COMPATIBLE); 842 ppb_1284_set_state(dev, PPB_FORWARD_IDLE); | 854 ppb_set_mode(bus, PPB_COMPATIBLE); 855 ppb_1284_set_state(bus, PPB_FORWARD_IDLE); |
843 844 return (0); 845} | 856 857 return (0); 858} |