bpp.c

操作系统SunOS 4.1.3版本的源码

                          
                        k = 0;
                        while ((mem_cl[k] == rone) && (k < MEMSC))
                          ++k;
                        if (k < MEMSC) {
                            send_message(0, ERROR, check_err_msg,
                                         rone, mem_cl[k], device_name);
                            exit(errsave);
                        }
                        bpp_trans.read_handshake = BPP_CLEAR_MEM;
          
                        /* write zeroes to memory */
                        if(ioctl(fdp, BPPIOC_SETPARMS, &bpp_trans) == -1) {
                            errsave = errno;
                            send_message(0, ERROR, ioctl_err_msg,
                                         device_name, errmsg(errsave));
                            exit(errsave);
                        }
                        if (read(fdp,mem_cl,MEMSC) != MEMSC)
                          errsave = errno;
                        k = 0;
                        while (mem_cl[k] == rzero && k < MEMSC)
                          ++k;
                        if (k < MEMSC) {
                            send_message(0, ERROR, check_err_msg,
                                         rzero, mem_cl[k], device_name);
                            exit(errsave);
                        }  
                        /* give up resources to other bpp devices */
                     }
                     send_message(0, VERBOSE,"%s:Finished DMA memory test\n",
                                                                device_name);
                     exit(0);
           
          }
	  sleep(do_sleep);
          signal(SIGUSR2, SIG_IGN);
          kill(pidmemp, SIGUSR2); 
          send_message(0, VERBOSE, "closing %s", dev_name); 
          if (close(fdp) == -1)
              send_message(0, VERBOSE, "error in close %d\n", errno);
          /* open the bpp interface with write only permission */
          sleep(10);
          if ((fdp = open(dev_name, OMODE1)) == -1) {
              errsave = errno;
              send_message(0, VERBOSE, "WRITE PERM errsave = %d fdp = %d\n",
                                                        errsave, fdp);     
              send_message(OPEN_ERROR, ERROR, open_err_msg, dev_name);     
          }
          switch (pidp = fork()){
             case -1: errsave = errno; 
                      send_message(0, ERROR, "%s: main:fork %s", device_name,
                                   errmsg(errsave));
                      kill(pidmemp, SIGUSR2);
                      break;
             case 0:  /* call exit routine to terminate the process */
                      signal(SIGINT, exit_proc);

                      /* initialize the bpp buffer */
                      sleep(do_sleep);
                      signal(SIGUSR2, SIG_IGN);

                      /* send termination signal to DMA mem set and clear */
/*
                      kill(pidmemp, SIGUSR2);
*/
                      bppw = (u_char *) malloc(bsize + 51);
                      if (bppw != NULL) {
                         send_message(0, VERBOSE, "%s:initializing text data",
                                               dev_name);
                         init_txt(bsize);
                         /* wait until DMA process is terminated */
                         sleep(5);
                         send_message(0, VERBOSE,"Starting writing to %s\n",
                                                                  dev_name);
                         if ((BYTEWP = write(fdp,bppw,(bsize + 50))) !=
                                                          (bsize + 50)) {
                            if(BYTEWP == -1 || BYTEWP < (bsize + 50)) {
                               errsave = errno;
                               free(bppw);
                               get_errslpv(fdp);
                               close(fdp);
                               send_message(0, FATAL, write_fail_msg,
                                        errsave, device_name, bsize + 50, BYTEWP);
                               exit(errsave);
                            }
                         } 

                        send_message(0, VERBOSE,"RANDOM:Wrote %d bytes to %s\n",
                                                            BYTEWP, dev_name);
                         sleep(5);
                         init_txt_h(bsize); 
                         if ((BYTEWP = write(fdp,bppw,(bsize + 51))) !=
                                                          (bsize + 51)) {
                            if(BYTEWP == -1 || BYTEWP < (bsize + 50)) {
                               errsave = errno;
                               free(bppw);
                               get_errslpv(fdp);
                               close(fdp);
                               send_message(0, FATAL, write_fail_msg,
                                        errsave, device_name, bsize + 51, BYTEWP);
                               exit(errsave);
                            }
                         }  
                         send_message(0, VERBOSE,"FIXED:Wrote %d bytes to %s\n",
                                                            BYTEWP, dev_name);
                        
                         free(bppw);
                      }
                      else
                        send_message(0, WARNING, "%s: Malloc couldn't allocate memory", device_name);
                      exit(0);
          }/* switch() */
     }else {
        routine_comm();  
        routine_usage(); 
     }
     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",
                                         errsave, errmsg(errsave));
     TRACE_OUT
}



/*---------------------------------------------------------------------------*/
              /* function to initialize text data for bpp */
/*---------------------------------------------------------------------------*/
int init_txt(bsize)
u_long bsize;
{
    u_long i, k, l ;
    u_char *bbuff, j;

    func_name = "init_txt";
    TRACE_IN

    j = '0';
    k = 2;

    bbuff = bppw;
    for (i = 0; i < bsize + 51; i++)
      *(bbuff+i) = 0;
    *(bbuff+0) = 0xA;            /* Cr */
    *(bbuff+1) = 0xD;            /* Lf */

    l = 1;
    for (i = 1; i <= bsize; i++) {
     if (l == 80) {               /* insert (<CR>, <LF> after 80th character */
      *(bbuff+k) = 0xA;           /* Line feed */
      k++;
      *(bbuff+k) = 0xD;
      k++;                        /* Carriage Return */
      l = 1;
     }
     else {
       *(bbuff+k) = j++;         /* Repeat printable ascii characters */
       k++;
       l++;
     }

     /* wrap around if exhusted printable ascii character set */
     if (j > '~')
        j = '0';
    }
    TRACE_OUT
} 



int init_txt_h(bsize)
u_long bsize;
{
    u_long i, k, l ;
    u_char *bbuff, j;

    func_name = "init_txt_h";
    TRACE_IN

    k = 2;

    bbuff = bppw;
    for (i = 0; i < bsize + 51; i++)
      *(bbuff+i) = 0;
    *(bbuff+0) = 0xA;            /* Cr */
    *(bbuff+1) = 0xD;            /* Lf */

    l = 1;
    for (i = 1; i <= bsize; i++) {
     if (l == 80) {               /* insert (<CR>, <LF> after 80th character */
      *(bbuff+k) = 0xA;           /* Line feed */
      k++;
      *(bbuff+k) = 0xD;
      k++;                        /* Carriage Return */
      l = 1;
     }
     else {
       *(bbuff+k) = 'H';         /* Repeat printable ascii characters */
       k++;
       l++;
     }
    }
    *(bbuff+k) = 0xC;		 /* New page */
    TRACE_OUT
}




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

    func_name = "get_errslpv";
    TRACE_IN

      if (errsave == EBADF || errsave == EBUSY || errsave == EIO
          || errsave == EINVAL || errsave == ENXIO || errsave == ENODEV)
      {
       if(ioctl(fdvp, BPPIOC_GETERR, &bpp_errs) != -1)
       {
         send_message(0, ERROR, "%s: %s\n\n\
                      \t\t Time out Error:%x\n\
                      \t\t Bus Error: \t%x\n\
                      \t\t Pin Status: \t%x\n", device_name, errmsg(errsave),
                           bpp_errs.timeout_occurred, bpp_errs.bus_error,
                           bpp_errs.pin_status);
       }  
       else{ 
         send_message(0, ERROR, "%s\n", errmsg(errsave));
       }
      }
    TRACE_OUT
}



/*---------------------------------------------------------------------------*/
          /* function to reset all parameters and close bpp 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 (pidp > 0) {
    if (kill(pidp, SIGINT) == -1) {
       send_message(0, VERBOSE, "process %d is terminated: %s\n",
                     pidp, errmsg(errno));
    }
  }  
  if (pidmemp > 0) {
    if (kill(pidmemp, SIGINT) == -1) {
       send_message(0, VERBOSE, "process %d is terminated: %s\n",
                     pidmemp, errmsg(errno));
    }
  } 
  close(fdp);

  TRACE_OUT
}