lpvi.c

操作系统SunOS 4.1.3版本的源码

                         disfunc[i].func(Printer_X, vsize); 

                         sleep(2);  /* wait until DMA process is terminated */
                         if ((BYTEW[i] = write(fdv,vdbuff[i],vsize)) !=  vsize){
                            if (i == 1)
                               errsave = errno;
                            send_message(0, VERBOSE, "%s: bytes written %d \n",
                                                           dev_name, BYTEW[i]);
                            if(BYTEW[i] == -1 || BYTEW[i] < vsize) {
                                free(vdbuff[i]);
                                get_errslpv(fdv);
                                exit(errsave);
                            } 
                         } 
                         else {
                            free(vdbuff[i]);
                            /* sleep depending on selected mode */ 
                            if (!errsave) 
                                sleep(do_sleep); 
                         }
                      }
                      else 
                        send_message(0, WARNING, "%s: Malloc couldn't allocate memory", device_name);
                      exit(0);
            }/* switch() */
          }

          signal(SIGUSR2, SIG_IGN);
/*
          signal(SIGUSR1, SIG_IGN);
          kill(pidlpv[1], SIGUSR1);
          kill(pidlpv[2], SIGUSR1);
*/
       }else {
/*
          kill(pidv, SIGUSR2);	
*/
          /* select rasterfile to which comply with resolution */
	  if (strcmp(img_name, "57fonts") == 0) {
	     if (res == 300)
	        strcpy(img_name, "57fonts.300");
	     else
                strcpy(img_name, "57fonts.400"); 
          }
          /* read rasterfile header */
          if ((imgfd = fopen(img_name, "r")) == NULL)
             send_message(OPEN_ERROR, ERROR, open_err_msg, img_name);
          if (result = pr_load_header(imgfd, &rh)) 
             send_message(GEN_ERROR, ERROR,
                          "zrf: error reading rf header  %x for %s\n",
                           result, device_name);

          /* read colormap and image */
          if (result = pr_load_colormap(imgfd, &rh, &colormap) ||
                  !(pr = pr_load_image(imgfd, &rh, &colormap))) 
             send_message(GEN_ERROR, ERROR,
                          "load: error loading image file  %x for %s\n",
                           result, device_name);

          /* initialize page dimentions for lpv driver structure */
          send_message(0, VERBOSE, "%s: Reading Raster file header\n",
                                                        dev_name); 
          pg_dim.top_margin = 1;
          pg_dim.left_margin = 0;
          tmar = 1;
          lmar = 0;

          /* set page dim from rasterfile header */
	  if ((rh.ras_width > image_width) && (rh.ras_height > image_height))
             send_message(-IOCTL_ERROR, ERROR,"%s: %s raster file too big\n",
                                       device_name, img_name);
          pg_dim.page_length = (rh.ras_height - tmar);   
          pg_dim.page_width = (rh.ras_width -lmar); 
          pg_dim.bitmap_width = ((rh.ras_width - lmar) + 7)/8;
          pg_dim.resolution = res;

          send_message(0, VERBOSE, "%s: top marginw = %d Left Margin = %d\n",
                              dev_name, pg_dim.top_margin, pg_dim.left_margin);

          /* set dimensions for printed page in driver */
          if ((result = ioctl(fdv, LPVIIOC_SETPAGE, &pg_dim)) == -1) {
             errsave = errno;
             get_errslpv(fdv);
             send_message(IOCTL_ERROR, ERROR,ioctl_err_msg,
                           device_name, img_name);
          }
   
          n = pg_dim.bitmap_width*pg_dim.page_length;
          send_message(0, VERBOSE, "%s: image_size = %d img_name = %s\n",
                                    dev_name, n, img_name); 

retry:    if ((result = write(fdv,
             ((struct mpr_data *)pr->pr_data)->md_image, n)) != n) {
                errsave = errno;
                get_errslpv(fdv);
                if (errsave == 0)
                   goto retry;
                else
                   send_message(WRITE_ERROR, ERROR, "EXITING:error=%d %s\n",
                                                  errsave, errmsg(errsave)); 
          }
          /* sleep depending on selected mode */   
          if (!errsave)    
             sleep(do_sleep);
        } 
    }
    while(wait(&status) != -1)
    ;
    send_message(0, VERBOSE, "status = %d\n", status.w_retcode);
    if ((status.w_retcode > 0) && (status.w_retcode <= 90))
       send_message(WRITE_ERROR, ERROR, "EXITING:error=%d %s\n",
                    status.w_retcode, errmsg(status.w_retcode));
    TRACE_OUT
}





/*---------------------------------------------------------------------------*/
                   /* function to get lpv page size */
/*---------------------------------------------------------------------------*/
get_pg_size(psize)
char *psize;
{
   struct page *keypage;
   int done;
   
   func_name = "get_pg_size";
   TRACE_IN 
   done = FALSE; 
   if (res == 300)
     keypage = &p300[0];
   else
     keypage = &p400[0];
   while(!done)
   {
     if (strcmp(keypage->p_size, psize) == 0)
     {
       image_width = keypage->x_scan;   
       image_height = keypage->y_scan;
       done = TRUE;
     }
     else
       ++keypage;
   }
   TRACE_OUT
}




/*---------------------------------------------------------------------------*/
/*function to report lpv and bpp detailed info on the current error condition*/
/*---------------------------------------------------------------------------*/
get_errslpv(fdvp)
int fdvp;
{
    int retioct;

    func_name = "get_errslpv";
    TRACE_IN
    if (errsave == EIO) { 
       if((retioct = ioctl(fdvp, LPVIIOC_INQ, &lp_inf)) != -1)
       {
          send_message(0, FATAL, "%s:\n\n\
          \t-> Paper size: %x, Counters: %d, Print Engine: %s\n",
                       device_name, lp_inf.papersize,
                       lp_inf.counters, lp_inf.engine);
       }
       /* output laser printer error code and error messages */ 
       if((retioct = ioctl(fdvp, LPVIIOC_GETERR, &lp_errs)) != -1)
       { 
          switch (lp_errs.err_code) {
              case 0x01:
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, Error in Main Motor\n",
                                   device_name, lp_errs.err_code);
                     break;
              case 0x02: 
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, ROS out of order\n",
                                device_name, lp_errs.err_code);  
                     break;
              case 0x03:
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, FUSER out of order\n",
                                  device_name, lp_errs.err_code);   
                     break;
              case 0x04:
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, XERO fail happened\n",
                                  device_name, lp_errs.err_code);   
                     break;
              case 0x05: 
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, Interlock open\n",
                                  device_name, lp_errs.err_code);  
                     break; 
              case 0x06:  
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, No Tray Installed\n",
                                  device_name, lp_errs.err_code);   
                     break; 
              case 0x07: 
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, No paper exists in selected tray\n",
                                  device_name, lp_errs.err_code);   
                     break;
              case 0x08:
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, Exit JAM\n",
                                  device_name, lp_errs.err_code);   
                     break;
              case 0x09: 
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, Misfeed JAM\n",
                                  device_name, lp_errs.err_code);  
                     break; 
              case 0x0a:  
                     send_message(0, WARNING, "%s:\n\n\
                    \t-> Error Code: %x, Drum cartridge is nearly exhausted\n",
                                  device_name, lp_errs.err_code);   
                     break; 
              case 0x0b: 
                     send_message(0, WARNING, "%s:\n\n\
                     \t-> Error Code: %x, Deve module is nearly exhausted\n",
                                  device_name, lp_errs.err_code);   
                     break;
              case 0x0c:
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, No Drum cartridge\n",
                                  device_name, lp_errs.err_code);   
                     break;
              case 0x0d: 
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, No Deve cartridge\n",
                                  device_name, lp_errs.err_code);   
                     break;  
              case 0x0e:   
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, Drum cartridge exhausted\n",
                                  device_name, lp_errs.err_code);    
                     break;  
              case 0x0f:   
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, Deve cartridge exhausted\n",
                                  device_name, lp_errs.err_code);    
                     break; 
              case 0x10:  
                     send_message(0, WARNING, "%s:\n\n\
                     \t-> Error Code: %x, Printer is warmming-up\n",
                                  device_name, lp_errs.err_code);
                     break;
              case 0x11:   
                     send_message(0, FATAL, "%s:\n\n\
                     \t-> Error Code: %x, Timeout: no response from printer\n",
                                  device_name, lp_errs.err_code);
                     break;
          }
          switch (lp_errs.err_code) {
             case 0x10:
/*
                  while (ioctl(fdvp, LPVIIOC_TESTIO) == EIO)
                     get_errslpv(fdvp);
*/
                  send_message(0, WARNING, "%s: Wait for printer ready signal, and restart the test\n", dev_name);
                  break; 
             case 0x01: case 0x04: case 0x05: case 0x06: case 0x07: case 0x08:
             case 0x0c: case 0x0d: case 0x0e: case 0x0f: case 0x011:
                  send_message(0, FATAL, "%s: EIO Error\n", dev_name);
                  break;
          }
       }
    } 
    else 
        send_message(0, ERROR, "%s %d\n", errmsg(errsave), errsave);  

    TRACE_OUT
}



/*---------------------------------------------------------------------------*/
                   /* function to print Horizontal Lines */
/*---------------------------------------------------------------------------*/
void
printer_display1 (Xbyte, msize)
u_long  Xbyte, msize;
{
     register        i, j, k;
     u_char          *memory, *fbaddr, pattern;

     func_name = "printer_display1";
     TRACE_IN
     fbaddr = vdbuff[0];
     pattern = 0xFF;
     memory = fbaddr;
 
     for (i = 0; i < (msize - (40*Xbyte)); i += (20*Xbyte)) {
         for (k = 0; k < Xbyte; k++) {
           *(memory + k) = pattern;
         }
         memory += Xbyte;
         if (i < (msize - (40*Xbyte)))
          memory += (20*Xbyte);
     }
     TRACE_OUT
}




/*---------------------------------------------------------------------------*/
                  /* function to print Vertical Lines */
/*---------------------------------------------------------------------------*/
void
printer_display2 (Xbyte, msize)
u_long  Xbyte, msize;
{
     register        i, j, k;
     int             dx; 
     u_char          *memory, *fbaddr, pattern;
 
 
     func_name = "printer_display2";
     TRACE_IN
     
     dx = (res == 400) ? 53 :41;
     fbaddr = vdbuff[1];
     pattern = 0x80;
     memory = fbaddr;
 
    for (i = 0; i < (msize - Xbyte); i += Xbyte) {
      for (j = 0; j < dx; j++) {
          *(memory + (3*j)) = pattern;
      }
      if (i < (msize - 2*Xbyte))
         memory += Xbyte;
    }
    TRACE_OUT
}




/*---------------------------------------------------------------------------*/
                  /* function to print Grid pattern */
/*---------------------------------------------------------------------------*/
void
printer_display3 (Xbyte, msize)
u_long  Xbyte, msize;
{
    register        i, j, k, l;
    int             Printer_X, dx, offset;
    u_char          *memory, *fbaddr, pattern;
 
 
    func_name = "printer_display3";
    TRACE_IN
    dx = (res == 400) ? 4 : 3;
 
    fbaddr = vdbuff[2];
    pattern = 0x80;
    memory = fbaddr;
    i = offset = 0;
    while (memory < (fbaddr + msize - (120*Xbyte))) {
      if (!((memory-fbaddr)%120)) {
        for (l = 0; l < 120; l++) {
          for (j = 0; j < dx; j++) {
            for (k = 0; k < 20; k++) {
              *(memory + (2*j*20) + k + offset) = pattern;
            }
          }
          memory += Xbyte;
        }
        if (i == 0) {
          i++;
          offset = 20;
        }
        else {
          i = 0;
          offset = 0;
        }
      }
    }   
    TRACE_OUT
}




/*---------------------------------------------------------------------------*/
          /* function to reset all parameters and lpvi device */ 
/*---------------------------------------------------------------------------*/
clean_up()
{
  func_name = "clean_up";
  TRACE_IN
  
  /* start terminating all processes created by parent, this is necessary
   * when sundiag is terminating the test abnormally.
   */
  if (pidv > 0) {
    if (kill(pidv, SIGINT) == -1) {
       send_message(0, VERBOSE, "process %d is terminated: %s\n",
                     pidv, errmsg(errno));
    }
  }
  if (pidlpv[1] > 0) {
    if (kill(pidlpv[1], SIGINT) == -1) {
       send_message(0, VERBOSE, "process %d is terminated: %s\n",
                     pidlpv[1], errmsg(errno));
    }
  } 
  if (pidlpv[2] > 0) {
    if (kill(pidlpv[2], SIGINT) == -1) {  
       send_message(0, VERBOSE, "process %d is terminated: %s\n", 
                     pidlpv[2], errmsg(errno)); 
    }
  }
  if (!imgflg)
    close(imgfd);
  close(fdv);
  TRACE_OUT
}