1 /* $NetBSD: ppbus_base.c,v 1.7 2004/02/10 18:13:12 jdolecek Exp $ */
2
3 /*-
4 * Copyright (c) 1997, 1998, 1999 Nicolas Souchu
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 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * FreeBSD: src/sys/dev/ppbus/ppb_base.c,v 1.10.2.1 2000/08/01 23:26:26 n_hibma Exp
29 *
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: ppbus_base.c,v 1.7 2004/02/10 18:13:12 jdolecek Exp $");
34
35 #include "opt_ppbus_1284.h"
36 #include "opt_ppbus.h"
37
38 #include <sys/param.h>
39 #include <sys/kernel.h>
40 #include <sys/malloc.h>
41 #include <sys/proc.h>
42 #include <sys/lock.h>
43 #include <sys/systm.h>
44
45 #include <dev/ppbus/ppbus_1284.h>
46 #include <dev/ppbus/ppbus_conf.h>
47 #include <dev/ppbus/ppbus_base.h>
48 #include <dev/ppbus/ppbus_device.h>
49 #include <dev/ppbus/ppbus_io.h>
50 #include <dev/ppbus/ppbus_var.h>
51
52 #ifndef DONTPROBE_1284
53 /* Utility functions */
54 static char * search_token(char *, int, char *);
55 #endif
56
57 /* Perform general ppbus I/O request */
58 int
59 ppbus_io(struct device * dev, int iop, u_char * addr, int cnt, u_char byte)
60 {
61 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
62 return (bus->ppbus_io(dev->dv_parent, iop, addr, cnt, byte));
63 }
64
65 /* Execute microsequence */
66 int
67 ppbus_exec_microseq(struct device * dev, struct ppbus_microseq ** sequence)
68 {
69 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
70 return (bus->ppbus_exec_microseq(dev->dv_parent, sequence));
71 }
72
73 /* Read instance variables of ppbus */
74 int
75 ppbus_read_ivar(struct device * dev, int index, unsigned int * val)
76
77 {
78 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
79
80 switch (index) {
81 case PPBUS_IVAR_INTR:
82 case PPBUS_IVAR_EPP_PROTO:
83 case PPBUS_IVAR_DMA:
84 return (bus->ppbus_read_ivar(dev->dv_parent, index, val));
85
86 case PPBUS_IVAR_IEEE:
87 *val = (bus->sc_use_ieee == PPBUS_ENABLE_IEEE) ? 1 : 0;
88 break;
89
90 default:
91 return (ENOENT);
92 }
93
94 return 0;
95 }
96
97 /* Write an instance variable */
98 int
99 ppbus_write_ivar(struct device * dev, int index, unsigned int * val)
100 {
101 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
102
103 switch (index) {
104 case PPBUS_IVAR_INTR:
105 case PPBUS_IVAR_EPP_PROTO:
106 case PPBUS_IVAR_DMA:
107 return (bus->ppbus_write_ivar(dev->dv_parent, index, val));
108
109 case PPBUS_IVAR_IEEE:
110 bus->sc_use_ieee = ((*val != 0) ? PPBUS_ENABLE_IEEE :
111 PPBUS_DISABLE_IEEE);
112 break;
113
114 default:
115 return (ENOENT);
116 }
117
118 return 0;
119 }
120
121 /* Polls the bus for a max of 10-milliseconds */
122 int
123 ppbus_poll_bus(struct device * dev, int max, char mask, char status,
124 int how)
125 {
126 int i, j, error;
127 char r;
128
129 /* try at least up to 10ms */
130 for (j = 0; j < ((how & PPBUS_POLL) ? max : 1); j++) {
131 for (i = 0; i < 10000; i++) {
132 r = ppbus_rstr(dev);
133 DELAY(1);
134 if ((r & mask) == status)
135 return (0);
136 }
137 }
138
139 if (!(how & PPBUS_POLL)) {
140 for (i = 0; max == PPBUS_FOREVER || i < max-1; i++) {
141 if ((ppbus_rstr(dev) & mask) == status)
142 return (0);
143
144 switch (how) {
145 case PPBUS_NOINTR:
146 /* wait 10 ms */
147 tsleep((caddr_t)dev, PPBUSPRI, "ppbuspoll", hz/100);
148 break;
149
150 case PPBUS_INTR:
151 default:
152 /* wait 10 ms */
153 if (((error = tsleep((caddr_t)dev, PPBUSPRI | PCATCH,
154 "ppbuspoll", hz/100)) != EWOULDBLOCK) != 0) {
155 return (error);
156 }
157 break;
158 }
159 }
160 }
161
162 return (EWOULDBLOCK);
163 }
164
165 /* Get operating mode of the chipset */
166 int
167 ppbus_get_mode(struct device * dev)
168 {
169 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
170
171 return (bus->sc_mode);
172 }
173
174 /* Set the operating mode of the chipset, return 0 on success. */
175 int
176 ppbus_set_mode(struct device * dev, int mode, int options)
177 {
178 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
179 int error = 0;
180
181 /* If no mode change, do nothing */
182 if(bus->sc_mode == mode)
183 return error;
184
185 /* Do necessary negotiations */
186 if(bus->sc_use_ieee == PPBUS_ENABLE_IEEE) {
187 /* Cannot negotiate standard mode */
188 if(!(mode & (PPBUS_FAST | PPBUS_COMPATIBLE))) {
189 error = ppbus_1284_negotiate(dev, mode, options);
190 }
191 /* Termination is unnecessary for standard<->fast */
192 else if(!(bus->sc_mode & (PPBUS_FAST | PPBUS_COMPATIBLE))) {
193 ppbus_1284_terminate(dev);
194 }
195 }
196
197 if(!error) {
198 /* Set mode and update mode of ppbus to actual mode */
199 error = bus->ppbus_setmode(dev->dv_parent, mode);
200 bus->sc_mode = bus->ppbus_getmode(dev->dv_parent);
201 }
202
203 /* Update host state if necessary */
204 if(!(error) && (bus->sc_use_ieee == PPBUS_ENABLE_IEEE)) {
205 switch(mode) {
206 case PPBUS_COMPATIBLE:
207 case PPBUS_FAST:
208 case PPBUS_EPP:
209 case PPBUS_ECP:
210 ppbus_1284_set_state(dev, PPBUS_FORWARD_IDLE);
211 break;
212
213 case PPBUS_NIBBLE:
214 case PPBUS_PS2:
215 ppbus_1284_set_state(dev, PPBUS_REVERSE_IDLE);
216 break;
217 }
218 }
219
220 return error;
221 }
222
223 /* Write charaters to the port */
224 int
225 ppbus_write(struct device * dev, char * buf, int len, int how, size_t * cnt)
226 {
227 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
228
229 if(bus->sc_use_ieee == PPBUS_ENABLE_IEEE) {
230 if(bus->sc_1284_state != PPBUS_FORWARD_IDLE) {
231 printf("%s(%s): bus not in forward idle mode.\n",
232 __func__, dev->dv_xname);
233 return ENODEV;
234 }
235 }
236
237 return (bus->ppbus_write(bus->sc_dev.dv_parent, buf, len, how, cnt));
238 }
239
240 /* Read charaters from the port */
241 int
242 ppbus_read(struct device * dev, char * buf, int len, int how, size_t * cnt)
243 {
244 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
245
246 if(bus->sc_use_ieee == PPBUS_ENABLE_IEEE) {
247 if(bus->sc_1284_state != PPBUS_REVERSE_IDLE) {
248 printf("%s(%s): bus not in reverse idle mode.\n",
249 __func__, dev->dv_xname);
250 return ENODEV;
251 }
252 }
253
254 return (bus->ppbus_read(dev->dv_parent, buf, len, how, cnt));
255 }
256
257 /* Reset the EPP timeout bit in the status register */
258 int
259 ppbus_reset_epp_timeout(struct device * dev)
260 {
261 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
262
263 if(bus->sc_capabilities & PPBUS_HAS_EPP) {
264 bus->ppbus_reset_epp_timeout(dev->dv_parent);
265 return 0;
266 }
267 else {
268 return ENODEV;
269 }
270 }
271
272 /* Wait for the ECP FIFO to be empty */
273 int
274 ppbus_ecp_sync(struct device * dev)
275 {
276 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
277
278 if(bus->sc_capabilities & PPBUS_HAS_ECP) {
279 bus->ppbus_ecp_sync(dev->dv_parent);
280 return 0;
281 }
282 else {
283 return ENODEV;
284 }
285 }
286
287 /* Allocate DMA for use with ppbus */
288 int
289 ppbus_dma_malloc(struct device * dev, caddr_t * buf, bus_addr_t * addr,
290 bus_size_t size)
291 {
292 struct ppbus_softc * ppbus = (struct ppbus_softc *) dev;
293
294 if(ppbus->sc_capabilities & PPBUS_HAS_DMA)
295 return (ppbus->ppbus_dma_malloc(dev->dv_parent, buf, addr,
296 size));
297 else
298 return ENODEV;
299 }
300
301 /* Free memory allocated with ppbus_dma_malloc() */
302 int
303 ppbus_dma_free(struct device * dev, caddr_t * buf, bus_addr_t * addr,
304 bus_size_t size)
305 {
306 struct ppbus_softc * ppbus = (struct ppbus_softc *) dev;
307
308 if(ppbus->sc_capabilities & PPBUS_HAS_DMA) {
309 ppbus->ppbus_dma_free(dev->dv_parent, buf, addr, size);
310 return 0;
311 }
312 else {
313 return ENODEV;
314 }
315 }
316
317 /* Install a handler to be called by hardware interrupt handler */
318 int ppbus_add_handler(struct device * dev, void (*func)(void *), void * arg)
319 {
320 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
321
322 if(bus->sc_capabilities & PPBUS_HAS_INTR)
323 return bus->ppbus_add_handler(dev->dv_parent, func, arg);
324 else
325 return ENODEV;
326 }
327
328 /* Remove a handler registered with ppbus_add_handler() */
329 int ppbus_remove_handler(struct device * dev, void (*func)(void *))
330 {
331 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
332
333 if(bus->sc_capabilities & PPBUS_HAS_INTR)
334 return bus->ppbus_remove_handler(dev->dv_parent, func);
335 else
336 return ENODEV;
337 }
338
339 /*
340 * ppbus_get_status()
341 *
342 * Read the status register and update the status info
343 */
344 int
345 ppbus_get_status(struct device * dev, struct ppbus_status * status)
346 {
347 register char r = status->status = ppbus_rstr(dev);
348
349 status->timeout = r & TIMEOUT;
350 status->error = !(r & nFAULT);
351 status->select = r & SELECT;
352 status->paper_end = r & PERROR;
353 status->ack = !(r & nACK);
354 status->busy = !(r & nBUSY);
355
356 return (0);
357 }
358
359 /* Allocate the device to perform transfers */
360 int
361 ppbus_request_bus(struct device * dev, struct device * busdev, int how,
362 unsigned int timeout)
363 {
364 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
365 unsigned int counter = timeout;
366 int priority = PPBUSPRI;
367 int error;
368
369 if(how & PPBUS_INTR)
370 priority |= PCATCH;
371
372 /* Loop until lock acquired (if PPBUS_WAIT) or an error occurs */
373 for(;;) {
374 error = lockmgr(&(bus->sc_lock), LK_EXCLUSIVE | LK_RECURSEFAIL,
375 NULL);
376 if(!error)
377 break;
378
379 if(how & PPBUS_WAIT) {
380 error = ltsleep(bus, priority, __func__, hz/2, NULL);
381 counter -= (hz/2);
382 if(!(error))
383 continue;
384 else if(error != EWOULDBLOCK)
385 goto end;
386 if(counter == 0) {
387 error = ETIMEDOUT;
388 goto end;
389 }
390 }
391 else {
392 goto end;
393 }
394 }
395
396 /* Set bus owner or return error if bus is taken */
397 if(bus->ppbus_owner == NULL) {
398 bus->ppbus_owner = busdev;
399 error = 0;
400 }
401 else {
402 error = EBUSY;
403 }
404
405 /* Release lock */
406 lockmgr(&(bus->sc_lock), LK_RELEASE, NULL);
407
408 end:
409 return error;
410 }
411
412 /* Release the device allocated with ppbus_request_bus() */
413 int
414 ppbus_release_bus(struct device * dev, struct device * busdev, int how,
415 unsigned int timeout)
416 {
417 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
418 unsigned int counter = timeout;
419 int priority = PPBUSPRI;
420 int error;
421
422 if(how & PPBUS_INTR)
423 priority |= PCATCH;
424
425 /* Loop until lock acquired (if PPBUS_WAIT) or an error occurs */
426 for(;;) {
427 error = lockmgr(&(bus->sc_lock), LK_EXCLUSIVE | LK_RECURSEFAIL,
428 NULL);
429 if(!error)
430 break;
431
432 if(how & PPBUS_WAIT) {
433 error = ltsleep(bus, priority, __func__, hz/2, NULL);
434 counter -= (hz/2);
435 if(!(error))
436 continue;
437 else if(error != EWOULDBLOCK)
438 goto end;
439 if(counter == 0) {
440 error = ETIMEDOUT;
441 goto end;
442 }
443 }
444 else {
445 goto end;
446 }
447 }
448
449 /* If the device is the owner, release bus */
450 if(bus->ppbus_owner != busdev) {
451 error = EINVAL;
452 }
453 else {
454 bus->ppbus_owner = NULL;
455 error = 0;
456 }
457
458 /* Release lock */
459 lockmgr(&(bus->sc_lock), LK_RELEASE, NULL);
460
461 end:
462 return error;
463 }
464
465
466 /* IEEE 1284-based probes */
467
468 #ifndef DONTPROBE_1284
469
470 static char *pnp_tokens[] = {
471 "PRINTER", "MODEM", "NET", "HDC", "PCMCIA", "MEDIA",
472 "FDC", "PORTS", "SCANNER", "DIGICAM", "", NULL };
473
474 /* ??? */
475 #if 0
476 static char *pnp_classes[] = {
477 "printer", "modem", "network device",
478 "hard disk", "PCMCIA", "multimedia device",
479 "floppy disk", "ports", "scanner",
480 "digital camera", "unknown device", NULL };
481 #endif
482
483 /*
484 * Search the first occurence of a token within a string
485 * XXX should use strxxx() calls
486 */
487 static char *
488 search_token(char *str, int slen, char *token)
489 {
490 char *p;
491 int tlen, i, j;
492
493 #define UNKNOWN_LENGTH -1
494
495 if (slen == UNKNOWN_LENGTH)
496 /* get string's length */
497 for (slen = 0, p = str; *p != '\0'; p++)
498 slen ++;
499
500 /* get token's length */
501 for (tlen = 0, p = token; *p != '\0'; p++)
502 tlen ++;
503
504 if (tlen == 0)
505 return (str);
506
507 for (i = 0; i <= slen-tlen; i++) {
508 for (j = 0; j < tlen; j++)
509 if (str[i+j] != token[j])
510 break;
511 if (j == tlen)
512 return (&str[i]);
513 }
514
515 return (NULL);
516 }
517
518 /* Stores the class ID of the peripherial in soft config data */
519 void
520 ppbus_pnp_detect(struct device * dev)
521 {
522 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
523 int i;
524 int error;
525 size_t len = 0;
526 size_t str_sz = 0;
527 char * str = NULL;
528 char * class = NULL;
529 char * token;
530
531 #ifdef PPBUS_VERBOSE
532 printf("%s: Probing for PnP devices.\n", dev->dv_xname);
533 #endif
534
535 error = ppbus_1284_read_id(dev, PPBUS_NIBBLE, &str, &str_sz, &len);
536 if(str_sz != len) {
537 #ifdef DEBUG_1284
538 printf("%s(%s): device returned less characters than expected "
539 "in device ID.\n", __func__, dev->dv_xname);
540 #endif
541 }
542 if(error) {
543 printf("%s: Error getting device ID (errno = %d)\n",
544 dev->dv_xname, error);
545 goto end_detect;
546 }
547
548 #ifdef DEBUG_1284
549 printf("%s: <PnP> %d characters: ", dev->dv_xname, len);
550 for (i = 0; i < len; i++)
551 printf("%c(0x%x) ", str[i], str[i]);
552 printf("\n");
553 #endif
554
555 /* replace ';' characters by '\0' */
556 for (i = 0; i < len; i++)
557 if(str[i] == ';') str[i] = '\0';
558 /* str[i] = (str[i] == ';') ? '\0' : str[i]; */
559
560 if ((token = search_token(str, len, "MFG")) != NULL ||
561 (token = search_token(str, len, "MANUFACTURER")) != NULL)
562 printf("%s: <%s", dev->dv_xname,
563 search_token(token, UNKNOWN_LENGTH, ":") + 1);
564 else
565 printf("%s: <unknown", dev->dv_xname);
566
567 if ((token = search_token(str, len, "MDL")) != NULL ||
568 (token = search_token(str, len, "MODEL")) != NULL)
569 printf(" %s",
570 search_token(token, UNKNOWN_LENGTH, ":") + 1);
571
572 if ((token = search_token(str, len, "REV")) != NULL)
573 printf(".%s",
574 search_token(token, UNKNOWN_LENGTH, ":") + 1);
575
576 printf(">");
577
578 if ((token = search_token(str, len, "CLS")) != NULL) {
579 class = search_token(token, UNKNOWN_LENGTH, ":") + 1;
580 printf(" %s", class);
581 }
582
583 if ((token = search_token(str, len, "CMD")) != NULL ||
584 (token = search_token(str, len, "COMMAND")) != NULL)
585 printf(" %s",
586 search_token(token, UNKNOWN_LENGTH, ":") + 1);
587
588 printf("\n");
589
590 if (class) {
591 /* identify class ident */
592 for (i = 0; pnp_tokens[i] != NULL; i++) {
593 if (search_token(class, len, pnp_tokens[i]) != NULL) {
594 bus->sc_class_id = i;
595 goto end_detect;
596 }
597 }
598 }
599 bus->sc_class_id = PPBUS_PNP_UNKNOWN;
600
601 end_detect:
602 if(str)
603 free(str, M_DEVBUF);
604 return;
605 }
606
607 /* Scan the ppbus for IEEE1284 compliant devices */
608 int
609 ppbus_scan_bus(struct device * dev)
610 {
611 struct ppbus_softc * bus = (struct ppbus_softc *) dev;
612 int error;
613
614 /* Try IEEE1284 modes, one device only (no IEEE1284.3 support) */
615
616 error = ppbus_1284_negotiate(dev, PPBUS_NIBBLE, 0);
617 if (error && bus->sc_1284_state == PPBUS_ERROR
618 && bus->sc_1284_error == PPBUS_NOT_IEEE1284)
619 return (error);
620 ppbus_1284_terminate(dev);
621
622 #if defined(PPBUS_VERBOSE) || defined(PPBUS_DEBUG)
623 /* IEEE1284 supported, print info */
624 printf("%s: IEEE1284 negotiation: modes %s",
625 dev->dv_xname, "NIBBLE");
626
627 error = ppbus_1284_negotiate(dev, PPBUS_PS2, 0);
628 if (!error)
629 printf("/PS2");
630 ppbus_1284_terminate(dev);
631
632 error = ppbus_1284_negotiate(dev, PPBUS_ECP, 0);
633 if (!error)
634 printf("/ECP");
635 ppbus_1284_terminate(dev);
636
637 error = ppbus_1284_negotiate(dev, PPBUS_ECP, PPBUS_USE_RLE);
638 if (!error)
639 printf("/ECP_RLE");
640 ppbus_1284_terminate(dev);
641
642 error = ppbus_1284_negotiate(dev, PPBUS_EPP, 0);
643 if (!error)
644 printf("/EPP");
645 ppbus_1284_terminate(dev);
646
647 printf("\n");
648 #endif /* PPBUS_VERBOSE || PPBUS_DEBUG */
649
650 return 0;
651 }
652
653 #endif /* !DONTPROBE_1284 */
654
Cache object: 6a3dca3020a560e5e952651c63514774
|