The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ppbus/ppb_1284.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: fbb4270b878965c25d95752641305e99


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.