1 /*-
2 * Copyright (c) 1998, 1999 Nicolas Souchu
3 * Copyright (c) 2001 Alcove - Nicolas Souchu
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 *
28 */
29
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD: stable/10/sys/dev/ppbus/immio.c 187576 2009-01-21 23:10:06Z jhb $");
32
33 /*
34 * Iomega ZIP+ Matchmaker Parallel Port Interface driver
35 *
36 * Thanks to David Campbell work on the Linux driver and the Iomega specs
37 * Thanks to Thiebault Moeglin for the drive
38 */
39 #ifdef _KERNEL
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/module.h>
43 #include <sys/bus.h>
44 #include <sys/malloc.h>
45
46 #endif /* _KERNEL */
47
48 #include "opt_vpo.h"
49
50 #include <dev/ppbus/ppbio.h>
51 #include <dev/ppbus/ppbconf.h>
52 #include <dev/ppbus/ppb_msq.h>
53 #include <dev/ppbus/vpoio.h>
54 #include <dev/ppbus/ppb_1284.h>
55
56 #include "ppbus_if.h"
57
58 #define VP0_SELTMO 5000 /* select timeout */
59 #define VP0_FAST_SPINTMO 500000 /* wait status timeout */
60 #define VP0_LOW_SPINTMO 5000000 /* wait status timeout */
61
62 #define VP0_SECTOR_SIZE 512
63
64 /*
65 * Microcode to execute very fast I/O sequences at the lowest bus level.
66 */
67
68 #define WAIT_RET MS_PARAM(7, 2, MS_TYP_PTR)
69 #define WAIT_TMO MS_PARAM(1, 0, MS_TYP_INT)
70
71 #define DECLARE_WAIT_MICROSEQUENCE \
72 struct ppb_microseq wait_microseq[] = { \
73 MS_CASS(0x0c), \
74 MS_SET(MS_UNKNOWN), \
75 /* loop */ \
76 MS_BRSET(nBUSY, 4 /* ready */), \
77 MS_DBRA(-2 /* loop */), \
78 MS_CASS(0x04), \
79 MS_RET(1), /* timed out */ \
80 /* ready */ \
81 MS_CASS(0x04), \
82 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN ), \
83 MS_RET(0) /* no error */ \
84 }
85
86 #define SELECT_TARGET MS_PARAM(6, 1, MS_TYP_CHA)
87
88 #define DECLARE_SELECT_MICROSEQUENCE \
89 struct ppb_microseq select_microseq[] = { \
90 MS_CASS(0xc), \
91 /* first, check there is nothing holding onto the bus */ \
92 MS_SET(VP0_SELTMO), \
93 /* _loop: */ \
94 MS_BRCLEAR(0x8, 2 /* _ready */), \
95 MS_DBRA(-2 /* _loop */), \
96 MS_RET(2), /* bus busy */ \
97 /* _ready: */ \
98 MS_CASS(0x4), \
99 MS_DASS(MS_UNKNOWN /* 0x80 | 1 << target */), \
100 MS_DELAY(1), \
101 MS_CASS(0xc), \
102 MS_CASS(0xd), \
103 /* now, wait until the drive is ready */ \
104 MS_SET(VP0_SELTMO), \
105 /* loop: */ \
106 MS_BRSET(0x8, 3 /* ready */), \
107 MS_DBRA(-2 /* loop */), \
108 /* error: */ \
109 MS_CASS(0xc), \
110 MS_RET(VP0_ESELECT_TIMEOUT), \
111 /* ready: */ \
112 MS_CASS(0xc), \
113 MS_RET(0) \
114 }
115
116 static struct ppb_microseq transfer_epilog[] = {
117 MS_CASS(0x4),
118 MS_CASS(0xc),
119 MS_CASS(0xe),
120 MS_CASS(0x4),
121 MS_RET(0)
122 };
123
124 #define CPP_S1 MS_PARAM(10, 2, MS_TYP_PTR)
125 #define CPP_S2 MS_PARAM(13, 2, MS_TYP_PTR)
126 #define CPP_S3 MS_PARAM(16, 2, MS_TYP_PTR)
127 #define CPP_PARAM MS_PARAM(17, 1, MS_TYP_CHA)
128
129 #define DECLARE_CPP_MICROSEQ \
130 struct ppb_microseq cpp_microseq[] = { \
131 MS_CASS(0x0c), MS_DELAY(2), \
132 MS_DASS(0xaa), MS_DELAY(10), \
133 MS_DASS(0x55), MS_DELAY(10), \
134 MS_DASS(0x00), MS_DELAY(10), \
135 MS_DASS(0xff), MS_DELAY(10), \
136 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN /* &s1 */), \
137 MS_DASS(0x87), MS_DELAY(10), \
138 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN /* &s2 */), \
139 MS_DASS(0x78), MS_DELAY(10), \
140 MS_RFETCH(MS_REG_STR, 0x38, MS_UNKNOWN /* &s3 */), \
141 MS_DASS(MS_UNKNOWN /* param */), \
142 MS_DELAY(2), \
143 MS_CASS(0x0c), MS_DELAY(10), \
144 MS_CASS(0x0d), MS_DELAY(2), \
145 MS_CASS(0x0c), MS_DELAY(10), \
146 MS_DASS(0xff), MS_DELAY(10), \
147 MS_RET(0) \
148 }
149
150 #define NEGOCIATED_MODE MS_PARAM(2, 1, MS_TYP_CHA)
151
152 #define DECLARE_NEGOCIATE_MICROSEQ \
153 struct ppb_microseq negociate_microseq[] = { \
154 MS_CASS(0x4), \
155 MS_DELAY(5), \
156 MS_DASS(MS_UNKNOWN /* mode */), \
157 MS_DELAY(100), \
158 MS_CASS(0x6), \
159 MS_DELAY(5), \
160 MS_BRSET(0x20, 5 /* continue */), \
161 MS_DELAY(5), \
162 MS_CASS(0x7), \
163 MS_DELAY(5), \
164 MS_CASS(0x6), \
165 MS_RET(VP0_ENEGOCIATE), \
166 /* continue: */ \
167 MS_DELAY(5), \
168 MS_CASS(0x7), \
169 MS_DELAY(5), \
170 MS_CASS(0x6), \
171 MS_RET(0) \
172 }
173
174 #define INB_NIBBLE_L MS_PARAM(3, 2, MS_TYP_PTR)
175 #define INB_NIBBLE_H MS_PARAM(6, 2, MS_TYP_PTR)
176 #define INB_NIBBLE_F MS_PARAM(9, 0, MS_TYP_FUN)
177 #define INB_NIBBLE_P MS_PARAM(9, 1, MS_TYP_PTR)
178
179 /*
180 * This is the sub-microseqence for MS_GET in NIBBLE mode
181 * Retrieve the two nibbles and call the C function to generate the character
182 * and store it in the buffer (see nibble_inbyte_hook())
183 */
184
185 #define DECLARE_NIBBLE_INBYTE_SUBMICROSEQ \
186 struct ppb_microseq nibble_inbyte_submicroseq[] = { \
187 MS_CASS(0x4), \
188 /* loop: */ \
189 MS_CASS(0x6), \
190 MS_DELAY(1), \
191 MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* low nibble */),\
192 MS_CASS(0x5), \
193 MS_DELAY(1), \
194 MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* high nibble */),\
195 MS_CASS(0x4), \
196 MS_DELAY(1), \
197 /* do a C call to format the received nibbles */ \
198 MS_C_CALL(MS_UNKNOWN /* C hook */, MS_UNKNOWN /* param */), \
199 MS_DBRA(-7 /* loop */), \
200 MS_RET(0) \
201 }
202
203 static struct ppb_microseq reset_microseq[] = {
204 MS_CASS(0x04),
205 MS_DASS(0x40),
206 MS_DELAY(1),
207 MS_CASS(0x0c),
208 MS_CASS(0x0d),
209 MS_DELAY(50),
210 MS_CASS(0x0c),
211 MS_CASS(0x04),
212 MS_RET(0)
213 };
214
215 /*
216 * nibble_inbyte_hook()
217 *
218 * Formats high and low nibble into a character
219 */
220 static int
nibble_inbyte_hook(void * p,char * ptr)221 nibble_inbyte_hook (void *p, char *ptr)
222 {
223 struct vpo_nibble *s = (struct vpo_nibble *)p;
224
225 /* increment the buffer pointer */
226 *ptr = ((s->l >> 4) & 0x0f) + (s->h & 0xf0);
227
228 return (0);
229 }
230
231 /*
232 * This is the sub-microseqence for MS_GET in PS2 mode
233 */
234 static struct ppb_microseq ps2_inbyte_submicroseq[] = {
235 MS_CASS(0x4),
236
237 /* loop: */
238 MS_CASS(PCD | 0x6),
239 MS_RFETCH_P(1, MS_REG_DTR, MS_FETCH_ALL),
240 MS_CASS(PCD | 0x5),
241 MS_DBRA(-4 /* loop */),
242
243 MS_RET(0)
244 };
245
246 /*
247 * This is the sub-microsequence for MS_PUT in both NIBBLE and PS2 modes
248 */
249 static struct ppb_microseq spp_outbyte_submicroseq[] = {
250 MS_CASS(0x4),
251
252 /* loop: */
253 MS_RASSERT_P(1, MS_REG_DTR),
254 MS_CASS(0x5),
255 MS_DBRA(0), /* decrement counter */
256 MS_RASSERT_P(1, MS_REG_DTR),
257 MS_CASS(0x0),
258 MS_DBRA(-6 /* loop */),
259
260 /* return from the put call */
261 MS_CASS(0x4),
262 MS_RET(0)
263 };
264
265 /* EPP 1.7 microsequences, ptr and len set at runtime */
266 static struct ppb_microseq epp17_outstr[] = {
267 MS_CASS(0x4),
268 MS_RASSERT_P(MS_ACCUM, MS_REG_EPP_D),
269 MS_CASS(0xc),
270 MS_RET(0),
271 };
272
273 static struct ppb_microseq epp17_instr[] = {
274 MS_CASS(PCD | 0x4),
275 MS_RFETCH_P(MS_ACCUM, MS_REG_EPP_D, MS_FETCH_ALL),
276 MS_CASS(PCD | 0xc),
277 MS_RET(0),
278 };
279
280 static int
imm_disconnect(struct vpoio_data * vpo,int * connected,int release_bus)281 imm_disconnect(struct vpoio_data *vpo, int *connected, int release_bus)
282 {
283 DECLARE_CPP_MICROSEQ;
284
285 device_t ppbus = device_get_parent(vpo->vpo_dev);
286 char s1, s2, s3;
287 int ret;
288
289 /* all should be ok */
290 if (connected)
291 *connected = 0;
292
293 ppb_MS_init_msq(cpp_microseq, 4, CPP_S1, (void *)&s1,
294 CPP_S2, (void *)&s2, CPP_S3, (void *)&s3,
295 CPP_PARAM, 0x30);
296
297 ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret);
298
299 if ((s1 != (char)0xb8 || s2 != (char)0x18 || s3 != (char)0x38)) {
300 if (bootverbose)
301 device_printf(vpo->vpo_dev,
302 "(disconnect) s1=0x%x s2=0x%x, s3=0x%x\n",
303 s1 & 0xff, s2 & 0xff, s3 & 0xff);
304 if (connected)
305 *connected = VP0_ECONNECT;
306 }
307
308 if (release_bus)
309 return (ppb_release_bus(ppbus, vpo->vpo_dev));
310 else
311 return (0);
312 }
313
314 /*
315 * how : PPB_WAIT or PPB_DONTWAIT
316 */
317 static int
imm_connect(struct vpoio_data * vpo,int how,int * disconnected,int request_bus)318 imm_connect(struct vpoio_data *vpo, int how, int *disconnected, int request_bus)
319 {
320 DECLARE_CPP_MICROSEQ;
321
322 device_t ppbus = device_get_parent(vpo->vpo_dev);
323 char s1, s2, s3;
324 int error;
325 int ret;
326
327 /* all should be ok */
328 if (disconnected)
329 *disconnected = 0;
330
331 if (request_bus)
332 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, how)))
333 return (error);
334
335 ppb_MS_init_msq(cpp_microseq, 3, CPP_S1, (void *)&s1,
336 CPP_S2, (void *)&s2, CPP_S3, (void *)&s3);
337
338 /* select device 0 in compatible mode */
339 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0xe0);
340 ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret);
341
342 /* disconnect all devices */
343 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0x30);
344 ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret);
345
346 if (PPB_IN_EPP_MODE(ppbus))
347 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0x28);
348 else
349 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0xe0);
350
351 ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret);
352
353 if ((s1 != (char)0xb8 || s2 != (char)0x18 || s3 != (char)0x30)) {
354 if (bootverbose)
355 device_printf(vpo->vpo_dev,
356 "(connect) s1=0x%x s2=0x%x, s3=0x%x\n",
357 s1 & 0xff, s2 & 0xff, s3 & 0xff);
358 if (disconnected)
359 *disconnected = VP0_ECONNECT;
360 }
361
362 return (0);
363 }
364
365 /*
366 * imm_detect()
367 *
368 * Detect and initialise the VP0 adapter.
369 */
370 static int
imm_detect(struct vpoio_data * vpo)371 imm_detect(struct vpoio_data *vpo)
372 {
373 device_t ppbus = device_get_parent(vpo->vpo_dev);
374 int error;
375
376 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_DONTWAIT)))
377 return (error);
378
379 /* disconnect the drive, keep the bus */
380 imm_disconnect(vpo, NULL, 0);
381
382 vpo->vpo_mode_found = VP0_MODE_UNDEFINED;
383 error = 1;
384
385 /* try to enter EPP mode since vpoio failure put the bus in NIBBLE */
386 if (ppb_set_mode(ppbus, PPB_EPP) != -1) {
387 imm_connect(vpo, PPB_DONTWAIT, &error, 0);
388 }
389
390 /* if connection failed try PS/2 then NIBBLE modes */
391 if (error) {
392 if (ppb_set_mode(ppbus, PPB_PS2) != -1) {
393 imm_connect(vpo, PPB_DONTWAIT, &error, 0);
394 }
395 if (error) {
396 if (ppb_set_mode(ppbus, PPB_NIBBLE) != -1) {
397 imm_connect(vpo, PPB_DONTWAIT, &error, 0);
398 if (error)
399 goto error;
400 vpo->vpo_mode_found = VP0_MODE_NIBBLE;
401 } else {
402 device_printf(vpo->vpo_dev,
403 "NIBBLE mode unavailable!\n");
404 goto error;
405 }
406 } else {
407 vpo->vpo_mode_found = VP0_MODE_PS2;
408 }
409 } else {
410 vpo->vpo_mode_found = VP0_MODE_EPP;
411 }
412
413 /* send SCSI reset signal */
414 ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, NULL);
415
416 /* release the bus now */
417 imm_disconnect(vpo, &error, 1);
418
419 /* ensure we are disconnected or daisy chained peripheral
420 * may cause serious problem to the disk */
421
422 if (error) {
423 if (bootverbose)
424 device_printf(vpo->vpo_dev,
425 "can't disconnect from the drive\n");
426 goto error;
427 }
428
429 return (0);
430
431 error:
432 ppb_release_bus(ppbus, vpo->vpo_dev);
433 return (VP0_EINITFAILED);
434 }
435
436 /*
437 * imm_outstr()
438 */
439 static int
imm_outstr(struct vpoio_data * vpo,char * buffer,int size)440 imm_outstr(struct vpoio_data *vpo, char *buffer, int size)
441 {
442 device_t ppbus = device_get_parent(vpo->vpo_dev);
443 int error = 0;
444
445 if (PPB_IN_EPP_MODE(ppbus))
446 ppb_reset_epp_timeout(ppbus);
447
448 ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_PUT, (union ppb_insarg)buffer,
449 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error);
450
451 return (error);
452 }
453
454 /*
455 * imm_instr()
456 */
457 static int
imm_instr(struct vpoio_data * vpo,char * buffer,int size)458 imm_instr(struct vpoio_data *vpo, char *buffer, int size)
459 {
460 device_t ppbus = device_get_parent(vpo->vpo_dev);
461 int error = 0;
462
463 if (PPB_IN_EPP_MODE(ppbus))
464 ppb_reset_epp_timeout(ppbus);
465
466 ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_GET, (union ppb_insarg)buffer,
467 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error);
468
469 return (error);
470 }
471
472 static char
imm_select(struct vpoio_data * vpo,int initiator,int target)473 imm_select(struct vpoio_data *vpo, int initiator, int target)
474 {
475 DECLARE_SELECT_MICROSEQUENCE;
476 device_t ppbus = device_get_parent(vpo->vpo_dev);
477 int ret;
478
479 /* initialize the select microsequence */
480 ppb_MS_init_msq(select_microseq, 1,
481 SELECT_TARGET, 1 << initiator | 1 << target);
482
483 ppb_MS_microseq(ppbus, vpo->vpo_dev, select_microseq, &ret);
484
485 return (ret);
486 }
487
488 /*
489 * imm_wait()
490 *
491 * H_SELIN must be low.
492 *
493 */
494 static char
imm_wait(struct vpoio_data * vpo,int tmo)495 imm_wait(struct vpoio_data *vpo, int tmo)
496 {
497 DECLARE_WAIT_MICROSEQUENCE;
498
499 device_t ppbus = device_get_parent(vpo->vpo_dev);
500 int ret, err;
501
502 /*
503 * Return some status information.
504 * Semantics : 0x88 = ZIP+ wants more data
505 * 0x98 = ZIP+ wants to send more data
506 * 0xa8 = ZIP+ wants command
507 * 0xb8 = end of transfer, ZIP+ is sending status
508 */
509
510 ppb_MS_init_msq(wait_microseq, 2,
511 WAIT_RET, (void *)&ret,
512 WAIT_TMO, tmo);
513
514 ppb_MS_microseq(ppbus, vpo->vpo_dev, wait_microseq, &err);
515
516 if (err)
517 return (0); /* command timed out */
518
519 return(ret);
520 }
521
522 static int
imm_negociate(struct vpoio_data * vpo)523 imm_negociate(struct vpoio_data *vpo)
524 {
525 DECLARE_NEGOCIATE_MICROSEQ;
526 device_t ppbus = device_get_parent(vpo->vpo_dev);
527 int negociate_mode;
528 int ret;
529
530 if (PPB_IN_NIBBLE_MODE(ppbus))
531 negociate_mode = 0;
532 else if (PPB_IN_PS2_MODE(ppbus))
533 negociate_mode = 1;
534 else
535 return (0);
536
537 #if 0 /* XXX use standalone code not to depend on ppb_1284 code yet */
538 ret = ppb_1284_negociate(ppbus, negociate_mode);
539
540 if (ret)
541 return (VP0_ENEGOCIATE);
542 #endif
543
544 ppb_MS_init_msq(negociate_microseq, 1,
545 NEGOCIATED_MODE, negociate_mode);
546
547 ppb_MS_microseq(ppbus, vpo->vpo_dev, negociate_microseq, &ret);
548
549 return (ret);
550 }
551
552 /*
553 * imm_probe()
554 *
555 * Low level probe of vpo device
556 *
557 */
558 int
imm_probe(device_t dev,struct vpoio_data * vpo)559 imm_probe(device_t dev, struct vpoio_data *vpo)
560 {
561 int error;
562
563 /* ppbus dependent initialisation */
564 vpo->vpo_dev = dev;
565
566 /* now, try to initialise the drive */
567 if ((error = imm_detect(vpo))) {
568 return (error);
569 }
570
571 return (0);
572 }
573
574 /*
575 * imm_attach()
576 *
577 * Low level attachment of vpo device
578 *
579 */
580 int
imm_attach(struct vpoio_data * vpo)581 imm_attach(struct vpoio_data *vpo)
582 {
583 DECLARE_NIBBLE_INBYTE_SUBMICROSEQ;
584 device_t ppbus = device_get_parent(vpo->vpo_dev);
585 int error = 0;
586
587 /*
588 * Initialize microsequence code
589 */
590 vpo->vpo_nibble_inbyte_msq = (struct ppb_microseq *)malloc(
591 sizeof(nibble_inbyte_submicroseq), M_DEVBUF, M_NOWAIT);
592
593 if (!vpo->vpo_nibble_inbyte_msq)
594 return (ENXIO);
595
596 bcopy((void *)nibble_inbyte_submicroseq,
597 (void *)vpo->vpo_nibble_inbyte_msq,
598 sizeof(nibble_inbyte_submicroseq));
599
600 ppb_MS_init_msq(vpo->vpo_nibble_inbyte_msq, 4,
601 INB_NIBBLE_H, (void *)&(vpo)->vpo_nibble.h,
602 INB_NIBBLE_L, (void *)&(vpo)->vpo_nibble.l,
603 INB_NIBBLE_F, nibble_inbyte_hook,
604 INB_NIBBLE_P, (void *)&(vpo)->vpo_nibble);
605
606 /*
607 * Initialize mode dependent in/out microsequences
608 */
609 ppb_lock(ppbus);
610 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_WAIT)))
611 goto error;
612
613 /* ppbus automatically restore the last mode entered during detection */
614 switch (vpo->vpo_mode_found) {
615 case VP0_MODE_EPP:
616 ppb_MS_GET_init(ppbus, vpo->vpo_dev, epp17_instr);
617 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, epp17_outstr);
618 device_printf(vpo->vpo_dev, "EPP mode\n");
619 break;
620 case VP0_MODE_PS2:
621 ppb_MS_GET_init(ppbus, vpo->vpo_dev, ps2_inbyte_submicroseq);
622 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
623 device_printf(vpo->vpo_dev, "PS2 mode\n");
624 break;
625 case VP0_MODE_NIBBLE:
626 ppb_MS_GET_init(ppbus, vpo->vpo_dev, vpo->vpo_nibble_inbyte_msq);
627 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
628 device_printf(vpo->vpo_dev, "NIBBLE mode\n");
629 break;
630 default:
631 panic("imm: unknown mode %d", vpo->vpo_mode_found);
632 }
633
634 ppb_release_bus(ppbus, vpo->vpo_dev);
635 error:
636 ppb_unlock(ppbus);
637 return (error);
638 }
639
640 /*
641 * imm_reset_bus()
642 *
643 */
644 int
imm_reset_bus(struct vpoio_data * vpo)645 imm_reset_bus(struct vpoio_data *vpo)
646 {
647 device_t ppbus = device_get_parent(vpo->vpo_dev);
648 int disconnected;
649
650 /* first, connect to the drive and request the bus */
651 imm_connect(vpo, PPB_WAIT|PPB_INTR, &disconnected, 1);
652
653 if (!disconnected) {
654
655 /* reset the SCSI bus */
656 ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, NULL);
657
658 /* then disconnect */
659 imm_disconnect(vpo, NULL, 1);
660 }
661
662 return (0);
663 }
664
665 /*
666 * imm_do_scsi()
667 *
668 * Send an SCSI command
669 *
670 */
671 int
imm_do_scsi(struct vpoio_data * vpo,int host,int target,char * command,int clen,char * buffer,int blen,int * result,int * count,int * ret)672 imm_do_scsi(struct vpoio_data *vpo, int host, int target, char *command,
673 int clen, char *buffer, int blen, int *result, int *count,
674 int *ret)
675 {
676 device_t ppbus = device_get_parent(vpo->vpo_dev);
677 register char r;
678 char l, h = 0;
679 int len, error = 0, not_connected = 0;
680 register int k;
681 int negociated = 0;
682
683 /*
684 * enter disk state, allocate the ppbus
685 *
686 * XXX
687 * Should we allow this call to be interruptible?
688 * The only way to report the interruption is to return
689 * EIO to upper SCSI code :^(
690 */
691 if ((error = imm_connect(vpo, PPB_WAIT|PPB_INTR, ¬_connected, 1)))
692 return (error);
693
694 if (not_connected) {
695 *ret = VP0_ECONNECT;
696 goto error;
697 }
698
699 /*
700 * Select the drive ...
701 */
702 if ((*ret = imm_select(vpo,host,target)))
703 goto error;
704
705 /*
706 * Send the command ...
707 */
708 for (k = 0; k < clen; k+=2) {
709 if (imm_wait(vpo, VP0_FAST_SPINTMO) != (char)0xa8) {
710 *ret = VP0_ECMD_TIMEOUT;
711 goto error;
712 }
713 if (imm_outstr(vpo, &command[k], 2)) {
714 *ret = VP0_EPPDATA_TIMEOUT;
715 goto error;
716 }
717 }
718
719 if (!(r = imm_wait(vpo, VP0_LOW_SPINTMO))) {
720 *ret = VP0_ESTATUS_TIMEOUT;
721 goto error;
722 }
723
724 if ((r & 0x30) == 0x10) {
725 if (imm_negociate(vpo)) {
726 *ret = VP0_ENEGOCIATE;
727 goto error;
728 } else
729 negociated = 1;
730 }
731
732 /*
733 * Complete transfer ...
734 */
735 *count = 0;
736 for (;;) {
737
738 if (!(r = imm_wait(vpo, VP0_LOW_SPINTMO))) {
739 *ret = VP0_ESTATUS_TIMEOUT;
740 goto error;
741 }
742
743 /* stop when the ZIP+ wants to send status */
744 if (r == (char)0xb8)
745 break;
746
747 if (*count >= blen) {
748 *ret = VP0_EDATA_OVERFLOW;
749 goto error;
750 }
751
752 /* ZIP+ wants to send data? */
753 if (r == (char)0x88) {
754 len = (((blen - *count) >= VP0_SECTOR_SIZE)) ?
755 VP0_SECTOR_SIZE : 2;
756
757 error = imm_outstr(vpo, &buffer[*count], len);
758 } else {
759 if (!PPB_IN_EPP_MODE(ppbus))
760 len = 1;
761 else
762 len = (((blen - *count) >= VP0_SECTOR_SIZE)) ?
763 VP0_SECTOR_SIZE : 1;
764
765 error = imm_instr(vpo, &buffer[*count], len);
766 }
767
768 if (error) {
769 *ret = error;
770 goto error;
771 }
772
773 *count += len;
774 }
775
776 if ((PPB_IN_NIBBLE_MODE(ppbus) ||
777 PPB_IN_PS2_MODE(ppbus)) && negociated)
778 ppb_MS_microseq(ppbus, vpo->vpo_dev, transfer_epilog, NULL);
779
780 /*
781 * Retrieve status ...
782 */
783 if (imm_negociate(vpo)) {
784 *ret = VP0_ENEGOCIATE;
785 goto error;
786 } else
787 negociated = 1;
788
789 if (imm_instr(vpo, &l, 1)) {
790 *ret = VP0_EOTHER;
791 goto error;
792 }
793
794 /* check if the ZIP+ wants to send more status */
795 if (imm_wait(vpo, VP0_FAST_SPINTMO) == (char)0xb8)
796 if (imm_instr(vpo, &h, 1)) {
797 *ret = VP0_EOTHER + 2;
798 goto error;
799 }
800
801 /* Experience showed that we should discard this */
802 if (h == (char) -1)
803 h = 0;
804
805 *result = ((int) h << 8) | ((int) l & 0xff);
806
807 error:
808 if ((PPB_IN_NIBBLE_MODE(ppbus) ||
809 PPB_IN_PS2_MODE(ppbus)) && negociated)
810 ppb_MS_microseq(ppbus, vpo->vpo_dev, transfer_epilog, NULL);
811
812 /* return to printer state, release the ppbus */
813 imm_disconnect(vpo, NULL, 1);
814
815 return (0);
816 }
817