"Fossies" - the Fresh Open Source Software Archive

Member "linux_logo-6.0/libsysinfo-0.3.0/Linux/cpuinfo_sparc.c" (8 May 2020, 7320 Bytes) of package /linux/misc/linux_logo-6.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /* Re-written from scratch 4 March 2001      */
    2 /* Handles sparc chips on Linux architecture */
    3 /* by Vince Weaver <vince@deater.net>        */
    4 
    5 #include <stdio.h>
    6 #include <string.h>
    7 #include <stdlib.h>  /* atof */
    8 #include <fnmatch.h>
    9 
   10 #include "../sysinfo.h"
   11 #include "../include/generic.h"
   12 
   13 
   14 
   15 int get_cpu_info(struct cpu_info_type *cpu_info) {
   16 
   17     FILE *fff;
   18     char temp_string[BUFSIZ],temp[BUFSIZ];
   19     char vendor_string[BUFSIZ],model_string[BUFSIZ];
   20     int cpu_count=0;
   21     float megahertz=0.0,bogomips=0.0;
   22    
   23     vendor_string[0]=model_string[0]=0;
   24  
   25        /* We get all of our info here from /proc/cpuinfo */
   26     if ((fff=fopen(get_cpuinfo_file(),"r") )!=NULL) {
   27        
   28        while ( (fgets(temp_string,BUFSIZ,fff)!=NULL) ) {
   29     
   30       if ( !(strncmp(temp_string,"cpu",3))) {
   31          strncpy(model_string,parse_line(temp_string),BUFSIZ);
   32          clip_lf(model_string,BUFSIZ);
   33       }
   34 
   35       if ( !(strncmp(temp_string,"ncpus active",12))) {
   36          cpu_count=atoi(parse_line(temp_string));        
   37       }
   38       
   39          /* Suggested change by Ben Collins <bmc@visi.net> */
   40       if ( !(strncasecmp(temp_string,"bogomips",8)) ||
   41          !(fnmatch("Cpu[0-9]*Bogo*",temp_string,0))) {
   42           
   43 #if 0     
   44          /* Ugh why must people play with capitalization */
   45       if ( !(strncmp(temp_string,"bogomips",8)) ||
   46            !(strncmp(temp_string,"BogoMips",8)) ||
   47            !(strncmp(temp_string,"BogoMIPS",8)) ||
   48            !(strncmp(temp_string,"Cpu",3))) {
   49 #endif       
   50          bogomips+=atof(parse_line(temp_string));
   51       }
   52       
   53        }
   54     }
   55   
   56     strncpy(cpu_info->chip_vendor,"Sparc",SYSINFO_CHIP_VENDOR_SIZE);
   57     strncpy(cpu_info->chip_type,model_string,SYSINFO_CHIP_TYPE_SIZE);
   58   
   59        /* Fix up cpuinfo some */
   60    
   61     if (!strncmp(model_string,"Cypress",7)) {
   62        strncpy(cpu_info->chip_vendor,"Cypress",8);
   63        sscanf(model_string,"%*s %s",temp);
   64        strncpy(cpu_info->chip_type,temp,SYSINFO_CHIP_TYPE_SIZE);
   65     }
   66    
   67     if (!strncmp(model_string,"ROSS",4)) {
   68        strncpy(cpu_info->chip_vendor,"ROSS",5);
   69        sscanf(model_string,"%*s %s",temp);
   70        strncpy(cpu_info->chip_type,temp,SYSINFO_CHIP_TYPE_SIZE);
   71     }
   72    
   73     if (!strncmp(model_string,"Texas",5)) {
   74        strncpy(cpu_info->chip_vendor,"TI",3);
   75        sscanf(model_string,"%*s %*s %*s %*s %s",temp);
   76        strncpy(cpu_info->chip_type,temp,SYSINFO_CHIP_TYPE_SIZE);
   77        
   78        if (strstr(model_string,"UltraSparc II ")!=NULL) {
   79       strncpy(cpu_info->chip_type,"UltraSparc II",14);  
   80        }
   81        
   82     }
   83 
   84     if (strstr(model_string,"SpitFire")!=NULL) {
   85        strncpy(cpu_info->chip_type,"SpitFire",9);
   86     } else
   87     if (strstr(model_string,"Power-UP")!=NULL) {
   88        strncpy(cpu_info->chip_type,"Power-UP",9);  
   89     } else
   90     if (strstr(model_string,"UltraSparc II ")!=NULL) {
   91        strncpy(cpu_info->chip_type,"UltraSparc II",14);  
   92     } else
   93     if (strstr(model_string,"UltraSparc III+")!=NULL) {
   94        strncpy(cpu_info->chip_type,"UltraSparc III+",16);  
   95     }   
   96        
   97    
   98        
   99     cpu_info->num_cpus=cpu_count;
  100     cpu_info->megahertz=megahertz;
  101     cpu_info->bogomips=bogomips;
  102 
  103     return 0;
  104    
  105 }
  106 
  107 int get_hardware(char *hardware_string) {
  108     
  109     char temp_string[BUFSIZ];
  110     FILE *fff;
  111    
  112     if ((fff=fopen(get_cpuinfo_file(),"r") )!=NULL) {
  113        
  114        while ( (fgets(temp_string,BUFSIZ,fff)!=NULL) ) {
  115           
  116       if (!(strncmp(temp_string,"type",4))) {
  117              strncpy(hardware_string,parse_line(temp_string),
  118              SYSINFO_HARDWARE_STRING_SIZE);
  119       }
  120        }
  121     }
  122     return 1;
  123 }
  124 
  125    
  126     /* I don't have a machine to test the below code on.  I have */
  127     /* had multiple reports that the PROM code DOESN'T work, so  */
  128     /* until someone sends me a patch that fixes it, I have turned */
  129     /* off the PROM code */
  130    
  131 #define CROSS_DEBUGGING 1
  132    
  133 /* Following routine provided by Ben Collins <bmc@visi.net>  */
  134 /* Ripped from prtconf: Copyright (C) 1998 Jakub Jelinek (jj@ultra.linux.cz) */
  135 
  136    
  137 #if (CROSS_DEBUGGING==1)
  138  
  139 long long get_arch_specific_mem_size(void) {
  140     
  141        /* /proc/kcore does not reflect memsize on sparc */
  142    return MEM_USE_MEMINFO;
  143     
  144 }
  145 #else
  146    
  147 #include <sys/ioctl.h>
  148 #include <sys/types.h>
  149 #include <sys/stat.h>
  150 #include <fcntl.h>
  151 #include <sys/utsname.h>
  152 #include <unistd.h>
  153 #include <asm/openpromio.h>
  154    
  155     static int promfd;
  156     static char buf[4096];
  157     static int prom_root_node, prom_current_node;
  158 #define DECL_OP(size) struct openpromio *op = (struct openpromio *)buf; op->oprom_size = (size)
  159 
  160 static int prom_getsibling(int node) {
  161            
  162     DECL_OP(sizeof(int));
  163     
  164     if (node == -1) return 0;
  165        *(int *)op->oprom_array = node;
  166        if (ioctl (promfd, OPROMNEXT, op) < 0)
  167       return 0;
  168        prom_current_node = *(int *)op->oprom_array;
  169        return *(int *)op->oprom_array;  
  170 }
  171    
  172 static int prom_getchild(int node) {
  173 
  174     DECL_OP(sizeof(int));
  175     
  176     if (!node || node == -1) return 0;
  177     *(int *)op->oprom_array = node;
  178     if (ioctl (promfd, OPROMCHILD, op) < 0)
  179        return 0;
  180     prom_current_node = *(int *)op->oprom_array;
  181     return *(int *)op->oprom_array;
  182 }
  183    
  184 static char *prom_getproperty(char *prop, int *lenp) {
  185      
  186     DECL_OP(4096-128-4);
  187       
  188     strcpy (op->oprom_array, prop);
  189     if (ioctl (promfd, OPROMGETPROP, op) < 0)
  190        return 0;
  191     if (lenp) *lenp = op->oprom_size;
  192        return op->oprom_array;
  193 }
  194        
  195 static int prom_searchsiblings(char *name) {
  196     
  197     char *prop;
  198     int len;
  199     
  200     for (;;) {
  201        if (!(prop = prom_getproperty("name", &len)))
  202       return 0;
  203        prop[len] = 0;
  204        if (!strcmp(prop, name))
  205       return prom_current_node;
  206        if (!prom_getsibling(prom_current_node))
  207        return 0;                
  208     }
  209 }
  210    
  211 static inline int is_sparc64(void) {
  212            
  213     struct utsname uts_info;
  214     
  215     prom_getsibling(0);
  216     uname(&uts_info);
  217     if (!strcmp(uts_info.machine, "sparc64"))
  218        return 1;
  219     
  220     return 0;
  221     
  222 }
  223    
  224 /* On sparc, the best method of memory detection is the prom. We use
  225  * sparse memory, so /proc/kcore is almost never right, and we all know
  226  * that /proc/meminfo never reports physical ram accurately.  */
  227      
  228 long long get_arch_specific_mem_size(void) {
  229       
  230     long long memory_size = 0;
  231     int len, i;
  232     unsigned int *prop;
  233       
  234     promfd = open("/dev/openprom", O_RDONLY);
  235     if (promfd == -1) {
  236        memory_size=MEM_USE_MEMINFO;
  237        goto mem_done;
  238     }
  239       
  240     prom_root_node = prom_getsibling(0);
  241     if (!prom_root_node) {
  242        memory_size=MEM_USE_MEMINFO;
  243        goto mem_done;
  244     }
  245       
  246     prom_getchild(prom_getsibling(0));
  247     if (!prom_searchsiblings("memory")) {
  248        memory_size=MEM_USE_MEMINFO;
  249        goto mem_done;
  250     }
  251 
  252     prop = (unsigned int *)prom_getproperty("reg", &len);
  253       
  254     if (!prop || (len % sizeof(int)))
  255        goto mem_done;
  256       
  257     len /= sizeof(int);
  258     if (is_sparc64()) {
  259        if (len % 4) {
  260       goto mem_done;
  261                        
  262        } else {
  263           for (i = 0; i < len; i+=4) {
  264           memory_size += ((unsigned long long)prop[i + 2] << 32);
  265           memory_size += prop[i + 3];
  266       }               
  267        }
  268     } else {
  269        if (len % 3) {
  270       goto mem_done;
  271        } else {
  272           for (i = 0; i < len; i+=3)
  273           memory_size += prop[i + 2];
  274        }
  275     }
  276    
  277 mem_done:
  278     if (promfd >= 0)
  279        close(promfd);
  280 
  281     /* Memory size is megabytes */
  282     return memory_size;
  283 }
  284       
  285 #endif