FreeBSD/Linux Kernel Cross Reference
sys/dev/ppbus/vpoio.c
1 /*-
2 * Copyright (c) 1998, 1999 Nicolas Souchu
3 * Copyright (c) 2000 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: releng/5.4/sys/dev/ppbus/vpoio.c 119418 2003-08-24 17:55:58Z obrien $");
32
33 #ifdef _KERNEL
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/module.h>
37 #include <sys/bus.h>
38 #include <sys/malloc.h>
39
40 #include <machine/clock.h>
41
42 #endif
43
44 #include "opt_vpo.h"
45
46 #include <dev/ppbus/ppbio.h>
47 #include <dev/ppbus/ppbconf.h>
48 #include <dev/ppbus/ppb_msq.h>
49 #include <dev/ppbus/vpoio.h>
50
51 #include "ppbus_if.h"
52
53 /*
54 * The driver pools the drive. We may add a timeout queue to avoid
55 * active polling on nACK. I've tried this but it leads to unreliable
56 * transfers
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 /*
63 * Actually, VP0 timings are more accurate (about few 16MHZ cycles),
64 * but succeeding in respecting such timings leads to architecture
65 * dependent considerations.
66 */
67 #define VP0_PULSE 1
68
69 #define VP0_SECTOR_SIZE 512
70 #define VP0_BUFFER_SIZE 0x12000
71
72 #define n(flags) (~(flags) & (flags))
73
74 /*
75 * VP0 connections.
76 */
77 #define H_AUTO n(AUTOFEED)
78 #define H_nAUTO AUTOFEED
79 #define H_STROBE n(STROBE)
80 #define H_nSTROBE STROBE
81 #define H_BSY n(nBUSY)
82 #define H_nBSY nBUSY
83 #define H_SEL SELECT
84 #define H_nSEL n(SELECT)
85 #define H_ERR PERROR
86 #define H_nERR n(PERROR)
87 #define H_ACK nACK
88 #define H_nACK n(nACK)
89 #define H_FLT nFAULT
90 #define H_nFLT n(nFAULT)
91 #define H_SELIN n(SELECTIN)
92 #define H_nSELIN SELECTIN
93 #define H_INIT nINIT
94 #define H_nINIT n(nINIT)
95
96 /*
97 * Microcode to execute very fast I/O sequences at the lowest bus level.
98 */
99
100 #define WAIT_RET MS_PARAM(4, 2, MS_TYP_PTR)
101 #define WAIT_TMO MS_PARAM(0, 0, MS_TYP_INT)
102
103 #define DECLARE_WAIT_MICROSEQUENCE \
104 struct ppb_microseq wait_microseq[] = { \
105 MS_SET(MS_UNKNOWN), \
106 /* loop */ \
107 MS_BRSET(nBUSY, 2 /* ready */), \
108 MS_DBRA(-2 /* loop */), \
109 MS_RET(1), /* timed out */ \
110 /* ready */ \
111 MS_RFETCH(MS_REG_STR, 0xf0, MS_UNKNOWN), \
112 MS_RET(0) /* no error */ \
113 }
114
115 /* call this macro to initialize connect/disconnect microsequences */
116 #define INIT_TRIG_MICROSEQ { \
117 int i; \
118 for (i=1; i <= 7; i+=2) { \
119 disconnect_microseq[i].arg[2] = (union ppb_insarg)d_pulse; \
120 connect_epp_microseq[i].arg[2] = \
121 connect_spp_microseq[i].arg[2] = (union ppb_insarg)c_pulse; \
122 } \
123 }
124
125 #define trig_d_pulse MS_TRIG(MS_REG_CTR,5,MS_UNKNOWN /* d_pulse */)
126 static char d_pulse[] = {
127 H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
128 H_nAUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE,
129 H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
130 H_AUTO | H_SELIN | H_INIT | H_STROBE, VP0_PULSE,
131 H_AUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE
132 };
133
134 #define trig_c_pulse MS_TRIG(MS_REG_CTR,5,MS_UNKNOWN /* c_pulse */)
135 static char c_pulse[] = {
136 H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
137 H_AUTO | H_SELIN | H_INIT | H_STROBE, 0,
138 H_nAUTO | H_SELIN | H_INIT | H_STROBE, VP0_PULSE,
139 H_AUTO | H_SELIN | H_INIT | H_STROBE, 0,
140 H_AUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE
141 };
142
143 static struct ppb_microseq disconnect_microseq[] = {
144 MS_DASS(0x0), trig_d_pulse, MS_DASS(0x3c), trig_d_pulse,
145 MS_DASS(0x20), trig_d_pulse, MS_DASS(0xf), trig_d_pulse, MS_RET(0)
146 };
147
148 static struct ppb_microseq connect_epp_microseq[] = {
149 MS_DASS(0x0), trig_c_pulse, MS_DASS(0x3c), trig_c_pulse,
150 MS_DASS(0x20), trig_c_pulse, MS_DASS(0xcf), trig_c_pulse, MS_RET(0)
151 };
152
153 static struct ppb_microseq connect_spp_microseq[] = {
154 MS_DASS(0x0), trig_c_pulse, MS_DASS(0x3c), trig_c_pulse,
155 MS_DASS(0x20), trig_c_pulse, MS_DASS(0x8f), trig_c_pulse, MS_RET(0)
156 };
157
158 /*
159 * nibble_inbyte_hook()
160 *
161 * Formats high and low nibble into a character
162 */
163 static int
164 nibble_inbyte_hook (void *p, char *ptr)
165 {
166 struct vpo_nibble *s = (struct vpo_nibble *)p;
167
168 /* increment the buffer pointer */
169 *ptr++ = ((s->l >> 4) & 0x0f) + (s->h & 0xf0);
170
171 return (0);
172 }
173
174 #define INB_NIBBLE_H MS_PARAM(2, 2, MS_TYP_PTR)
175 #define INB_NIBBLE_L MS_PARAM(4, 2, MS_TYP_PTR)
176 #define INB_NIBBLE_F MS_PARAM(5, 0, MS_TYP_FUN)
177 #define INB_NIBBLE_P MS_PARAM(5, 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 /* loop: */ \
188 MS_CASS( H_AUTO | H_SELIN | H_INIT | H_STROBE), \
189 MS_DELAY(VP0_PULSE), \
190 MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* high nibble */),\
191 MS_CASS(H_nAUTO | H_SELIN | H_INIT | H_STROBE), \
192 MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* low nibble */),\
193 /* do a C call to format the received nibbles */ \
194 MS_C_CALL(MS_UNKNOWN /* C hook */, MS_UNKNOWN /* param */),\
195 MS_DBRA(-7 /* loop */), \
196 MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE), \
197 MS_RET(0) \
198 }
199
200 /*
201 * This is the sub-microseqence for MS_GET in PS2 mode
202 */
203 static struct ppb_microseq ps2_inbyte_submicroseq[] = {
204 MS_CASS(PCD | H_AUTO | H_SELIN | H_INIT | H_nSTROBE),
205
206 /* loop: */
207 MS_RFETCH_P(1, MS_REG_DTR, MS_FETCH_ALL),
208 MS_CASS(PCD | H_nAUTO | H_SELIN | H_INIT | H_nSTROBE),
209 MS_CASS(PCD | H_AUTO | H_SELIN | H_INIT | H_nSTROBE),
210 MS_DBRA(-4 /* loop */),
211
212 MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
213 MS_RET(0)
214 };
215
216 /*
217 * This is the sub-microsequence for MS_PUT in both NIBBLE and PS2 modes
218 */
219 static struct ppb_microseq spp_outbyte_submicroseq[] = {
220
221 /* loop: */
222 MS_RASSERT_P(1, MS_REG_DTR),
223 MS_CASS(H_nAUTO | H_nSELIN | H_INIT | H_STROBE),
224 MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
225 MS_DELAY(VP0_PULSE),
226 MS_DBRA(-5 /* loop */),
227
228 /* return from the put call */
229 MS_RET(0)
230 };
231
232 /* EPP 1.7 microsequences, ptr and len set at runtime */
233 static struct ppb_microseq epp17_outstr_body[] = {
234 MS_CASS(H_AUTO | H_SELIN | H_INIT | H_STROBE),
235
236 /* loop: */
237 MS_RASSERT_P(1, MS_REG_EPP_D),
238 MS_BRSET(TIMEOUT, 3 /* error */), /* EPP timeout? */
239 MS_DBRA(-3 /* loop */),
240
241 MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
242 MS_RET(0),
243 /* error: */
244 MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
245 MS_RET(1)
246 };
247
248 static struct ppb_microseq epp17_instr_body[] = {
249 MS_CASS(PCD | H_AUTO | H_SELIN | H_INIT | H_STROBE),
250
251 /* loop: */
252 MS_RFETCH_P(1, MS_REG_EPP_D, MS_FETCH_ALL),
253 MS_BRSET(TIMEOUT, 3 /* error */), /* EPP timeout? */
254 MS_DBRA(-3 /* loop */),
255
256 MS_CASS(PCD | H_AUTO | H_nSELIN | H_INIT | H_STROBE),
257 MS_RET(0),
258 /* error: */
259 MS_CASS(PCD | H_AUTO | H_nSELIN | H_INIT | H_STROBE),
260 MS_RET(1)
261 };
262
263 static struct ppb_microseq in_disk_mode[] = {
264 MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
265 MS_CASS(H_nAUTO | H_nSELIN | H_INIT | H_STROBE),
266
267 MS_BRCLEAR(H_FLT, 3 /* error */),
268 MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
269 MS_BRSET(H_FLT, 1 /* error */),
270
271 MS_RET(1),
272 /* error: */
273 MS_RET(0)
274 };
275
276 static int
277 vpoio_disconnect(struct vpoio_data *vpo)
278 {
279 device_t ppbus = device_get_parent(vpo->vpo_dev);
280 int ret;
281
282 ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
283 return (ppb_release_bus(ppbus, vpo->vpo_dev));
284 }
285
286 /*
287 * how : PPB_WAIT or PPB_DONTWAIT
288 */
289 static int
290 vpoio_connect(struct vpoio_data *vpo, int how)
291 {
292 device_t ppbus = device_get_parent(vpo->vpo_dev);
293 int error;
294 int ret;
295
296 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, how))) {
297
298 #ifdef VP0_DEBUG
299 printf("%s: can't request bus!\n", __func__);
300 #endif
301 return error;
302 }
303
304 if (PPB_IN_EPP_MODE(ppbus))
305 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_epp_microseq, &ret);
306 else
307 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_spp_microseq, &ret);
308
309 return (0);
310 }
311
312 /*
313 * vpoio_reset()
314 *
315 * SCSI reset signal, the drive must be in disk mode
316 */
317 static void
318 vpoio_reset (struct vpoio_data *vpo)
319 {
320 device_t ppbus = device_get_parent(vpo->vpo_dev);
321 int ret;
322
323 struct ppb_microseq reset_microseq[] = {
324
325 #define INITIATOR MS_PARAM(0, 1, MS_TYP_INT)
326
327 MS_DASS(MS_UNKNOWN),
328 MS_CASS(H_AUTO | H_nSELIN | H_nINIT | H_STROBE),
329 MS_DELAY(25),
330 MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
331 MS_RET(0)
332 };
333
334 ppb_MS_init_msq(reset_microseq, 1, INITIATOR, 1 << VP0_INITIATOR);
335 ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, &ret);
336
337 return;
338 }
339
340 /*
341 * vpoio_in_disk_mode()
342 */
343 static int
344 vpoio_in_disk_mode(struct vpoio_data *vpo)
345 {
346 device_t ppbus = device_get_parent(vpo->vpo_dev);
347 int ret;
348
349 ppb_MS_microseq(ppbus, vpo->vpo_dev, in_disk_mode, &ret);
350
351 return (ret);
352 }
353
354 /*
355 * vpoio_detect()
356 *
357 * Detect and initialise the VP0 adapter.
358 */
359 static int
360 vpoio_detect(struct vpoio_data *vpo)
361 {
362 device_t ppbus = device_get_parent(vpo->vpo_dev);
363 int error, ret;
364
365 /* allocate the bus, then apply microsequences */
366 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_DONTWAIT)))
367 return (error);
368
369 /* Force disconnection */
370 ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
371
372 /* Try to enter EPP mode, then connect to the drive in EPP mode */
373 if (ppb_set_mode(ppbus, PPB_EPP) != -1) {
374 /* call manually the microseq instead of using the appropriate function
375 * since we already requested the ppbus */
376 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_epp_microseq, &ret);
377 }
378
379 /* If EPP mode switch failed or ZIP connection in EPP mode failed,
380 * try to connect in NIBBLE mode */
381 if (!vpoio_in_disk_mode(vpo)) {
382
383 /* The interface must be at least PS/2 or NIBBLE capable.
384 * There is no way to know if the ZIP will work with
385 * PS/2 mode since PS/2 and SPP both use the same connect
386 * sequence. One must supress PS/2 with boot flags if
387 * PS/2 mode fails (see ppc(4)).
388 */
389 if (ppb_set_mode(ppbus, PPB_PS2) != -1) {
390 vpo->vpo_mode_found = VP0_MODE_PS2;
391 } else {
392 if (ppb_set_mode(ppbus, PPB_NIBBLE) == -1)
393 goto error;
394
395 vpo->vpo_mode_found = VP0_MODE_NIBBLE;
396 }
397
398 /* Can't know if the interface is capable of PS/2 yet */
399 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_spp_microseq, &ret);
400 if (!vpoio_in_disk_mode(vpo)) {
401 vpo->vpo_mode_found = VP0_MODE_UNDEFINED;
402 if (bootverbose)
403 printf("vpo%d: can't connect to the drive\n",
404 vpo->vpo_unit);
405
406 /* disconnect and release the bus */
407 ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq,
408 &ret);
409 goto error;
410 }
411 } else {
412 vpo->vpo_mode_found = VP0_MODE_EPP;
413 }
414
415 /* send SCSI reset signal */
416 vpoio_reset(vpo);
417
418 ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
419
420 /* ensure we are disconnected or daisy chained peripheral
421 * may cause serious problem to the disk */
422 if (vpoio_in_disk_mode(vpo)) {
423 if (bootverbose)
424 printf("vpo%d: can't disconnect from the drive\n",
425 vpo->vpo_unit);
426 goto error;
427 }
428
429 ppb_release_bus(ppbus, vpo->vpo_dev);
430 return (0);
431
432 error:
433 ppb_release_bus(ppbus, vpo->vpo_dev);
434 return (VP0_EINITFAILED);
435 }
436
437 /*
438 * vpoio_outstr()
439 */
440 static int
441 vpoio_outstr(struct vpoio_data *vpo, char *buffer, int size)
442 {
443 device_t ppbus = device_get_parent(vpo->vpo_dev);
444 int error = 0;
445
446 ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_PUT, (union ppb_insarg)buffer,
447 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error);
448
449 ppb_ecp_sync(ppbus);
450
451 return (error);
452 }
453
454 /*
455 * vpoio_instr()
456 */
457 static int
458 vpoio_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 ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_GET, (union ppb_insarg)buffer,
464 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error);
465
466 ppb_ecp_sync(ppbus);
467
468 return (error);
469 }
470
471 static char
472 vpoio_select(struct vpoio_data *vpo, int initiator, int target)
473 {
474 device_t ppbus = device_get_parent(vpo->vpo_dev);
475 int ret;
476
477 struct ppb_microseq select_microseq[] = {
478
479 /* parameter list
480 */
481 #define SELECT_TARGET MS_PARAM(0, 1, MS_TYP_INT)
482 #define SELECT_INITIATOR MS_PARAM(3, 1, MS_TYP_INT)
483
484 /* send the select command to the drive */
485 MS_DASS(MS_UNKNOWN),
486 MS_CASS(H_nAUTO | H_nSELIN | H_INIT | H_STROBE),
487 MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
488 MS_DASS(MS_UNKNOWN),
489 MS_CASS( H_AUTO | H_nSELIN | H_nINIT | H_STROBE),
490
491 /* now, wait until the drive is ready */
492 MS_SET(VP0_SELTMO),
493 /* loop: */ MS_BRSET(H_ACK, 2 /* ready */),
494 MS_DBRA(-2 /* loop */),
495 /* error: */ MS_RET(1),
496 /* ready: */ MS_RET(0)
497 };
498
499 /* initialize the select microsequence */
500 ppb_MS_init_msq(select_microseq, 2,
501 SELECT_TARGET, 1 << target,
502 SELECT_INITIATOR, 1 << initiator);
503
504 ppb_MS_microseq(ppbus, vpo->vpo_dev, select_microseq, &ret);
505
506 if (ret)
507 return (VP0_ESELECT_TIMEOUT);
508
509 return (0);
510 }
511
512 /*
513 * vpoio_wait()
514 *
515 * H_SELIN must be low.
516 *
517 * XXX should be ported to microseq
518 */
519 static char
520 vpoio_wait(struct vpoio_data *vpo, int tmo)
521 {
522 DECLARE_WAIT_MICROSEQUENCE;
523
524 device_t ppbus = device_get_parent(vpo->vpo_dev);
525 int ret, err;
526
527 #if 0 /* broken */
528 if (ppb_poll_device(ppbus, 150, nBUSY, nBUSY, PPB_INTR))
529 return (0);
530
531 return (ppb_rstr(ppbus) & 0xf0);
532 #endif
533
534 /*
535 * Return some status information.
536 * Semantics : 0xc0 = ZIP wants more data
537 * 0xd0 = ZIP wants to send more data
538 * 0xe0 = ZIP wants command
539 * 0xf0 = end of transfer, ZIP is sending status
540 */
541
542 ppb_MS_init_msq(wait_microseq, 2,
543 WAIT_RET, (void *)&ret,
544 WAIT_TMO, tmo);
545
546 ppb_MS_microseq(ppbus, vpo->vpo_dev, wait_microseq, &err);
547
548 if (err)
549 return (0); /* command timed out */
550
551 return(ret);
552 }
553
554 /*
555 * vpoio_probe()
556 *
557 * Low level probe of vpo device
558 *
559 */
560 int
561 vpoio_probe(device_t dev, struct vpoio_data *vpo)
562 {
563 int error;
564
565 /* ppbus dependent initialisation */
566 vpo->vpo_dev = dev;
567
568 /*
569 * Initialize microsequence code
570 */
571 INIT_TRIG_MICROSEQ;
572
573 /* now, try to initialise the drive */
574 if ((error = vpoio_detect(vpo))) {
575 return (error);
576 }
577
578 return (0);
579 }
580
581 /*
582 * vpoio_attach()
583 *
584 * Low level attachment of vpo device
585 *
586 */
587 int
588 vpoio_attach(struct vpoio_data *vpo)
589 {
590 DECLARE_NIBBLE_INBYTE_SUBMICROSEQ;
591 device_t ppbus = device_get_parent(vpo->vpo_dev);
592 int error = 0;
593
594 vpo->vpo_nibble_inbyte_msq = (struct ppb_microseq *)malloc(
595 sizeof(nibble_inbyte_submicroseq), M_DEVBUF, M_NOWAIT);
596
597 if (!vpo->vpo_nibble_inbyte_msq)
598 return (ENXIO);
599
600 bcopy((void *)nibble_inbyte_submicroseq,
601 (void *)vpo->vpo_nibble_inbyte_msq,
602 sizeof(nibble_inbyte_submicroseq));
603
604 ppb_MS_init_msq(vpo->vpo_nibble_inbyte_msq, 4,
605 INB_NIBBLE_H, (void *)&(vpo)->vpo_nibble.h,
606 INB_NIBBLE_L, (void *)&(vpo)->vpo_nibble.l,
607 INB_NIBBLE_F, nibble_inbyte_hook,
608 INB_NIBBLE_P, (void *)&(vpo)->vpo_nibble);
609
610 /*
611 * Initialize mode dependent in/out microsequences
612 */
613 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_WAIT)))
614 goto error;
615
616 /* ppbus sets automatically the last mode entered during detection */
617 switch (vpo->vpo_mode_found) {
618 case VP0_MODE_EPP:
619 ppb_MS_GET_init(ppbus, vpo->vpo_dev, epp17_instr_body);
620 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, epp17_outstr_body);
621 printf("vpo%d: EPP mode\n", vpo->vpo_unit);
622 break;
623 case VP0_MODE_PS2:
624 ppb_MS_GET_init(ppbus, vpo->vpo_dev, ps2_inbyte_submicroseq);
625 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
626 printf("vpo%d: PS2 mode\n", vpo->vpo_unit);
627 break;
628 case VP0_MODE_NIBBLE:
629 ppb_MS_GET_init(ppbus, vpo->vpo_dev, vpo->vpo_nibble_inbyte_msq);
630 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
631 printf("vpo%d: NIBBLE mode\n", vpo->vpo_unit);
632 break;
633 default:
634 panic("vpo: unknown mode %d", vpo->vpo_mode_found);
635 }
636
637 ppb_release_bus(ppbus, vpo->vpo_dev);
638
639 error:
640 return (error);
641 }
642
643 /*
644 * vpoio_reset_bus()
645 *
646 */
647 int
648 vpoio_reset_bus(struct vpoio_data *vpo)
649 {
650 /* first, connect to the drive */
651 if (vpoio_connect(vpo, PPB_WAIT|PPB_INTR) || !vpoio_in_disk_mode(vpo)) {
652
653 #ifdef VP0_DEBUG
654 printf("%s: not in disk mode!\n", __func__);
655 #endif
656 /* release ppbus */
657 vpoio_disconnect(vpo);
658 return (1);
659 }
660
661 /* reset the SCSI bus */
662 vpoio_reset(vpo);
663
664 /* then disconnect */
665 vpoio_disconnect(vpo);
666
667 return (0);
668 }
669
670 /*
671 * vpoio_do_scsi()
672 *
673 * Send an SCSI command
674 *
675 */
676 int
677 vpoio_do_scsi(struct vpoio_data *vpo, int host, int target, char *command,
678 int clen, char *buffer, int blen, int *result, int *count,
679 int *ret)
680 {
681 device_t ppbus = device_get_parent(vpo->vpo_dev);
682 register char r;
683 char l, h = 0;
684 int len, error = 0;
685 register int k;
686
687 /*
688 * enter disk state, allocate the ppbus
689 *
690 * XXX
691 * Should we allow this call to be interruptible?
692 * The only way to report the interruption is to return
693 * EIO do upper SCSI code :^(
694 */
695 if ((error = vpoio_connect(vpo, PPB_WAIT|PPB_INTR)))
696 return (error);
697
698 if (!vpoio_in_disk_mode(vpo)) {
699 *ret = VP0_ECONNECT; goto error;
700 }
701
702 if ((*ret = vpoio_select(vpo,host,target)))
703 goto error;
704
705 /*
706 * Send the command ...
707 *
708 * set H_SELIN low for vpoio_wait().
709 */
710 ppb_wctr(ppbus, H_AUTO | H_nSELIN | H_INIT | H_STROBE);
711
712 for (k = 0; k < clen; k++) {
713 if (vpoio_wait(vpo, VP0_FAST_SPINTMO) != (char)0xe0) {
714 *ret = VP0_ECMD_TIMEOUT;
715 goto error;
716 }
717 if (vpoio_outstr(vpo, &command[k], 1)) {
718 *ret = VP0_EPPDATA_TIMEOUT;
719 goto error;
720 }
721 }
722
723 /*
724 * Completion ...
725 */
726
727 *count = 0;
728 for (;;) {
729
730 if (!(r = vpoio_wait(vpo, VP0_LOW_SPINTMO))) {
731 *ret = VP0_ESTATUS_TIMEOUT; goto error;
732 }
733
734 /* stop when the ZIP wants to send status */
735 if (r == (char)0xf0)
736 break;
737
738 if (*count >= blen) {
739 *ret = VP0_EDATA_OVERFLOW;
740 goto error;
741 }
742
743 /* if in EPP mode or writing bytes, try to transfer a sector
744 * otherwise, just send one byte
745 */
746 if (PPB_IN_EPP_MODE(ppbus) || r == (char)0xc0)
747 len = (((blen - *count) >= VP0_SECTOR_SIZE)) ?
748 VP0_SECTOR_SIZE : 1;
749 else
750 len = 1;
751
752 /* ZIP wants to send data? */
753 if (r == (char)0xc0)
754 error = vpoio_outstr(vpo, &buffer[*count], len);
755 else
756 error = vpoio_instr(vpo, &buffer[*count], len);
757
758 if (error) {
759 *ret = error;
760 goto error;
761 }
762
763 *count += len;
764 }
765
766 if (vpoio_instr(vpo, &l, 1)) {
767 *ret = VP0_EOTHER; goto error;
768 }
769
770 /* check if the ZIP wants to send more status */
771 if (vpoio_wait(vpo, VP0_FAST_SPINTMO) == (char)0xf0)
772 if (vpoio_instr(vpo, &h, 1)) {
773 *ret = VP0_EOTHER+2; goto error;
774 }
775
776 *result = ((int) h << 8) | ((int) l & 0xff);
777
778 error:
779 /* return to printer state, release the ppbus */
780 vpoio_disconnect(vpo);
781 return (0);
782 }
Cache object: 8212a0f0e18893dc80c7c55f8f2935c7
|