WebSVN – HelenOS – Diff – /branches/dynload/kernel/generic/src/lib/func.c


/*
 * Copyright (c) 2001-2004 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup generic
 * @{
 */
 
/**
 * @file
 * @brief   Miscellaneous functions.
 */
 
#include <func.h>
#include <print.h>
#include <cpu.h>
#include <arch/asm.h>
#include <arch.h>
#include <console/kconsole.h>
 
atomic_t haltstate = {0}; /**< Halt flag */
 
 
/** Halt wrapper
 *
 * Set halt flag and halt the CPU.
 *
 */
void halt()
{
#ifdef CONFIG_DEBUG
    bool rundebugger = false;
   
    if (!atomic_get(&haltstate)) {
        atomic_set(&haltstate, 1);
        rundebugger = true;
    }
#else
    atomic_set(&haltstate, 1);
#endif
   
    interrupts_disable();
   
#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
    if ((rundebugger) && (kconsole_check_poll()))
        kconsole("panic", "\nLast resort kernel console ready.\n", false);
#endif
   
    if (CPU)
        printf("cpu%u: halted\n", CPU->id);
    else
        printf("cpu: halted\n");
   
    cpu_halt();
}
 
/** Convert ascii representation to unative_t
 *
 * Supports 0x for hexa & 0 for octal notation.
 * Does not check for overflows, does not support negative numbers
 *
 * @param text Textual representation of number
 * @return Converted number or 0 if no valid number ofund
 */
unative_t atoi(const char *text)
{
    int base = 10;
    unative_t result = 0;
 
    if (text[0] == '0' && text[1] == 'x') {
        base = 16;
        text += 2;
    } else if (text[0] == '0')
        base = 8;
 
    while (*text) {
        if (base != 16 && \
            ((*text >= 'A' && *text <= 'F' )
             || (*text >='a' && *text <='f')))
            break;
        if (base == 8 && *text >='8')
            break;
 
        if (*text >= '0' && *text <= '9') {
            result *= base;
            result += *text - '0';
        } else if (*text >= 'A' && *text <= 'F') {
            result *= base;
            result += *text - 'A' + 10;
        } else if (*text >= 'a' && *text <= 'f') {
            result *= base;
            result += *text - 'a' + 10;
        } else
            break;
        text++;
    }
 
    return result;
}
 
 
void order(const uint64_t val, uint64_t *rv, char *suffix)
{
    if (val > 10000000000000000000ULL) {
        *rv = val / 1000000000000000000ULL;
        *suffix = 'Z';
    } else if (val > 1000000000000000000ULL) {
        *rv = val / 1000000000000000ULL;
        *suffix = 'E';
    } else if (val > 1000000000000000ULL) {
        *rv = val / 1000000000000ULL;
        *suffix = 'T';
    } else if (val > 1000000000000ULL) {
        *rv = val / 1000000000ULL;
        *suffix = 'G';
    } else if (val > 1000000000ULL) {
        *rv = val / 1000000ULL;
        *suffix = 'M';
    } else if (val > 1000000ULL) {
        *rv = val / 1000ULL;
        *suffix = 'k';
    } else {
        *rv = val;
        *suffix = ' ';
    }
}
 
/** @}
 */
 

Rev 4345	Rev 4346
1	/*	1	/*
2	* Copyright (c) 2001-2004 Jakub Jermar	2	* Copyright (c) 2001-2004 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup generic	29	/** @addtogroup generic
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file	34	* @file
35	* @brief Miscellaneous functions.	35	* @brief Miscellaneous functions.
36	*/	36	*/
37		37
38	#include <func.h>	38	#include <func.h>
39	#include <print.h>	39	#include <print.h>
40	#include <cpu.h>	40	#include <cpu.h>
41	#include <arch/asm.h>	41	#include <arch/asm.h>
42	#include <arch.h>	42	#include <arch.h>
43	#include <console/kconsole.h>	43	#include <console/kconsole.h>
44		44
45	atomic_t haltstate = {0}; /*< Halt flag /	45	atomic_t haltstate = {0}; /*< Halt flag /
46		46
47		47
48	/** Halt wrapper	48	/** Halt wrapper
49	*	49	*
50	* Set halt flag and halt the cpu.	50	* Set halt flag and halt the CPU.
51	*	51	*
52	*/	52	*/
53	void halt()	53	void halt()
54	{	54	{
55	#ifdef CONFIG_DEBUG	55	#ifdef CONFIG_DEBUG
56	bool rundebugger = false;	56	bool rundebugger = false;
57		57
58	if (!atomic_get(&haltstate)) {	58	if (!atomic_get(&haltstate)) {
59	atomic_set(&haltstate, 1);	59	atomic_set(&haltstate, 1);
60	rundebugger = true;	60	rundebugger = true;
61	}	61	}
62	#else	62	#else
63	atomic_set(&haltstate, 1);	63	atomic_set(&haltstate, 1);
64	#endif	64	#endif
65		65
66	interrupts_disable();	66	interrupts_disable();
67		67
68	#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))	68	#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
69	if (rundebugger)	69	if ((rundebugger) && (kconsole_check_poll()))
70	kconsole("panic", "\nLast resort kernel console ready\n", false);	70	kconsole("panic", "\nLast resort kernel console ready.\n", false);
71	#endif	71	#endif
72		72
73	if (CPU)	73	if (CPU)
74	printf("cpu%u: halted\n", CPU->id);	74	printf("cpu%u: halted\n", CPU->id);
75	else	75	else
76	printf("cpu: halted\n");	76	printf("cpu: halted\n");
-		77
77	cpu_halt();	78	cpu_halt();
78	}	79	}
79		80
80	/** Convert ascii representation to unative_t	81	/** Convert ascii representation to unative_t
81	*	82	*
82	* Supports 0x for hexa & 0 for octal notation.	83	* Supports 0x for hexa & 0 for octal notation.
83	* Does not check for overflows, does not support negative numbers	84	* Does not check for overflows, does not support negative numbers
84	*	85	*
85	* @param text Textual representation of number	86	* @param text Textual representation of number
86	* @return Converted number or 0 if no valid number ofund	87	* @return Converted number or 0 if no valid number ofund
87	*/	88	*/
88	unative_t atoi(const char *text)	89	unative_t atoi(const char *text)
89	{	90	{
90	int base = 10;	91	int base = 10;
91	unative_t result = 0;	92	unative_t result = 0;
92		93
93	if (text[0] == '0' && text[1] == 'x') {	94	if (text[0] == '0' && text[1] == 'x') {
94	base = 16;	95	base = 16;
95	text += 2;	96	text += 2;
96	} else if (text[0] == '0')	97	} else if (text[0] == '0')
97	base = 8;	98	base = 8;
98		99
99	while (*text) {	100	while (*text) {
100	if (base != 16 && \	101	if (base != 16 && \
101	((text >= 'A' && text <= 'F' )	102	((text >= 'A' && text <= 'F' )
102	\|\| (text >='a' && text <='f')))	103	\|\| (text >='a' && text <='f')))
103	break;	104	break;
104	if (base == 8 && *text >='8')	105	if (base == 8 && *text >='8')
105	break;	106	break;
106		107
107	if (text >= '0' && text <= '9') {	108	if (text >= '0' && text <= '9') {
108	result *= base;	109	result *= base;
109	result += *text - '0';	110	result += *text - '0';
110	} else if (text >= 'A' && text <= 'F') {	111	} else if (text >= 'A' && text <= 'F') {
111	result *= base;	112	result *= base;
112	result += *text - 'A' + 10;	113	result += *text - 'A' + 10;
113	} else if (text >= 'a' && text <= 'f') {	114	} else if (text >= 'a' && text <= 'f') {
114	result *= base;	115	result *= base;
115	result += *text - 'a' + 10;	116	result += *text - 'a' + 10;
116	} else	117	} else
117	break;	118	break;
118	text++;	119	text++;
119	}	120	}
120		121
121	return result;	122	return result;
122	}	123	}
123		124
124		125
125	void order(const uint64_t val, uint64_t rv, char suffix)	126	void order(const uint64_t val, uint64_t rv, char suffix)
126	{	127	{
127	if (val > 10000000000000000000ULL) {	128	if (val > 10000000000000000000ULL) {
128	*rv = val / 1000000000000000000ULL;	129	*rv = val / 1000000000000000000ULL;
129	*suffix = 'Z';	130	*suffix = 'Z';
130	} else if (val > 1000000000000000000ULL) {	131	} else if (val > 1000000000000000000ULL) {
131	*rv = val / 1000000000000000ULL;	132	*rv = val / 1000000000000000ULL;
132	*suffix = 'E';	133	*suffix = 'E';
133	} else if (val > 1000000000000000ULL) {	134	} else if (val > 1000000000000000ULL) {
134	*rv = val / 1000000000000ULL;	135	*rv = val / 1000000000000ULL;
135	*suffix = 'T';	136	*suffix = 'T';
136	} else if (val > 1000000000000ULL) {	137	} else if (val > 1000000000000ULL) {
137	*rv = val / 1000000000ULL;	138	*rv = val / 1000000000ULL;
138	*suffix = 'G';	139	*suffix = 'G';
139	} else if (val > 1000000000ULL) {	140	} else if (val > 1000000000ULL) {
140	*rv = val / 1000000ULL;	141	*rv = val / 1000000ULL;
141	*suffix = 'M';	142	*suffix = 'M';
142	} else if (val > 1000000ULL) {	143	} else if (val > 1000000ULL) {
143	*rv = val / 1000ULL;	144	*rv = val / 1000ULL;
144	*suffix = 'k';	145	*suffix = 'k';
145	} else {	146	} else {
146	*rv = val;	147	*rv = val;
147	*suffix = ' ';	148	*suffix = ' ';
148	}	149	}
149	}	150	}
150		151
151	/** @}	152	/** @}
152	*/	153	*/
153		154

Subversion Repositories HelenOS

(root)/branches/dynload/kernel/generic/src/lib/func.c – Rev 4345 → 4346