blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
357
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
58
| license_type
stringclasses 2
values | repo_name
stringlengths 4
115
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringlengths 4
58
| visit_date
timestamp[ns]date 2015-07-14 21:31:45
2023-09-06 10:45:08
| revision_date
timestamp[ns]date 1970-01-01 00:00:00
2023-09-05 23:26:37
| committer_date
timestamp[ns]date 1970-01-01 00:00:00
2023-09-05 23:26:37
| github_id
int64 966
689M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 24
values | gha_event_created_at
timestamp[ns]date 2012-06-07 00:51:45
2023-09-14 21:58:52
⌀ | gha_created_at
timestamp[ns]date 2008-02-03 21:17:16
2023-08-24 19:49:39
⌀ | gha_language
stringclasses 180
values | src_encoding
stringclasses 35
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 6
10.4M
| extension
stringclasses 121
values | filename
stringlengths 1
148
| content
stringlengths 6
10.4M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
c9802e438483cc1d0dbde7a313a387eca5f06179 | a1782ef8b19a1a2d07a9314dd2b02ba73b2144f4 | /0x08-recursion/5-sqrt_recursion.c | a3912bba4688c4eba9364d3144036816d53bef08 | [] | no_license | DiegoSusviela/holbertonschool-low_level_programming | e5d01edadecbc3505c288683622e4bfafabb1536 | 1805d346ecbbe560b6f0ff9b277afb5c75bbc10b | refs/heads/main | 2023-07-19T04:37:24.501048 | 2021-09-02T01:31:42 | 2021-09-02T01:31:42 | 335,614,488 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 561 | c | 5-sqrt_recursion.c | #include "holberton.h"
/**
* recursion - imprime
* @n: numero a imprimir
* @cand_root: un char ahi
*
* Description: Show a message blablabla
* Return: Always 0 (Success)
*/
int recursion(int n, int cand_root)
{
int aux = cand_root * cand_root;
if ((aux) < n)
return (recursion(n, cand_root + 1));
if (aux == n)
return (cand_root);
else
return (-1);
}
/**
* _sqrt_recursion - imprime
* @n: numero a imprimir
*
* Description: Show a message blablabla
* Return: Always 0 (Success)
*/
int _sqrt_recursion(int n)
{
return (recursion(n, 0));
}
|
098e24bf8b8d78377c0a8fe5d7a860bbddc7dac0 | 5069aab5743db98be7692a438d0c59c1fb01fa28 | /Core/Inc/MPU_9255.h | b33c94acc3c41e9d6dd725d8ddcaf62291278b0a | [] | no_license | alone141/SRHEX | 10495d06066111280ef6395cacbc6b4257a7b48e | de2cc27e6948539b8d4f672a86e1a433e0d504a0 | refs/heads/main | 2023-08-18T01:22:54.081465 | 2021-08-28T21:08:42 | 2021-08-28T21:08:42 | 400,886,764 | 0 | 0 | null | 2021-09-13T18:15:03 | 2021-08-28T20:43:26 | C | UTF-8 | C | false | false | 2,019 | h | MPU_9255.h | /*
* MPU_9255.h
*
* Created on: Jul 15, 2021
* Author: Meliksah Sagun
*
* Disclaimer:
* This is a free software under the GNU license as published by the Free Software Foundation, either version 3 of the License, or any later version.
* This program is published without any warranty and not responsible for any errors or omissions, or for the results obtained from the use of this information.
* All information is provided "as is", with no guarantee of completeness, accuracy, timeliness or of the results obtained from the use of this information,
* and without warranty of any kind, express or implied.
*
* This document was last updated on July 15, 2021
*
*/
#ifndef MPU_9255_H_
#define MPU_9255_H_
#include "stm32f4xx_hal.h"
#include <math.h> //Pow() and atan()
#include <string.h>
#define ADDRESS_9255 0x68
#define WHO_AM_I 0x75
#define POWER_1 0x6B
#define POWER_2 0x6C
#define CONFIG 0x1A
#define GYRO_CONFIG 0x1B
#define ACCEL_CONFIG 0x1C
#define SMPLRT_DIV 0x19
#define INT_STATUS 0x3A
#define ACCEL_XOUT_H 0x3B
#define TEMP_OUT_H 0x41
#define GYRO_XOUT_H 0x43
#define i2c_timeout 100
typedef struct
{
int16_t Ax_RAW;
int16_t Ay_RAW;
int16_t Az_RAW;
double Ax;
double Ay;
double Az;
int16_t Gx_RAW;
int16_t Gy_RAW;
int16_t Gz_RAW;
double Gx;
double Gy;
double Gz;
double roll;
double pitch;
double Temp; // Temperature in C
}MPU_DataStruct;
HAL_StatusTypeDef MPU9255_Init(I2C_HandleTypeDef *hi2c_handle); // Initialize
void MPU9255_Accel_Raw(MPU_DataStruct *rawAcc);// Raw Acceleration values
void MPU9255_Accel_Scaled(MPU_DataStruct *scaledAcc); //Scaled Acceleration values
void MPU9255_Gyro_Raw(MPU_DataStruct *rawGyro); // Raw Gyro values
void MPU9255_Gyro_Scaled(MPU_DataStruct *scaledGyro); // Scaled
void MPU9255_Angle(MPU_DataStruct *getAngle);
void MPU_READ_ALL(MPU_DataStruct *ALL); // ALL VALUES
#endif /* MPU_9255_H_ */
|
f0f87a553654e8dd118d1ce530596532ca79f599 | 06695d43ac30e328d372e62ad2e48566840688be | /include/fifo.h | 92db65415859fa345701f67b00433a4397dab373 | [] | no_license | duhuasong/myos | 3d83faedc0b3b1ba81309e372e056af41e3dac25 | 6360fb1d771d5bafcd47c880128f39959aff22e2 | refs/heads/master | 2021-05-01T22:52:45.234728 | 2013-08-09T03:27:05 | 2013-08-09T03:27:05 | null | 0 | 0 | null | null | null | null | GB18030 | C | false | false | 387 | h | fifo.h | #ifndef _CTYPE_H_
#define _CTYPE_H_
struct TASK;
struct FIFO{
int *buf;
int cur;
int p;
int free;
int size;
struct TASK* task;//我们让任务与fifo对应。
};
extern void fifo_init(struct FIFO * fifo, int * buf, int size,struct TASK* task);
extern int fifo_put(struct FIFO*fifo, int data);
extern int fifo_get(struct FIFO*fifo);
extern int fifo_status(struct FIFO*fifo);
#endif |
0b1dcbf21b4cfb2f82bd6567f6158bccb9fcd4b0 | 4223eee4e127ac2d182baaa2bbfce5cfe7ada946 | /src/syscall.h | fbd13a0e3c479e7b2e175ba6186daf0d75fbfbfa | [] | no_license | oaioa/advancedOperatingSystem | 0930ca5cd248ae6ff8ca21d0d5d7b0694f953f80 | 45c275968709ab025a239f39eae05de87edaf9db | refs/heads/master | 2020-04-09T02:41:38.512316 | 2018-12-01T14:14:33 | 2018-12-01T14:14:33 | 159,950,306 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 128 | h | syscall.h | #include <inttypes.h>
void sys_reboot();
void sys_nop();
void sys_settime(uint64_t date_ms);
void sys_yieldto();
int* sp_svc;
|
9b6962fbcc1fabcd0fbea42ea3a77ef1adf79a83 | 40b83dec47e6e24acf12f2c57fbd34a92205aa02 | /cpu-cycles/libcpucycles/cpucycles/arm64-vct.c | a04b59e108edf6d1ba1e61cc82371f27b69be12a | [
"CC0-1.0",
"Apache-2.0"
] | permissive | nymtech/nym | 803133d223108773dfd65838707f00b23c83bdc2 | a50b4ad211261a3d37a53eafd67770d57568dbeb | refs/heads/develop | 2023-08-30T07:03:32.700384 | 2023-08-29T15:18:36 | 2023-08-29T15:18:36 | 232,312,458 | 896 | 254 | null | 2023-09-14T15:54:13 | 2020-01-07T11:42:53 | Rust | UTF-8 | C | false | false | 358 | c | arm64-vct.c | // version 20230105
// public domain
// djb
// adapted from supercop/cpucycles/vct.c
#include "cpucycles_internal.h"
long long ticks(void)
{
long long result;
asm volatile("mrs %0, CNTVCT_EL0" : "=r" (result));
return result;
}
long long ticks_setup(void)
{
if (!cpucycles_works(ticks)) return cpucycles_SKIP;
return cpucycles_FINDMULTIPLIER;
}
|
f1db4ad614a5ed627110551fa98f0ee0d95f2dbb | 7e125605816ac46d01679b7f20f8c679322efe3e | /ext/toml/keytable.zep.c | fec1267549d06cfc8fd4808e2c716bcbce3e2ffe | [] | no_license | betrixed/toml-zephir | 4689436d63c7e9854cb8445927d2e3127fb6af7d | ff33a41bc6ce64251585f70d4d8a48a6da8f3202 | refs/heads/master | 2021-05-01T21:57:08.153013 | 2018-02-23T01:57:31 | 2018-02-23T01:57:31 | 120,981,528 | 1 | 0 | null | null | null | null | UTF-8 | C | false | true | 11,353 | c | keytable.zep.c |
#ifdef HAVE_CONFIG_H
#include "../ext_config.h"
#endif
#include <php.h>
#include "../php_ext.h"
#include "../ext.h"
#include <Zend/zend_operators.h>
#include <Zend/zend_exceptions.h>
#include <Zend/zend_interfaces.h>
#include "kernel/main.h"
#include "kernel/object.h"
#include "kernel/memory.h"
#include "kernel/operators.h"
#include "kernel/array.h"
#include "kernel/fcall.h"
/**
* @author Michael Rynn
*/
/**
* This is more general, no frills, object wrap of a PHP array
* It is more inefficient than a bare PHP array.
* The internal $_store is public for easy iteration.
* Any PHP key type is allowed.
* Strict TOML04 - says integer key values must
* be converted to strings!
*
* Hence if we parsed an integer key, and converted it, and set the key as a string
* and then extracted the key later, it would of integer type again, due to PHP's
* convert everything that looks like an integer, to an integer, for Array keys.
* "1" and intval(1) are the PHP same key,
* stored as binary integer. Hash algorithms are faster on binary integers, because the Hash,
* usually becomes a binary integer value, restricted to hash table storage.
* Quite often integer values are what is intended.
* It makes sense for internet HTML forms convenience, where everything is text,
* and numeric values are returned as string.
* If the numeric string is beyond an upper limit of representation it remains a string,
* and in this case can never be an integer.
* So if this class was used as TOML tables, all integer keys may need to be converted back to
* string on retrieval.
* This class gives a standard "referenced" array as object without a reference operator &
*/
ZEPHIR_INIT_CLASS(Toml_KeyTable) {
ZEPHIR_REGISTER_CLASS(Toml, KeyTable, toml, keytable, toml_keytable_method_entry, ZEND_ACC_FINAL_CLASS);
zend_declare_property_null(toml_keytable_ce, SL("_store"), ZEND_ACC_PUBLIC TSRMLS_CC);
zend_declare_property_null(toml_keytable_ce, SL("_tag"), ZEND_ACC_PRIVATE TSRMLS_CC);
zend_class_implements(toml_keytable_ce TSRMLS_CC, 1, toml_arrayable_ce);
return SUCCESS;
}
PHP_METHOD(Toml_KeyTable, __construct) {
zend_string *_5$$3, *_8$$5;
zend_ulong _4$$3, _7$$5;
zend_bool _0;
zval *seed = NULL, seed_sub, __$null, _1, key$$3, value$$3, _2$$3, *_3$$3, key$$5, value$$5, *_6$$5, init$$7;
zval *this_ptr = getThis();
ZVAL_UNDEF(&seed_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&key$$3);
ZVAL_UNDEF(&value$$3);
ZVAL_UNDEF(&_2$$3);
ZVAL_UNDEF(&key$$5);
ZVAL_UNDEF(&value$$5);
ZVAL_UNDEF(&init$$7);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &seed);
if (!seed) {
seed = &seed_sub;
seed = &__$null;
}
_0 = Z_TYPE_P(seed) == IS_OBJECT;
if (_0) {
_0 = (zephir_instance_of_ev(seed, toml_keytable_ce TSRMLS_CC));
}
ZEPHIR_INIT_VAR(&_1);
zephir_gettype(&_1, seed TSRMLS_CC);
if (_0) {
zephir_read_property(&_2$$3, seed, SL("_store"), PH_NOISY_CC | PH_READONLY);
zephir_is_iterable(&_2$$3, 0, "toml/KeyTable.zep", 45);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_2$$3), _4$$3, _5$$3, _3$$3)
{
ZEPHIR_INIT_NVAR(&key$$3);
if (_5$$3 != NULL) {
ZVAL_STR_COPY(&key$$3, _5$$3);
} else {
ZVAL_LONG(&key$$3, _4$$3);
}
ZEPHIR_INIT_NVAR(&value$$3);
ZVAL_COPY(&value$$3, _3$$3);
zephir_update_property_array(this_ptr, SL("_store"), &key$$3, &value$$3 TSRMLS_CC);
} ZEND_HASH_FOREACH_END();
ZEPHIR_INIT_NVAR(&value$$3);
ZEPHIR_INIT_NVAR(&key$$3);
} else if (ZEPHIR_IS_STRING_IDENTICAL(&_1, "array")) {
zephir_is_iterable(seed, 0, "toml/KeyTable.zep", 51);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(seed), _7$$5, _8$$5, _6$$5)
{
ZEPHIR_INIT_NVAR(&key$$5);
if (_8$$5 != NULL) {
ZVAL_STR_COPY(&key$$5, _8$$5);
} else {
ZVAL_LONG(&key$$5, _7$$5);
}
ZEPHIR_INIT_NVAR(&value$$5);
ZVAL_COPY(&value$$5, _6$$5);
zephir_update_property_array(this_ptr, SL("_store"), &key$$5, &value$$5 TSRMLS_CC);
} ZEND_HASH_FOREACH_END();
ZEPHIR_INIT_NVAR(&value$$5);
ZEPHIR_INIT_NVAR(&key$$5);
} else {
ZEPHIR_INIT_VAR(&init$$7);
array_init(&init$$7);
zephir_update_property_zval(this_ptr, SL("_store"), &init$$7);
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Toml_KeyTable, getTag) {
zval *this_ptr = getThis();
RETURN_MEMBER(getThis(), "_tag");
}
PHP_METHOD(Toml_KeyTable, setTag) {
zval *tag, tag_sub;
zval *this_ptr = getThis();
ZVAL_UNDEF(&tag_sub);
zephir_fetch_params(0, 1, 0, &tag);
zephir_update_property_zval(this_ptr, SL("_tag"), tag);
}
/**
* @param type $index
*/
PHP_METHOD(Toml_KeyTable, offsetSet) {
zval *index, index_sub, *value, value_sub;
zval *this_ptr = getThis();
ZVAL_UNDEF(&index_sub);
ZVAL_UNDEF(&value_sub);
zephir_fetch_params(0, 2, 0, &index, &value);
zephir_update_property_array(this_ptr, SL("_store"), index, value TSRMLS_CC);
}
PHP_METHOD(Toml_KeyTable, offsetExists) {
zval *index, index_sub, _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&index_sub);
ZVAL_UNDEF(&_0);
zephir_fetch_params(0, 1, 0, &index);
zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY);
RETURN_BOOL(zephir_array_isset(&_0, index));
}
PHP_METHOD(Toml_KeyTable, offsetGet) {
zval *index, index_sub, _0, _1;
zval *this_ptr = getThis();
ZVAL_UNDEF(&index_sub);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
zephir_fetch_params(0, 1, 0, &index);
zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY);
zephir_array_fetch(&_1, &_0, index, PH_NOISY | PH_READONLY, "toml/KeyTable.zep", 80 TSRMLS_CC);
RETURN_CTORW(&_1);
}
PHP_METHOD(Toml_KeyTable, offsetUnset) {
zval *index, index_sub, _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&index_sub);
ZVAL_UNDEF(&_0);
zephir_fetch_params(0, 1, 0, &index);
zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY);
zephir_array_unset(&_0, index, PH_SEPARATE);
}
PHP_METHOD(Toml_KeyTable, count) {
zval _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY);
RETURN_LONG(zephir_fast_count_int(&_0 TSRMLS_CC));
}
PHP_METHOD(Toml_KeyTable, get) {
zval *index, index_sub, *defaultValue = NULL, defaultValue_sub, __$null, _0, _1, _2;
zval *this_ptr = getThis();
ZVAL_UNDEF(&index_sub);
ZVAL_UNDEF(&defaultValue_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &index, &defaultValue);
if (!defaultValue) {
defaultValue = &defaultValue_sub;
defaultValue = &__$null;
}
ZEPHIR_INIT_VAR(&_0);
zephir_read_property(&_1, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY);
if (zephir_array_isset(&_1, index)) {
zephir_read_property(&_2, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY);
zephir_array_fetch(&_0, &_2, index, PH_NOISY, "toml/KeyTable.zep", 95 TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(&_0, defaultValue);
}
RETURN_CCTOR(&_0);
}
/**
* Return array copy of everything with nested KeyTable object
* mediation removed.
* Modification to Config - allow recurse option,
* false for no recurse. It can't be passed on.
* @param bool $recurse
* @return array
*/
PHP_METHOD(Toml_KeyTable, toArray) {
zend_string *_4$$3;
zend_ulong _3$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *recurse_param = NULL, result, key, value, _0, _1$$3, *_2$$3, _7$$5;
zend_bool recurse, _5$$4, _6$$4;
zval *this_ptr = getThis();
ZVAL_UNDEF(&result);
ZVAL_UNDEF(&key);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_7$$5);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &recurse_param);
if (!recurse_param) {
recurse = 1;
} else {
recurse = zephir_get_boolval(recurse_param);
}
ZEPHIR_INIT_VAR(&result);
array_init(&result);
zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY);
if (!(ZEPHIR_IS_EMPTY(&_0))) {
zephir_read_property(&_1$$3, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY);
zephir_is_iterable(&_1$$3, 0, "toml/KeyTable.zep", 118);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_1$$3), _3$$3, _4$$3, _2$$3)
{
ZEPHIR_INIT_NVAR(&key);
if (_4$$3 != NULL) {
ZVAL_STR_COPY(&key, _4$$3);
} else {
ZVAL_LONG(&key, _3$$3);
}
ZEPHIR_INIT_NVAR(&value);
ZVAL_COPY(&value, _2$$3);
_5$$4 = recurse;
if (_5$$4) {
_5$$4 = Z_TYPE_P(&value) == IS_OBJECT;
}
_6$$4 = _5$$4;
if (_6$$4) {
_6$$4 = (zephir_instance_of_ev(&value, toml_arrayable_ce TSRMLS_CC));
}
if (_6$$4) {
ZEPHIR_CALL_METHOD(&_7$$5, &value, "toarray", NULL, 0);
zephir_check_call_status();
zephir_array_update_zval(&result, &key, &_7$$5, PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_zval(&result, &key, &value, PH_COPY | PH_SEPARATE);
}
} ZEND_HASH_FOREACH_END();
ZEPHIR_INIT_NVAR(&value);
ZEPHIR_INIT_NVAR(&key);
}
RETURN_CCTOR(&result);
}
/**
* @param myKeyTable should be a KeyTable
* @return KeyTable
*/
PHP_METHOD(Toml_KeyTable, merge) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *kt, kt_sub;
zval *this_ptr = getThis();
ZVAL_UNDEF(&kt_sub);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &kt);
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_merge", NULL, 1, kt);
zephir_check_call_status();
RETURN_MM();
}
/**
* Merge values in $config, into the properties of $instance
*
* @param \Yosy\KeyTable $config
* @param \Yosy\KeyTable $instance
* @return \Yosy\KeyTable
*/
PHP_METHOD(Toml_KeyTable, _merge) {
zend_bool _5$$6, _6$$6;
zend_string *_3;
zend_ulong _2;
zephir_fcall_cache_entry *_7 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *kt, kt_sub, *target = NULL, target_sub, __$null, key, value, myObj, _0, *_1, _4$$4;
zval *this_ptr = getThis();
ZVAL_UNDEF(&kt_sub);
ZVAL_UNDEF(&target_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&key);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&myObj);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_4$$4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &kt, &target);
if (!target) {
target = &target_sub;
ZEPHIR_CPY_WRT(target, &__$null);
} else {
ZEPHIR_SEPARATE_PARAM(target);
}
if (!(Z_TYPE_P(target) == IS_OBJECT)) {
ZEPHIR_CPY_WRT(target, this_ptr);
}
zephir_read_property(&_0, kt, SL("_store"), PH_NOISY_CC | PH_READONLY);
zephir_is_iterable(&_0, 0, "toml/KeyTable.zep", 160);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_0), _2, _3, _1)
{
ZEPHIR_INIT_NVAR(&key);
if (_3 != NULL) {
ZVAL_STR_COPY(&key, _3);
} else {
ZVAL_LONG(&key, _2);
}
ZEPHIR_INIT_NVAR(&value);
ZVAL_COPY(&value, _1);
ZEPHIR_OBS_NVAR(&myObj);
zephir_read_property(&_4$$4, target, SL("_store"), PH_NOISY_CC | PH_READONLY);
if (!(zephir_array_isset_fetch(&myObj, &_4$$4, &key, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(&myObj);
ZVAL_NULL(&myObj);
}
if (Z_TYPE_P(&myObj) == IS_OBJECT) {
_5$$6 = (zephir_is_instance_of(&myObj, SL("Yosy\\KeyTable") TSRMLS_CC));
if (_5$$6) {
_5$$6 = Z_TYPE_P(&value) == IS_OBJECT;
}
_6$$6 = _5$$6;
if (_6$$6) {
_6$$6 = (zephir_instance_of_ev(&value, toml_keytable_ce TSRMLS_CC));
}
if (_6$$6) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_merge", &_7, 1, &value, &myObj);
zephir_check_call_status();
continue;
}
}
zephir_update_property_array(target, SL("_store"), &key, &value TSRMLS_CC);
} ZEND_HASH_FOREACH_END();
ZEPHIR_INIT_NVAR(&value);
ZEPHIR_INIT_NVAR(&key);
RETVAL_ZVAL(target, 1, 0);
RETURN_MM();
}
|
4cd08a2abcd527351a8c1982d7b0667bf39de073 | 933b3ba215f53617d722b479ca2fe972e7225610 | /GUICode/Core/GUI2DLib.c | f9448ba6388973412adf50fc4ce90bd6b9acac9f | [] | no_license | symfund/eclipse_ucgui_3.98 | 92cc02be1930bd504e22e271366ae950f2f7024e | d49b0da1a044e4e997e6dede1df81fc821c6a0e4 | refs/heads/master | 2023-03-29T03:27:58.459820 | 2021-03-24T02:20:02 | 2021-03-24T02:20:02 | 296,966,304 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,304 | c | GUI2DLib.c | /*
*********************************************************************************************************
* uC/GUI V3.98
* Universal graphic software for embedded applications
*
* (c) Copyright 2002, Micrium Inc., Weston, FL
* (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
*
* �C/GUI is protected by international copyright laws. Knowledge of the
* source code may not be used to write a similar product. This file may
* only be used in accordance with a license and should not be redistributed
* in any way. We appreciate your understanding and fairness.
*
----------------------------------------------------------------------
File : GUI2DLib.C
Purpose : Main part of the 2D graphics library
---------------------------END-OF-HEADER------------------------------
*/
//#include <stddef.h> /* needed for definition of NULL */
#include "GUI_Protected.h"
#include "GUIDebug.h"
/*********************************************************************
*
* Public code
*
**********************************************************************
*/
#define RETURN_IF_OUT() \
if (x0 > x1) return; \
if (y0 > y1) return;
#define CLIP_X() \
if (x0 < GUI_Context.ClipRect.x0) { x0 = GUI_Context.ClipRect.x0; } \
if (x1 > GUI_Context.ClipRect.x1) { x1 = GUI_Context.ClipRect.x1; }
#define CLIP_Y() \
if (y0 < GUI_Context.ClipRect.y0) { y0 = GUI_Context.ClipRect.y0; } \
if (y1 > GUI_Context.ClipRect.y1) { y1 = GUI_Context.ClipRect.y1; }
/*********************************************************************
*
* GUI_MoveRel
*/
/*tbd: GL_LinePos. */
void GUI_MoveRel(I32 dx, I32 dy)
{
GUI_Context.DrawPosX += dx;
GUI_Context.DrawPosY += dy;
}
/*********************************************************************
*
* GL_MoveTo
*/
void GL_MoveTo(I32 x, I32 y)
{
GUI_Context.DrawPosX = x;
GUI_Context.DrawPosY = y;
}
/*********************************************************************
*
* GUI_MoveTo
*/
void GUI_MoveTo(I32 x, I32 y)
{
#if (GUI_WINSUPPORT)
WM_ADDORG(x,y);
#endif
GL_MoveTo(x,y);
}
/*********************************************************************
*
* Rectangle filling / inverting
*
**********************************************************************
*/
/*********************************************************************
*
* _DrawRect
*/
static void _DrawRect(I32 x0, I32 y0, I32 x1, I32 y1)
{
LCD_DrawHLine(x0, y0, x1);
LCD_DrawHLine(x0, y1, x1);
LCD_DrawVLine(x0, y0 + 1, y1 - 1);
LCD_DrawVLine(x1, y0 + 1, y1 - 1);
}
/*********************************************************************
*
* GUI_DrawRect
*/
void GUI_DrawRect(I32 x0, I32 y0, I32 x1, I32 y1)
{
#if GUI_WINSUPPORT
/* Perform clipping and check if there is something to do */
WM_ADDORG(x0, y0);
WM_ADDORG(x1, y1);
CLIP_X();
CLIP_Y();
RETURN_IF_OUT();
#endif
_DrawRect(x0, y0, x1, y1);
}
/*************************** End of file ****************************/
|
06491a5a27a2ddef41c62fc33d0230cefb6016fc | 7eaf54a78c9e2117247cb2ab6d3a0c20719ba700 | /SOFTWARE/A64-TERES/linux-a64/drivers/ata/libata-acpi.c | cf4e7020adacde5e69881a21adb0c578d31d7a3e | [
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] | permissive | OLIMEX/DIY-LAPTOP | ae82f4ee79c641d9aee444db9a75f3f6709afa92 | a3fafd1309135650bab27f5eafc0c32bc3ca74ee | refs/heads/rel3 | 2023-08-04T01:54:19.483792 | 2023-04-03T07:18:12 | 2023-04-03T07:18:12 | 80,094,055 | 507 | 92 | Apache-2.0 | 2023-04-03T07:05:59 | 2017-01-26T07:25:50 | C | UTF-8 | C | false | false | 28,836 | c | libata-acpi.c | /*
* libata-acpi.c
* Provides ACPI support for PATA/SATA.
*
* Copyright (C) 2006 Intel Corp.
* Copyright (C) 2006 Randy Dunlap
*/
#include <linux/module.h>
#include <linux/ata.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/acpi.h>
#include <linux/libata.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/pm_runtime.h>
#include <scsi/scsi_device.h>
#include "libata.h"
#include <acpi/acpi_bus.h>
unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT;
module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644);
MODULE_PARM_DESC(acpi_gtf_filter, "filter mask for ACPI _GTF commands, set to filter out (0x1=set xfermode, 0x2=lock/freeze lock, 0x4=DIPM, 0x8=FPDMA non-zero offset, 0x10=FPDMA DMA Setup FIS auto-activate)");
#define NO_PORT_MULT 0xffff
#define SATA_ADR(root, pmp) (((root) << 16) | (pmp))
#define REGS_PER_GTF 7
struct ata_acpi_gtf {
u8 tf[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */
} __packed;
/*
* Helper - belongs in the PCI layer somewhere eventually
*/
static int is_pci_dev(struct device *dev)
{
return (dev->bus == &pci_bus_type);
}
static void ata_acpi_clear_gtf(struct ata_device *dev)
{
kfree(dev->gtf_cache);
dev->gtf_cache = NULL;
}
/**
* ata_ap_acpi_handle - provide the acpi_handle for an ata_port
* @ap: the acpi_handle returned will correspond to this port
*
* Returns the acpi_handle for the ACPI namespace object corresponding to
* the ata_port passed into the function, or NULL if no such object exists
*/
acpi_handle ata_ap_acpi_handle(struct ata_port *ap)
{
if (ap->flags & ATA_FLAG_ACPI_SATA)
return NULL;
return ap->scsi_host ?
DEVICE_ACPI_HANDLE(&ap->scsi_host->shost_gendev) : NULL;
}
EXPORT_SYMBOL(ata_ap_acpi_handle);
/**
* ata_dev_acpi_handle - provide the acpi_handle for an ata_device
* @dev: the acpi_device returned will correspond to this port
*
* Returns the acpi_handle for the ACPI namespace object corresponding to
* the ata_device passed into the function, or NULL if no such object exists
*/
acpi_handle ata_dev_acpi_handle(struct ata_device *dev)
{
acpi_integer adr;
struct ata_port *ap = dev->link->ap;
if (libata_noacpi || dev->flags & ATA_DFLAG_ACPI_DISABLED)
return NULL;
if (ap->flags & ATA_FLAG_ACPI_SATA) {
if (!sata_pmp_attached(ap))
adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
else
adr = SATA_ADR(ap->port_no, dev->link->pmp);
return acpi_get_child(DEVICE_ACPI_HANDLE(ap->host->dev), adr);
} else
return acpi_get_child(ata_ap_acpi_handle(ap), dev->devno);
}
EXPORT_SYMBOL(ata_dev_acpi_handle);
/* @ap and @dev are the same as ata_acpi_handle_hotplug() */
static void ata_acpi_detach_device(struct ata_port *ap, struct ata_device *dev)
{
if (dev)
dev->flags |= ATA_DFLAG_DETACH;
else {
struct ata_link *tlink;
struct ata_device *tdev;
ata_for_each_link(tlink, ap, EDGE)
ata_for_each_dev(tdev, tlink, ALL)
tdev->flags |= ATA_DFLAG_DETACH;
}
ata_port_schedule_eh(ap);
}
/**
* ata_acpi_handle_hotplug - ACPI event handler backend
* @ap: ATA port ACPI event occurred
* @dev: ATA device ACPI event occurred (can be NULL)
* @event: ACPI event which occurred
*
* All ACPI bay / device realted events end up in this function. If
* the event is port-wide @dev is NULL. If the event is specific to a
* device, @dev points to it.
*
* Hotplug (as opposed to unplug) notification is always handled as
* port-wide while unplug only kills the target device on device-wide
* event.
*
* LOCKING:
* ACPI notify handler context. May sleep.
*/
static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev,
u32 event)
{
struct ata_eh_info *ehi = &ap->link.eh_info;
int wait = 0;
unsigned long flags;
spin_lock_irqsave(ap->lock, flags);
/*
* When dock driver calls into the routine, it will always use
* ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
* ACPI_NOTIFY_EJECT_REQUEST for remove
*/
switch (event) {
case ACPI_NOTIFY_BUS_CHECK:
case ACPI_NOTIFY_DEVICE_CHECK:
ata_ehi_push_desc(ehi, "ACPI event");
ata_ehi_hotplugged(ehi);
ata_port_freeze(ap);
break;
case ACPI_NOTIFY_EJECT_REQUEST:
ata_ehi_push_desc(ehi, "ACPI event");
ata_acpi_detach_device(ap, dev);
wait = 1;
break;
}
spin_unlock_irqrestore(ap->lock, flags);
if (wait) {
ata_port_wait_eh(ap);
flush_work(&ap->hotplug_task.work);
}
}
static void ata_acpi_dev_notify_dock(acpi_handle handle, u32 event, void *data)
{
struct ata_device *dev = data;
ata_acpi_handle_hotplug(dev->link->ap, dev, event);
}
static void ata_acpi_ap_notify_dock(acpi_handle handle, u32 event, void *data)
{
struct ata_port *ap = data;
ata_acpi_handle_hotplug(ap, NULL, event);
}
static void ata_acpi_uevent(struct ata_port *ap, struct ata_device *dev,
u32 event)
{
struct kobject *kobj = NULL;
char event_string[20];
char *envp[] = { event_string, NULL };
if (dev) {
if (dev->sdev)
kobj = &dev->sdev->sdev_gendev.kobj;
} else
kobj = &ap->dev->kobj;
if (kobj) {
snprintf(event_string, 20, "BAY_EVENT=%d", event);
kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
}
}
static void ata_acpi_ap_uevent(acpi_handle handle, u32 event, void *data)
{
ata_acpi_uevent(data, NULL, event);
}
static void ata_acpi_dev_uevent(acpi_handle handle, u32 event, void *data)
{
struct ata_device *dev = data;
ata_acpi_uevent(dev->link->ap, dev, event);
}
static const struct acpi_dock_ops ata_acpi_dev_dock_ops = {
.handler = ata_acpi_dev_notify_dock,
.uevent = ata_acpi_dev_uevent,
};
static const struct acpi_dock_ops ata_acpi_ap_dock_ops = {
.handler = ata_acpi_ap_notify_dock,
.uevent = ata_acpi_ap_uevent,
};
void ata_acpi_hotplug_init(struct ata_host *host)
{
int i;
for (i = 0; i < host->n_ports; i++) {
struct ata_port *ap = host->ports[i];
acpi_handle handle;
struct ata_device *dev;
if (!ap)
continue;
handle = ata_ap_acpi_handle(ap);
if (handle) {
/* we might be on a docking station */
register_hotplug_dock_device(handle,
&ata_acpi_ap_dock_ops, ap,
NULL, NULL);
}
ata_for_each_dev(dev, &ap->link, ALL) {
handle = ata_dev_acpi_handle(dev);
if (!handle)
continue;
/* we might be on a docking station */
register_hotplug_dock_device(handle,
&ata_acpi_dev_dock_ops,
dev, NULL, NULL);
}
}
}
/**
* ata_acpi_dissociate - dissociate ATA host from ACPI objects
* @host: target ATA host
*
* This function is called during driver detach after the whole host
* is shut down.
*
* LOCKING:
* EH context.
*/
void ata_acpi_dissociate(struct ata_host *host)
{
int i;
/* Restore initial _GTM values so that driver which attaches
* afterward can use them too.
*/
for (i = 0; i < host->n_ports; i++) {
struct ata_port *ap = host->ports[i];
const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
if (ata_ap_acpi_handle(ap) && gtm)
ata_acpi_stm(ap, gtm);
}
}
static int __ata_acpi_gtm(struct ata_port *ap, acpi_handle handle,
struct ata_acpi_gtm *gtm)
{
struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
union acpi_object *out_obj;
acpi_status status;
int rc = 0;
status = acpi_evaluate_object(handle, "_GTM", NULL, &output);
rc = -ENOENT;
if (status == AE_NOT_FOUND)
goto out_free;
rc = -EINVAL;
if (ACPI_FAILURE(status)) {
ata_port_err(ap, "ACPI get timing mode failed (AE 0x%x)\n",
status);
goto out_free;
}
out_obj = output.pointer;
if (out_obj->type != ACPI_TYPE_BUFFER) {
ata_port_warn(ap, "_GTM returned unexpected object type 0x%x\n",
out_obj->type);
goto out_free;
}
if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) {
ata_port_err(ap, "_GTM returned invalid length %d\n",
out_obj->buffer.length);
goto out_free;
}
memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm));
rc = 0;
out_free:
kfree(output.pointer);
return rc;
}
/**
* ata_acpi_gtm - execute _GTM
* @ap: target ATA port
* @gtm: out parameter for _GTM result
*
* Evaluate _GTM and store the result in @gtm.
*
* LOCKING:
* EH context.
*
* RETURNS:
* 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
*/
int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *gtm)
{
if (ata_ap_acpi_handle(ap))
return __ata_acpi_gtm(ap, ata_ap_acpi_handle(ap), gtm);
else
return -EINVAL;
}
EXPORT_SYMBOL_GPL(ata_acpi_gtm);
/**
* ata_acpi_stm - execute _STM
* @ap: target ATA port
* @stm: timing parameter to _STM
*
* Evaluate _STM with timing parameter @stm.
*
* LOCKING:
* EH context.
*
* RETURNS:
* 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
*/
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm)
{
acpi_status status;
struct ata_acpi_gtm stm_buf = *stm;
struct acpi_object_list input;
union acpi_object in_params[3];
in_params[0].type = ACPI_TYPE_BUFFER;
in_params[0].buffer.length = sizeof(struct ata_acpi_gtm);
in_params[0].buffer.pointer = (u8 *)&stm_buf;
/* Buffers for id may need byteswapping ? */
in_params[1].type = ACPI_TYPE_BUFFER;
in_params[1].buffer.length = 512;
in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
in_params[2].type = ACPI_TYPE_BUFFER;
in_params[2].buffer.length = 512;
in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
input.count = 3;
input.pointer = in_params;
status = acpi_evaluate_object(ata_ap_acpi_handle(ap), "_STM", &input,
NULL);
if (status == AE_NOT_FOUND)
return -ENOENT;
if (ACPI_FAILURE(status)) {
ata_port_err(ap, "ACPI set timing mode failed (status=0x%x)\n",
status);
return -EINVAL;
}
return 0;
}
EXPORT_SYMBOL_GPL(ata_acpi_stm);
/**
* ata_dev_get_GTF - get the drive bootup default taskfile settings
* @dev: target ATA device
* @gtf: output parameter for buffer containing _GTF taskfile arrays
*
* This applies to both PATA and SATA drives.
*
* The _GTF method has no input parameters.
* It returns a variable number of register set values (registers
* hex 1F1..1F7, taskfiles).
* The <variable number> is not known in advance, so have ACPI-CA
* allocate the buffer as needed and return it, then free it later.
*
* LOCKING:
* EH context.
*
* RETURNS:
* Number of taskfiles on success, 0 if _GTF doesn't exist. -EINVAL
* if _GTF is invalid.
*/
static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
{
struct ata_port *ap = dev->link->ap;
acpi_status status;
struct acpi_buffer output;
union acpi_object *out_obj;
int rc = 0;
/* if _GTF is cached, use the cached value */
if (dev->gtf_cache) {
out_obj = dev->gtf_cache;
goto done;
}
/* set up output buffer */
output.length = ACPI_ALLOCATE_BUFFER;
output.pointer = NULL; /* ACPI-CA sets this; save/free it later */
if (ata_msg_probe(ap))
ata_dev_dbg(dev, "%s: ENTER: port#: %d\n",
__func__, ap->port_no);
/* _GTF has no input parameters */
status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_GTF", NULL,
&output);
out_obj = dev->gtf_cache = output.pointer;
if (ACPI_FAILURE(status)) {
if (status != AE_NOT_FOUND) {
ata_dev_warn(dev, "_GTF evaluation failed (AE 0x%x)\n",
status);
rc = -EINVAL;
}
goto out_free;
}
if (!output.length || !output.pointer) {
if (ata_msg_probe(ap))
ata_dev_dbg(dev, "%s: Run _GTF: length or ptr is NULL (0x%llx, 0x%p)\n",
__func__,
(unsigned long long)output.length,
output.pointer);
rc = -EINVAL;
goto out_free;
}
if (out_obj->type != ACPI_TYPE_BUFFER) {
ata_dev_warn(dev, "_GTF unexpected object type 0x%x\n",
out_obj->type);
rc = -EINVAL;
goto out_free;
}
if (out_obj->buffer.length % REGS_PER_GTF) {
ata_dev_warn(dev, "unexpected _GTF length (%d)\n",
out_obj->buffer.length);
rc = -EINVAL;
goto out_free;
}
done:
rc = out_obj->buffer.length / REGS_PER_GTF;
if (gtf) {
*gtf = (void *)out_obj->buffer.pointer;
if (ata_msg_probe(ap))
ata_dev_dbg(dev, "%s: returning gtf=%p, gtf_count=%d\n",
__func__, *gtf, rc);
}
return rc;
out_free:
ata_acpi_clear_gtf(dev);
return rc;
}
/**
* ata_acpi_gtm_xfermode - determine xfermode from GTM parameter
* @dev: target device
* @gtm: GTM parameter to use
*
* Determine xfermask for @dev from @gtm.
*
* LOCKING:
* None.
*
* RETURNS:
* Determined xfermask.
*/
unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
const struct ata_acpi_gtm *gtm)
{
unsigned long xfer_mask = 0;
unsigned int type;
int unit;
u8 mode;
/* we always use the 0 slot for crap hardware */
unit = dev->devno;
if (!(gtm->flags & 0x10))
unit = 0;
/* PIO */
mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio);
xfer_mask |= ata_xfer_mode2mask(mode);
/* See if we have MWDMA or UDMA data. We don't bother with
* MWDMA if UDMA is available as this means the BIOS set UDMA
* and our error changedown if it works is UDMA to PIO anyway.
*/
if (!(gtm->flags & (1 << (2 * unit))))
type = ATA_SHIFT_MWDMA;
else
type = ATA_SHIFT_UDMA;
mode = ata_timing_cycle2mode(type, gtm->drive[unit].dma);
xfer_mask |= ata_xfer_mode2mask(mode);
return xfer_mask;
}
EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask);
/**
* ata_acpi_cbl_80wire - Check for 80 wire cable
* @ap: Port to check
* @gtm: GTM data to use
*
* Return 1 if the @gtm indicates the BIOS selected an 80wire mode.
*/
int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm)
{
struct ata_device *dev;
ata_for_each_dev(dev, &ap->link, ENABLED) {
unsigned long xfer_mask, udma_mask;
xfer_mask = ata_acpi_gtm_xfermask(dev, gtm);
ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask);
if (udma_mask & ~ATA_UDMA_MASK_40C)
return 1;
}
return 0;
}
EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
static void ata_acpi_gtf_to_tf(struct ata_device *dev,
const struct ata_acpi_gtf *gtf,
struct ata_taskfile *tf)
{
ata_tf_init(dev, tf);
tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
tf->protocol = ATA_PROT_NODATA;
tf->feature = gtf->tf[0]; /* 0x1f1 */
tf->nsect = gtf->tf[1]; /* 0x1f2 */
tf->lbal = gtf->tf[2]; /* 0x1f3 */
tf->lbam = gtf->tf[3]; /* 0x1f4 */
tf->lbah = gtf->tf[4]; /* 0x1f5 */
tf->device = gtf->tf[5]; /* 0x1f6 */
tf->command = gtf->tf[6]; /* 0x1f7 */
}
static int ata_acpi_filter_tf(struct ata_device *dev,
const struct ata_taskfile *tf,
const struct ata_taskfile *ptf)
{
if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) {
/* libata doesn't use ACPI to configure transfer mode.
* It will only confuse device configuration. Skip.
*/
if (tf->command == ATA_CMD_SET_FEATURES &&
tf->feature == SETFEATURES_XFER)
return 1;
}
if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) {
/* BIOS writers, sorry but we don't wanna lock
* features unless the user explicitly said so.
*/
/* DEVICE CONFIGURATION FREEZE LOCK */
if (tf->command == ATA_CMD_CONF_OVERLAY &&
tf->feature == ATA_DCO_FREEZE_LOCK)
return 1;
/* SECURITY FREEZE LOCK */
if (tf->command == ATA_CMD_SEC_FREEZE_LOCK)
return 1;
/* SET MAX LOCK and SET MAX FREEZE LOCK */
if ((!ptf || ptf->command != ATA_CMD_READ_NATIVE_MAX) &&
tf->command == ATA_CMD_SET_MAX &&
(tf->feature == ATA_SET_MAX_LOCK ||
tf->feature == ATA_SET_MAX_FREEZE_LOCK))
return 1;
}
if (tf->command == ATA_CMD_SET_FEATURES &&
tf->feature == SETFEATURES_SATA_ENABLE) {
/* inhibit enabling DIPM */
if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM &&
tf->nsect == SATA_DIPM)
return 1;
/* inhibit FPDMA non-zero offset */
if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET &&
(tf->nsect == SATA_FPDMA_OFFSET ||
tf->nsect == SATA_FPDMA_IN_ORDER))
return 1;
/* inhibit FPDMA auto activation */
if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA &&
tf->nsect == SATA_FPDMA_AA)
return 1;
}
return 0;
}
/**
* ata_acpi_run_tf - send taskfile registers to host controller
* @dev: target ATA device
* @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
*
* Outputs ATA taskfile to standard ATA host controller.
* Writes the control, feature, nsect, lbal, lbam, and lbah registers.
* Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
* hob_lbal, hob_lbam, and hob_lbah.
*
* This function waits for idle (!BUSY and !DRQ) after writing
* registers. If the control register has a new value, this
* function also waits for idle after writing control and before
* writing the remaining registers.
*
* LOCKING:
* EH context.
*
* RETURNS:
* 1 if command is executed successfully. 0 if ignored, rejected or
* filtered out, -errno on other errors.
*/
static int ata_acpi_run_tf(struct ata_device *dev,
const struct ata_acpi_gtf *gtf,
const struct ata_acpi_gtf *prev_gtf)
{
struct ata_taskfile *pptf = NULL;
struct ata_taskfile tf, ptf, rtf;
unsigned int err_mask;
const char *level;
const char *descr;
char msg[60];
int rc;
if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
&& (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
&& (gtf->tf[6] == 0))
return 0;
ata_acpi_gtf_to_tf(dev, gtf, &tf);
if (prev_gtf) {
ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf);
pptf = &ptf;
}
if (!ata_acpi_filter_tf(dev, &tf, pptf)) {
rtf = tf;
err_mask = ata_exec_internal(dev, &rtf, NULL,
DMA_NONE, NULL, 0, 0);
switch (err_mask) {
case 0:
level = KERN_DEBUG;
snprintf(msg, sizeof(msg), "succeeded");
rc = 1;
break;
case AC_ERR_DEV:
level = KERN_INFO;
snprintf(msg, sizeof(msg),
"rejected by device (Stat=0x%02x Err=0x%02x)",
rtf.command, rtf.feature);
rc = 0;
break;
default:
level = KERN_ERR;
snprintf(msg, sizeof(msg),
"failed (Emask=0x%x Stat=0x%02x Err=0x%02x)",
err_mask, rtf.command, rtf.feature);
rc = -EIO;
break;
}
} else {
level = KERN_INFO;
snprintf(msg, sizeof(msg), "filtered out");
rc = 0;
}
descr = ata_get_cmd_descript(tf.command);
ata_dev_printk(dev, level,
"ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n",
tf.command, tf.feature, tf.nsect, tf.lbal,
tf.lbam, tf.lbah, tf.device,
(descr ? descr : "unknown"), msg);
return rc;
}
/**
* ata_acpi_exec_tfs - get then write drive taskfile settings
* @dev: target ATA device
* @nr_executed: out parameter for the number of executed commands
*
* Evaluate _GTF and execute returned taskfiles.
*
* LOCKING:
* EH context.
*
* RETURNS:
* Number of executed taskfiles on success, 0 if _GTF doesn't exist.
* -errno on other errors.
*/
static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
{
struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL;
int gtf_count, i, rc;
/* get taskfiles */
rc = ata_dev_get_GTF(dev, >f);
if (rc < 0)
return rc;
gtf_count = rc;
/* execute them */
for (i = 0; i < gtf_count; i++, gtf++) {
rc = ata_acpi_run_tf(dev, gtf, pgtf);
if (rc < 0)
break;
if (rc) {
(*nr_executed)++;
pgtf = gtf;
}
}
ata_acpi_clear_gtf(dev);
if (rc < 0)
return rc;
return 0;
}
/**
* ata_acpi_push_id - send Identify data to drive
* @dev: target ATA device
*
* _SDD ACPI object: for SATA mode only
* Must be after Identify (Packet) Device -- uses its data
* ATM this function never returns a failure. It is an optional
* method and if it fails for whatever reason, we should still
* just keep going.
*
* LOCKING:
* EH context.
*
* RETURNS:
* 0 on success, -ENOENT if _SDD doesn't exist, -errno on failure.
*/
static int ata_acpi_push_id(struct ata_device *dev)
{
struct ata_port *ap = dev->link->ap;
acpi_status status;
struct acpi_object_list input;
union acpi_object in_params[1];
if (ata_msg_probe(ap))
ata_dev_dbg(dev, "%s: ix = %d, port#: %d\n",
__func__, dev->devno, ap->port_no);
/* Give the drive Identify data to the drive via the _SDD method */
/* _SDD: set up input parameters */
input.count = 1;
input.pointer = in_params;
in_params[0].type = ACPI_TYPE_BUFFER;
in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
in_params[0].buffer.pointer = (u8 *)dev->id;
/* Output buffer: _SDD has no output */
/* It's OK for _SDD to be missing too. */
swap_buf_le16(dev->id, ATA_ID_WORDS);
status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_SDD", &input,
NULL);
swap_buf_le16(dev->id, ATA_ID_WORDS);
if (status == AE_NOT_FOUND)
return -ENOENT;
if (ACPI_FAILURE(status)) {
ata_dev_warn(dev, "ACPI _SDD failed (AE 0x%x)\n", status);
return -EIO;
}
return 0;
}
/**
* ata_acpi_on_suspend - ATA ACPI hook called on suspend
* @ap: target ATA port
*
* This function is called when @ap is about to be suspended. All
* devices are already put to sleep but the port_suspend() callback
* hasn't been executed yet. Error return from this function aborts
* suspend.
*
* LOCKING:
* EH context.
*
* RETURNS:
* 0 on success, -errno on failure.
*/
int ata_acpi_on_suspend(struct ata_port *ap)
{
/* nada */
return 0;
}
/**
* ata_acpi_on_resume - ATA ACPI hook called on resume
* @ap: target ATA port
*
* This function is called when @ap is resumed - right after port
* itself is resumed but before any EH action is taken.
*
* LOCKING:
* EH context.
*/
void ata_acpi_on_resume(struct ata_port *ap)
{
const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
struct ata_device *dev;
if (ata_ap_acpi_handle(ap) && gtm) {
/* _GTM valid */
/* restore timing parameters */
ata_acpi_stm(ap, gtm);
/* _GTF should immediately follow _STM so that it can
* use values set by _STM. Cache _GTF result and
* schedule _GTF.
*/
ata_for_each_dev(dev, &ap->link, ALL) {
ata_acpi_clear_gtf(dev);
if (ata_dev_enabled(dev) &&
ata_dev_get_GTF(dev, NULL) >= 0)
dev->flags |= ATA_DFLAG_ACPI_PENDING;
}
} else {
/* SATA _GTF needs to be evaulated after _SDD and
* there's no reason to evaluate IDE _GTF early
* without _STM. Clear cache and schedule _GTF.
*/
ata_for_each_dev(dev, &ap->link, ALL) {
ata_acpi_clear_gtf(dev);
if (ata_dev_enabled(dev))
dev->flags |= ATA_DFLAG_ACPI_PENDING;
}
}
}
static int ata_acpi_choose_suspend_state(struct ata_device *dev, bool runtime)
{
int d_max_in = ACPI_STATE_D3_COLD;
if (!runtime)
goto out;
/*
* For ATAPI, runtime D3 cold is only allowed
* for ZPODD in zero power ready state
*/
if (dev->class == ATA_DEV_ATAPI &&
!(zpodd_dev_enabled(dev) && zpodd_zpready(dev)))
d_max_in = ACPI_STATE_D3_HOT;
out:
return acpi_pm_device_sleep_state(&dev->sdev->sdev_gendev,
NULL, d_max_in);
}
static void sata_acpi_set_state(struct ata_port *ap, pm_message_t state)
{
bool runtime = PMSG_IS_AUTO(state);
struct ata_device *dev;
acpi_handle handle;
int acpi_state;
ata_for_each_dev(dev, &ap->link, ENABLED) {
handle = ata_dev_acpi_handle(dev);
if (!handle)
continue;
if (!(state.event & PM_EVENT_RESUME)) {
acpi_state = ata_acpi_choose_suspend_state(dev, runtime);
if (acpi_state == ACPI_STATE_D0)
continue;
if (runtime && zpodd_dev_enabled(dev) &&
acpi_state == ACPI_STATE_D3_COLD)
zpodd_enable_run_wake(dev);
acpi_bus_set_power(handle, acpi_state);
} else {
if (runtime && zpodd_dev_enabled(dev))
zpodd_disable_run_wake(dev);
acpi_bus_set_power(handle, ACPI_STATE_D0);
}
}
}
/* ACPI spec requires _PS0 when IDE power on and _PS3 when power off */
static void pata_acpi_set_state(struct ata_port *ap, pm_message_t state)
{
struct ata_device *dev;
acpi_handle port_handle;
port_handle = ata_ap_acpi_handle(ap);
if (!port_handle)
return;
/* channel first and then drives for power on and vica versa
for power off */
if (state.event & PM_EVENT_RESUME)
acpi_bus_set_power(port_handle, ACPI_STATE_D0);
ata_for_each_dev(dev, &ap->link, ENABLED) {
acpi_handle dev_handle = ata_dev_acpi_handle(dev);
if (!dev_handle)
continue;
acpi_bus_set_power(dev_handle, state.event & PM_EVENT_RESUME ?
ACPI_STATE_D0 : ACPI_STATE_D3);
}
if (!(state.event & PM_EVENT_RESUME))
acpi_bus_set_power(port_handle, ACPI_STATE_D3);
}
/**
* ata_acpi_set_state - set the port power state
* @ap: target ATA port
* @state: state, on/off
*
* This function sets a proper ACPI D state for the device on
* system and runtime PM operations.
*/
void ata_acpi_set_state(struct ata_port *ap, pm_message_t state)
{
if (ap->flags & ATA_FLAG_ACPI_SATA)
sata_acpi_set_state(ap, state);
else
pata_acpi_set_state(ap, state);
}
/**
* ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
* @dev: target ATA device
*
* This function is called when @dev is about to be configured.
* IDENTIFY data might have been modified after this hook is run.
*
* LOCKING:
* EH context.
*
* RETURNS:
* Positive number if IDENTIFY data needs to be refreshed, 0 if not,
* -errno on failure.
*/
int ata_acpi_on_devcfg(struct ata_device *dev)
{
struct ata_port *ap = dev->link->ap;
struct ata_eh_context *ehc = &ap->link.eh_context;
int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
int nr_executed = 0;
int rc;
if (!ata_dev_acpi_handle(dev))
return 0;
/* do we need to do _GTF? */
if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
!(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
return 0;
/* do _SDD if SATA */
if (acpi_sata) {
rc = ata_acpi_push_id(dev);
if (rc && rc != -ENOENT)
goto acpi_err;
}
/* do _GTF */
rc = ata_acpi_exec_tfs(dev, &nr_executed);
if (rc)
goto acpi_err;
dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
/* refresh IDENTIFY page if any _GTF command has been executed */
if (nr_executed) {
rc = ata_dev_reread_id(dev, 0);
if (rc < 0) {
ata_dev_err(dev,
"failed to IDENTIFY after ACPI commands\n");
return rc;
}
}
return 0;
acpi_err:
/* ignore evaluation failure if we can continue safely */
if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
return 0;
/* fail and let EH retry once more for unknown IO errors */
if (!(dev->flags & ATA_DFLAG_ACPI_FAILED)) {
dev->flags |= ATA_DFLAG_ACPI_FAILED;
return rc;
}
dev->flags |= ATA_DFLAG_ACPI_DISABLED;
ata_dev_warn(dev, "ACPI: failed the second time, disabled\n");
/* We can safely continue if no _GTF command has been executed
* and port is not frozen.
*/
if (!nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
return 0;
return rc;
}
/**
* ata_acpi_on_disable - ATA ACPI hook called when a device is disabled
* @dev: target ATA device
*
* This function is called when @dev is about to be disabled.
*
* LOCKING:
* EH context.
*/
void ata_acpi_on_disable(struct ata_device *dev)
{
ata_acpi_clear_gtf(dev);
}
static int compat_pci_ata(struct ata_port *ap)
{
struct device *dev = ap->tdev.parent;
struct pci_dev *pdev;
if (!is_pci_dev(dev))
return 0;
pdev = to_pci_dev(dev);
if ((pdev->class >> 8) != PCI_CLASS_STORAGE_SATA &&
(pdev->class >> 8) != PCI_CLASS_STORAGE_IDE)
return 0;
return 1;
}
static int ata_acpi_bind_host(struct ata_port *ap, acpi_handle *handle)
{
if (libata_noacpi || ap->flags & ATA_FLAG_ACPI_SATA)
return -ENODEV;
*handle = acpi_get_child(DEVICE_ACPI_HANDLE(ap->tdev.parent),
ap->port_no);
if (!*handle)
return -ENODEV;
if (__ata_acpi_gtm(ap, *handle, &ap->__acpi_init_gtm) == 0)
ap->pflags |= ATA_PFLAG_INIT_GTM_VALID;
return 0;
}
static int ata_acpi_bind_device(struct ata_port *ap, struct scsi_device *sdev,
acpi_handle *handle)
{
struct ata_device *ata_dev;
if (ap->flags & ATA_FLAG_ACPI_SATA) {
if (!sata_pmp_attached(ap))
ata_dev = &ap->link.device[sdev->id];
else
ata_dev = &ap->pmp_link[sdev->channel].device[sdev->id];
}
else {
ata_dev = &ap->link.device[sdev->id];
}
*handle = ata_dev_acpi_handle(ata_dev);
if (!*handle)
return -ENODEV;
return 0;
}
static int is_ata_port(const struct device *dev)
{
return dev->type == &ata_port_type;
}
static struct ata_port *dev_to_ata_port(struct device *dev)
{
while (!is_ata_port(dev)) {
if (!dev->parent)
return NULL;
dev = dev->parent;
}
return to_ata_port(dev);
}
static int ata_acpi_find_device(struct device *dev, acpi_handle *handle)
{
struct ata_port *ap = dev_to_ata_port(dev);
if (!ap)
return -ENODEV;
if (!compat_pci_ata(ap))
return -ENODEV;
if (scsi_is_host_device(dev))
return ata_acpi_bind_host(ap, handle);
else if (scsi_is_sdev_device(dev)) {
struct scsi_device *sdev = to_scsi_device(dev);
return ata_acpi_bind_device(ap, sdev, handle);
} else
return -ENODEV;
}
static struct acpi_bus_type ata_acpi_bus = {
.name = "ATA",
.find_device = ata_acpi_find_device,
};
int ata_acpi_register(void)
{
return scsi_register_acpi_bus_type(&ata_acpi_bus);
}
void ata_acpi_unregister(void)
{
scsi_unregister_acpi_bus_type(&ata_acpi_bus);
}
|
3c777fe3796cacc5f6ffc85d327845e4996c3574 | ef37f427ddd18b37bf1a882423ba6f81e879864f | /usb_core.c | eb089b73e7c22df0094faca7feec541b311fdbca | [
"MIT"
] | permissive | ahmedalkabir/bluepill-serial-monster | 23ba538cfcce3810ec70c9f42df2508cb7ba0464 | f7d85767b855b9efed46befa293c1ab5f6d2bb54 | refs/heads/main | 2023-08-28T21:58:39.353535 | 2021-09-28T11:07:30 | 2021-09-28T11:07:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 12,693 | c | usb_core.c | /*
* MIT License
*
* Copyright (c) 2020 Kirill Kotyagin
*/
#include <stddef.h>
#include <string.h>
#include "status_led.h"
#include "usb_core.h"
#include "usb_std.h"
#include "usb_cdc.h"
#include "usb_descriptors.h"
#include "usb_io.h"
#include "usb_uid.h"
#include "usb_panic.h"
#include "usb.h"
/* Device Level Events */
static struct {
usb_device_state_t state;
uint8_t address;
uint8_t configuration;
} usb_device;
void usb_device_handle_reset() {
usb_device.state = usb_device_state_reset;
usb_device.address = 0;
usb_device.configuration = 0;
usb_cdc_reset();
usb_io_reset();
}
void usb_device_handle_configured() {
if (usb_device.state != usb_device_state_configured) {
usb_cdc_enable();
}
}
void usb_device_handle_suspend() {
if (usb_device.state == usb_device_state_configured) {
usb_cdc_suspend();
}
USB->DADDR = USB_DADDR_EF;
usb_device.state = usb_device_state_reset;
}
void usb_device_handle_wakeup() {
}
void usb_device_handle_frame() {
usb_cdc_frame();
}
void usb_device_poll() {
usb_cdc_poll();
}
/* Device Descriptor Requests Handling */
usb_status_t usb_control_endpoint_process_get_descriptor(usb_setup_t *setup,
void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) {
usb_descriptor_type_t descriptor_type = (setup->wValue >> 8);
uint8_t descriptor_index = (setup->wValue & 0xff);
switch (descriptor_type) {
case usb_descriptor_type_device:
*payload = (void*)&usb_device_descriptor;
*payload_size = usb_device_descriptor.bLength;
break;
case usb_descriptor_type_configuration:
*payload = (void*)&usb_configuration_descriptor;
*payload_size = usb_configuration_descriptor.config.wTotalLength;
break;
case usb_descriptor_type_string:
if (descriptor_index == usb_string_index_serial) {
usb_string_descriptor_t *uid_descriptor = usb_get_uid_string_descriptor();
*payload = uid_descriptor;
*payload_size = uid_descriptor->bLength;
} else {
if (descriptor_index < usb_string_index_last) {
*payload = (void*)usb_string_descriptors[descriptor_index];
*payload_size = usb_string_descriptors[descriptor_index]->bLength;
} else {
return usb_status_fail;
}
}
break;
default:
return usb_status_fail;
}
return usb_status_ack;
}
/* Standard Control Endpoint Requests Handling */
static void usb_assign_device_address_cb() {
USB->DADDR = USB_DADDR_EF | usb_device.address;
usb_device.state = usb_device_state_address_set;
}
usb_status_t usb_control_endpoint_process_device_request(usb_setup_t *setup,
void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) {
switch(setup->bRequest) {
case usb_device_request_get_configuration:
*(uint8_t*)payload[0] = usb_device.configuration;
return usb_status_ack;
case usb_device_request_get_descriptor:
return usb_control_endpoint_process_get_descriptor(setup, payload, payload_size, tx_callback_ptr);
case usb_device_request_get_status:
((uint8_t*)(*payload))[0] = 0;
((uint8_t*)(*payload))[1] = 0;
return usb_status_ack;
case usb_device_request_set_address:
usb_device.address = setup->wValue & USB_DADDR_ADD_Msk;
*tx_callback_ptr = usb_assign_device_address_cb;
return usb_status_ack;
case usb_device_request_set_configuration: {
uint8_t device_configuration = setup->wValue & 0xff;
if (device_configuration == 1) {
usb_device.configuration = device_configuration;
usb_device_handle_configured();
return usb_status_ack;
}
break;
}
case usb_device_request_set_descriptor:
case usb_device_request_set_feature:
case usb_device_request_clear_feature:
break;
default:
break;
}
return usb_status_fail;
}
usb_status_t usb_control_endpoint_process_interface_request(usb_setup_t *setup,
void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) {
if (setup->bRequest == usb_device_request_get_status) {
((uint8_t*)(*payload))[0] = 0;
((uint8_t*)(*payload))[1] = 0;
return usb_status_ack;
}
return usb_status_fail;
}
usb_status_t usb_control_endpoint_process_endpoint_request(usb_setup_t *setup,
void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) {
uint8_t ep_num = setup->wIndex & ~(usb_endpoint_direction_in);
usb_endpoint_direction_t ep_direction = setup->wIndex & usb_endpoint_direction_in;
if ((setup->bRequest == usb_device_request_set_feature) ||
(setup->bRequest == usb_device_request_clear_feature)) {
uint8_t ep_stall = (setup->bRequest == usb_device_request_set_feature);
usb_endpoint_set_stall(ep_num, ep_direction, ep_stall);
return usb_status_ack;
} else if (setup->bRequest == usb_device_request_get_status) {
((uint8_t*)(*payload))[0] = usb_endpoint_is_stalled(ep_num , ep_direction);
((uint8_t*)(*payload))[1] = 0;
return usb_status_ack;
} else {
return usb_status_fail;
}
}
/* Control Endpoint Request Processing */
usb_status_t usb_control_endpoint_process_request(usb_setup_t *setup,
void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) {
usb_status_t status = usb_cdc_ctrl_process_request(setup, payload, payload_size, tx_callback_ptr);
if (status != usb_status_fail) {
return status;
}
if (setup->type == usb_setup_type_standard) {
switch (setup->recepient) {
case usb_setup_recepient_device:
return usb_control_endpoint_process_device_request(setup, payload, payload_size, tx_callback_ptr);
case usb_setup_recepient_interface:
return usb_control_endpoint_process_interface_request(setup, payload, payload_size, tx_callback_ptr);
case usb_setup_recepient_endpoint:
return usb_control_endpoint_process_endpoint_request(setup, payload, payload_size, tx_callback_ptr);
default:
break;
}
}
return usb_status_fail;
}
/* Control Endpoint Data Echange */
static struct {
enum {
usb_control_state_idle,
usb_control_state_rx,
usb_control_state_tx,
usb_control_state_tx_zlp,
usb_control_state_tx_last,
usb_control_state_status_in,
usb_control_state_status_out,
} state;
uint8_t setup_buf[USB_SETUP_MAX_SIZE];
void *payload;
size_t payload_size;
usb_setup_t *setup;
usb_tx_complete_cb_t tx_complete_callback;
} usb_control_ep_struct;
void usb_control_endpoint_stall(uint8_t ep_num) {
usb_endpoint_set_stall(ep_num, usb_endpoint_direction_out, 1);
usb_endpoint_set_stall(ep_num, usb_endpoint_direction_in, 1);
usb_control_ep_struct.state = usb_control_state_idle;
}
static void usb_control_endpoint_process_callback() {
if (usb_control_ep_struct.tx_complete_callback) {
usb_control_ep_struct.tx_complete_callback();
usb_control_ep_struct.tx_complete_callback = 0;
}
}
static void usb_control_endpoint_process_tx(uint8_t ep_num) {
size_t bytes_sent = 0;
switch (usb_control_ep_struct.state) {
case usb_control_state_tx:
case usb_control_state_tx_zlp:
bytes_sent = usb_send(ep_num, usb_control_ep_struct.payload, usb_control_ep_struct.payload_size);
usb_control_ep_struct.payload = ((uint8_t*)usb_control_ep_struct.payload) + bytes_sent;
usb_control_ep_struct.payload_size -= bytes_sent;
if (usb_control_ep_struct.payload_size == 0) {
if ((usb_control_ep_struct.state == usb_control_state_tx) ||
(bytes_sent != usb_endpoints[ep_num].tx_size)) {
usb_control_ep_struct.state = usb_control_state_tx_last;
}
}
break;
case usb_control_state_tx_last:
usb_control_ep_struct.state = usb_control_state_status_out;
break;
case usb_control_state_status_in:
usb_control_ep_struct.state = usb_control_state_idle;
usb_control_endpoint_process_callback();
break;
default:
usb_panic();
break;
}
}
static void usb_control_endpoint_process_rx(uint8_t ep_num) {
size_t setup_size;
size_t payload_bytes_received = 0;
switch (usb_control_ep_struct.state) {
case usb_control_state_idle:
setup_size = usb_read(ep_num, usb_control_ep_struct.setup_buf, sizeof(usb_setup_t));
if (setup_size != sizeof(usb_setup_t)) {
usb_control_endpoint_stall(ep_num);
return;
} else {
usb_control_ep_struct.setup = (usb_setup_t *)&usb_control_ep_struct.setup_buf;
usb_control_ep_struct.payload = usb_control_ep_struct.setup->payload;
usb_control_ep_struct.payload_size = usb_control_ep_struct.setup->wLength;
if ((usb_control_ep_struct.setup->direction == usb_setup_direction_host_to_device) &&
(usb_control_ep_struct.setup->wLength != 0)) {
if (usb_control_ep_struct.payload_size > USB_SETUP_MAX_PAYLOAD_SIZE) {
usb_control_endpoint_stall(ep_num);
} else {
usb_control_ep_struct.state = usb_control_state_rx;
}
return;
}
}
break;
case usb_control_state_rx:
payload_bytes_received = usb_read(ep_num, usb_control_ep_struct.payload, usb_control_ep_struct.payload_size);
if (usb_control_ep_struct.payload_size != payload_bytes_received) {
usb_control_ep_struct.payload = ((uint8_t*)usb_control_ep_struct.payload) + payload_bytes_received;
usb_control_ep_struct.payload_size -= payload_bytes_received;
return;
}
break;
case usb_control_state_status_out:
usb_read(ep_num, 0, 0);
usb_control_ep_struct.state = usb_control_state_idle;
usb_control_endpoint_process_callback();
return;
default:
usb_control_endpoint_stall(ep_num);
return;
}
usb_control_ep_struct.payload = usb_control_ep_struct.setup->payload;
usb_control_ep_struct.payload_size = USB_SETUP_MAX_PAYLOAD_SIZE;
switch (usb_control_endpoint_process_request(usb_control_ep_struct.setup,
&usb_control_ep_struct.payload,
&usb_control_ep_struct.payload_size,
&usb_control_ep_struct.tx_complete_callback)) {
case usb_status_ack:
if (usb_control_ep_struct.setup->direction == usb_setup_direction_device_to_host) {
if (usb_control_ep_struct.payload_size < usb_control_ep_struct.setup->wLength) {
usb_control_ep_struct.state = usb_control_state_tx_zlp;
} else {
if (usb_control_ep_struct.payload_size > usb_control_ep_struct.setup->wLength) {
usb_control_ep_struct.payload_size = usb_control_ep_struct.setup->wLength;
}
usb_control_ep_struct.state = usb_control_state_tx;
}
usb_control_endpoint_process_tx(ep_num);
return;
} else {
usb_send(ep_num, 0, 0);
usb_control_ep_struct.state = usb_control_state_status_in;
}
break;
case usb_status_nak:
usb_control_ep_struct.state = usb_control_state_status_in;
break;
default:
usb_control_endpoint_stall(ep_num);
}
}
void usb_control_endpoint_event_handler(uint8_t ep_num, usb_endpoint_event_t ep_event) {
if (ep_num == usb_endpoint_address_control) {
if (ep_event == usb_endpoint_event_setup || ep_event == usb_endpoint_event_data_received) {
if (ep_event == usb_endpoint_event_setup) {
usb_control_ep_struct.state = usb_control_state_idle;
}
usb_control_endpoint_process_rx(ep_num);
} else if (ep_event == usb_endpoint_event_data_sent) {
usb_control_endpoint_process_tx(ep_num);
} else {
usb_panic();
}
} else {
usb_panic();
}
}
void usb_init() {
usb_io_init();
}
|
c27f899bdced95e8dd1aafcf3119ae5cb604039b | 2a34b0c2779c8220272cd3781a39c5867146b615 | /src/libc/uv/uv_mutex_init_recursive.c | 3714d711d8379209be160bb6458bcf6ab1a16288 | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause"
] | permissive | yurydelendik/cloudlibc | f824043879ee7147049eb2bf5b243e7b0b5ac530 | b25d9232b3e5b3757231afdc888d2b9072673917 | refs/heads/master | 2020-04-10T02:42:27.618187 | 2018-12-15T00:53:03 | 2018-12-15T00:53:03 | 160,750,519 | 0 | 0 | NOASSERTION | 2018-12-07T00:43:43 | 2018-12-07T00:43:43 | null | UTF-8 | C | false | false | 538 | c | uv_mutex_init_recursive.c | // Copyright (c) 2017 Nuxi, https://nuxi.nl/
//
// SPDX-License-Identifier: BSD-2-Clause
#include <pthread.h>
#include <uv.h>
int uv_mutex_init_recursive(uv_mutex_t *handle) {
pthread_mutexattr_t attr;
int error = pthread_mutexattr_init(&attr);
if (error != 0)
return -error;
error = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
if (error != 0) {
pthread_mutexattr_destroy(&attr);
return -error;
}
error = pthread_mutex_init(handle, &attr);
pthread_mutexattr_destroy(&attr);
return -error;
}
|
0213c7e4791f16d922488d7e3a2994da2fedc128 | 51635684d03e47ebad12b8872ff469b83f36aa52 | /external/gcc-12.1.0/gcc/testsuite/g++.dg/overload/ref-conv1.C | 1c525fbc7822bcf86df68fc93cb3516ceffc9e56 | [
"LGPL-2.1-only",
"FSFAP",
"LGPL-3.0-only",
"GPL-3.0-only",
"GPL-2.0-only",
"GCC-exception-3.1",
"LGPL-2.0-or-later",
"Zlib",
"LicenseRef-scancode-public-domain"
] | permissive | zhmu/ananas | 8fb48ddfe3582f85ff39184fc7a3c58725fe731a | 30850c1639f03bccbfb2f2b03361792cc8fae52e | refs/heads/master | 2022-06-25T10:44:46.256604 | 2022-06-12T17:04:40 | 2022-06-12T17:04:40 | 30,108,381 | 59 | 8 | Zlib | 2021-09-26T17:30:30 | 2015-01-31T09:44:33 | C | UTF-8 | C | false | false | 242 | c | ref-conv1.C | // PR c++/50442
// { dg-additional-options "-Wno-return-type" }
template <typename T> struct MoveRef { operator T& () {} };
template <typename T> MoveRef <T> Move(T&) {}
struct Thing {};
Thing foo(const Thing* p) { return Thing(Move(*p)); }
|
4532eced121b288fdffbbf947f47f2dcd8027840 | 987c34058d582d9f64eb4386e1eaca515d31ec82 | /0x03-more_functions_nested_loops/10-print_triangle.c | 24a430cbd53e69e69e38e3de7f6998fd926f702c | [] | no_license | GucciGerm/holbertonschool-low_level_programming | 44f0c7ba22752e7a097bf338c6899d260fdce09c | e69b3a515443816b0c77dfc608e8afab46103787 | refs/heads/master | 2021-03-19T16:20:52.638993 | 2018-08-10T17:10:23 | 2018-08-10T17:10:23 | 117,909,465 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 446 | c | 10-print_triangle.c | #include "holberton.h"
/**
* print_triangle - Function prints a triangle followed by a new line
* @size: Represents the size of the triangle
*
*/
void print_triangle(int size)
{
int a;
int b;
if (size > 0)
{
for (a = 1; a <= size; a++)
{
for (b = 0; b < size; b++)
{
if (b < size - a)
{
_putchar(' ');
}
else
{
_putchar('#');
}
}
_putchar('\n');
}
}
else
{
_putchar('\n');
}
}
|
47e39a23e4995b46b01d8fb6514edef3b3ea965b | d6e1d668d99a482922081c7f36002fbc538a7729 | /A3Q1/syntax.h | e44965e613c737d6e1e36faeccba133440678686 | [] | no_license | afuadhossain/Intro_Modular_Programming | e47ce1349acb14edcb80c1d17f5f2430f6e68332 | 8c7ba0d311ec2574d6c7f1cb91006cc6f9b0a7ff | refs/heads/master | 2021-05-05T01:52:08.822994 | 2016-04-30T22:36:57 | 2016-04-30T22:36:57 | 119,763,491 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 156 | h | syntax.h |
//these are all the functions from syntax.c that can be utilzed by other c files
int isValidCommand(char *token);
int isValidExpression(char *expression);
|
5636859c81b44071565bfb4127f30035017be3e6 | 405d5d6c4b0e89562d67d354689c20cfe0d10d9e | /WinRTInteropTools/streamHelpers.h | 9855bb5ad7a1ed41f5aa87549694a10ba5e987a8 | [
"MIT"
] | permissive | asdlei99/WinRTInteropTools | 7f8c7c86dcf6f29de57ca10b7bcd70882d26b3a6 | 0db9d30abb39669421977dbefbf8a684914d2f85 | refs/heads/master | 2023-07-13T23:35:03.211030 | 2021-08-23T07:17:45 | 2021-08-23T07:17:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 417 | h | streamHelpers.h | #pragma once
#include <shcore.h>
#include <windows.storage.streams.h>
inline auto CreateStreamOverRandomAccessStream(
winrt::Windows::Storage::Streams::IRandomAccessStream const& stream)
{
winrt::com_ptr<IStream> result;
auto unknown = stream.as<IUnknown>();
winrt::check_hresult(::CreateStreamOverRandomAccessStream(unknown.get(), winrt::guid_of<IStream>(), result.put_void()));
return result;
} |
ccee1842691901d4fd2186107bb603dc7e78df95 | 0598f42d187f67094f97a3dab94728ec2f088208 | /C/Testh/newton.h | 3b7a95a5f3b74b57070e972bae1b061aa69681d6 | [] | no_license | TanXze/HaiZei | 4ff8f7d667728644e53518c76344d48aecba3521 | 848a8d42e721d5166827acbdaec309d98b59f7f0 | refs/heads/master | 2020-03-28T18:20:19.267692 | 2019-01-21T11:36:02 | 2019-01-21T11:36:02 | 148,872,749 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 349 | h | newton.h | /*************************************************************************
> File Name: newton.h
> Author: Tanxiaoze
> Mail: [email protected]
> Created Time: 2018年10月07日 星期日 19时48分52秒
************************************************************************/
#ifndef _NEWTON_H
#define _NEWTON_H
double newton(double);
#endif
|
c1fa477c4e670ba96cf53290fe01ac06c9eb4663 | 06cc925a6a1aa30ab239b398705d23895aac9bd4 | /GPIO_driver/GPIO_interface.h | 2bb5c8fcf361e38a6c56ec1cef8c6b41e36d9a06 | [] | no_license | shaimaa-77/STM32_drivers | 9d34096fa91729d991e74074c733e3883be9a793 | 55eb7840de6a9b5c3aa69f26b73d91f3d76a63d2 | refs/heads/main | 2023-08-30T21:40:18.895025 | 2021-10-02T15:51:45 | 2021-10-02T15:51:45 | 310,468,421 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 2,844 | h | GPIO_interface.h | /****************************************************************************************/
/* Author : Shaimaa Mahmoud */
/* Date : 18/8/2020 */
/* version : v01 */
/****************************************************************************************/
#ifndef GPIO_INTERFACE_H
#define GPIO_INTERFACE_H
#define GPIO_HIEGH 1
#define GPIO_LOW 0
#define GPIOA 0
#define GPIOB 1
#define GPIOC 2
/*DEFINITIONS FOR PINS*/
#define PIN0 0
#define PIN1 1
#define PIN2 2
#define PIN3 3
#define PIN4 4
#define PIN5 5
#define PIN6 6
#define PIN7 7
#define PIN8 8
#define PIN9 9
#define PIN10 10
#define PIN11 11
#define PIN12 12
#define PIN13 13
#define PIN14 14
#define PIN15 15
/* modes of GPIO */
//IN INPUT MODE 00
#define INPUT_ANALOG 0b0000
#define INPUT_FLOATING 0b0100 //sensitive for hiegh &low
#define INPUT_PULL_UP_DOWN 0b1000 //it need anther config to be up or dwon
// IN OUTPUT MODE
#define OUTPUT_10MHZ_PUSH_PULL 0b0001
#define OUTPUT_10MHZ_OPEN_DRAIN 0b0101
#define OUTPUT_10MHZ_AF_PUSH_PULL 0b1001
#define INPUT_10MHZ_AF_PUSH_PULL 0b1101
#define OUTPUT_2MHZ_PUSH_PULL 0b0010
#define OUTPUT_2MHZ_OPEN_DRAIN 0b0110
#define OUTPUT_2MHZ_AF_PUSH_PULL 0b1010
#define INPUT_2MHZ_AF_PUSH_PULL 0b1110
#define OUTPUT_50MHZ_PUSH_PULL 0b0011
#define OUTPUT_50MHZ_OPEN_DRAIN 0b0111
#define OUTPUT_50MHZ_AF_PUSH_PULL 0b1011
#define INPUT_50MHZ_AF_PUSH_PULL 0b1111
/*PROTOTYPES FOR FUN USED*/
//FUN FOR SET DIRECTION OF THE PIN
void GPIO_voidSetPinDirection(u8 copy_u8PORT , u8 copy_u8PIN , u8 copy_u8Mode );
//FUN FOR SET VALUE OF THE PIIN
void GPIO_voidSetPinValue (u8 copy_u8PORT , u8 copy_u8PIN , u8 copy_u8Value);
// FUN FOR GET VALUE OF THE PIN
u8 GPIO_u8GetPinValue(u8 copy_u8PORT , u8 copy_u8PIN );
#endif
|
41017852ae7e7036cd36e2592fe2121e391d068a | fb3561e80f6d7d38458c58e5e0d208422a3a787f | /src/chainparamsseeds.h | 5fe267aff24204924da2eb81376f9d4d40fc32f9 | [
"MIT"
] | permissive | cryptoghass/sifcash | f375a0fab2323c15be6ee27c5614d5d1cc6d0e87 | 775954d5a61b9c876ca6c0ad90ad922a9e41250f | refs/heads/master | 2020-03-30T08:12:08.827899 | 2018-08-22T15:07:48 | 2018-08-22T15:07:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,450 | h | chainparamsseeds.h | #ifndef BITCOIN_CHAINPARAMSSEEDS_H
#define BITCOIN_CHAINPARAMSSEEDS_H
/**
* List of fixed seed nodes for the bitcoin network
* AUTOGENERATED by contrib/seeds/generate-seeds.py
*
* Each line contains a 16-byte IPv6 address and a port.
* IPv4 as well as onion addresses are wrapped inside a IPv6 address accordingly.
*/
// ***TODO*** fix generate-seeds.py and REGENERATE
static SeedSpec6 pnSeed6_main[] = {
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xad,0x00,0x9d,0xeb}, 14033},
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x2a,0x3e,0x1b}, 14033},
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0x6c,0xd9,0x50}, 14033},
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x67,0x17,0xd0,0xad}, 14033},
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x2a,0x3e,0x1c}, 14033}
};
static SeedSpec6 pnSeed6_test[] = {
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xad,0x00,0x9d,0xeb}, 24033},
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x2a,0x3e,0x1b}, 24033},
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0x6c,0xd9,0x50}, 24033},
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x67,0x17,0xd0,0xad}, 24033},
{{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x2a,0x3e,0x1c}, 24033}
};
#endif // BITCOIN_CHAINPARAMSSEEDS_H
|
426cc8680f715e069070b70e402f6ba53edb2594 | 280f5ac90d60c77f3f24b6c8803893e860d73937 | /lab 5/dzialka.c | 4e533b80f913598b4837393174336b70540bbfff | [] | no_license | mpyrek/PI | fe0dfb8d0b054663e5d14ca45d7617c4ad4931a6 | 8a12d6952f483d0454b186a07a45333322c0ff33 | refs/heads/main | 2023-08-02T08:05:16.859268 | 2021-09-24T18:41:34 | 2021-09-24T18:41:34 | 409,977,289 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,929 | c | dzialka.c | #include <stdio.h>
#include <stdlib.h>
int licz(int **T,int **S,int **G,int n){
for(int i=0;i<n;i++){
if(T[0][i]==0){
G[0][i]=1;
}
else{
G[0][i]=0;
}
}
for(int i=1;i<n;i++){
for(int j=0;j<n;j++){
if(T[i][j]==0){
G[i][j]=1+G[i-1][j];
}
else{
G[i][j]=0;
}
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
int k=j-1;
S[i][j]=G[i][j];
int minimum=G[i][j];
int z=0;
while(k>=0){
if(minimum<=G[i][k]){
z=minimum*(j-k+1);
}
else{
minimum=G[i][k];
z=minimum*(j-k+1);
}
if(S[i][j]<z){
S[i][j]=z;
}
k--;
}
}
}
int z=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(z<S[i][j]){
z=S[i][j];
}
}
}
printf("%d", z);
}
int main()
{
int n=0;
scanf("%d",&n);
int **T;
T=(int**)malloc(n*sizeof(int*));
for(int i=0;i<n;i++){
T[i]=(int*)malloc(n*sizeof(int));
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
scanf("%d",&T[i][j]);
}
}
int **G;
G=(int**)malloc(n*sizeof(int*));
for(int i=0;i<n;i++){
G[i]=(int*)malloc(n*sizeof(int));
}
int **S;
S=(int**)malloc(n*sizeof(int*));
for(int i=0;i<n;i++){
S[i]=(int*)malloc(n*sizeof(int));
}
licz(T,S,G,n);
for(int i=0;i<n;i++){
free(T[i]);
free(S[i]);
free(G[i]);
}
free(S);
free(T);
free(G);
}
|
1ed8bf13bac870fdc95f9cde3387ccb97449a25c | 4945846704933d53a67178523c691cc9b1ca63c2 | /libft/ft_strclr.c | 43adfea9344b5ccb12c34eaea05c5d6f7e09c370 | [] | no_license | mpotapov/fractol | 676339cfa3910f45271e58f7221b3ac1935f10bd | e2a885877395a97cd890eabc5b2af7c18d525cd3 | refs/heads/master | 2021-09-16T22:32:43.540960 | 2018-05-30T14:51:38 | 2018-05-30T14:51:38 | 107,035,047 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 982 | c | ft_strclr.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strclr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mpotapov <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/29 17:55:48 by mpotapov #+# #+# */
/* Updated: 2016/12/30 17:49:21 by mpotapov ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_strclr(char *s)
{
if (s != NULL)
while (*s)
*s++ = 0;
}
|
55bfb81efa1999fc0c7a138fb47a0f3b36edb739 | afafb6a0608c658b5b0b0e96f071c8539f0aee60 | /mydll/MyLib.h | 033bf8fc8d87c9a3844a621e0da486b5a47ad646 | [] | no_license | OlehKostiv/mydll | 7d69f9c7e6ba995665117703b20727951b30ecdc | 45f501649e6a565b3c1f8dbc83ad0d6c46a8eeed | refs/heads/master | 2021-09-07T16:56:16.194486 | 2018-02-26T12:07:33 | 2018-02-26T12:07:33 | 122,381,365 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 150 | h | MyLib.h | #pragma once
#ifndef MYLIBAPI
#define MYLIBAPI extern "C" __declspec(dllimport)
#endif
MYLIBAPI int g_result;
MYLIBAPI int Add(int nLeft, int nRight); |
9e74c9a92457d019b135360e21725fc80ec7070e | f82e4c16ed3dbb95b6753e25b477cb9f9c1d379d | /Bai3_1.c | 708e86b8000ad3b04b2e453440d9a3f677d6c5a1 | [] | no_license | sandl99/THDC | 78cb0f37e5f1d7600e891e7a02f523f2a4626ce6 | dcf8110fefe17bad1784c742fff8580c91f9b37b | refs/heads/master | 2021-10-09T04:37:00.145882 | 2018-12-21T07:54:56 | 2018-12-21T07:54:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 445 | c | Bai3_1.c | // Đặng Lâm San (20170111)
#include <stdio.h>
#include <conio.h>
#include <math.h>
double Abs(double x) {
if (x<0) return -x;
else return x;
}
int main() {
double x,y,z;
printf("Nhap vao 3 so thuc bat ky\n");
scanf("%lf %lf %lf", &x,&y,&z);
double F;
F = (x+y+z)/(x*x+y*y+1)-Abs(x-z*cos(y));
printf("Gia tri cua F =%lf",F);
printf("\nDANG LAM SAN 20170111");
getch();
return 0;
} |
0dfa8420cd3a47ccfb20926d56c22315bfb19db0 | 153c0ffa46ac87be61199a6f2d05ea8f30abd4f4 | /lib/gmfcore/gevent.c | a1e2ae0efb280611e2336ac69c2b674db35817ec | [] | no_license | gmobi-tian/iot-gmf | b8067217ee75447f1c88d82732f9bc1c93c13923 | 3666d9b002208f25865331d64526ac18b3064e31 | refs/heads/master | 2021-01-21T21:33:23.250887 | 2016-06-03T10:05:10 | 2016-06-03T10:05:10 | 47,596,570 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 2,656 | c | gevent.c | #include "include/gevent.h"
GEvent * g_event_new(gpointer sender)
{
GEvent * self = g_new(GEvent, 1);
self->sender = sender;
self->callback_list = NULL;
self->data_list = NULL;
self->event_firing = FALSE;
self->items_to_free = NULL;
return (GEvent *)self;
}
void g_event_free(GEvent * self)
{
if (self == NULL) return;
if (self->callback_list != NULL)
g_list_free(self->callback_list);
if (self->data_list != NULL)
g_list_free(self->data_list);
g_free(self);
}
void g_event_add_listener(GEvent * self, EVENT_CALLBACK callback, gpointer data)
{
GList *callback_list, *data_list;
g_return_if_fail(self != NULL);
callback_list = self->callback_list;
data_list = self->data_list;
for(; callback_list != NULL; callback_list = g_list_next(callback_list), data_list = g_list_next(data_list))
{
if (callback_list->data == (gpointer)callback && data_list->data == data) return;
}
self->callback_list = g_list_append(self->callback_list, (gpointer)callback);
self->data_list = g_list_append(self->data_list, data);
}
void g_event_remove_listener(GEvent * self, EVENT_CALLBACK callback, gpointer data)
{
GList *callback_list, *data_list;
g_return_if_fail(self != NULL);
callback_list = self->callback_list;
data_list = self->data_list;
for(; callback_list != NULL; callback_list = g_list_next(callback_list), data_list = g_list_next(data_list))
{
if (callback_list->data == (gpointer)callback && data_list->data == data)
{
self->callback_list = g_list_remove_link(self->callback_list, callback_list);
self->data_list = g_list_remove_link(self->data_list, data_list);
if (self->event_firing)
{
if (self->items_to_free == NULL) self->items_to_free = g_ptr_array_new();
g_ptr_array_add(self->items_to_free, callback_list);
g_ptr_array_add(self->items_to_free, data_list);
}
else
{
g_list_free_1(callback_list);
g_list_free_1(data_list);
}
break;
}
}
}
void g_event_fire(GEvent * self, gpointer args)
{
int i;
GList *callback_list, *data_list;
g_return_if_fail(self != NULL);
callback_list = self->callback_list;
data_list = self->data_list;
self->event_firing = TRUE;
for(; callback_list != NULL; callback_list = g_list_next(callback_list), data_list = g_list_next(data_list))
{
((EVENT_CALLBACK)callback_list->data)(self->sender, data_list->data, args);
}
self->event_firing = FALSE;
if (self->items_to_free != NULL && g_ptr_array_length(self->items_to_free) > 0)
{
for(i = 0; i < g_ptr_array_length(self->items_to_free); i++)
{
g_list_free_1((GList*)g_ptr_array_index(self->items_to_free, i));
}
g_ptr_array_set_size(self->items_to_free, 0);
}
}
|
2c46152f1f756de53a2675017404209e5c59d290 | 5ff4b6986e6799bc0e143e060bafc14369030d8b | /toolchain/riscv-isa-sim/riscv/insns/vwsub_wx.h | f72341ba8089e65f75d81736fd4140f0748d8ef6 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"GPL-1.0-or-later",
"LLVM-exception",
"Apache-2.0",
"BSD-3-Clause",
"LicenseRef-scancode-bsd-3-clause-jtag",
"GPL-3.0-or-later"
] | permissive | pulp-platform/mempool | 7583204b2436cfc12ed95599463e51ad4df51557 | c98fb3ada4f255623eaf9b09861f397a60c3d96b | refs/heads/main | 2023-08-08T09:07:56.696580 | 2023-07-27T17:24:38 | 2023-07-27T17:24:38 | 223,218,149 | 178 | 28 | Apache-2.0 | 2023-07-27T17:24:39 | 2019-11-21T16:34:37 | C | UTF-8 | C | false | false | 100 | h | vwsub_wx.h | // vwsub.wx vd, vs2, rs1
VI_CHECK_DDS(false);
VI_VX_LOOP_WIDEN
({
VI_WIDE_WVX_OP(rs1, -, int);
})
|
20a8234192e6db4083e771d342c6c30bf29cb25a | ee57eff47054b37673f06f94a00c4375597f3602 | /project/libraries/liblist/sources/item_next.c | b084f887f7795ee36034b0eae6113cc7195d4241 | [] | no_license | damiensauv/zappy | 2f69ac9ce650a34c9065ad8ca10224023a48fe32 | b0c7bf64b3adf0dac531087fbbce3e437cb17758 | refs/heads/master | 2021-01-18T08:58:39.680914 | 2014-07-13T13:29:33 | 2014-07-13T13:29:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 409 | c | item_next.c | /*
** item_next.c for liblist in /home/raphy/Epitech/Libraries/liblist/sources
**
** Made by raphael defreitas
** Login <[email protected]>
**
** Started on Thu Apr 17 19:22:53 2014 raphael defreitas
** Last update Sun Jun 29 06:25:59 2014 raphael defreitas
*/
#include <stdlib.h>
#include "list.h"
t_item *item_next(t_item *this)
{
if (this == NULL)
return (NULL);
return (this->next);
}
|
25d32b075c72aefc39cfbda785ebeaa66025846e | ab276b278dd84d1b5d2859b3093b6ed404fbd965 | /bg.h | 1bb8ec3993cbb1e463f9f935d92f5089e3e83526 | [] | no_license | hachemba/RoadToEarth | 8f0d9b9e5483e556b966eaaa569dae63bc697bd0 | 87dff0c98c5c742d1b99895e566697d3e17a6037 | refs/heads/master | 2022-10-17T16:33:33.583416 | 2020-06-11T14:07:47 | 2020-06-11T14:07:47 | 271,327,728 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 682 | h | bg.h |
/**
@file bg.c
@brief test du code du background
@date 06/06/2020
@version 1.0
@author amal
*/
#ifndef BG_H_INCLUDED
#define BG_H_INCLUDED
#include<stdio.h>
#include"SDL/SDL.h"
#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <stdbool.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_mixer.h>
typedef struct background
{
SDL_Surface *background;
SDL_Surface *background_tile;
//SDL_Rect camera;
SDL_Rect posbg;
}background;
void initialiser_background (background *b);
void afficher_background (SDL_Surface *screen,background b,SDL_Rect camera);
#endif // BG_H_INCLUDED
|
c088e91450937df730aa66ef016ce55d4d082b6b | 19a955385f0ce4e1530161c379e6bc8e14326482 | /da/odas_name_info.h | 085efc61c87c2b0eac588a0d149d6f944f6fd56d | [
"MIT"
] | permissive | awsdert/da | 4086b9eef09f4a9560cad6113f4539e6283e0e48 | 9e30e9f22a6e4bd7d9e9d5bc2eb1dcda229e951f | refs/heads/master | 2020-04-17T23:22:26.064833 | 2019-02-21T11:12:09 | 2019-02-21T11:12:09 | 167,032,491 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 173 | h | odas_name_info.h | #ifndef INC_ODAS_NAME_INFO
#define INC_ODAS_NAME_INFO
#include "odas.h"
#include "odas_ucs.h"
#ifndef DA_OS_MSWIN
struct odas_name_info {
odas_ucs_t Name;
};
#endif
#endif
|
20a69731093b1281dce2a6f60adae1cf2d564bde | 922f61dbfa70d4ad86ecc67bf715e0b70969c645 | /tree/tree.h | 54c57ac7808ea84dd50541f6811b93593ca2fef0 | [] | no_license | sumitvarude/DSA | 1b436c0b9c9292ea739955c340f4098abda2296c | 3309fcb3de83edce8c172c0bcd74d245056a96da | refs/heads/master | 2021-01-15T11:18:39.636065 | 2014-01-08T09:17:54 | 2014-01-08T09:17:54 | 14,852,755 | 0 | 1 | null | null | null | null | UTF-8 | C | false | false | 373 | h | tree.h | #include "../DLinked-list/iterator.h"
typedef int (*compareFunc)(void* first,void* second);
typedef struct {
void* root;
compareFunc compare;
} Tree;
Tree createTree(compareFunc compare);
int insertTreeNode(Tree* tree,void* parent,void* data);
int removeTreeNode(Tree *tree,void* data);
Iterator getChildren(Tree *tree,void* parent);
int search(void* tree,void* parent); |
dc9a9408ae891a97e280c462df328693be64f8e9 | d91ec0184f1c638ae3a28d0f7c6ac976d548ad67 | /src/v1/str.c | 742a6b95c8f403d8b5298567ded6b5b0ed6a28ff | [
"BSD-2-Clause"
] | permissive | riboseinc/retrace | cba06d1af0073f2630288263431f4918f373f3da | cccf46a001adaf006e5ce8c070d366966cbd4353 | refs/heads/main | 2022-03-06T04:34:27.418252 | 2022-02-09T18:18:58 | 2022-02-14T08:16:20 | 92,924,805 | 61 | 24 | NOASSERTION | 2022-02-17T14:52:55 | 2017-05-31T08:44:14 | C | UTF-8 | C | false | false | 11,063 | c | str.c | /*
* Copyright (c) 2017, [Ribose Inc](https://www.ribose.com).
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``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 COPYRIGHT
* OWNER OR CONTRIBUTORS 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.
*/
#include "common.h"
#include <string.h>
#include "str.h"
char *RETRACE_IMPLEMENTATION(strstr)(const char *s1, const char *s2)
{
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END};
void const *parameter_values[] = {&s1, &s2};
char *result = NULL;
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strstr";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_STRING;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strstr(s1, s2);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strstr, char *, (const char *s1, const char *s2), (s1, s2))
size_t RETRACE_IMPLEMENTATION(strlen)(const char *s)
{
size_t len;
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_END};
void const *parameter_values[] = {&s};
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strlen";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_INT;
event_info.return_value = &len;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
len = real_strlen(s);
retrace_log_and_redirect_after(&event_info);
return len;
}
RETRACE_REPLACE(strlen, size_t, (const char *s), (s))
int RETRACE_IMPLEMENTATION(strncmp)(const char *s1, const char *s2, size_t n)
{
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING_LEN, PARAMETER_TYPE_STRING_LEN, PARAMETER_TYPE_INT, PARAMETER_TYPE_END};
void const *parameter_values[] = {&n, &s1, &n, &s2, &n};
int result;
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strncmp";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_INT;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strncmp(s1, s2, n);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strncmp, int, (const char *s1, const char *s2, size_t n), (s1, s2, n))
int RETRACE_IMPLEMENTATION(strcmp)(const char *s1, const char *s2)
{
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END};
void const *parameter_values[] = {&s1, &s2};
int result;
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strcmp";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_INT;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strcmp(s1, s2);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strcmp, int, (const char *s1, const char *s2), (s1, s2))
char *RETRACE_IMPLEMENTATION(strncpy)(char *s1, const char *s2, size_t n)
{
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING_LEN, PARAMETER_TYPE_STRING_LEN, PARAMETER_TYPE_INT, PARAMETER_TYPE_END};
void const *parameter_values[] = {&n, &s1, &n, &s2, &n};
char *result = NULL;
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strncpy";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_STRING;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strncpy(s1, s2, n);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strncpy, char *, (char *s1, const char *s2, size_t n), (s1, s2, n))
char *RETRACE_IMPLEMENTATION(strcat)(char *s1, const char *s2)
{
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END};
void const *parameter_values[] = {&s1, &s2};
char *result = NULL;
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strcat";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_STRING;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strcat(s1, s2);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strcat, char *, (char *s1, const char *s2), (s1, s2))
char *RETRACE_IMPLEMENTATION(strncat)(char *s1, const char *s2, size_t n)
{
char *result = NULL;
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_INT, PARAMETER_TYPE_END};
void const *parameter_values[] = {&s1, &s2, &n};
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strncat";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_STRING;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strncat(s1, s2, n);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strncat, char *, (char *s1, const char *s2, size_t n), (s1, s2, n))
char *RETRACE_IMPLEMENTATION(strcpy)(char *s1, const char *s2)
{
char *result = NULL;
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END};
void const *parameter_values[] = {&s1, &s2};
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strcpy";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_STRING;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strcpy(s1, s2);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strcpy, char *, (char *s1, const char *s2), (s1, s2))
int RETRACE_IMPLEMENTATION(strcasecmp)(const char *s1, const char *s2)
{
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END};
void const *parameter_values[] = {&s1, &s2};
int ret;
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strcasecmp";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_INT;
event_info.return_value = &ret;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
ret = real_strcasecmp(s1, s2);
retrace_log_and_redirect_after(&event_info);
return (ret);
}
RETRACE_REPLACE(strcasecmp, int, (const char *s1, const char *s2), (s1, s2))
char *RETRACE_IMPLEMENTATION(strchr)(const char *s, int c)
{
char *result = NULL;
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_CHAR, PARAMETER_TYPE_END};
void const *parameter_values[] = {&s, &c};
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strchr";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_STRING;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strchr(s, c);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strchr, char *, (const char *s, int c), (s, c))
char *RETRACE_IMPLEMENTATION(strtok)(char *str, const char *delim)
{
char *result = NULL;
struct rtr_event_info event_info;
unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END};
void const *parameter_values[] = {&str, &delim};
memset(&event_info, 0, sizeof(event_info));
event_info.function_name = "strtok";
event_info.function_group = RTR_FUNC_GRP_STR;
event_info.parameter_types = parameter_types;
event_info.parameter_values = (void **) parameter_values;
event_info.return_value_type = PARAMETER_TYPE_STRING;
event_info.return_value = &result;
event_info.logging_level = RTR_LOG_LEVEL_NOR;
retrace_log_and_redirect_before(&event_info);
result = real_strtok(str, delim);
retrace_log_and_redirect_after(&event_info);
return (result);
}
RETRACE_REPLACE(strtok, char *, (char *str, const char *delim), (str, delim))
|
fcf63812b18b33db2bd41a310449b6d2b67edb30 | cbec2fbe3dc9d16f140dd0de818dccb5a508733f | /examples/solv/solv.c | 6a5dab7360614e61aee241bc35fbaae4f76951fd | [
"LicenseRef-scancode-warranty-disclaimer",
"BSD-2-Clause"
] | permissive | jdieter/libsolv | 9f0f7e9a889ebf95c0a66055a35bb43481a14b06 | 2234584efcc601dcb9a780b13f503cf60707782e | refs/heads/master | 2020-03-18T20:02:09.946319 | 2018-10-08T11:24:57 | 2018-10-08T11:24:57 | 135,192,308 | 1 | 0 | null | 2018-05-28T17:46:15 | 2018-05-28T17:46:15 | null | UTF-8 | C | false | false | 26,456 | c | solv.c | /*
* Copyright (c) 2009-2015, SUSE LLC.
*
* This program is licensed under the BSD license, read LICENSE.BSD
* for further information
*/
/* solv, a little software installer demoing the sat solver library */
/* things it does:
* - understands globs for package names / dependencies
* - understands .arch suffix
* - installation of commandline packages
* - repository data caching
* - on demand loading of secondary repository data
* - gpg and checksum verification
* - file conflicts
* - deltarpm support
* - fastestmirror implementation
*
* things available in the library but missing from solv:
* - vendor policy loading
* - multi version handling
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/utsname.h>
#include "pool.h"
#include "poolarch.h"
#include "evr.h"
#include "selection.h"
#include "repo.h"
#include "solver.h"
#include "solverdebug.h"
#include "transaction.h"
#include "testcase.h"
#ifdef SUSE
#include "repo_autopattern.h"
#endif
#include "repoinfo.h"
#include "repoinfo_cache.h"
#include "repoinfo_download.h"
#if defined(ENABLE_RPMDB)
#include "fileprovides.h"
#include "fileconflicts.h"
#include "deltarpm.h"
#endif
#if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
#include "patchjobs.h"
#endif
void
setarch(Pool *pool)
{
struct utsname un;
if (uname(&un))
{
perror("uname");
exit(1);
}
pool_setarch(pool, un.machine);
}
int
yesno(const char *str, int other)
{
char inbuf[128], *ip;
for (;;)
{
printf("%s", str);
fflush(stdout);
*inbuf = 0;
if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
{
printf("Abort.\n");
exit(1);
}
while (*ip == ' ' || *ip == '\t')
ip++;
if (*ip == 'q')
{
printf("Abort.\n");
exit(1);
}
if (*ip == 'y' || *ip == 'n' || *ip == other)
return *ip == 'n' ? 0 : *ip;
}
}
#ifdef SUSE
static Id
nscallback(Pool *pool, void *data, Id name, Id evr)
{
#if 0
if (name == NAMESPACE_LANGUAGE)
{
if (!strcmp(pool_id2str(pool, evr), "ja"))
return 1;
if (!strcmp(pool_id2str(pool, evr), "de"))
return 1;
if (!strcmp(pool_id2str(pool, evr), "en"))
return 1;
if (!strcmp(pool_id2str(pool, evr), "en_US"))
return 1;
}
#endif
return 0;
}
#endif
#ifdef SUSE
static void
showdiskusagechanges(Transaction *trans)
{
DUChanges duc[4];
int i;
/* XXX: use mountpoints here */
memset(duc, 0, sizeof(duc));
duc[0].path = "/";
duc[1].path = "/usr/share/man";
duc[2].path = "/sbin";
duc[3].path = "/etc";
transaction_calc_duchanges(trans, duc, 4);
for (i = 0; i < 4; i++)
printf("duchanges %s: %d K %d inodes\n", duc[i].path, duc[i].kbytes, duc[i].files);
}
#endif
static Id
find_repo(const char *name, Pool *pool, struct repoinfo *repoinfos, int nrepoinfos)
{
const char *rp;
int i;
for (rp = name; *rp; rp++)
if (*rp <= '0' || *rp >= '9')
break;
if (!*rp)
{
/* repo specified by number */
int rnum = atoi(name);
for (i = 0; i < nrepoinfos; i++)
{
struct repoinfo *cinfo = repoinfos + i;
if (!cinfo->enabled || !cinfo->repo)
continue;
if (--rnum == 0)
return cinfo->repo->repoid;
}
}
else
{
/* repo specified by alias */
Repo *repo;
FOR_REPOS(i, repo)
{
if (!strcasecmp(name, repo->name))
return repo->repoid;
}
}
return 0;
}
#define MODE_LIST 0
#define MODE_INSTALL 1
#define MODE_ERASE 2
#define MODE_UPDATE 3
#define MODE_DISTUPGRADE 4
#define MODE_VERIFY 5
#define MODE_PATCH 6
#define MODE_INFO 7
#define MODE_REPOLIST 8
#define MODE_SEARCH 9
void
usage(int r)
{
fprintf(stderr, "Usage: solv COMMAND <select>\n");
fprintf(stderr, "\n");
fprintf(stderr, " dist-upgrade: replace installed packages with\n");
fprintf(stderr, " versions from the repositories\n");
fprintf(stderr, " erase: erase installed packages\n");
fprintf(stderr, " info: display package information\n");
fprintf(stderr, " install: install packages\n");
fprintf(stderr, " list: list packages\n");
fprintf(stderr, " repos: list enabled repositories\n");
fprintf(stderr, " search: search name/summary/description\n");
fprintf(stderr, " update: update installed packages\n");
fprintf(stderr, " verify: check dependencies of installed packages\n");
#if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
fprintf(stderr, " patch: install newest maintenance updates\n");
#endif
fprintf(stderr, "\n");
exit(r);
}
int
main(int argc, char **argv)
{
Pool *pool;
Repo *commandlinerepo = 0;
Id *commandlinepkgs = 0;
Id p;
struct repoinfo *repoinfos, installedrepoinfo;
int nrepoinfos = 0;
int mainmode = 0, mode = 0;
int i, newpkgs;
Queue job, checkq;
Solver *solv = 0;
Transaction *trans;
FILE **newpkgsfps;
Queue repofilter;
Queue kindfilter;
Queue archfilter;
int archfilter_src = 0;
int cleandeps = 0;
int forcebest = 0;
char *rootdir = 0;
char *keyname = 0;
int keyname_depstr = 0;
int keyname_alldeps = 0; /* dnf repoquesy --alldeps */
int debuglevel = 0;
int answer, acnt = 0;
char *testcase = 0;
argc--;
argv++;
while (argc && !strcmp(argv[0], "-d"))
{
debuglevel++;
argc--;
argv++;
}
if (!argv[0])
usage(1);
if (!strcmp(argv[0], "install") || !strcmp(argv[0], "in"))
{
mainmode = MODE_INSTALL;
mode = SOLVER_INSTALL;
}
#if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
else if (!strcmp(argv[0], "patch"))
{
mainmode = MODE_PATCH;
mode = SOLVER_INSTALL;
}
#endif
else if (!strcmp(argv[0], "erase") || !strcmp(argv[0], "rm"))
{
mainmode = MODE_ERASE;
mode = SOLVER_ERASE;
}
else if (!strcmp(argv[0], "list") || !strcmp(argv[0], "ls"))
{
mainmode = MODE_LIST;
mode = 0;
}
else if (!strcmp(argv[0], "info"))
{
mainmode = MODE_INFO;
mode = 0;
}
else if (!strcmp(argv[0], "search") || !strcmp(argv[0], "se"))
{
mainmode = MODE_SEARCH;
mode = 0;
}
else if (!strcmp(argv[0], "verify"))
{
mainmode = MODE_VERIFY;
mode = SOLVER_VERIFY;
}
else if (!strcmp(argv[0], "update") || !strcmp(argv[0], "up"))
{
mainmode = MODE_UPDATE;
mode = SOLVER_UPDATE;
}
else if (!strcmp(argv[0], "dist-upgrade") || !strcmp(argv[0], "dup"))
{
mainmode = MODE_DISTUPGRADE;
mode = SOLVER_DISTUPGRADE;
}
else if (!strcmp(argv[0], "repos") || !strcmp(argv[0], "repolist") || !strcmp(argv[0], "lr"))
{
mainmode = MODE_REPOLIST;
mode = 0;
}
else
usage(1);
for (;;)
{
if (argc > 2 && !strcmp(argv[1], "--root"))
{
rootdir = argv[2];
argc -= 2;
argv += 2;
}
else if (argc > 1 && !strcmp(argv[1], "--clean"))
{
cleandeps = 1;
argc--;
argv++;
}
else if (argc > 1 && !strcmp(argv[1], "--best"))
{
forcebest = 1;
argc--;
argv++;
}
else if (argc > 1 && !strcmp(argv[1], "--alldeps"))
{
keyname_alldeps = 1; /* dnf repoquesy --alldeps */
argc--;
argv++;
}
else if (argc > 1 && !strcmp(argv[1], "--depstr"))
{
keyname_depstr = 1; /* do literal matching instead of dep intersection */
argc--;
argv++;
}
else if (argc > 2 && !strcmp(argv[1], "--keyname"))
{
keyname = argv[2];
argc -= 2;
argv += 2;
}
else if (argc > 2 && !strcmp(argv[1], "--testcase"))
{
testcase = argv[2];
argc -= 2;
argv += 2;
}
else
break;
}
set_userhome();
pool = pool_create();
pool_set_rootdir(pool, rootdir);
#if 0
{
const char *langs[] = {"de_DE", "de", "en"};
pool_set_languages(pool, langs, sizeof(langs)/sizeof(*langs));
}
#endif
pool_setloadcallback(pool, load_stub, 0);
#ifdef SUSE
pool->nscallback = nscallback;
#endif
if (debuglevel)
pool_setdebuglevel(pool, debuglevel);
setarch(pool);
pool_set_flag(pool, POOL_FLAG_ADDFILEPROVIDESFILTERED, 1);
repoinfos = read_repoinfos(pool, &nrepoinfos);
sort_repoinfos(repoinfos, nrepoinfos);
if (mainmode == MODE_REPOLIST)
{
int j = 1;
for (i = 0; i < nrepoinfos; i++)
{
struct repoinfo *cinfo = repoinfos + i;
if (!cinfo->enabled)
continue;
printf("%d: %-20s %s (prio %d)\n", j++, cinfo->alias, cinfo->name, cinfo->priority);
}
exit(0);
}
memset(&installedrepoinfo, 0, sizeof(installedrepoinfo));
if (!read_installed_repo(&installedrepoinfo, pool))
exit(1);
read_repos(pool, repoinfos, nrepoinfos);
/* setup filters */
queue_init(&repofilter);
queue_init(&kindfilter);
queue_init(&archfilter);
while (argc > 1)
{
if (!strcmp(argv[1], "-i"))
{
queue_push2(&repofilter, SOLVER_SOLVABLE_REPO | SOLVER_SETREPO, pool->installed->repoid);
argc--;
argv++;
}
else if (argc > 2 && (!strcmp(argv[1], "-r") || !strcmp(argv[1], "--repo")))
{
Id repoid = find_repo(argv[2], pool, repoinfos, nrepoinfos);
if (!repoid)
{
fprintf(stderr, "%s: no such repo\n", argv[2]);
exit(1);
}
/* SETVENDOR is actually wrong but useful */
queue_push2(&repofilter, SOLVER_SOLVABLE_REPO | SOLVER_SETREPO | SOLVER_SETVENDOR, repoid);
argc -= 2;
argv += 2;
}
else if (argc > 2 && !strcmp(argv[1], "--arch"))
{
if (!strcmp(argv[2], "src") || !strcmp(argv[2], "nosrc"))
archfilter_src = 1;
queue_push2(&archfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, pool_str2id(pool, argv[2], 1), REL_ARCH, 1));
argc -= 2;
argv += 2;
}
else if (argc > 2 && (!strcmp(argv[1], "-t") || !strcmp(argv[1], "--type")))
{
const char *kind = argv[2];
if (!strcmp(kind, "srcpackage"))
{
/* hey! should use --arch! */
queue_push2(&archfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, ARCH_SRC, REL_ARCH, 1));
archfilter_src = 1;
argc -= 2;
argv += 2;
continue;
}
if (!strcmp(kind, "package"))
kind = "";
if (!strcmp(kind, "all"))
queue_push2(&kindfilter, SOLVER_SOLVABLE_ALL, 0);
else
queue_push2(&kindfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, pool_str2id(pool, kind, 1), REL_KIND, 1));
argc -= 2;
argv += 2;
}
else
break;
}
if (mainmode == MODE_SEARCH)
{
Queue sel, q;
Dataiterator di;
if (argc != 2)
usage(1);
pool_createwhatprovides(pool);
queue_init(&sel);
dataiterator_init(&di, pool, 0, 0, 0, argv[1], SEARCH_SUBSTRING|SEARCH_NOCASE);
dataiterator_set_keyname(&di, SOLVABLE_NAME);
dataiterator_set_search(&di, 0, 0);
while (dataiterator_step(&di))
queue_push2(&sel, SOLVER_SOLVABLE, di.solvid);
dataiterator_set_keyname(&di, SOLVABLE_SUMMARY);
dataiterator_set_search(&di, 0, 0);
while (dataiterator_step(&di))
queue_push2(&sel, SOLVER_SOLVABLE, di.solvid);
dataiterator_set_keyname(&di, SOLVABLE_DESCRIPTION);
dataiterator_set_search(&di, 0, 0);
while (dataiterator_step(&di))
queue_push2(&sel, SOLVER_SOLVABLE, di.solvid);
dataiterator_free(&di);
if (repofilter.count)
selection_filter(pool, &sel, &repofilter);
if (archfilter.count)
selection_filter(pool, &sel, &archfilter);
if (kindfilter.count)
selection_filter(pool, &sel, &kindfilter);
queue_init(&q);
selection_solvables(pool, &sel, &q);
queue_free(&sel);
for (i = 0; i < q.count; i++)
{
Solvable *s = pool_id2solvable(pool, q.elements[i]);
printf(" - %s [%s]: %s\n", pool_solvable2str(pool, s), s->repo->name, solvable_lookup_str(s, SOLVABLE_SUMMARY));
}
queue_free(&q);
exit(0);
}
/* process command line packages */
if (mainmode == MODE_LIST || mainmode == MODE_INFO || mainmode == MODE_INSTALL)
{
for (i = 1; i < argc; i++)
{
if (!is_cmdline_package((const char *)argv[i]))
continue;
if (access(argv[i], R_OK))
{
perror(argv[i]);
exit(1);
}
if (!commandlinepkgs)
commandlinepkgs = solv_calloc(argc, sizeof(Id));
if (!commandlinerepo)
commandlinerepo = repo_create(pool, "@commandline");
p = add_cmdline_package(commandlinerepo, (const char *)argv[i]);
if (!p)
{
fprintf(stderr, "could not add '%s'\n", argv[i]);
exit(1);
}
commandlinepkgs[i] = p;
}
if (commandlinerepo)
{
repo_internalize(commandlinerepo);
#ifdef SUSE
repo_add_autopattern(commandlinerepo, 0);
#endif
}
}
#if defined(ENABLE_RPMDB)
if (pool->disttype == DISTTYPE_RPM)
addfileprovides(pool);
#endif
pool_createwhatprovides(pool);
if (keyname)
keyname = solv_dupjoin("solvable:", keyname, 0);
queue_init(&job);
for (i = 1; i < argc; i++)
{
Queue job2;
int flags, rflags;
if (commandlinepkgs && commandlinepkgs[i])
{
queue_push2(&job, SOLVER_SOLVABLE, commandlinepkgs[i]);
continue;
}
queue_init(&job2);
flags = SELECTION_NAME|SELECTION_PROVIDES|SELECTION_GLOB;
flags |= SELECTION_CANON|SELECTION_DOTARCH|SELECTION_REL;
if (kindfilter.count)
flags |= SELECTION_SKIP_KIND;
if (mode == MODE_LIST || archfilter_src)
flags |= SELECTION_WITH_SOURCE;
if (argv[i][0] == '/')
flags |= SELECTION_FILELIST | (mode == MODE_ERASE ? SELECTION_INSTALLED_ONLY : 0);
if (keyname && keyname_depstr)
flags |= SELECTION_MATCH_DEPSTR;
if (!keyname || keyname_alldeps)
rflags = selection_make(pool, &job2, argv[i], flags);
else
rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0);
if (repofilter.count)
selection_filter(pool, &job2, &repofilter);
if (archfilter.count)
selection_filter(pool, &job2, &archfilter);
if (kindfilter.count)
selection_filter(pool, &job2, &kindfilter);
if (!job2.count)
{
flags |= SELECTION_NOCASE;
if (!keyname || keyname_alldeps)
rflags = selection_make(pool, &job2, argv[i], flags);
else
rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0);
if (repofilter.count)
selection_filter(pool, &job2, &repofilter);
if (archfilter.count)
selection_filter(pool, &job2, &archfilter);
if (kindfilter.count)
selection_filter(pool, &job2, &kindfilter);
if (job2.count)
printf("[ignoring case for '%s']\n", argv[i]);
}
if (!job2.count)
{
fprintf(stderr, "nothing matches '%s'\n", argv[i]);
exit(1);
}
if (rflags & SELECTION_FILELIST)
printf("[using file list match for '%s']\n", argv[i]);
if (rflags & SELECTION_PROVIDES)
printf("[using capability match for '%s']\n", argv[i]);
if (keyname && keyname_alldeps)
{
Queue q;
queue_init(&q);
selection_solvables(pool, &job2, &q);
selection_make_matchsolvablelist(pool, &job2, &q, 0, pool_str2id(pool, keyname, 1), 0);
queue_free(&q);
}
queue_insertn(&job, job.count, job2.count, job2.elements);
queue_free(&job2);
}
keyname = solv_free(keyname);
if (!job.count && (mainmode == MODE_UPDATE || mainmode == MODE_DISTUPGRADE || mainmode == MODE_VERIFY || repofilter.count || archfilter.count || kindfilter.count))
{
queue_push2(&job, SOLVER_SOLVABLE_ALL, 0);
if (repofilter.count)
selection_filter(pool, &job, &repofilter);
if (archfilter.count)
selection_filter(pool, &job, &archfilter);
if (kindfilter.count)
selection_filter(pool, &job, &kindfilter);
}
queue_free(&repofilter);
queue_free(&archfilter);
queue_free(&kindfilter);
if (!job.count && mainmode != MODE_PATCH)
{
printf("no package matched\n");
exit(1);
}
if (mainmode == MODE_LIST || mainmode == MODE_INFO)
{
/* list mode, no solver needed */
Queue q;
queue_init(&q);
for (i = 0; i < job.count; i += 2)
{
int j;
queue_empty(&q);
pool_job2solvables(pool, &q, job.elements[i], job.elements[i + 1]);
for (j = 0; j < q.count; j++)
{
Solvable *s = pool_id2solvable(pool, q.elements[j]);
if (mainmode == MODE_INFO)
{
const char *str;
printf("Name: %s\n", pool_solvable2str(pool, s));
printf("Repo: %s\n", s->repo->name);
printf("Summary: %s\n", solvable_lookup_str(s, SOLVABLE_SUMMARY));
str = solvable_lookup_str(s, SOLVABLE_URL);
if (str)
printf("Url: %s\n", str);
str = solvable_lookup_str(s, SOLVABLE_LICENSE);
if (str)
printf("License: %s\n", str);
printf("Description:\n%s\n", solvable_lookup_str(s, SOLVABLE_DESCRIPTION));
printf("\n");
}
else
{
#if 1
const char *sum = solvable_lookup_str_lang(s, SOLVABLE_SUMMARY, "de", 1);
#else
const char *sum = solvable_lookup_str_poollang(s, SOLVABLE_SUMMARY);
#endif
printf(" - %s [%s]\n", pool_solvable2str(pool, s), s->repo->name);
if (sum)
printf(" %s\n", sum);
}
}
}
queue_free(&q);
queue_free(&job);
pool_free(pool);
free_repoinfos(repoinfos, nrepoinfos);
solv_free(commandlinepkgs);
exit(0);
}
#if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
if (mainmode == MODE_PATCH)
add_patchjobs(pool, &job);
#endif
// add mode
for (i = 0; i < job.count; i += 2)
{
job.elements[i] |= mode;
if (mode == SOLVER_UPDATE && pool_isemptyupdatejob(pool, job.elements[i], job.elements[i + 1]))
job.elements[i] ^= SOLVER_UPDATE ^ SOLVER_INSTALL;
if (cleandeps)
job.elements[i] |= SOLVER_CLEANDEPS;
if (forcebest)
job.elements[i] |= SOLVER_FORCEBEST;
}
#if 0
// multiversion test
queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_PROVIDES, pool_str2id(pool, "multiversion(kernel)", 1));
#endif
#if 0
queue_push2(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1));
queue_push2(&job, SOLVER_ERASE|SOLVER_CLEANDEPS|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1));
#endif
rerunsolver:
solv = solver_create(pool);
solver_set_flag(solv, SOLVER_FLAG_SPLITPROVIDES, 1);
#if 0
solver_set_flag(solv, SOLVER_FLAG_IGNORE_RECOMMENDED, 1);
#endif
#if defined(FEDORA) || defined(MAGEIA)
solver_set_flag(solv, SOLVER_FLAG_ALLOW_VENDORCHANGE, 1);
#endif
if (mainmode == MODE_ERASE)
solver_set_flag(solv, SOLVER_FLAG_ALLOW_UNINSTALL, 1); /* don't nag */
solver_set_flag(solv, SOLVER_FLAG_BEST_OBEY_POLICY, 1);
for (;;)
{
Id problem, solution;
int pcnt, scnt;
pcnt = solver_solve(solv, &job);
if (testcase)
{
printf("Writing solver testcase:\n");
if (!testcase_write(solv, testcase, TESTCASE_RESULT_TRANSACTION | TESTCASE_RESULT_PROBLEMS, 0, 0))
printf("%s\n", pool_errstr(pool));
testcase = 0;
}
if (!pcnt)
break;
pcnt = solver_problem_count(solv);
printf("Found %d problems:\n", pcnt);
for (problem = 1; problem <= pcnt; problem++)
{
int take = 0;
printf("Problem %d/%d:\n", problem, pcnt);
solver_printprobleminfo(solv, problem);
printf("\n");
scnt = solver_solution_count(solv, problem);
for (solution = 1; solution <= scnt; solution++)
{
printf("Solution %d:\n", solution);
solver_printsolution(solv, problem, solution);
printf("\n");
}
for (;;)
{
char inbuf[128], *ip;
printf("Please choose a solution: ");
fflush(stdout);
*inbuf = 0;
if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
{
printf("Abort.\n");
exit(1);
}
while (*ip == ' ' || *ip == '\t')
ip++;
if (*ip >= '0' && *ip <= '9')
{
take = atoi(ip);
if (take >= 1 && take <= scnt)
break;
}
if (*ip == 's')
{
take = 0;
break;
}
if (*ip == 'q')
{
printf("Abort.\n");
exit(1);
}
}
if (!take)
continue;
solver_take_solution(solv, problem, take, &job);
}
}
trans = solver_create_transaction(solv);
if (!trans->steps.count)
{
printf("Nothing to do.\n");
transaction_free(trans);
solver_free(solv);
queue_free(&job);
pool_free(pool);
free_repoinfos(repoinfos, nrepoinfos);
solv_free(commandlinepkgs);
exit(1);
}
/* display transaction to the user and ask for confirmation */
printf("\n");
printf("Transaction summary:\n\n");
transaction_print(trans);
#if defined(SUSE)
showdiskusagechanges(trans);
#endif
printf("install size change: %d K\n", transaction_calc_installsizechange(trans));
printf("\n");
acnt = solver_alternatives_count(solv);
if (acnt)
{
if (acnt == 1)
printf("Have one alternative:\n");
else
printf("Have %d alternatives:\n", acnt);
for (i = 1; i <= acnt; i++)
{
Id id, from;
int atype = solver_get_alternative(solv, i, &id, &from, 0, 0, 0);
printf(" - %s\n", solver_alternative2str(solv, atype, id, from));
}
printf("\n");
answer = yesno("OK to continue (y/n/a)? ", 'a');
}
else
answer = yesno("OK to continue (y/n)? ", 0);
if (answer == 'a')
{
Queue choicesq;
Queue answerq;
Id id, from, chosen;
int j;
queue_init(&choicesq);
queue_init(&answerq);
for (i = 1; i <= acnt; i++)
{
int atype = solver_get_alternative(solv, i, &id, &from, &chosen, &choicesq, 0);
printf("\n%s\n", solver_alternative2str(solv, atype, id, from));
for (j = 0; j < choicesq.count; j++)
{
Id p = choicesq.elements[j];
if (p < 0)
p = -p;
queue_push(&answerq, p);
printf("%6d: %s\n", answerq.count, pool_solvid2str(pool, p));
}
}
queue_free(&choicesq);
printf("\n");
for (;;)
{
char inbuf[128], *ip;
int neg = 0;
printf("OK to continue (y/n), or number to change alternative: ");
fflush(stdout);
*inbuf = 0;
if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
{
printf("Abort.\n");
exit(1);
}
while (*ip == ' ' || *ip == '\t')
ip++;
if (*ip == '-' && ip[1] >= '0' && ip[1] <= '9')
{
neg = 1;
ip++;
}
if (*ip >= '0' && *ip <= '9')
{
int take = atoi(ip);
if (take > 0 && take <= answerq.count)
{
Id p = answerq.elements[take - 1];
queue_free(&answerq);
queue_push2(&job, (neg ? SOLVER_DISFAVOR : SOLVER_FAVOR) | SOLVER_SOLVABLE_NAME, pool->solvables[p].name);
solver_free(solv);
solv = 0;
goto rerunsolver;
break;
}
}
if (*ip == 'n' || *ip == 'y')
{
answer = *ip == 'n' ? 0 : *ip;
break;
}
}
queue_free(&answerq);
}
if (!answer)
{
printf("Abort.\n");
transaction_free(trans);
solver_free(solv);
queue_free(&job);
pool_free(pool);
free_repoinfos(repoinfos, nrepoinfos);
solv_free(commandlinepkgs);
exit(1);
}
/* download all new packages */
queue_init(&checkq);
newpkgs = transaction_installedresult(trans, &checkq);
newpkgsfps = 0;
if (newpkgs)
{
int downloadsize = 0;
for (i = 0; i < newpkgs; i++)
{
Solvable *s;
p = checkq.elements[i];
s = pool_id2solvable(pool, p);
downloadsize += solvable_lookup_sizek(s, SOLVABLE_DOWNLOADSIZE, 0);
}
printf("Downloading %d packages, %d K\n", newpkgs, downloadsize);
newpkgsfps = solv_calloc(newpkgs, sizeof(*newpkgsfps));
for (i = 0; i < newpkgs; i++)
{
const char *loc;
Solvable *s;
struct repoinfo *cinfo;
p = checkq.elements[i];
s = pool_id2solvable(pool, p);
if (s->repo == commandlinerepo)
{
loc = solvable_lookup_location(s, 0);
if (!loc)
continue;
if (!(newpkgsfps[i] = fopen(loc, "r")))
{
perror(loc);
exit(1);
}
putchar('.');
continue;
}
cinfo = s->repo->appdata;
if (!cinfo || cinfo->type == TYPE_INSTALLED)
{
printf("%s: no repository information\n", s->repo->name);
exit(1);
}
loc = solvable_lookup_location(s, 0);
if (!loc)
continue; /* pseudo package? */
#if defined(ENABLE_RPMDB)
if (pool->installed && pool->installed->nsolvables)
{
if ((newpkgsfps[i] = trydeltadownload(s, loc)) != 0)
{
putchar('d');
fflush(stdout);
continue; /* delta worked! */
}
}
#endif
if ((newpkgsfps[i] = downloadpackage(s, loc)) == 0)
{
printf("\n%s: %s not found in repository\n", s->repo->name, loc);
exit(1);
}
putchar('.');
fflush(stdout);
}
putchar('\n');
}
#if defined(ENABLE_RPMDB) && (defined(SUSE) || defined(FEDORA) || defined(MANDRIVA) || defined(MAGEIA))
/* check for file conflicts */
if (newpkgs)
{
Queue conflicts;
queue_init(&conflicts);
if (checkfileconflicts(pool, &checkq, newpkgs, newpkgsfps, &conflicts))
{
if (yesno("Re-run solver (y/n/q)? ", 0))
{
for (i = 0; i < newpkgs; i++)
if (newpkgsfps[i])
fclose(newpkgsfps[i]);
newpkgsfps = solv_free(newpkgsfps);
solver_free(solv);
solv = 0;
pool_add_fileconflicts_deps(pool, &conflicts);
queue_free(&conflicts);
goto rerunsolver;
}
}
queue_free(&conflicts);
}
#endif
/* and finally commit the transaction */
printf("Committing transaction:\n\n");
transaction_order(trans, 0);
for (i = 0; i < trans->steps.count; i++)
{
int j;
FILE *fp;
Id type;
p = trans->steps.elements[i];
type = transaction_type(trans, p, SOLVER_TRANSACTION_RPM_ONLY);
switch(type)
{
case SOLVER_TRANSACTION_ERASE:
printf("erase %s\n", pool_solvid2str(pool, p));
commit_transactionelement(pool, type, p, 0);
break;
case SOLVER_TRANSACTION_INSTALL:
case SOLVER_TRANSACTION_MULTIINSTALL:
printf("install %s\n", pool_solvid2str(pool, p));
for (j = 0; j < newpkgs; j++)
if (checkq.elements[j] == p)
break;
fp = j < newpkgs ? newpkgsfps[j] : 0;
if (!fp)
continue;
commit_transactionelement(pool, type, p, fp);
fclose(fp);
newpkgsfps[j] = 0;
break;
default:
break;
}
}
for (i = 0; i < newpkgs; i++)
if (newpkgsfps[i])
fclose(newpkgsfps[i]);
solv_free(newpkgsfps);
queue_free(&checkq);
transaction_free(trans);
solver_free(solv);
queue_free(&job);
pool_free(pool);
free_repoinfos(repoinfos, nrepoinfos);
solv_free(commandlinepkgs);
exit(0);
}
|
967cbbb57c98f8b6cd47a5a90d03d40c91a2633e | b6c008b671fa8e735c89fa7836ede44d498f9e75 | /TP_04_Canepa/Canepa_TP_04/getUTN.c | 5b3aa09a108b35640964a3ef8f5b28271d43fb2a | [] | no_license | sacanepa/tp_laboratorio_1 | d0a0028597358a1d3fe7f759f782a03aa449e412 | 8e3f4b77afe9765a96628523387551e47e4a83c2 | refs/heads/master | 2021-01-21T04:50:33.239061 | 2016-06-22T01:43:41 | 2016-06-22T01:43:41 | 54,387,083 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 6,925 | c | getUTN.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "getUTN.h"
/** \brief desplega menu y solicita una opcion
* \param item Es el texto desplegado en el menu
* \return devuelve un entero que representa la opción elegida
*
*/
int menu (char* item)
{
int choice; //Almacena la opción del menú elegida por el usuario
printf(item);
printf("\n\nSeleccione una opci%cn: ", 162);
scanf("%d",&choice);
return choice;
}
/**
* \brief Solicita un número al usuario y lo valida
* \param input Se carga el numero ingresado
* \param message Es el mensaje a ser mostrado
* \param eMessage Es el mensaje a ser mostrado en caso de error
* \param lowLimit Limite inferior a validar
* \param hiLimit Limite superior a validar
* \return Si obtuvo el numero [0] si no [-1]
*
*/
int getInt(int* input,char message[],char eMessage[], int lowLimit, int hiLimit)
{
int i=0;
do
{
if (i!=0)
{
printf("%s",eMessage);
if (validaS_N() == 1 && i<3)
{
printf("%s",message);
scanf("%d",input);
} else
{
return -1;
}
} else
{
printf("%s",message);
scanf("%d",input);
}
i++;
} while (*input < lowLimit || *input > hiLimit);
//*input = 44;
return 0;
}
/**
* \brief Solicita un número al usuario y lo valida
* \param input Se carga el numero ingresado
* \param message Es el mensaje a ser mostrado
* \param eMessage Es el mensaje a ser mostrado en caso de error
* \param lowLimit Limite inferior a validar
* \param hiLimit Limite superior a validar
* \return Si obtuvo el numero [0] si no [-1]
*
*/
int getDate(long int* pDate,char message[])
{
int wDay, wMonth, wYear;
if (getInt(&wDay,"Ingrese el dia (DD): ","Error. Formato DD.", 01, 31) == 0)
{
if (getInt(&wMonth,"Ingrese el mes (MM): ","Error. Formato MM.", 01, 12) == 0)
{
if (getInt(&wYear,"Ingrese el dia (YYYY): ","Error. Formato YYYY.", 1900, 2999) == 0)
{
*pDate = (long)wDay + ((long)wMonth * 100) + ((long)wYear * 10000);
return 0;
}else {
return -1;
}
}else {
return -1;
}
}else {
return -1;
}
return -1;
}
/**
* \brief Solicita un número al usuario y lo valida
* \param input Se carga el numero ingresado
* \param message Es el mensaje a ser mostrado
* \param eMessage Es el mensaje a ser mostrado en caso de error
* \param lowLimit Limite inferior a validar
* \param hiLimit Limite superior a validar
* \return Si obtuvo el numero [0] si no [-1]
*
*/
int getLongInt(long int* input,char message[],char eMessage[],long int lowLimit,long int hiLimit)
{
/* int i=0;
do
{
if (i!=0)
{
printf("%s",eMessage);
if (validaS_N() == 1 && i<3)
{
printf("%s",message);
scanf("%ld",input);
} else
{
return -1;
}
} else
{
printf("%s",message);
scanf("%ld",input);
}
i++;
} while (*input < lowLimit || *input > hiLimit);
*/
//*input = 44;
return 0;
}
/**
* \brief Solicita un número al usuario y lo valida
* \param input Se carga el numero ingresado
* \param message Es el mensaje a ser mostrado
* \param eMessage Es el mensaje a ser mostrado en caso de error
* \param lowLimit Limite inferior a validar
* \param hiLimit Limite superior a validar
* \return Si obtuvo el numero [0] si no [-1]
*
*/
int getFloat(float* input,char message[],char eMessage[], float lowLimit, float hiLimit)
{
int i=0;
do
{
if (i!=0)
{
printf("%s",eMessage);
if (validaS_N() == 1 && i<3)
{
printf("%s",message);
scanf("%f",input);
} else
{
return -1;
}
} else
{
printf("%s",message);
scanf("%f",input);
}
i++;
} while (*input < lowLimit || *input > hiLimit);
//*input = 1234.88;
return 0;
}
/**
* \brief Solicita un número al usuario y lo valida
* \param input Se carga el numero ingresado
* \param message Es el mensaje a ser mostrado
* \param eMessage Es el mensaje a ser mostrado en caso de error
* \param lowLimit Limite inferior a validar
* \param hiLimit Limite superior a validar
* \return Si obtuvo el numero [0] si no [-1]
*
*/
int getAvg(float* input1,float* input2,float *solution)
{
*solution = *input1 / *input2;
return 0;
}
/**
* \brief Solicita una cadena de caracteres al usuario y la valida
* \param input Se carga el string ingresado
* \param message Es el mensaje a ser mostrado
* \param eMessage Es el mensaje a ser mostrado en caso de error
* \param lowLimit Longitud mÃnima de la cadena
* \param hiLimit Longitud máxima de la cadena
* \return Si obtuvo la cadena [0] si no [-1]
*
*/
int getString(char* input,char message[],char eMessage[], int lowLimit, int hiLimit)
{
int i=0;
char buffer[1024];
int nbrChar;
do
{
if (i!=0)
{
printf("%s",eMessage);
if (validaS_N() == 1 && i<3)
{
printf("%s",message);
fflush(stdin);
gets(buffer);
nbrChar=strlen(buffer);
} else
{
return -1;
}
} else
{
printf("%s",message);
fflush(stdin);
gets(buffer);
nbrChar=strlen(buffer);
}
i++;
} while (nbrChar < lowLimit || nbrChar > hiLimit);
strcpy(input,buffer);
return 0;
}
int validaS_N(void)
{
char respuesta;
int i;
printf("Ingresa de nuevo? S/N?");
fflush(stdin);
scanf("%c", &respuesta);
respuesta = toupper(respuesta);
i=0;
while(respuesta != 'S' && respuesta != 'N' && i<3){
printf("ERROR REINGRESE, Continua S/N?");
fflush(stdin);
scanf("%c", &respuesta);
respuesta = toupper(respuesta);
i++;
}
if(respuesta == 'S'){
return 1;
}
else{
return 0;
}
}
int validaDecision(char message[])
{
char respuesta;
int i;
printf("%s",message);
fflush(stdin);
scanf("%c", &respuesta);
respuesta = toupper(respuesta);
i=0;
while(respuesta != 'S' && respuesta != 'N' && i<3){
printf("ERROR REINGRESE, Continua S/N?");
fflush(stdin);
scanf("%c", &respuesta);
respuesta = toupper(respuesta);
i++;
}
if(respuesta == 'S'){
return 0;
}
else{
return -1;
}
}
|
548c340df12472810094a9646a14d4b881b0620c | 8553ff106e88fb5c263664b4337984530a4c479b | /LCS.c | 1f4dfd63105c943263309a1402b1626c0fed628d | [] | no_license | kartikmanaguli/DataStructureAndAlgorithms | d53e87d57bd33f4a27e83e2034f1f491afcc7a4b | e87a3098b546535935d44c6ffe2d4b6875e936e7 | refs/heads/master | 2021-08-16T01:39:40.267303 | 2021-07-23T11:15:39 | 2021-07-23T11:15:39 | 246,648,388 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,289 | c | LCS.c | /* --------------------------------------------------------------------------------------------------------------------------
THE LONGEST COMMON SUBSEQUENT ALGORITM (MEMORY EFFICIENT) USING DYNAMIC PROGRAMMING APPROACH (BOTTOM-UP APPROACH)
AUTHOR : KARTIK MANGULI, SOFTWARE DEVELOPER WIPRO LTD.
-------------------------------------------------------------------------------------------------------------------------*/
#include<stdio.h>
#include<stdlib.h>
int max(int variable1, int variable2) { return (variable1<variable2?variable2:variable1);}
void main()
{
char *x,*y;
int **c;
int n,m,i,j;
printf("Enter The Size Of String A\n");
scanf("%d",&n);
x=(char*) malloc(n*sizeof(char));
printf("Enter The String A:\n");
scanf("%s",x);
printf("Enter The Size Of String B\n");
scanf("%d",&m);
y=(char*) malloc(m*sizeof(char));
printf("Enter The String B\n");
scanf("%s",y);
m++,n++;
c = (int **)malloc(m*sizeof(int*));
c[0] = (int *) malloc(m*n*sizeof(int)) ;
for(i=0;i<=m;i++)
c[i]=c[0]+i*n;
for(i=1;i<m;i++)
{
for(j=1;j<n;j++)
{
if(y[i-1]==x[j-1])
c[i][j] = 1+c[i-1][j-1];
else
c[i][j]=max(c[i-1][j],c[i][j-1]);
}
}
printf("The Longest Common Sub Sequence is :%d",c[m-1][n-1]);
}
|
27195c836d8d41316fb058ab60878a5b71b5014f | 08875e634d7f8c704f32a9e11c8ed99a3f7849c9 | /include/md.h | 1c63fc865710689e74c1dada6d8afd4f2a54a093 | [] | no_license | Hypo-Li/glToy | 8de93f0fd6e13ac4a15a267ec637f08d967f0389 | fbbd4a5fc7ea7eddcd015c9a7fbe827f79fb2764 | refs/heads/master | 2022-11-30T20:08:46.880085 | 2020-08-14T12:44:19 | 2020-08-14T12:44:19 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C | false | false | 2,764 | h | md.h | #pragma once
#include <glm/glm.hpp>
#include <typedef.h>
enum TextureType
{
TEXTURE_TYPE_AMBIENT = 0x0,
TEXTURE_TYPE_DIFFUSE = 0x1,
TEXTURE_TYPE_SPECULAR = 0x2,
TEXTURE_TYPE_NORMALS = 0x3,
TEXTURE_TYPE_HEIGHT = 0x4,
};
const DWORD BONE_NUM_PER_VERTEX = 4;
const DWORD STATIC_MESH_SIZE = 24;
const DWORD VERTEX_SIZE = 56;
const DWORD WEIGHT_VERTEX_SIZE = VERTEX_SIZE + 8 * BONE_NUM_PER_VERTEX;
const DWORD FACE_SIZE = 12;
const DWORD TEXTURE_SIZE = 8;
const DWORD ANIM_MESH_SIZE = 32;
const DWORD BONE_SIZE = 76;
const DWORD WEIGHT_SIZE = 8;
const DWORD BONE_NODE_SIZE = 16;
const DWORD ANIM_SIZE = 16;
const DWORD BONE_ANIM_SIZE = 28;
const DWORD POS_FRAME_SIZE = 16;
const DWORD ROT_FRAME_SIZE = 20;
const DWORD SCA_FRAME_SIZE = 16;
/*
typedef struct Vertex
{
glm::vec3 position;
glm::vec3 normals;
glm::vec3 tangent;
glm::vec3 bitangent;
glm::vec2 texCoords;
}Vertex; //56byte
typedef struct WeightVertex
{
glm::vec3 position;
glm::vec3 normals;
glm::vec3 tangent;
glm::vec3 bitangent;
glm::vec2 texCoords;
DWORD bone[];
float weight[];
}WeightVertex;
typedef struct Face
{
DWORD indexes[3];
}Face; //12byte
enum TextureType
{
TEXTURE_TYPE_AMBIENT = 0x0,
TEXTURE_TYPE_DIFFUSE = 0x1,
TEXTURE_TYPE_SPECULAR = 0x2,
TEXTURE_TYPE_NORMALS = 0x3,
TEXTURE_TYPE_HEIGHT = 0x4,
};
typedef struct Texture
{
TextureType type;
DWORD offset;
}Texture; //8byte
typedef struct StaticMesh
{
DWORD numVertex;
DWORD vertexOffset;
DWORD numFace;
DWORD faceOffset;
DWORD numTexture;
DWORD textureOffset;
}StaticMesh; //24byte
typedef struct Bone
{
DWORD id;
DWORD numWeight;
DWORD weightOffset;
glm::mat4 offsetMat;
}Bone; //76byte
typedef struct Weight
{
DWORD indexes;
float weight;
}Weight; //8byte
typedef struct AnimMesh
{
DWORD numVertex;
DWORD vertexOffset;
DWORD numFace;
DWORD faceOffset;
DWORD numTexture;
DWORD textureOffset;
DWORD numBone;
DWORD boneOffset;
}AnimMesh; //32byte
typedef struct BoneNode
{
DWORD id;
DWORD parentNodeID;
DWORD numChildren;
DWORD childrenNodeID;
}BoneNode; //16byte
typedef struct Anim
{
DWORD fps;
DWORD numFrame;
DWORD numBoneAnim;
DWORD boneAnimOffset;
}Anim; //16byte
typedef struct BoneAnim
{
DWORD id;
DWORD numPositionKeyFrame;
DWORD PositionKeyFrameOffset;
DWORD numRotationKeyFrame;
DWORD RotationKeyFrameOffset;
DWORD numScalingKeyFrame;
DWORD ScalingKeyFrameOffset;
}BoneAnim; //28byte
typedef struct PositionKeyFrame
{
DWORD timeStamp;
glm::vec3 position;
}PositionKeyFrame; //16byte
typedef struct RotationKeyFrame
{
DWORD timeStamp;
glm::vec4 rotation; //ËÄÔªÊý
}RotationKeyFrame; //20byte
typedef struct ScalingKeyFrame
{
DWORD timeStamp;
glm::vec3 scaling;
}ScalingKeyFrame; //16byte
*/
|
97e389021a5526b2ea985503f52f09e2b27c3e15 | 440a7caaf14c75c3a2bd3f8337fc3ade4bca4da8 | /TP 3/1.minimum.c | e8722c89b4fcd10968c3aebc4a9f4d04f94a2df8 | [] | no_license | ly-hourt/TP | c284a260619f17eba3b60db188ff7795c9b16b2f | ba9bad538f788db49973471a013922f3974c6170 | refs/heads/master | 2022-07-05T13:32:56.700931 | 2020-05-15T17:42:23 | 2020-05-15T17:42:23 | 264,257,804 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,344 | c | 1.minimum.c | #include<stdio.h>
int main()
{
int num1 ,num2 ,num3,num4,num5,num6,num7;
printf("Enter your the 7 numbers : ");
scanf("%d%d%d%d%d%d%d",&num1 ,&num2 ,&num3,&num4,&num5,&num6,&num7);
if(num1<num2&&num1<num3&&num1<num4&&num1<num5&&num1<num6&&num1<num7)
{
printf("The biggest number is : %d.",num1);
}
else if(num2<num1&&num2<num3&&num2<num4&&num2<num5&&num2<num6&&num2<num7)
{
printf("The biggest number is : %d.",num2);
}
else if(num3<num1&&num3<num2&&num4<num4&&num3<num5&&num3<num6&&num3<num7)
{
printf("The biggest number is : %d.",num3);
}
else if(num4<num1&&num4<num3&&num4<num2&&num4<num5&&num4<num6&&num4<num7)
{
printf("The biggest number is : %d.",num4);
}
else if(num5<num1&&num5<num3&&num5<num4&&num5<num2&&num5<num6&&num5<num7)
{
printf("The biggest number is : %d.",num5);
}
else if(num6<num1&&num6<num3&&num6<num4&&num6<num5&&num6<num2&&num6<num7)
{
printf("The biggest number is : %d.",num6);
}
else if(num7<num1&&num7<num3&&num7<num4&&num7<num5&&num7<num6&&num7<num2)
{
printf("The biggest number is : %d.",num7);
}
else
{
printf("The input : %d %d %d %d %d %d %d is error ",num1 ,num2 ,num3,num4,num5,num6,num7);
}
}
|
b357d303078754dc2e017c99e86f2ba1392a5e53 | bbf3855ea8fcd83922c70b6a9234e0c3125c497e | /src/fifo.c | 8e842e195c47be4d661e90efe133b4b360d1851e | [] | no_license | N3U2O/CFIFO | 8dc2e768b813db08803701f287e49890d19b3829 | bc468e39f52a8c71a7f5fa5005022b4fc2865d1e | refs/heads/master | 2021-01-18T15:21:40.231662 | 2015-10-14T19:04:46 | 2015-10-14T19:04:46 | 24,559,743 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 7,842 | c | fifo.c | //- --------------------------------------------------------------------------
//! \file fifo.c
//! \brief A FIFO implementation using circular buffer with stored last
//! operation. The main file tests the functionality of the FIFO.
//! \author Adrian Gugyin
//! \date 28/09/2014
//- --------------------------------------------------------------------------
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
// Turn on debug messages
#define _DEBUG_
// Version (VERMAJOR.VERMINOR[.BUILD_ID])
#define VERMAJOR 0
#define VERMINOR 1
#define BUILD 1
// Macro contants
#define NFIFOCAP 4
#define NITEMS 6
#define NNAMESIZE 20
//- --------------------------------------------------------------------------
//! \brief FIFO entry structure definiton
//- --------------------------------------------------------------------------
struct FifoEntry
{
uint8_t ID;
char Name [NNAMESIZE];
clock_t TimeStamp;
};
// FIFO entry typedef
typedef struct FifoEntry FifoEntry_t;
//- --------------------------------------------------------------------------
//! \brief FIFO structure definiton
//- --------------------------------------------------------------------------
struct Fifo
{
FifoEntry_t data [NFIFOCAP]; // statically allocated array for entries
FifoEntry_t *pRd; // read pointer
FifoEntry_t *pWr; // write pointer
bool fRd; // last operation, true if it was a read
};
// FIFO typedef
typedef struct Fifo Fifo_t;
// Global function prototypes
bool FifoInit(Fifo_t *pFifo);
bool FifoPut(Fifo_t *pFifo, FifoEntry_t item);
bool FifoGet(Fifo_t *pFifo, FifoEntry_t *pItem);
bool testFIFO(void);
#ifdef _DEBUG_
// For debug purposes, compile the file "dump.c" for a hexadecimal dump
// to list the contents of \c length bytes of memory starting from address
// \c addr with an optional constant string description \c desc
extern void hexDump(const char* desc, void* addr, uint32_t length);
#endif
//= ==========================================================================
//!
//! MAIN
//!
//= ==========================================================================
int main(void)
{
printf("FIFO demo v%d.%d\n"
"==============\n\n", VERMAJOR, VERMINOR);
testFIFO();
return 0;
}
//= ==========================================================================
//!
//! END OF MAIN
//!
//= ==========================================================================
// Main test function for the FIFO
bool testFIFO(void)
{
uint8_t idx; // run index for the loop to make entries
Fifo_t fifo; // the FIFO structure
clock_t tick0 = clock(); // reference time [CPU clocks] set here
FifoInit(&fifo); // initialize the FIFO
#ifdef _DEBUG_
printf("[DEBUG]: Size of FIFO: %d\n\n", (uint32_t)sizeof(fifo));
#endif
for (idx = 0; idx < NITEMS; idx++)
{
uint8_t eIdx = idx + 1;
char eName [NNAMESIZE];
// We have to be careful when assigning names, that's why we use the
// function snprintf to put a formatted literal into the eName string.
snprintf(eName, NNAMESIZE-1, "( entry [%d] )", eIdx);
// Create a temporary FIFO entry item which we'll put into the FIFO
FifoEntry_t item;
// Set its members, starting with ID:
item.ID = eIdx;
// Name (using strncpy to safely assign strings to one another):
strncpy(item.Name, eName, sizeof(item.Name));
// and the TimeStamp [in CPU ticks elapsed since the reference time]:
item.TimeStamp = clock() - tick0;
#ifdef _DEBUG_
printf("[DEBUG]: timestamp for entry #(%d) is %f seconds.\n",
eIdx, ((float) item.TimeStamp)/CLOCKS_PER_SEC );
printf("[DEBUG]: entry #(%d) data: { %d, \"%s\", %d }\n",
eIdx, item.ID, item.Name, item.TimeStamp);
#endif
if (FifoPut(&fifo, item))
printf("FifoPut successful!\n");
else
printf("FifoPut unsuccessful, the FIFO is probably full.\n");
}
#ifdef _DEBUG_
#define NMSGLEN 40
{
char msg[NMSGLEN];
snprintf(msg, NMSGLEN-1, "[DEBUG]: FIFO (start address %08X) dump",
(uint64_t)&fifo);
hexDump(msg, &fifo, (uint32_t)sizeof(fifo));
}
#undef NMSGLEN
#endif
printf("\n");
// Get items from FIFO
for (idx = 0; idx < NITEMS; idx++)
{
FifoEntry_t e;
if (FifoGet(&fifo, &e))
printf("FifoGet successful! Got { %d, \"%s\", %d }\n",
e.ID, e.Name, e.TimeStamp);
else
printf("FifoGet unsuccessful, the FIFO is probably empty.\n");
}
}
//- --------------------------------------------------------------------------
//! \brief FIFO initialization
//! \desc Sets a default entry, then sets the read and write pointers to
//! match the inital address of the FIFO's circular buffer that is
//! at the beginning of the statically allocated arrays RAM location.
//! It order to start with an empty FIFO, the function sets the last
//! operation to "read" (fRd <- true).
//! \param [in]
//! pFifo : FIFO address
//! \return
//! Type : bool
//! Value : true, if initalization was successful
//- --------------------------------------------------------------------------
bool FifoInit(Fifo_t *pFifo)
{
FifoEntry_t defaultEntry = {0, "DEFAULT", clock()};
pFifo->pRd = pFifo->data;
pFifo->pWr = pFifo->data;
// Set last operation to "read" to indicate FIFO is empty.
pFifo->fRd = true;
return true;
}
//- --------------------------------------------------------------------------
//! \brief Put an entry to the FIFO end (pointed by pWr)
//! \param [in]
//! pFifo : FIFO address
//! item : FIFO entry item
//! \return
//! Type : bool
//! Value : true, if write was successful (ie. the FIFO wasn't full)
//- --------------------------------------------------------------------------
bool FifoPut(Fifo_t *pFifo, FifoEntry_t item)
{
// If the last operation wasn't a read and the read and write pointers
// coincide, the FIFO is full, we have to reject the 'put' request.
if (!pFifo->fRd && pFifo->pWr==pFifo->pRd) return false;
// Copy the item to the current write location and update the pointer
*pFifo->pWr++ = item;
pFifo->fRd = false; // update last operation
// If we've reached the end of the buffer, reset pWr to the start location.
if (pFifo->pWr >= pFifo->data + NFIFOCAP) pFifo->pWr = pFifo->data;
return true;
}
//- --------------------------------------------------------------------------
//! \brief Get an entry from the FIFO start (pointed by pRd)
//! \param [in]
//! pFifo : FIFO address
//! \param [out]
//! pItem : FIFO entry item
//! \return
//! Type : bool
//! Value : true, if read was successful (ie. the FIFO wasn't empty)
//- --------------------------------------------------------------------------
bool FifoGet(Fifo_t *pFifo, FifoEntry_t *pItem)
{
// If the last operation was a read and the read and write pointers
// coincide, the FIFO is empty, no item to get, so reject the request.
if (pFifo->fRd && pFifo->pWr==pFifo->pRd) return false;
// Copy the item from current read location and update the pointer
*pItem = *pFifo->pRd++;
pFifo->fRd = true; // update last operation
// If we've reached the end of the buffer, reset pRd to the start location.
if (pFifo->pRd >= pFifo->data + NFIFOCAP) pFifo->pRd = pFifo->data;
return true;
}
|
9894ee315425b883f9d4c4c08cac24894fcc65f9 | 1375cc7e1bd596fa6a449f58aa4dd4a9d718f240 | /netWorkSocketProgram/1thNetworkBook/6Chapters/server/server.c | e7d1d357734d4bdd525d88b562e1dc07fc1777ec | [] | no_license | Skin---yang/StudyCode | c09697ed654a793c7711d9af8f51ffb0396948e1 | 824e939141bed5599ae11794093f2cd19e8fe2eb | refs/heads/master | 2021-01-15T11:58:18.807729 | 2017-11-02T10:20:06 | 2017-11-02T10:20:06 | 99,637,276 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,284 | c | server.c | #include "../../comm/unp.h"
// this is a base sever
// this server use select deal with the client connect.
void ServerBase()
{
int sevSocket, i;
struct sockaddr_in serveraddr;
int transSocket, connSocket;
int nready, client[FD_SETSIZE];
fd_set reset, allset;
int maxfd, maxi;
char buf[MAXLINE];
bzero(buf, MAXLINE);
//create
sevSocket = socket(AF_INET, SOCK_STREAM, 0);
if(sevSocket < 0)
err_quit("sevSocket fail\n");
bzero(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
// if not use the htons function, the server will bind * port.
serveraddr.sin_port = htons(SERV_PORT);
// INADDR_ANY mean is 0.0.0.0 because a server can have multiple networks cards.
serveraddr.sin_addr.s_addr = INADDR_ANY;
if(bind(sevSocket, (const struct sockaddr*)&serveraddr, sizeof(serveraddr)) < 0)
err_quit("bind fail\n");
listen(sevSocket, LISTENQ);
maxfd = sevSocket;
maxi = -1; // the variable is mean client arrary maximum index.
// init
for(i = 0; i < FD_SETSIZE; ++i)
{
client[i] = -1;
}
FD_ZERO(&allset);
FD_SET(sevSocket, &allset);
while(1)
{
reset = allset;
nready = select(maxfd+1, &reset, NULL, NULL, NULL);
if(nready == -1)
err_quit("function select fail.\n");
if(FD_ISSET(sevSocket, &reset))
{
transSocket = accept(sevSocket, NULL, NULL);
if(nready == -1)
{
err_quit("function select fail.\n");
}
for(i = 0; i < FD_SETSIZE; ++i)
{
if(client[i] < 0)
{
client[i] = transSocket;
break;
}
}
if(i == FD_SETSIZE)
{
err_quit("not have enough descriptot");
}
FD_SET(transSocket, &allset);
if(i > maxi)
maxi = i;
// update the maximum
if(transSocket > maxfd)
maxfd = transSocket;
if(--nready <= 0)
continue;
}
// check all client for data
for(i = 0; i <= maxi; ++i)
{
if((connSocket = client[i]) < 0)
continue;
// clear the buf
bzero(buf, MAXLINE);
if(FD_ISSET(connSocket, &reset))
{
if(read(connSocket, buf, MAXLINE) == 0)
{
// close and clear the socket
close(connSocket);
FD_CLR(connSocket, &allset);
client[i] = -1;
}
else
{
char sendbuf[MAXLINE];
sprintf(sendbuf, "server: %s", buf);
//print the server data
puts(buf);
// answer the client.
write(connSocket, sendbuf, sizeof(buf));
}
// not have more socket
if(--nready <= 0)
break;
}
}
}
}
int main(int argc, char **argv)
{
ServerBase();
return 0;
}
|
58493daffd4692cd6b57ace892007b54a4844695 | 74a44e5174847a60c747428a9271a234954163a2 | /SquiLu-ext/sq_axtls.c | 67573d8801b2a068d60b72e2250c93d9e3edba4b | [] | no_license | mingodad/squilu | 8bc74484d0af7c5c5a66cb577e1feeebc9ce9774 | ef96bae1f0b226737367c3ad662de2526fd58a65 | refs/heads/master | 2022-12-10T06:56:55.251824 | 2022-12-08T17:31:36 | 2022-12-08T17:31:36 | 33,980,799 | 81 | 15 | null | null | null | null | UTF-8 | C | false | false | 15,349 | c | sq_axtls.c | #ifdef __cplusplus
extern "C" {
#endif
#ifdef USE_AXTLS
#include "squirrel.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h> /* for malloc */
#include <assert.h> /* for a few sanity tests */
#include "os_port.h"
#include "ssl.h"
#include "crypto.h"
static const SQChar SQ_LIBNAME[] = _SC("axtls");
static const SQChar ssl_ctx_NAME[] = _SC("ssl_ctx");
static const SQChar ssl_NAME[] = _SC("ssl");
SQ_OPT_STRING_STRLEN();
static const SQChar SSL_CTX_Tag[] = _SC("sq_axtls_ssl_ctx");
#define GET_ssl_ctx_INSTANCE() SQ_GET_INSTANCE(v, 1, SSL_CTX, SSL_CTX_Tag) \
if(self == NULL) return sq_throwerror(v, _SC("ssl_ctx object already closed"));
static const SQChar SSL_Tag[] = _SC("sq_axtls_ssl");
#define GET_ssl_INSTANCE() SQ_GET_INSTANCE(v, 1, SSL, SSL_Tag) \
if(self == NULL) return sq_throwerror(v, _SC("ssl object already closed"));
static SQRESULT ssl_release_hook(SQUserPointer p, SQInteger size, void *ep)
{
SSL *self = (SSL*)p;
if(self) ssl_free(self);
return 0;
}
static SQRESULT sq_ssl_free(HSQUIRRELVM v)
{
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
ssl_release_hook(self, 0, v);
sq_setinstanceup(v, 1, 0);
return 0;
}
static SQRESULT ssl_constructor(HSQUIRRELVM v, SSL *ssl, int free_on_gc)
{
if(!ssl)
return sq_throwerror(v, _SC("Could'nt create an ssl object."));
sq_pushstring(v, SQ_LIBNAME, -1);
if(sq_getonroottable(v) == SQ_OK){
sq_pushstring(v, ssl_NAME, -1);
if(sq_get(v, -2) == SQ_OK){
if(sq_createinstance(v, -1) == SQ_OK){
sq_setinstanceup(v, -1, ssl);
if(free_on_gc) sq_setreleasehook(v,-1, ssl_release_hook);
return 1;
}
}
}
return SQ_ERROR;
}
static SQRESULT sq_ssl_read(HSQUIRRELVM v){
SQ_FUNC_VARS(v);
GET_ssl_INSTANCE();
SQ_OPT_INTEGER(v, 2, count, 0);
uint8_t *in_data = NULL;
int result = ssl_read(self, &in_data, count);
if (result > SSL_OK) sq_pushstring(v, (const SQChar*)in_data, result);
else sq_pushinteger(v, result);
return 1;
}
static SQRESULT sq_ssl_write(HSQUIRRELVM v){
SQ_FUNC_VARS(v);
GET_ssl_INSTANCE();
SQ_GET_STRING(v, 2, out_data);
if(_top_ > 2) {
SQ_GET_INTEGER(v, 3, size);
if(size > out_data_size) return sq_throwerror(v, _SC("parameter 2 size bigger than data size"));
out_data_size = size;
}
sq_pushinteger(v, ssl_write(self, (const uint8_t *)out_data, out_data_size));
return 1;
}
static SQRESULT sq_ssl_get_session_id(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
const uint8_t * result = ssl_get_session_id(self);
sq_pushstring(v, (char *)result, ssl_get_session_id_size(self));
return 1;
}
static SQRESULT sq_ssl_get_session_id_size(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
uint8_t result = ssl_get_session_id_size(self);
sq_pushinteger(v, result);
return 1;
}
static SQRESULT sq_ssl_get_cipher_id(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
uint8_t result = ssl_get_cipher_id(self);
sq_pushinteger(v, result);
return 1;
}
static SQRESULT sq_ssl_handshake_status(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
int result = ssl_handshake_status(self);
sq_pushinteger(v, result);
return 1;
}
static SQRESULT sq_ssl_verify_cert(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
int result = ssl_verify_cert(self);
sq_pushinteger(v, result);
return 1;
}
static SQRESULT sq_ssl_get_cert_dn(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
SQ_GET_INTEGER(v, 2, component);
const char* result = ssl_get_cert_dn(self, component);
sq_pushstring(v, result, -1);
return 1;
}
static SQRESULT sq_ssl_get_cert_subject_alt_dnsname(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
SQ_GET_INTEGER(v, 2, dnsindex);
const char* result = ssl_get_cert_subject_alt_dnsname(self, dnsindex);
sq_pushstring(v, result, -1);
return 1;
}
static SQRESULT sq_ssl_renegotiate(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
int result = ssl_renegotiate(self);
sq_pushinteger(v, result);
return 1;
}
static SQRESULT sq_ssl_ctx_server_new(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_ctx_INSTANCE();
SQ_GET_INTEGER(v, 2, client_fd);
SSL *ssl = ssl_server_new(self, client_fd);
SQRESULT rc = ssl_constructor(v, ssl, 1);
if(rc == SQ_ERROR && ssl){
ssl_free(ssl);
}
return rc;
}
static SQRESULT sq_ssl_ctx_client_new(HSQUIRRELVM v){
SQ_FUNC_VARS(v);
GET_ssl_ctx_INSTANCE();
SQ_GET_INTEGER(v, 2, client_fd);
SQ_OPT_STRING(v, 3, session_id, NULL);
SQ_OPT_INTEGER(v, 4, size, -1);
SSL *ssl = ssl_client_new(self, client_fd, (const uint8_t *)session_id,
size >= 0 ? size : session_id_size, NULL);
SQRESULT rc = ssl_constructor(v, ssl, 1);
if(rc == SQ_ERROR && ssl){
ssl_free(ssl);
}
return rc;
}
static SQRESULT sq_ssl_ctx_find(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_ctx_INSTANCE();
SQ_GET_INTEGER(v, 2, client_fd);
SSL *ssl = ssl_find(self, client_fd);
if(ssl) return ssl_constructor(v, ssl, 0);
else sq_pushnull(v);
return 1;
}
static SQRESULT sq_ssl_ctx_obj_load(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_ctx_INSTANCE();
SQ_GET_INTEGER(v, 2, obj_type);
SQ_GET_STRING(v, 3, filename);
SQ_GET_STRING(v, 4, password);
int result = ssl_obj_load(self, obj_type, filename, password);
sq_pushinteger(v, result);
return 1;
}
static SQRESULT sq_ssl_ctx_obj_memory_load(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_ctx_INSTANCE();
SQ_GET_INTEGER(v, 2, obj_type);
SQ_GET_STRING(v, 3, data);
SQ_GET_STRING(v, 4, password);
int result = ssl_obj_memory_load(self, obj_type, (const uint8_t *)data, data_size, password);
sq_pushinteger(v, result);
return 1;
}
static SQRESULT sq_axtls_version(HSQUIRRELVM v){
sq_pushstring(v,(const char*)ssl_version(), -1);
return 1;
}
static SQRESULT sq_axtls_get_config(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
SQ_GET_INTEGER(v, 2, info);
sq_pushinteger(v, ssl_get_config(info));
return 1;
}
static SQRESULT sq_axtls_display_error(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
SQ_GET_INTEGER(v, 2, error);
ssl_display_error(error);
return 0;
}
static SQRESULT sq_axtls_get_error(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
SQ_GET_INTEGER(v, 2, error);
SQInteger buff_size = 250;
SQChar *buff = sq_getscratchpad(v, buff_size);
sq_pushstring(v, ssl_get_error(error, buff, buff_size), -1);
return 1;
}
static SQRESULT ssl_ctx_release_hook(SQUserPointer p, SQInteger size, void *ep)
{
SSL_CTX *self = (SSL_CTX*)p;
if(self) ssl_ctx_free(self);
return 0;
}
static SQRESULT sq_ssl_ctx_free(HSQUIRRELVM v)
{
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_ctx_INSTANCE();
ssl_ctx_release_hook(self, 0, v);
sq_setinstanceup(v, 1, 0);
return 0;
}
static SQRESULT sq_ssl_ctx_constructor(HSQUIRRELVM v)
{
SQInteger options, num_sessions;
sq_getinteger(v, 2, &options);
sq_getinteger(v, 3, &num_sessions);
SSL_CTX *ssl_ctx = ssl_ctx_new(options, num_sessions);
if(!ssl_ctx)
return sq_throwerror(v, _SC("Could'nt create an ssl context."));
sq_setinstanceup(v, 1, ssl_ctx);
sq_setreleasehook(v,1, ssl_ctx_release_hook);
return 1;
}
// Stringify binary data. Output buffer must be twice as big as input,
// because each byte takes 2 bytes in string representation
void sq_axtls_bin2str(char *to, const unsigned char *p, size_t len) {
static const char *hex = "0123456789abcdef";
for (; len--; p++) {
*to++ = hex[p[0] >> 4];
*to++ = hex[p[0] & 0x0f];
}
*to = '\0';
}
static SQRESULT sq_axtls_md5(HSQUIRRELVM v)
{
SQ_FUNC_VARS(v);
char buf[(MD5_SIZE*2)+1];
unsigned char hash[MD5_SIZE];
MD5_CTX ctx;
MD5_Init(&ctx);
for (int i = 2; i <= _top_; ++i) {
SQ_GET_STRING(v, i, p);
MD5_Update(&ctx, (const unsigned char *) p, p_size);
}
MD5_Final(hash, &ctx);
sq_axtls_bin2str(buf, hash, sizeof(hash));
sq_pushstring(v, buf, -1);
return 1;
}
static SQRESULT sq_axtls_sha1(HSQUIRRELVM v)
{
SQ_FUNC_VARS(v);
char buf[(SHA1_SIZE*2)+1];
unsigned char hash[SHA1_SIZE];
SHA1_CTX ctx;
SHA1_Init(&ctx);
for (int i = 2; i <= _top_; ++i) {
SQ_GET_STRING(v, i, p);
SHA1_Update(&ctx, (const unsigned char *) p, p_size);
}
SHA1_Final(hash, &ctx);
sq_axtls_bin2str(buf, hash, sizeof(hash));
sq_pushstring(v, buf, -1);
return 1;
}
static SQRESULT sq_axtls_sha256(HSQUIRRELVM v)
{
SQ_FUNC_VARS(v);
char buf[(SHA256_SIZE*2)+1];
unsigned char hash[SHA256_SIZE];
SHA256_CTX ctx;
SHA256_Init(&ctx);
for (int i = 2; i <= _top_; ++i) {
SQ_GET_STRING(v, i, p);
SHA256_Update(&ctx, (const unsigned char *) p, p_size);
}
SHA256_Final(hash, &ctx);
sq_axtls_bin2str(buf, hash, sizeof(hash));
sq_pushstring(v, buf, -1);
return 1;
}
static SQRESULT sq_axtls_rng_initialize(HSQUIRRELVM v)
{
RNG_initialize();
return 0;
}
static SQRESULT sq_axtls_rng_terminate(HSQUIRRELVM v)
{
RNG_terminate();
return 0;
}
typedef int (*get_random_fptr_t)(int, uint8_t*);
static SQRESULT sq_axtls_get_random0(HSQUIRRELVM v, get_random_fptr_t grf)
{
SQ_FUNC_VARS_NO_TOP(v);
SQ_GET_INTEGER(v, 2, length);
if(length < 1) return sq_throwerror(v, _SC("Minimun length error " _PRINT_INT_FMT), length);
if(!RNG_is_initialized()) return sq_throwerror(v, _SC("Need to call rng_initialize first"));
SQChar *buff = sq_getscratchpad(v, length);
(*grf)(length, buff);
sq_pushstring(v, buff, length);
return 1;
}
static SQRESULT sq_axtls_get_random(HSQUIRRELVM v)
{
return sq_axtls_get_random0(v, get_random);
}
static SQRESULT sq_axtls_get_random_nz(HSQUIRRELVM v)
{
return sq_axtls_get_random0(v, get_random_NZ);
}
#define _DECL_AXTLS_FUNC(name,nparams,pmask) {_SC(#name),sq_axtls_##name,nparams,pmask}
static SQRegFunction axtls_obj_funcs[]={
_DECL_AXTLS_FUNC(get_config,2,_SC(".i")),
_DECL_AXTLS_FUNC(display_error,2,_SC(".i")),
_DECL_AXTLS_FUNC(get_error,2,_SC(".i")),
_DECL_AXTLS_FUNC(version,1,_SC(".")),
_DECL_AXTLS_FUNC(md5,-2,_SC(".s")),
_DECL_AXTLS_FUNC(sha1,-2,_SC(".s")),
_DECL_AXTLS_FUNC(sha256,-2,_SC(".s")),
_DECL_AXTLS_FUNC(rng_initialize,1,_SC(".")),
_DECL_AXTLS_FUNC(rng_terminate,1,_SC(".")),
_DECL_AXTLS_FUNC(get_random,2,_SC(".i")),
_DECL_AXTLS_FUNC(get_random_nz,2,_SC(".i")),
{0,0}
};
#undef _DECL_AXTLS_FUNC
#define _DECL_SSL_CTX_FUNC(name,nparams,pmask) {_SC(#name),sq_ssl_ctx_##name,nparams,pmask}
static SQRegFunction ssl_ctx_obj_funcs[]={
_DECL_SSL_CTX_FUNC(constructor,3,_SC("xii")),
_DECL_SSL_CTX_FUNC(free,1,_SC("x")),
_DECL_SSL_CTX_FUNC(server_new,2,_SC("xi")),
_DECL_SSL_CTX_FUNC(client_new,-2,_SC("xisi")),
_DECL_SSL_CTX_FUNC(find,2,_SC("xs")),
_DECL_SSL_CTX_FUNC(obj_load,2,_SC("xs")),
_DECL_SSL_CTX_FUNC(obj_memory_load,2,_SC("xs")),
{0,0}
};
#undef _DECL_SSL_CTX_FUNC
#define _DECL_SSL_FUNC(name,nparams,pmask) {_SC(#name),sq_ssl_##name,nparams,pmask}
static SQRegFunction ssl_obj_funcs[]={
_DECL_SSL_FUNC(free,1,_SC("x")),
_DECL_SSL_FUNC(read,-1,_SC("xi")),
_DECL_SSL_FUNC(write,-2,_SC("xsi")),
_DECL_SSL_FUNC(get_session_id,1,_SC("x")),
_DECL_SSL_FUNC(get_session_id_size,1,_SC("x")),
_DECL_SSL_FUNC(get_cipher_id,1,_SC("x")),
_DECL_SSL_FUNC(handshake_status,1,_SC("x")),
_DECL_SSL_FUNC(verify_cert,1,_SC("x")),
_DECL_SSL_FUNC(get_cert_dn,2,_SC("xi")),
_DECL_SSL_FUNC(get_cert_subject_alt_dnsname,2,_SC("xi")),
_DECL_SSL_FUNC(renegotiate,1,_SC("x")),
{0,0}
};
#undef _DECL_SSL_FUNC
typedef struct {
const SQChar *Str;
SQInteger Val;
} KeyIntType, * KeyIntPtrType;
static KeyIntType axtls_constants[] = {
#define MK_CONST(c) {_SC(#c), c}
MK_CONST(SSL_SESSION_ID_SIZE),
MK_CONST(SSL_CLIENT_AUTHENTICATION),
MK_CONST(SSL_SERVER_VERIFY_LATER),
MK_CONST(SSL_NO_DEFAULT_KEY),
MK_CONST(SSL_DISPLAY_STATES),
MK_CONST(SSL_DISPLAY_BYTES),
MK_CONST(SSL_DISPLAY_CERTS),
MK_CONST(SSL_DISPLAY_RSA),
MK_CONST(SSL_CONNECT_IN_PARTS),
MK_CONST(SSL_OK),
MK_CONST(SSL_NOT_OK),
MK_CONST(SSL_ERROR_DEAD),
MK_CONST(SSL_CLOSE_NOTIFY),
MK_CONST(SSL_ERROR_CONN_LOST),
MK_CONST(SSL_ERROR_SOCK_SETUP_FAILURE),
MK_CONST(SSL_ERROR_INVALID_HANDSHAKE),
MK_CONST(SSL_ERROR_INVALID_PROT_MSG),
MK_CONST(SSL_ERROR_INVALID_HMAC),
MK_CONST(SSL_ERROR_INVALID_VERSION),
MK_CONST(SSL_ERROR_INVALID_SESSION),
MK_CONST(SSL_ERROR_NO_CIPHER),
MK_CONST(SSL_ERROR_BAD_CERTIFICATE),
MK_CONST(SSL_ERROR_INVALID_KEY),
MK_CONST(SSL_ERROR_FINISHED_INVALID),
MK_CONST(SSL_ERROR_NO_CERT_DEFINED),
MK_CONST(SSL_ERROR_NO_CLIENT_RENOG),
MK_CONST(SSL_ERROR_NOT_SUPPORTED),
MK_CONST(SSL_X509_OFFSET),
MK_CONST(SSL_ALERT_TYPE_WARNING),
MK_CONST(SLL_ALERT_TYPE_FATAL),
MK_CONST(SSL_ALERT_CLOSE_NOTIFY),
MK_CONST(SSL_ALERT_UNEXPECTED_MESSAGE),
MK_CONST(SSL_ALERT_BAD_RECORD_MAC),
MK_CONST(SSL_ALERT_HANDSHAKE_FAILURE),
MK_CONST(SSL_ALERT_BAD_CERTIFICATE),
MK_CONST(SSL_ALERT_ILLEGAL_PARAMETER),
MK_CONST(SSL_ALERT_DECODE_ERROR),
MK_CONST(SSL_ALERT_DECRYPT_ERROR),
MK_CONST(SSL_ALERT_INVALID_VERSION),
MK_CONST(SSL_ALERT_NO_RENEGOTIATION),
MK_CONST(SSL_AES128_SHA),
MK_CONST(SSL_AES256_SHA),
MK_CONST(SSL_BUILD_SKELETON_MODE),
MK_CONST(SSL_BUILD_SERVER_ONLY),
MK_CONST(SSL_BUILD_ENABLE_VERIFICATION),
MK_CONST(SSL_BUILD_ENABLE_CLIENT),
MK_CONST(SSL_BUILD_FULL_MODE),
MK_CONST(SSL_BUILD_MODE),
MK_CONST(SSL_MAX_CERT_CFG_OFFSET),
MK_CONST(SSL_MAX_CA_CERT_CFG_OFFSET),
MK_CONST(SSL_HAS_PEM),
MK_CONST(SSL_DEFAULT_SVR_SESS),
MK_CONST(SSL_DEFAULT_CLNT_SESS),
MK_CONST(SSL_X509_CERT_COMMON_NAME),
MK_CONST(SSL_X509_CERT_ORGANIZATION),
MK_CONST(SSL_X509_CERT_ORGANIZATIONAL_NAME),
MK_CONST(SSL_X509_CA_CERT_COMMON_NAME),
MK_CONST(SSL_X509_CA_CERT_ORGANIZATION),
MK_CONST(SSL_X509_CA_CERT_ORGANIZATIONAL_NAME),
MK_CONST(SSL_OBJ_X509_CERT),
MK_CONST(SSL_OBJ_X509_CACERT),
MK_CONST(SSL_OBJ_RSA_KEY),
MK_CONST(SSL_OBJ_PKCS8),
MK_CONST(SSL_OBJ_PKCS12),
{0,0}
};
/* This defines a function that opens up your library. */
SQRESULT sqext_register_axtls (HSQUIRRELVM v) {
//add a namespace axtls
sq_pushstring(v, SQ_LIBNAME, -1);
sq_newtable(v);
sq_insert_reg_funcs(v, axtls_obj_funcs);
//add constants
KeyIntPtrType KeyIntPtr;
for (KeyIntPtr = axtls_constants; KeyIntPtr->Str; KeyIntPtr++) {
sq_pushstring(v, KeyIntPtr->Str, -1); //first the key
sq_pushinteger(v, KeyIntPtr->Val); //then the value
sq_newslot(v, -3, SQFalse); //store then
}
//now create the SSL Context class
sq_pushstring(v,ssl_ctx_NAME,-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)SSL_CTX_Tag);
sq_insert_reg_funcs(v, ssl_ctx_obj_funcs);
sq_newslot(v,-3,SQFalse);
//now create the SSL class
sq_pushstring(v,ssl_NAME,-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)SSL_Tag);
sq_insert_reg_funcs(v, ssl_obj_funcs);
sq_newslot(v,-3,SQFalse);
sq_newslot(v,-3,SQFalse); //add axtls table to the root table
return SQ_OK;
}
#ifdef __cplusplus
}
#endif //USE_AXTLS
#endif
|
5135e6fc5f8193701a99da84450e231dab2585e0 | fcddd423d14a62a1fe1de3fb53abf3155b044b59 | /test/t/t_comb.c | 07994b5f713cd6aa5bab2837df89f86ab649060e | [
"MIT"
] | permissive | theisro/Soundpipe | f39b098a30d4d21fff99b1dc788fe0aefe12f7a0 | a7f029d212c4868daa92b38203afd63f8f0b2dd7 | refs/heads/master | 2021-04-15T06:50:26.725894 | 2018-03-26T04:54:43 | 2018-03-26T04:54:43 | 126,774,733 | 2 | 0 | MIT | 2018-03-26T04:49:14 | 2018-03-26T04:49:14 | null | UTF-8 | C | false | false | 1,163 | c | t_comb.c | #include "soundpipe.h"
#include "md5.h"
#include "tap.h"
#include "test.h"
typedef struct {
sp_comb *comb;
sp_tenv *env;
sp_noise *nz;
} UserData;
int t_comb(sp_test *tst, sp_data *sp, const char *hash)
{
sp_srand(sp, 0);
uint32_t n;
int fail = 0;
SPFLOAT tick = 0, env = 0, noise = 0, comb = 0;
UserData ud;
sp_comb_create(&ud.comb);
sp_tenv_create(&ud.env);
sp_noise_create(&ud.nz);
sp_comb_init(sp, ud.comb, 0.01);
sp_tenv_init(sp, ud.env);
ud.env->atk = 0.001;
ud.env->hold = 0.00;
ud.env->rel = 0.1;
sp_noise_init(sp, ud.nz);
for(n = 0; n < tst->size; n++) {
tick = 0, env = 0, noise = 0, comb = 0;
tick = (sp->pos == 0) ? 1 : 0;
sp_tenv_compute(sp, ud.env, &tick, &env);
sp_noise_compute(sp, ud.nz, NULL, &noise);
noise *= env * 0.5;
sp_comb_compute(sp, ud.comb, &noise, &comb);
sp_test_add_sample(tst, comb);
}
fail = sp_test_verify(tst, hash);
sp_noise_destroy(&ud.nz);
sp_tenv_destroy(&ud.env);
sp_comb_destroy(&ud.comb);
if(fail) return SP_NOT_OK;
else return SP_OK;
}
|
f95ee1a71f6437f9e75028287d70be5f82a140d2 | 976f5e0b583c3f3a87a142187b9a2b2a5ae9cf6f | /source/linux/drivers/iio/adc/extr_qcom-pm8xxx-xoadc.c_pm8xxx_xoadc_probe.c | 3e9537f0b04903bd660926869db0e1f8871bf694 | [] | no_license | isabella232/AnghaBench | 7ba90823cf8c0dd25a803d1688500eec91d1cf4e | 9a5f60cdc907a0475090eef45e5be43392c25132 | refs/heads/master | 2023-04-20T09:05:33.024569 | 2021-05-07T18:36:26 | 2021-05-07T18:36:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 4,633 | c | extr_qcom-pm8xxx-xoadc.c_pm8xxx_xoadc_probe.c | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
typedef struct TYPE_2__ TYPE_1__ ;
/* Type definitions */
struct xoadc_variant {int /*<<< orphan*/ name; } ;
struct regmap {int dummy; } ;
struct pm8xxx_xoadc {int /*<<< orphan*/ vref; int /*<<< orphan*/ nchans; int /*<<< orphan*/ iio_chans; struct regmap* map; int /*<<< orphan*/ lock; int /*<<< orphan*/ complete; struct xoadc_variant const* variant; struct device* dev; } ;
struct device {int /*<<< orphan*/ parent; struct device_node* of_node; } ;
struct platform_device {struct device dev; } ;
struct TYPE_2__ {struct device_node* of_node; struct device* parent; } ;
struct iio_dev {int /*<<< orphan*/ num_channels; int /*<<< orphan*/ channels; int /*<<< orphan*/ * info; int /*<<< orphan*/ modes; int /*<<< orphan*/ name; TYPE_1__ dev; } ;
struct device_node {int dummy; } ;
/* Variables and functions */
int ENODEV ;
int ENOMEM ;
int ENXIO ;
int /*<<< orphan*/ INDIO_DIRECT_MODE ;
scalar_t__ IS_ERR (int /*<<< orphan*/ ) ;
int PTR_ERR (int /*<<< orphan*/ ) ;
int /*<<< orphan*/ dev_err (struct device*,char*) ;
struct regmap* dev_get_regmap (int /*<<< orphan*/ ,int /*<<< orphan*/ *) ;
int /*<<< orphan*/ dev_info (struct device*,char*,int /*<<< orphan*/ ) ;
struct iio_dev* devm_iio_device_alloc (struct device*,int) ;
int /*<<< orphan*/ devm_regulator_get (struct device*,char*) ;
int devm_request_threaded_irq (struct device*,int /*<<< orphan*/ ,int /*<<< orphan*/ ,int /*<<< orphan*/ *,int /*<<< orphan*/ ,int /*<<< orphan*/ ,struct iio_dev*) ;
int iio_device_register (struct iio_dev*) ;
int /*<<< orphan*/ iio_device_unregister (struct iio_dev*) ;
struct pm8xxx_xoadc* iio_priv (struct iio_dev*) ;
int /*<<< orphan*/ init_completion (int /*<<< orphan*/ *) ;
int /*<<< orphan*/ mutex_init (int /*<<< orphan*/ *) ;
struct xoadc_variant* of_device_get_match_data (struct device*) ;
int /*<<< orphan*/ platform_get_irq (struct platform_device*,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ platform_set_drvdata (struct platform_device*,struct iio_dev*) ;
int pm8xxx_calibrate_device (struct pm8xxx_xoadc*) ;
int /*<<< orphan*/ pm8xxx_eoc_irq ;
int /*<<< orphan*/ pm8xxx_xoadc_info ;
int pm8xxx_xoadc_parse_channels (struct pm8xxx_xoadc*,struct device_node*) ;
int /*<<< orphan*/ regulator_disable (int /*<<< orphan*/ ) ;
int regulator_enable (int /*<<< orphan*/ ) ;
__attribute__((used)) static int pm8xxx_xoadc_probe(struct platform_device *pdev)
{
const struct xoadc_variant *variant;
struct pm8xxx_xoadc *adc;
struct iio_dev *indio_dev;
struct device_node *np = pdev->dev.of_node;
struct regmap *map;
struct device *dev = &pdev->dev;
int ret;
variant = of_device_get_match_data(dev);
if (!variant)
return -ENODEV;
indio_dev = devm_iio_device_alloc(dev, sizeof(*adc));
if (!indio_dev)
return -ENOMEM;
platform_set_drvdata(pdev, indio_dev);
adc = iio_priv(indio_dev);
adc->dev = dev;
adc->variant = variant;
init_completion(&adc->complete);
mutex_init(&adc->lock);
ret = pm8xxx_xoadc_parse_channels(adc, np);
if (ret)
return ret;
map = dev_get_regmap(dev->parent, NULL);
if (!map) {
dev_err(dev, "parent regmap unavailable.\n");
return -ENXIO;
}
adc->map = map;
/* Bring up regulator */
adc->vref = devm_regulator_get(dev, "xoadc-ref");
if (IS_ERR(adc->vref)) {
dev_err(dev, "failed to get XOADC VREF regulator\n");
return PTR_ERR(adc->vref);
}
ret = regulator_enable(adc->vref);
if (ret) {
dev_err(dev, "failed to enable XOADC VREF regulator\n");
return ret;
}
ret = devm_request_threaded_irq(dev, platform_get_irq(pdev, 0),
pm8xxx_eoc_irq, NULL, 0, variant->name, indio_dev);
if (ret) {
dev_err(dev, "unable to request IRQ\n");
goto out_disable_vref;
}
indio_dev->dev.parent = dev;
indio_dev->dev.of_node = np;
indio_dev->name = variant->name;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->info = &pm8xxx_xoadc_info;
indio_dev->channels = adc->iio_chans;
indio_dev->num_channels = adc->nchans;
ret = iio_device_register(indio_dev);
if (ret)
goto out_disable_vref;
ret = pm8xxx_calibrate_device(adc);
if (ret)
goto out_unreg_device;
dev_info(dev, "%s XOADC driver enabled\n", variant->name);
return 0;
out_unreg_device:
iio_device_unregister(indio_dev);
out_disable_vref:
regulator_disable(adc->vref);
return ret;
} |
da231588e97f1b88c5d5fcd00e1855e25dfa8fbd | 2cb2bc953975540de8dfe3aee256fb3daa852bfb | /matthew/tyama_codeiq1092.c | 5ee1dce87283b92b7d3cebdd34e985a2982e6e3c | [] | no_license | cielavenir/codeiq_solutions | db0c2001f9a837716aee1effbd92071e4033d7e0 | 750a22c937db0a5d94bfa5b6ee5ae7f1a2c06d57 | refs/heads/master | 2023-04-27T14:20:09.251817 | 2023-04-17T03:22:57 | 2023-04-17T03:22:57 | 19,687,315 | 2 | 4 | null | null | null | null | UTF-8 | C | false | false | 250 | c | tyama_codeiq1092.c | #include <stdio.h>
#define M 500
int t[M+1];
int main(){
int i,j,f=0;
t[0]=t[1]=1;
for(i=2;i<=M;i++)if(!t[i])for(j=i*2;j<=M;j+=i)t[j]=1;
for(i=2;i<=M-6;i++)if(!t[i]&&!t[i+6]){
if(f)printf(", ");
f=1;
printf("(%d,%d)",i,i+6);
}
puts("");
} |
582a6be3045da41d01f0156b34d1546ab97310e7 | 28d0f8c01599f8f6c711bdde0b59f9c2cd221203 | /sys/arch/evbarm/stand/bootimx23/power_prep.c | 6ea9e175e2fe6cce77285e4c506986b1c3b932f6 | [] | no_license | NetBSD/src | 1a9cbc22ed778be638b37869ed4fb5c8dd616166 | 23ee83f7c0aea0777bd89d8ebd7f0cde9880d13c | refs/heads/trunk | 2023-08-31T13:24:58.105962 | 2023-08-27T15:50:47 | 2023-08-27T15:50:47 | 88,439,547 | 656 | 348 | null | 2023-07-20T20:07:24 | 2017-04-16T20:03:43 | null | UTF-8 | C | false | false | 11,314 | c | power_prep.c | /* $Id: power_prep.c,v 1.5 2016/08/17 22:04:51 skrll Exp $ */
/*
* Copyright (c) 2012 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Petri Laakso.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``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 FOUNDATION OR CONTRIBUTORS
* 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.
*/
#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/types.h>
#include <arm/imx/imx23_powerreg.h>
#include <lib/libkern/libkern.h>
#include <lib/libsa/stand.h>
#include "common.h"
#define PWR_CTRL (HW_POWER_BASE + HW_POWER_CTRL)
#define PWR_CTRL_S (HW_POWER_BASE + HW_POWER_CTRL_SET)
#define PWR_CTRL_C (HW_POWER_BASE + HW_POWER_CTRL_CLR)
#define PWR_5VCTRL (HW_POWER_BASE + HW_POWER_5VCTRL)
#define PWR_5VCTRL_S (HW_POWER_BASE + HW_POWER_5VCTRL_SET)
#define PWR_5VCTRL_C (HW_POWER_BASE + HW_POWER_5VCTRL_CLR)
#define PWR_MINPWR (HW_POWER_BASE + HW_POWER_MINPWR)
#define PWR_MINPWR_S (HW_POWER_BASE + HW_POWER_MINPWR_SET)
#define PWR_MINPWR_C (HW_POWER_BASE + HW_POWER_MINPWR_CLR)
#define PWR_CHARGE (HW_POWER_BASE + HW_POWER_CHARGE)
#define PWR_CHARGE_S (HW_POWER_BASE + HW_POWER_CHARGE_SET)
#define PWR_CHARGE_C (HW_POWER_BASE + HW_POWER_CHARGE_CLR)
#define PWR_VDDDCTRL (HW_POWER_BASE + HW_POWER_VDDDCTRL)
#define PWR_VDDACTRL (HW_POWER_BASE + HW_POWER_VDDACTRL)
#define PWR_VDDIOCTRL (HW_POWER_BASE + HW_POWER_VDDIOCTRL)
#define PWR_VDDMEMCTRL (HW_POWER_BASE + HW_POWER_VDDMEMCTRL)
#define PWR_DCDC4P2 (HW_POWER_BASE + HW_POWER_DCDC4P2)
#define PWR_MISC (HW_POWER_BASE + HW_POWER_MISC)
#define PWR_DCLIMITS (HW_POWER_BASE + HW_POWER_DCLIMITS)
#define PWR_LOOPCTRL (HW_POWER_BASE + HW_POWER_LOOPCTRL)
#define PWR_LOOPCTRL_S (HW_POWER_BASE + HW_POWER_LOOPCTRL_SET)
#define PWR_LOOPCTRL_C (HW_POWER_BASE + HW_POWER_LOOPCTRL_CLR)
#define PWR_STATUS (HW_POWER_BASE + HW_POWER_STS)
#define PWR_SPEED (HW_POWER_BASE + HW_POWER_SPEED)
#define PWR_BATTMONITOR (HW_POWER_BASE + HW_POWER_BATTMONITOR)
#define PWR_RESET (HW_POWER_BASE + HW_POWER_RESET)
#define PWR_DEBUG (HW_POWER_BASE + HW_POWER_DEBUG)
#define PWR_SPECIAL (HW_POWER_BASE + HW_POWER_SPECIAL)
#define PWR_VERSION (HW_POWER_BASE + HW_POWER_VERSION)
#define VBUSVALID_TRSH 5 /* 4.4V */
#define CHARGE_4P2_ILIMIT_MAX 0x3f
#define CMPTRIP 0x1f /* DCDC_4P2 pin >= 1.05 * BATTERY pin. */
#define DROPOUT_CTRL 0xa /* BO 100mV, DCDC selects higher. */
void en_vbusvalid(void);
int vbusvalid(void);
void power_tune(void);
void en_4p2_reg(void);
void en_4p2_to_dcdc(void);
void power_vddd_from_dcdc(int, int);
void power_vdda_from_dcdc(int, int);
void power_vddio_from_dcdc(int, int);
void power_vddmem(int);
/*
* Configure the DCDC control logic 5V detection to use VBUSVALID.
*/
void
en_vbusvalid(void)
{
uint32_t tmp_r;
tmp_r = REG_RD(PWR_5VCTRL);
tmp_r &= ~HW_POWER_5VCTRL_VBUSVALID_TRSH;
tmp_r |= __SHIFTIN(VBUSVALID_TRSH, HW_POWER_5VCTRL_VBUSVALID_TRSH);
REG_WR(PWR_5VCTRL, tmp_r);
REG_WR(PWR_5VCTRL_S, HW_POWER_5VCTRL_PWRUP_VBUS_CMPS);
delay(1000);
REG_WR(PWR_5VCTRL_S, HW_POWER_5VCTRL_VBUSVALID_5VDETECT);
return;
}
/*
* Test VBUSVALID.
*/
int
vbusvalid(void)
{
if (REG_RD(PWR_STATUS) & HW_POWER_STS_VBUSVALID)
return 1;
else
return 0;
}
/*
* Set various registers.
*/
void
power_tune(void)
{
uint32_t tmp_r;
REG_WR(PWR_LOOPCTRL_S, HW_POWER_LOOPCTRL_TOGGLE_DIF |
HW_POWER_LOOPCTRL_EN_CM_HYST |
HW_POWER_LOOPCTRL_EN_DF_HYST |
HW_POWER_LOOPCTRL_RCSCALE_THRESH |
__SHIFTIN(3, HW_POWER_LOOPCTRL_EN_RCSCALE));
REG_WR(PWR_MINPWR_S, HW_POWER_MINPWR_DOUBLE_FETS);
REG_WR(PWR_5VCTRL_S, __SHIFTIN(4, HW_POWER_5VCTRL_HEADROOM_ADJ));
tmp_r = REG_RD(PWR_DCLIMITS);
tmp_r &= ~HW_POWER_DCLIMITS_POSLIMIT_BUCK;
tmp_r |= __SHIFTIN(0x30, HW_POWER_DCLIMITS_POSLIMIT_BUCK);
REG_WR(PWR_DCLIMITS, tmp_r);
return;
}
/*
* AN3883.pdf 2.1.3.1 Enabling the 4P2 LinReg
*/
void
en_4p2_reg(void)
{
uint32_t tmp_r;
int ilimit;
/* TRG is 4.2V by default. */
tmp_r = REG_RD(PWR_DCDC4P2);
tmp_r |= HW_POWER_DCDC4P2_ENABLE_4P2;
REG_WR(PWR_DCDC4P2, tmp_r);
REG_WR(PWR_CHARGE_S, HW_POWER_CHARGE_ENABLE_LOAD);
/* Set CHARGE_4P2_ILIMIT to minimum. */
REG_WR(PWR_5VCTRL_C, HW_POWER_5VCTRL_CHARGE_4P2_ILIMIT);
REG_WR(PWR_5VCTRL_S, __SHIFTIN(1, HW_POWER_5VCTRL_CHARGE_4P2_ILIMIT));
/* Power up 4.2V regulation circuit. */
REG_WR(PWR_5VCTRL_C, HW_POWER_5VCTRL_PWD_CHARGE_4P2);
/* Ungate path from 4P2 reg to DCDC. */
tmp_r = REG_RD(PWR_DCDC4P2);
tmp_r |= HW_POWER_DCDC4P2_ENABLE_DCDC;
REG_WR(PWR_DCDC4P2, tmp_r);
delay(10000);
/* Charge 4P2 capacitance. */
tmp_r = REG_RD(PWR_5VCTRL);
for (ilimit = 2; ilimit <= CHARGE_4P2_ILIMIT_MAX; ilimit++) {
tmp_r &= ~HW_POWER_5VCTRL_CHARGE_4P2_ILIMIT;
tmp_r |= __SHIFTIN(ilimit, HW_POWER_5VCTRL_CHARGE_4P2_ILIMIT);
REG_WR(PWR_5VCTRL, tmp_r);
delay(10000);
}
return;
}
/*
* AN3883.pdf 2.1.3.3 Enabling 4P2 Input to DC-DC
*/
void en_4p2_to_dcdc(void)
{
uint32_t tmp_r;
tmp_r = REG_RD(PWR_DCDC4P2);
tmp_r &= ~HW_POWER_DCDC4P2_CMPTRIP;
tmp_r |= __SHIFTIN(CMPTRIP, HW_POWER_DCDC4P2_CMPTRIP);
tmp_r &= ~HW_POWER_DCDC4P2_DROPOUT_CTRL;
tmp_r |= __SHIFTIN(DROPOUT_CTRL, HW_POWER_DCDC4P2_DROPOUT_CTRL);
REG_WR(PWR_DCDC4P2, tmp_r);
REG_WR(PWR_5VCTRL_C, HW_POWER_5VCTRL_DCDC_XFER);
/* Enabling DCDC triggers 5V brownout. */
REG_WR(PWR_5VCTRL_C, HW_POWER_5VCTRL_PWDN_5VBRNOUT);
REG_WR(PWR_5VCTRL_S, HW_POWER_5VCTRL_ENABLE_DCDC);
delay(10000);
REG_WR(PWR_5VCTRL_S, HW_POWER_5VCTRL_PWDN_5VBRNOUT);
/* Now DCDC is using 4P2 so I can remove extra temporary load. */
REG_WR(PWR_CHARGE_C, HW_POWER_CHARGE_ENABLE_LOAD);
return;
}
/*
* Configure VDDD to source power from DCDC.
*/
void
power_vddd_from_dcdc(int target, int brownout)
{
uint32_t tmp_r;
/* BO_OFFSET must be within 800mV - 1475mV */
if (brownout > 1475)
brownout = 1475;
else if (brownout < 800)
brownout = 800;
/* Set LINREG_OFFSET one step below TRG. */
tmp_r = REG_RD(PWR_VDDDCTRL);
tmp_r &= ~HW_POWER_VDDDCTRL_LINREG_OFFSET;
tmp_r |= __SHIFTIN(2, HW_POWER_VDDDCTRL_LINREG_OFFSET);
REG_WR(PWR_VDDDCTRL, tmp_r);
delay(10000);
/* Enable VDDD switching converter output. */
tmp_r = REG_RD(PWR_VDDDCTRL);
tmp_r &= ~HW_POWER_VDDDCTRL_DISABLE_FET;
REG_WR(PWR_VDDDCTRL, tmp_r);
delay(10000);
/* Disable linear regulator output. */
tmp_r = REG_RD(PWR_VDDDCTRL);
tmp_r &= ~HW_POWER_VDDDCTRL_ENABLE_LINREG;
REG_WR(PWR_VDDDCTRL, tmp_r);
delay(10000);
/* Set target voltage and brownout level. */
tmp_r = REG_RD(PWR_VDDDCTRL);
tmp_r &= ~(HW_POWER_VDDDCTRL_BO_OFFSET | HW_POWER_VDDDCTRL_TRG);
tmp_r |= __SHIFTIN(((target - brownout) / 25),
HW_POWER_VDDDCTRL_BO_OFFSET);
tmp_r |= __SHIFTIN(((target - 800) / 25), HW_POWER_VDDDCTRL_TRG);
REG_WR(PWR_VDDDCTRL, tmp_r);
delay(10000);
/* Enable PWDN_BRNOUT. */
REG_WR(PWR_CTRL_C, HW_POWER_CTRL_VDDD_BO_IRQ);
tmp_r = REG_RD(PWR_VDDDCTRL);
tmp_r |= HW_POWER_VDDDCTRL_PWDN_BRNOUT;
REG_WR(PWR_VDDDCTRL, tmp_r);
return;
}
/*
* Configure VDDA to source power from DCDC.
*/
void
power_vdda_from_dcdc(int target, int brownout)
{
uint32_t tmp_r;
/* BO_OFFSET must be within 1400mV - 2175mV */
if (brownout > 2275)
brownout = 2275;
else if (brownout < 1400)
brownout = 1400;
/* Set LINREG_OFFSET one step below TRG. */
tmp_r = REG_RD(PWR_VDDACTRL);
tmp_r &= ~HW_POWER_VDDACTRL_LINREG_OFFSET;
tmp_r |= __SHIFTIN(2, HW_POWER_VDDACTRL_LINREG_OFFSET);
REG_WR(PWR_VDDACTRL, tmp_r);
delay(10000);
/* Enable VDDA switching converter output. */
tmp_r = REG_RD(PWR_VDDACTRL);
tmp_r &= ~HW_POWER_VDDACTRL_DISABLE_FET;
REG_WR(PWR_VDDACTRL, tmp_r);
delay(10000);
/* Disable linear regulator output. */
tmp_r = REG_RD(PWR_VDDACTRL);
tmp_r &= ~HW_POWER_VDDACTRL_ENABLE_LINREG;
REG_WR(PWR_VDDACTRL, tmp_r);
delay(10000);
/* Set target voltage and brownout level. */
tmp_r = REG_RD(PWR_VDDACTRL);
tmp_r &= ~(HW_POWER_VDDACTRL_BO_OFFSET | HW_POWER_VDDACTRL_TRG);
tmp_r |= __SHIFTIN(((target - brownout) / 25),
HW_POWER_VDDACTRL_BO_OFFSET);
tmp_r |= __SHIFTIN(((target - 1500) / 25), HW_POWER_VDDACTRL_TRG);
REG_WR(PWR_VDDACTRL, tmp_r);
delay(10000);
/* Enable PWDN_BRNOUT. */
REG_WR(PWR_CTRL_C, HW_POWER_CTRL_VDDA_BO_IRQ);
tmp_r = REG_RD(PWR_VDDACTRL);
tmp_r |= HW_POWER_VDDACTRL_PWDN_BRNOUT;
REG_WR(PWR_VDDACTRL, tmp_r);
return;
}
/*
* Configure VDDIO to source power from DCDC.
*/
void
power_vddio_from_dcdc(int target, int brownout)
{
uint32_t tmp_r;
/* BO_OFFSET must be within 2700mV - 3475mV */
if (brownout > 3475)
brownout = 3475;
else if (brownout < 2700)
brownout = 2700;
/* Set LINREG_OFFSET one step below TRG. */
tmp_r = REG_RD(PWR_VDDIOCTRL);
tmp_r &= ~HW_POWER_VDDIOCTRL_LINREG_OFFSET;
tmp_r |= __SHIFTIN(2, HW_POWER_VDDIOCTRL_LINREG_OFFSET);
REG_WR(PWR_VDDIOCTRL, tmp_r);
delay(10000);
/* Enable VDDIO switching converter output. */
tmp_r = REG_RD(PWR_VDDIOCTRL);
tmp_r &= ~HW_POWER_VDDIOCTRL_DISABLE_FET;
REG_WR(PWR_VDDIOCTRL, tmp_r);
delay(10000);
/* Set target voltage and brownout level. */
tmp_r = REG_RD(PWR_VDDIOCTRL);
tmp_r &= ~(HW_POWER_VDDIOCTRL_BO_OFFSET | HW_POWER_VDDIOCTRL_TRG);
tmp_r |= __SHIFTIN(((target - brownout) / 25),
HW_POWER_VDDIOCTRL_BO_OFFSET);
tmp_r |= __SHIFTIN(((target - 2800) / 25), HW_POWER_VDDIOCTRL_TRG);
REG_WR(PWR_VDDIOCTRL, tmp_r);
delay(10000);
/* Enable PWDN_BRNOUT. */
REG_WR(PWR_CTRL_C, HW_POWER_CTRL_VDDIO_BO_IRQ);
tmp_r = REG_RD(PWR_VDDIOCTRL);
tmp_r |= HW_POWER_VDDIOCTRL_PWDN_BRNOUT;
REG_WR(PWR_VDDIOCTRL, tmp_r);
return;
}
/*
* AN3883.pdf 2.3.1.2 Setting VDDMEM Target Voltage
*/
void
power_vddmem(int target)
{
uint32_t tmp_r;
/* Set target voltage. */
tmp_r = REG_RD(PWR_VDDMEMCTRL);
tmp_r &= ~(HW_POWER_VDDMEMCTRL_TRG);
tmp_r |= __SHIFTIN(((target - 1700) / 50), HW_POWER_VDDMEMCTRL_TRG);
REG_WR(PWR_VDDMEMCTRL, tmp_r);
delay(10000);
tmp_r = REG_RD(PWR_VDDMEMCTRL);
tmp_r |= (HW_POWER_VDDMEMCTRL_PULLDOWN_ACTIVE |
HW_POWER_VDDMEMCTRL_ENABLE_ILIMIT |
HW_POWER_VDDMEMCTRL_ENABLE_LINREG);
REG_WR(PWR_VDDMEMCTRL, tmp_r);
delay(1000);
tmp_r = REG_RD(PWR_VDDMEMCTRL);
tmp_r &= ~(HW_POWER_VDDMEMCTRL_PULLDOWN_ACTIVE |
HW_POWER_VDDMEMCTRL_ENABLE_ILIMIT);
REG_WR(PWR_VDDMEMCTRL, tmp_r);
return;
}
|
92313c0c0dd46f485465cf4c1df170b643d79b58 | 4caa4cbd5b06a3ceeebb04c077a1baf65375c8e9 | /src/fs/iwfsmfile.c | 75cc4d594991a7c88e7060b27553ce237e96ef18 | [
"MIT"
] | permissive | Softmotions/iowow | 22cdfa56944fd38d106d603a41a14541f1d96ffb | a233a246577f5ba02a643a23b417c7bac7feaf06 | refs/heads/master | 2023-08-08T13:19:12.913521 | 2023-08-06T05:21:28 | 2023-08-06T05:21:28 | 40,618,114 | 274 | 25 | MIT | 2023-08-06T04:13:54 | 2015-08-12T18:44:57 | C | UTF-8 | C | false | false | 59,849 | c | iwfsmfile.c | /**************************************************************************************************
* IOWOW library
*
* MIT License
*
* Copyright (c) 2012-2022 Softmotions Ltd <[email protected]>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*************************************************************************************************/
#include "iwfsmfile.h"
#include "iwavl.h"
#include "iwbits.h"
#include "iwlog.h"
#include "iwp.h"
#include "iwutils.h"
#include "iwcfg.h"
#include <pthread.h>
void iwfs_fsmdbg_dump_fsm_tree(IWFS_FSM *f, const char *hdr);
/**
* Free-space blocks-tree key.
*/
struct bkey {
uint32_t off;
uint32_t len;
};
struct bkey_node {
struct bkey key;
struct iwavl_node node;
};
#define BKEY(nptr_) iwavl_entry(nptr_, struct bkey_node, node)->key
/** Additional options for `_fsm_set_bit_status_lw` routine */
typedef uint8_t fsm_bmopts_t;
/** No options. */
#define FSM_BM_NONE ((fsm_bmopts_t) 0x00U)
/** Do not modify bitmap. */
#define FSM_BM_DRY_RUN ((fsm_bmopts_t) 0x01U)
/** Perform strict checking of bitmap consistency */
#define FSM_BM_STRICT ((fsm_bmopts_t) 0x02U)
/* Maximum size of block: 1Mb */
#define FSM_MAX_BLOCK_POW 20
/* Maximum number of records used in allocation statistics */
#define FSM_MAX_STATS_COUNT 0x0000ffff
#define FSM_ENSURE_OPEN(impl_) \
if (!(impl_) || !(impl_)->f) return IW_ERROR_INVALID_STATE;
#define FSM_ENSURE_OPEN2(f_) \
if (!(f_) || !(f_)->impl) return IW_ERROR_INVALID_STATE;
#define FSMBK_OFFSET(b_) ((b_)->off)
#define FSMBK_LENGTH(b_) ((b_)->len)
////////////////////////////////////////////////////////////////////////////////////////////////////
struct fsm {
IWFS_EXT pool; /**< Underlying rwl file. */
uint64_t bmlen; /**< Free-space bitmap block length in bytes. */
uint64_t bmoff; /**< Free-space bitmap block offset in bytes. */
uint64_t lfbkoff; /**< Offset in blocks of free block chunk with the largest offset. */
uint64_t lfbklen; /**< Length in blocks of free block chunk with the largest offset. */
uint64_t crzsum; /**< Cumulative sum all allocated blocks */
uint64_t crzvar; /**< Record sizes standard variance (deviation^2 * N) */
uint32_t hdrlen; /**< Length of custom file header */
uint32_t crznum; /**< Number of all allocated continuous areas acquired by `allocate` */
uint32_t fsmnum; /**< Number of records in fsm */
IWFS_FSM *f; /**< Self reference. */
IWDLSNR *dlsnr; /**< Data events listener */
struct iwavl_node *root; /**< Free-space tree */
pthread_rwlock_t *ctlrwlk; /**< Methods RW lock */
size_t aunit; /**< System allocation unit size.
- Page size on *NIX
- Minimal allocation unit for WIN32 */
iwfs_fsm_openflags oflags; /**< Operation mode flags. */
iwfs_omode omode; /**< Open mode. */
uint8_t bpow; /**< Block size power for 2 */
bool mmap_all; /**< Mmap all file data */
iwfs_ext_mmap_opts_t mmap_opts; /**< Defaul mmap options used in `add_mmap` */
};
static iwrc _fsm_ensure_size_lw(struct fsm *fsm, off_t size);
////////////////////////////////////////////////////////////////////////////////////////////////////
IW_INLINE int _fsm_cmp_key(const struct bkey *a, const struct bkey *b) {
int ret = ((FSMBK_LENGTH(b) < FSMBK_LENGTH(a)) - (FSMBK_LENGTH(a) < FSMBK_LENGTH(b)));
if (ret) {
return ret;
} else {
return ((FSMBK_OFFSET(b) < FSMBK_OFFSET(a)) - (FSMBK_OFFSET(a) < FSMBK_OFFSET(b)));
}
}
IW_INLINE int _fsm_cmp_node(const struct iwavl_node *an, const struct iwavl_node *bn) {
const struct bkey *ak = &BKEY(an);
const struct bkey *bk = &BKEY(bn);
return _fsm_cmp_key(ak, bk);
}
IW_INLINE int _fsm_cmp_ctx(const void *ctx, const struct iwavl_node *bn) {
const struct bkey *ak = ctx;
const struct bkey *bk = &BKEY(bn);
return _fsm_cmp_key(ak, bk);
}
IW_INLINE iwrc _fsm_ctrl_wlock(struct fsm *fsm) {
int rci = fsm->ctlrwlk ? pthread_rwlock_wrlock(fsm->ctlrwlk) : 0;
return (rci ? iwrc_set_errno(IW_ERROR_THREADING_ERRNO, rci) : 0);
}
IW_INLINE iwrc _fsm_ctrl_rlock(struct fsm *fsm) {
int rci = fsm->ctlrwlk ? pthread_rwlock_rdlock(fsm->ctlrwlk) : 0;
return (rci ? iwrc_set_errno(IW_ERROR_THREADING_ERRNO, rci) : 0);
}
IW_INLINE iwrc _fsm_ctrl_unlock(struct fsm *fsm) {
int rci = fsm->ctlrwlk ? pthread_rwlock_unlock(fsm->ctlrwlk) : 0;
return (rci ? iwrc_set_errno(IW_ERROR_THREADING_ERRNO, rci) : 0);
}
IW_INLINE iwrc _fsm_bmptr(struct fsm *fsm, uint64_t **bmptr) {
size_t sp;
uint8_t *mm;
*bmptr = 0;
// get mmap pointer without locked
iwrc rc = fsm->pool.probe_mmap(&fsm->pool, fsm->mmap_all ? 0 : fsm->bmoff, &mm, &sp);
RCRET(rc);
if (fsm->mmap_all) {
if (sp < fsm->bmoff + fsm->bmlen) {
return IWFS_ERROR_NOT_MMAPED;
}
*bmptr = (uint64_t*) (mm + fsm->bmoff);
} else {
if (sp < fsm->bmlen) {
return IWFS_ERROR_NOT_MMAPED;
}
*bmptr = (uint64_t*) mm;
}
return 0;
}
IW_INLINE WUR iwrc _fsm_init_bkey_node(struct bkey_node *n, uint64_t offset_blk, uint64_t len_blk) {
if (offset_blk > (uint32_t) -1 || len_blk > (uint32_t) -1) {
return IW_ERROR_OVERFLOW;
}
n->key.off = (uint32_t) offset_blk;
n->key.len = (uint32_t) len_blk;
return 0;
}
IW_INLINE iwrc _fsm_init_bkey(struct bkey *k, uint64_t offset_blk, uint64_t len_blk) {
if (offset_blk > (uint32_t) -1 || len_blk > (uint32_t) -1) {
return IW_ERROR_OVERFLOW;
}
k->off = (uint32_t) offset_blk;
k->len = (uint32_t) len_blk;
return 0;
}
IW_INLINE void _fsm_del_fbk2(struct fsm *fsm, struct iwavl_node *n) {
iwavl_remove(&fsm->root, n), --fsm->fsmnum;
struct bkey_node *bk = iwavl_entry(n, struct bkey_node, node);
if (bk->key.off == fsm->lfbkoff) {
fsm->lfbkoff = 0;
fsm->lfbklen = 0;
}
free(bk);
}
IW_INLINE void _fsm_del_fbk(struct fsm *fsm, uint64_t offset_blk, uint64_t length_blk) {
struct bkey bkey;
if (!_fsm_init_bkey(&bkey, offset_blk, length_blk)) {
struct iwavl_node *n = iwavl_lookup(fsm->root, &bkey, _fsm_cmp_ctx);
assert(n);
if (n) {
_fsm_del_fbk2(fsm, n);
}
}
}
IW_INLINE iwrc _fsm_put_fbk(struct fsm *fsm, uint64_t offset_blk, uint64_t length_blk) {
iwrc rc = 0;
struct bkey_node *bk;
RCB(finish, bk = malloc(sizeof(*bk)));
RCC(rc, finish, _fsm_init_bkey_node(bk, offset_blk, length_blk));
if (iwavl_insert(&fsm->root, &bk->node, _fsm_cmp_node)) {
free(bk);
} else {
++fsm->fsmnum;
if (offset_blk + length_blk >= fsm->lfbkoff + fsm->lfbklen) {
fsm->lfbkoff = offset_blk;
fsm->lfbklen = length_blk;
}
}
finish:
if (rc) {
free(bk);
}
return rc;
}
IW_INLINE const struct iwavl_node* _fsm_find_matching_fblock_lw(
struct fsm *fsm,
uint64_t offset_blk,
uint64_t length_blk,
iwfs_fsm_aflags opts
) {
struct bkey bk;
const struct iwavl_node *ub, *lb;
if (_fsm_init_bkey(&bk, offset_blk, length_blk)) {
return 0;
}
iwavl_lookup_bounds(fsm->root, &bk, _fsm_cmp_ctx, &lb, &ub);
struct bkey *uk = ub ? &BKEY(ub) : 0;
struct bkey *lk = lb ? &BKEY(lb) : 0;
uint64_t lklength = lk ? FSMBK_LENGTH(lk) : 0;
uint64_t uklength = uk ? FSMBK_LENGTH(uk) : 0;
if (lklength == length_blk) {
return lb;
} else if (uklength == length_blk) {
return ub;
}
if (lklength > length_blk) {
return lb;
} else if (uklength > length_blk) {
return ub;
}
return 0;
}
/**
* @brief Set the allocation bits in the fsm bitmap.
*
* @param fms
* @param offset_bits Bit offset in the bitmap.
* @param length_bits Number of bits to set
* @param bit_status If `1` bits will be set to `1` otherwise `0`
* @param opts Operation options
*/
static iwrc _fsm_set_bit_status_lw(
struct fsm *fsm,
const uint64_t offset_bits,
const uint64_t length_bits_,
const int bit_status,
const fsm_bmopts_t opts
) {
iwrc rc;
size_t sp;
uint8_t *mm;
register int64_t length_bits = length_bits_;
register uint64_t *p, set_mask;
uint64_t bend = offset_bits + length_bits;
int set_bits;
if (bend < offset_bits) { // overflow
return IW_ERROR_OUT_OF_BOUNDS;
}
assert(fsm->bmlen * 8 >= offset_bits + length_bits);
if (fsm->bmlen * 8 < offset_bits + length_bits) {
return IWFS_ERROR_FSM_SEGMENTATION;
}
if (fsm->mmap_all) {
rc = fsm->pool.probe_mmap(&fsm->pool, 0, &mm, &sp);
RCRET(rc);
if (sp < fsm->bmoff + fsm->bmlen) {
return IWFS_ERROR_NOT_MMAPED;
} else {
mm += fsm->bmoff;
}
} else {
rc = fsm->pool.probe_mmap(&fsm->pool, fsm->bmoff, &mm, &sp);
RCRET(rc);
if (sp < fsm->bmlen) {
return IWFS_ERROR_NOT_MMAPED;
}
}
p = ((uint64_t*) mm) + offset_bits / 64;
set_bits = 64 - (offset_bits & (64 - 1)); // NOLINT
set_mask = (~((uint64_t) 0) << (offset_bits & (64 - 1)));
#ifdef IW_BIGENDIAN
while (length_bits - set_bits >= 0) {
uint64_t pv = *p;
pv = IW_ITOHLL(pv);
if (bit_status) {
if ((opts & FSM_BM_STRICT) && (pv & set_mask)) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
}
if ((opts & FSM_BM_DRY_RUN) == 0) {
pv |= set_mask;
*p = IW_HTOILL(pv);
}
} else {
if ((opts & FSM_BM_STRICT) && ((pv & set_mask) != set_mask)) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
}
if ((opts & FSM_BM_DRY_RUN) == 0) {
pv &= ~set_mask;
*p = IW_HTOILL(pv);
}
}
length_bits -= set_bits;
set_bits = 64;
set_mask = ~((uint64_t) 0);
++p;
}
if (length_bits) {
uint64_t pv = *p;
pv = IW_ITOHLL(pv);
set_mask &= (bend & (64 - 1)) ? ((((uint64_t) 1) << (bend & (64 - 1))) - 1) : ~((uint64_t) 0);
if (bit_status) {
if ((opts & FSM_BM_STRICT) && (pv & set_mask)) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
}
if ((opts & FSM_BM_DRY_RUN) == 0) {
pv |= set_mask;
*p = IW_HTOILL(pv);
}
} else {
if ((opts & FSM_BM_STRICT) && ((pv & set_mask) != set_mask)) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
}
if ((opts & FSM_BM_DRY_RUN) == 0) {
pv &= ~set_mask;
*p = IW_HTOILL(pv);
}
}
}
#else
while (length_bits - set_bits >= 0) {
if (bit_status) {
if ((opts & FSM_BM_STRICT) && (*p & set_mask)) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
}
if ((opts & FSM_BM_DRY_RUN) == 0) {
*p |= set_mask;
}
} else {
if ((opts & FSM_BM_STRICT) && ((*p & set_mask) != set_mask)) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
}
if ((opts & FSM_BM_DRY_RUN) == 0) {
*p &= ~set_mask;
}
}
length_bits -= set_bits;
set_bits = 64;
set_mask = ~((uint64_t) 0);
++p;
}
if (length_bits) {
set_mask &= (bend & (64 - 1)) ? ((((uint64_t) 1) << (bend & (64 - 1))) - 1) : ~((uint64_t) 0);
if (bit_status) {
if ((opts & FSM_BM_STRICT) && (*p & set_mask)) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
}
if ((opts & FSM_BM_DRY_RUN) == 0) {
*p |= set_mask;
}
} else {
if ((opts & FSM_BM_STRICT) && ((*p & set_mask) != set_mask)) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
}
if ((opts & FSM_BM_DRY_RUN) == 0) {
*p &= ~set_mask;
}
}
}
#endif
if (!rc && fsm->dlsnr) {
uint64_t so = offset_bits / 8;
uint64_t lb = length_bits_ + offset_bits % 8;
uint64_t dl = lb / 8;
if (lb % 8) {
++dl;
}
rc = fsm->dlsnr->onwrite(fsm->dlsnr, fsm->bmoff + so, mm + so, dl, 0);
}
return rc;
}
/**
* @brief Allocate a continuous segment of blocks with page aligned offset.
*
* @param fsm `struct fsm`
* @param length_blk Desired segment length in blocks.
* @param [in,out] offset_blk Allocated segment offset in blocks will be stored into.
It also specified the desired segment offset to provide
* allocation locality.
* @param [out] olength_blk Assigned segment length in blocks.
* @param max_offset_blk Maximal offset of allocated block.
* @param opts Allocation options.
*/
static iwrc _fsm_blk_allocate_aligned_lw(
struct fsm *fsm,
const uint64_t length_blk,
uint64_t *offset_blk,
uint64_t *olength_blk,
const uint64_t max_offset_blk,
const iwfs_fsm_aflags opts
) {
fsm_bmopts_t bopts = FSM_BM_NONE;
size_t aunit_blk = (fsm->aunit >> fsm->bpow);
assert(fsm && length_blk > 0);
if (fsm->oflags & IWFSM_STRICT) {
bopts |= FSM_BM_STRICT;
}
*olength_blk = 0;
*offset_blk = 0;
/* First attempt */
const struct iwavl_node *nn = _fsm_find_matching_fblock_lw(fsm, 0, length_blk + aunit_blk, opts);
if (!nn) {
nn = _fsm_find_matching_fblock_lw(fsm, 0, length_blk, opts);
if (!nn) {
return IWFS_ERROR_NO_FREE_SPACE;
}
}
struct bkey *nk = &BKEY(nn);
uint64_t akoff = FSMBK_OFFSET(nk);
uint64_t aklen = FSMBK_LENGTH(nk);
uint64_t noff = IW_ROUNDUP(akoff, aunit_blk);
if ((noff <= max_offset_blk) && (noff < aklen + akoff) && (aklen - (noff - akoff) >= length_blk)) {
_fsm_del_fbk(fsm, akoff, aklen);
aklen = aklen - (noff - akoff);
if (noff > akoff) {
_fsm_put_fbk(fsm, akoff, noff - akoff);
}
if (aklen > length_blk) {
_fsm_put_fbk(fsm, noff + length_blk, aklen - length_blk);
}
*offset_blk = noff;
*olength_blk = length_blk;
return _fsm_set_bit_status_lw(fsm, noff, length_blk, 1, bopts);
}
aklen = 0;
akoff = UINT64_MAX;
// full scan
for (struct iwavl_node *n = iwavl_first_in_order(fsm->root); n; n = iwavl_next_in_order(n)) {
struct bkey *k = &BKEY(n);
uint64_t koff = FSMBK_OFFSET(k);
uint64_t klen = FSMBK_LENGTH(k);
if (koff < akoff) {
noff = IW_ROUNDUP(koff, aunit_blk);
if (noff <= max_offset_blk && (noff < klen + koff) && (klen - (noff - koff) >= length_blk)) {
akoff = koff;
aklen = klen;
}
}
}
if (akoff == UINT64_MAX) {
return IWFS_ERROR_NO_FREE_SPACE;
}
_fsm_del_fbk(fsm, akoff, aklen);
noff = IW_ROUNDUP(akoff, aunit_blk);
aklen = aklen - (noff - akoff);
if (noff > akoff) {
_fsm_put_fbk(fsm, akoff, noff - akoff);
}
if (aklen > length_blk) {
_fsm_put_fbk(fsm, noff + length_blk, aklen - length_blk);
}
*offset_blk = noff;
*olength_blk = length_blk;
return _fsm_set_bit_status_lw(fsm, noff, length_blk, 1, bopts);
}
static void _fsm_node_destroy(struct iwavl_node *root) {
for (struct iwavl_node *n = iwavl_first_in_postorder(root), *p;
n && (p = iwavl_get_parent(n), 1);
n = iwavl_next_in_postorder(n, p)) {
struct bkey_node *bk = iwavl_entry(n, struct bkey_node, node);
free(bk);
}
}
/**
* @brief Load existing bitmap area into free-space search tree.
* @param fsm `struct fsm`
* @param bm Bitmap area start ptr
* @param len Bitmap area length in bytes.
*/
static void _fsm_load_fsm_lw(struct fsm *fsm, const uint8_t *bm, uint64_t len) {
uint64_t cbnum = 0, fbklength = 0, fbkoffset = 0;
_fsm_node_destroy(fsm->root);
fsm->root = 0;
fsm->fsmnum = 0;
for (uint64_t b = 0; b < len; ++b) {
register uint8_t bb = bm[b];
if (bb == 0) {
fbklength += 8;
cbnum += 8;
} else if (bb == 0xffU) {
if (fbklength) {
fbkoffset = cbnum - fbklength;
_fsm_put_fbk(fsm, fbkoffset, fbklength);
fbklength = 0;
}
cbnum += 8;
} else {
for (int i = 0; i < 8; ++i, ++cbnum) {
if (bb & (1U << i)) {
if (fbklength) {
fbkoffset = cbnum - fbklength;
_fsm_put_fbk(fsm, fbkoffset, fbklength);
fbklength = 0;
}
} else {
++fbklength;
}
}
}
}
if (fbklength > 0) {
fbkoffset = len * 8 - fbklength;
_fsm_put_fbk(fsm, fbkoffset, fbklength);
}
}
/**
* @brief Flush a current `iwfsmfile` metadata into the file header.
* @param fsm
* @param is_sync If `1` perform mmap sync.
* @return
*/
static iwrc _fsm_write_meta_lw(struct fsm *fsm) {
uint64_t llv;
size_t wlen;
uint32_t sp = 0, lv;
uint8_t hdr[IWFSM_CUSTOM_HDR_DATA_OFFSET] = { 0 };
/*
[FSM_CTL_MAGICK u32][block pow u8]
[bmoffset u64][bmlength u64]
[u64 crzsum][u32 crznum][u64 crszvar][u256 reserved]
[custom header size u32][custom header data...]
[fsm data...]
*/
/* magic */
lv = IW_HTOIL(IWFSM_MAGICK);
assert(sp + sizeof(lv) <= IWFSM_CUSTOM_HDR_DATA_OFFSET);
memcpy(hdr + sp, &lv, sizeof(lv));
sp += sizeof(lv);
/* block pow */
static_assert(sizeof(fsm->bpow) == 1, "sizeof(fms->bpow) == 1");
assert(sp + sizeof(fsm->bpow) <= IWFSM_CUSTOM_HDR_DATA_OFFSET);
memcpy(hdr + sp, &fsm->bpow, sizeof(fsm->bpow));
sp += sizeof(fsm->bpow);
/* fsm bitmap block offset */
llv = fsm->bmoff;
llv = IW_HTOILL(llv);
assert(sp + sizeof(llv) <= IWFSM_CUSTOM_HDR_DATA_OFFSET);
memcpy(hdr + sp, &llv, sizeof(llv));
sp += sizeof(llv);
/* fsm bitmap block length */
llv = fsm->bmlen;
llv = IW_HTOILL(llv);
assert(sp + sizeof(llv) <= IWFSM_CUSTOM_HDR_DATA_OFFSET);
memcpy(hdr + sp, &llv, sizeof(llv));
sp += sizeof(llv);
/* Cumulative sum of record sizes acquired by `allocate` */
llv = fsm->crzsum;
llv = IW_HTOILL(llv);
assert(sp + sizeof(llv) <= IWFSM_CUSTOM_HDR_DATA_OFFSET);
memcpy(hdr + sp, &llv, sizeof(llv));
sp += sizeof(llv);
/* Cumulative number of records acquired by `allocated` */
lv = fsm->crznum;
lv = IW_HTOIL(lv);
assert(sp + sizeof(lv) <= IWFSM_CUSTOM_HDR_DATA_OFFSET);
memcpy(hdr + sp, &lv, sizeof(lv));
sp += sizeof(lv);
/* Record sizes standard variance (deviation^2 * N) */
llv = fsm->crzvar;
llv = IW_HTOILL(llv);
assert(sp + sizeof(lv) <= IWFSM_CUSTOM_HDR_DATA_OFFSET);
memcpy(hdr + sp, &llv, sizeof(llv));
sp += sizeof(llv);
/* Reserved */
sp += 32;
/* Size of header */
lv = fsm->hdrlen;
lv = IW_HTOIL(lv);
assert(sp + sizeof(lv) <= IWFSM_CUSTOM_HDR_DATA_OFFSET);
memcpy(hdr + sp, &lv, sizeof(lv));
sp += sizeof(lv);
assert(sp == IWFSM_CUSTOM_HDR_DATA_OFFSET);
return fsm->pool.write(&fsm->pool, 0, hdr, IWFSM_CUSTOM_HDR_DATA_OFFSET, &wlen);
}
/**
* @brief Search for the first next set bit position
* starting from the specified offset bit (INCLUDED).
*/
static uint64_t _fsm_find_next_set_bit(
const uint64_t *addr,
register uint64_t offset_bit,
const uint64_t max_offset_bit,
int *found
) {
*found = 0;
register uint64_t bit, size;
register const uint64_t *p = addr + offset_bit / 64;
if (offset_bit >= max_offset_bit) {
return 0;
}
bit = offset_bit & (64 - 1);
offset_bit -= bit;
size = max_offset_bit - offset_bit;
#ifdef IW_BIGENDIAN
uint64_t pv = *p;
if (bit) {
pv = IW_ITOHLL(pv) & (~((uint64_t) 0) << bit);
if (pv) {
pv = iwbits_find_first_sbit64(pv);
if (pv >= size) {
return 0;
} else {
*found = 1;
return offset_bit + pv;
}
}
if (size <= 64) {
return 0;
}
offset_bit += 64;
size -= 64;
++p;
}
while (size & ~(64 - 1)) {
pv = *(p++);
if (pv) {
*found = 1;
return offset_bit + iwbits_find_first_sbit64(IW_ITOHLL(pv));
}
offset_bit += 64;
size -= 64;
}
if (!size) {
return 0;
}
pv = *p;
pv = IW_ITOHLL(pv) & (~((uint64_t) 0) >> (64 - size));
if (pv) {
*found = 1;
return offset_bit + iwbits_find_first_sbit64(pv);
} else {
return 0;
}
#else
register uint64_t tmp;
if (bit) {
tmp = *p & (~((uint64_t) 0) << bit);
if (tmp) {
tmp = iwbits_find_first_sbit64(tmp);
if (tmp >= size) {
return 0;
} else {
*found = 1;
return offset_bit + tmp;
}
}
if (size <= 64) {
return 0;
}
offset_bit += 64;
size -= 64;
++p;
}
while (size & ~(64 - 1)) {
if ((tmp = *(p++))) {
*found = 1;
return offset_bit + iwbits_find_first_sbit64(tmp);
}
offset_bit += 64;
size -= 64;
}
if (!size) {
return 0;
}
tmp = (*p) & (~((uint64_t) 0) >> (64 - size));
if (tmp) {
*found = 1;
return offset_bit + iwbits_find_first_sbit64(tmp);
} else {
return 0;
}
#endif
}
/**
* @brief Search for the first previous set bit position
* starting from the specified offset_bit (EXCLUDED).
*/
static uint64_t _fsm_find_prev_set_bit(
const uint64_t *addr,
register uint64_t offset_bit,
const uint64_t min_offset_bit,
int *found
) {
register const uint64_t *p;
register uint64_t tmp, bit, size;
*found = 0;
if (min_offset_bit >= offset_bit) {
return 0;
}
size = offset_bit - min_offset_bit;
bit = offset_bit & (64 - 1);
p = addr + offset_bit / 64;
#ifdef IW_BIGENDIAN
uint64_t pv;
if (bit) {
pv = *p;
pv = (iwbits_reverse_64(IW_ITOHLL(pv)) >> (64 - bit));
if (pv) {
pv = iwbits_find_first_sbit64(pv);
if (pv >= size) {
return 0;
} else {
*found = 1;
assert(offset_bit > pv);
return offset_bit > pv ? offset_bit - pv - 1 : 0;
}
}
offset_bit -= bit;
size -= bit;
}
while (size & ~(64 - 1)) {
if (*(--p)) {
pv = *p;
*found = 1;
tmp = iwbits_find_first_sbit64(iwbits_reverse_64(IW_ITOHLL(pv)));
assert(offset_bit > tmp);
return offset_bit > tmp ? offset_bit - tmp - 1 : 0;
}
offset_bit -= 64;
size -= 64;
}
if (size == 0) {
return 0;
}
pv = *(--p);
tmp = iwbits_reverse_64(IW_ITOHLL(pv)) & ((((uint64_t) 1) << size) - 1);
#else
if (bit) {
tmp = (iwbits_reverse_64(*p) >> (64 - bit));
if (tmp) {
tmp = iwbits_find_first_sbit64(tmp);
if (tmp >= size) {
return 0;
} else {
*found = 1;
assert(offset_bit > tmp);
return offset_bit > tmp ? offset_bit - tmp - 1 : 0;
}
}
offset_bit -= bit;
size -= bit;
}
while (size & ~(64 - 1)) {
if (*(--p)) {
*found = 1;
tmp = iwbits_find_first_sbit64(iwbits_reverse_64(*p));
assert(offset_bit > tmp);
return offset_bit > tmp ? offset_bit - tmp - 1 : 0;
}
offset_bit -= 64;
size -= 64;
}
if (size == 0) {
return 0;
}
tmp = iwbits_reverse_64(*(--p)) & ((((uint64_t) 1) << size) - 1);
#endif
if (tmp) {
uint64_t tmp2;
*found = 1;
tmp2 = iwbits_find_first_sbit64(tmp);
assert(offset_bit > tmp2);
return offset_bit > tmp2 ? offset_bit - tmp2 - 1 : 0;
} else {
return 0;
}
}
/**
* @brief Return a previously allocated blocks
* back into the free-blocks pool.
*
* @param fms `struct fsm`
* @param offset_blk Starting block number of the specified range.
* @param length_blk Range size in blocks.
*/
static iwrc _fsm_blk_deallocate_lw(
struct fsm *fsm,
const uint64_t offset_blk,
const uint64_t length_blk
) {
iwrc rc;
uint64_t *bmptr;
uint64_t left, right;
int hasleft = 0, hasright = 0;
uint64_t key_offset = offset_blk, key_length = length_blk;
uint64_t rm_offset = 0, rm_length = 0;
uint64_t lfbkoff = fsm->lfbkoff;
uint64_t end_offset_blk = offset_blk + length_blk;
fsm_bmopts_t bopts = FSM_BM_NONE;
if (fsm->oflags & IWFSM_STRICT) {
bopts |= FSM_BM_STRICT;
}
rc = _fsm_set_bit_status_lw(fsm, offset_blk, length_blk, 0, bopts);
RCRET(rc);
rc = _fsm_bmptr(fsm, &bmptr);
RCRET(rc);
/* Merge with neighborhoods */
left = _fsm_find_prev_set_bit(bmptr, offset_blk, 0, &hasleft);
if (lfbkoff && (lfbkoff == end_offset_blk)) {
right = lfbkoff + fsm->lfbklen;
hasright = 1;
} else {
uint64_t maxoff = lfbkoff ? lfbkoff : (fsm->bmlen << 3);
right = _fsm_find_next_set_bit(bmptr, end_offset_blk, maxoff, &hasright);
}
if (hasleft) {
if (offset_blk > left + 1) {
left += 1;
rm_offset = left;
rm_length = offset_blk - left;
_fsm_del_fbk(fsm, rm_offset, rm_length);
key_offset = rm_offset;
key_length += rm_length;
}
} else if (offset_blk > 0) { /* zero start */
rm_offset = 0;
rm_length = offset_blk;
_fsm_del_fbk(fsm, rm_offset, rm_length);
key_offset = rm_offset;
key_length += rm_length;
}
if (hasright && (right > end_offset_blk)) {
rm_offset = end_offset_blk;
rm_length = right - end_offset_blk;
_fsm_del_fbk(fsm, rm_offset, rm_length);
key_length += rm_length;
}
IWRC(_fsm_put_fbk(fsm, key_offset, key_length), rc);
return rc;
}
/**
* @brief Initialize a new free-space bitmap area.
*
* If bitmap exists, its content will be moved into newly created area.
* Blocks from the previous bitmap are will disposed and deallocated.
*
* @param fsm `struct fsm
* @param bmoff Byte offset of the new bitmap. Value must be page aligned.
* @param bmlen Byte length of the new bitmap. Value must be page aligned.
Its length must not be lesser than length of old bitmap.
*/
static iwrc _fsm_init_lw(struct fsm *fsm, uint64_t bmoff, uint64_t bmlen) {
iwrc rc;
uint8_t *mm, *mm2;
size_t sp, sp2;
uint64_t old_bmoff, old_bmlen;
IWFS_EXT *pool = &fsm->pool;
if ((bmlen & ((1U << fsm->bpow) - 1)) || (bmoff & ((1U << fsm->bpow) - 1)) || (bmoff & (fsm->aunit - 1))) {
return IWFS_ERROR_RANGE_NOT_ALIGNED;
}
if (bmlen < fsm->bmlen) {
rc = IW_ERROR_INVALID_ARGS;
iwlog_ecode_error(rc, "Length of the newly initiated bitmap area (bmlen): %" PRIu64
" must not be lesser than the current bitmap area length %" PRIu64 "",
bmlen, fsm->bmlen);
return rc;
}
if (bmlen * 8 < ((bmoff + bmlen) >> fsm->bpow) + 1) {
rc = IW_ERROR_INVALID_ARGS;
iwlog_ecode_error(rc, "Length of the newly initiated bitmap area (bmlen): %" PRIu64
" is not enough to handle bitmap itself and the file header area.",
bmlen);
return rc;
}
rc = _fsm_ensure_size_lw(fsm, bmoff + bmlen);
RCRET(rc);
if (fsm->mmap_all) {
// get mmap area without locking, since we ensured what pool file will not be remapped
rc = pool->probe_mmap(pool, 0, &mm, &sp);
RCRET(rc);
if (sp < bmoff + bmlen) {
return IWFS_ERROR_NOT_MMAPED;
} else {
mm += bmoff;
}
} else {
// get mmap area without locking, since we ensured what pool file will not be remapped
rc = pool->probe_mmap(pool, bmoff, &mm, &sp);
RCRET(rc);
if (sp < bmlen) {
return IWFS_ERROR_NOT_MMAPED;
}
}
if (fsm->bmlen) {
/* We have an old active bitmap. Lets copy its content to the new location.*/
if (IW_RANGES_OVERLAP(fsm->bmoff, fsm->bmoff + fsm->bmlen, bmoff, bmoff + bmlen)) {
iwlog_ecode_error2(rc, "New and old bitmap areas are overlaped");
return IW_ERROR_INVALID_ARGS;
}
if (fsm->mmap_all) {
mm2 = mm - bmoff + fsm->bmoff;
} else {
rc = pool->probe_mmap(pool, fsm->bmoff, &mm2, &sp2);
if (!rc && (sp2 < fsm->bmlen)) {
rc = IWFS_ERROR_NOT_MMAPED;
}
if (rc) {
iwlog_ecode_error2(rc, "Old bitmap area is not mmaped");
return rc;
}
}
assert(!((fsm->bmlen - bmlen) & ((1U << fsm->bpow) - 1)));
if (fsm->dlsnr) {
rc = fsm->dlsnr->onwrite(fsm->dlsnr, bmoff, mm2, fsm->bmlen, 0);
RCRET(rc);
}
memcpy(mm, mm2, fsm->bmlen);
if (bmlen > fsm->bmlen) {
memset(mm + fsm->bmlen, 0, bmlen - fsm->bmlen);
if (fsm->dlsnr) {
rc = fsm->dlsnr->onset(fsm->dlsnr, bmoff + fsm->bmlen, 0, bmlen - fsm->bmlen, 0);
RCRET(rc);
}
}
} else {
mm2 = 0;
memset(mm, 0, bmlen);
if (fsm->dlsnr) {
rc = fsm->dlsnr->onset(fsm->dlsnr, bmoff, 0, bmlen, 0);
RCRET(rc);
}
}
/* Backup the previous bitmap range */
old_bmlen = fsm->bmlen;
old_bmoff = fsm->bmoff;
fsm->bmoff = bmoff;
fsm->bmlen = bmlen;
RCC(rc, rollback, _fsm_set_bit_status_lw(fsm, (bmoff >> fsm->bpow), (bmlen >> fsm->bpow), 1, FSM_BM_NONE));
if (!old_bmlen) { /* First time initialization */
/* Header allocation */
RCC(rc, rollback, _fsm_set_bit_status_lw(fsm, 0, (fsm->hdrlen >> fsm->bpow), 1, FSM_BM_NONE));
}
/* Reload fsm tree */
_fsm_load_fsm_lw(fsm, mm, bmlen);
/* Flush new meta */
RCC(rc, rollback, _fsm_write_meta_lw(fsm));
RCC(rc, rollback, pool->sync(pool, IWFS_FDATASYNC));
if (old_bmlen) {
/* Now we are save to deallocate the old bitmap */
rc = _fsm_blk_deallocate_lw(fsm, (old_bmoff >> fsm->bpow), (old_bmlen >> fsm->bpow));
if (!fsm->mmap_all) {
pool->remove_mmap(pool, old_bmoff);
}
}
return rc;
rollback:
/* try to rollback previous bitmap state */
fsm->bmoff = old_bmoff;
fsm->bmlen = old_bmlen;
if (old_bmlen && mm2) {
_fsm_load_fsm_lw(fsm, mm2, old_bmlen);
}
pool->sync(pool, IWFS_FDATASYNC);
return rc;
}
/**
* @brief Resize bitmap area.
* @param fsm `structfsm
* @param size New size of bitmap area in bytes.
*/
static iwrc _fsm_resize_fsm_bitmap_lw(struct fsm *fsm, uint64_t size) {
iwrc rc;
uint64_t bmoffset = 0, bmlen, sp;
IWFS_EXT *pool = &fsm->pool;
if (fsm->bmlen >= size) {
return 0;
}
bmlen = IW_ROUNDUP(size, fsm->aunit); /* align to the system page size. */
rc = _fsm_blk_allocate_aligned_lw(
fsm, (bmlen >> fsm->bpow), &bmoffset, &sp, UINT64_MAX,
IWFSM_ALLOC_NO_STATS | IWFSM_ALLOC_NO_EXTEND | IWFSM_ALLOC_NO_OVERALLOCATE);
if (!rc) {
bmoffset = bmoffset << fsm->bpow;
bmlen = sp << fsm->bpow;
} else if (rc == IWFS_ERROR_NO_FREE_SPACE) {
bmoffset = fsm->bmlen * (1 << fsm->bpow) * 8;
bmoffset = IW_ROUNDUP(bmoffset, fsm->aunit);
}
if (!fsm->mmap_all) {
rc = pool->add_mmap(pool, bmoffset, bmlen, fsm->mmap_opts);
RCRET(rc);
}
rc = _fsm_init_lw(fsm, bmoffset, bmlen);
if (rc && !fsm->mmap_all) {
pool->remove_mmap(pool, bmoffset);
}
return rc;
}
/**
* @brief Allocate a continuous segment of blocks.
*
* @param fsm `struct fsm
* @param length_blk Desired segment length in blocks.
* @param [in,out] offset_blk Allocated segment offset in blocks will be stored into.
* It also specified the desired segment offset to provide allocation locality.
* @param [out] olength_blk Assigned segment length in blocks.
* @param opts
*/
static iwrc _fsm_blk_allocate_lw(
struct fsm *fsm,
uint64_t length_blk,
uint64_t *offset_blk,
uint64_t *olength_blk,
iwfs_fsm_aflags opts
) {
iwrc rc;
struct iwavl_node *nn;
fsm_bmopts_t bopts = FSM_BM_NONE;
if (opts & IWFSM_ALLOC_PAGE_ALIGNED) {
while (1) {
rc = _fsm_blk_allocate_aligned_lw(fsm, length_blk, offset_blk, olength_blk, UINT64_MAX, opts);
if (rc == IWFS_ERROR_NO_FREE_SPACE) {
if (opts & IWFSM_ALLOC_NO_EXTEND) {
return IWFS_ERROR_NO_FREE_SPACE;
}
rc = _fsm_resize_fsm_bitmap_lw(fsm, fsm->bmlen << 1);
RCRET(rc);
continue;
}
if (!rc && (opts & IWFSM_SOLID_ALLOCATED_SPACE)) {
uint64_t bs = *offset_blk;
int64_t bl = *olength_blk;
rc = _fsm_ensure_size_lw(fsm, (bs << fsm->bpow) + (bl << fsm->bpow));
}
return rc;
}
}
*olength_blk = length_blk;
start:
nn = (struct iwavl_node*) _fsm_find_matching_fblock_lw(fsm, *offset_blk, length_blk, opts);
if (nn) { /* use existing free space block */
const struct bkey *nk = &BKEY(nn);
uint64_t nlength = FSMBK_LENGTH(nk);
*offset_blk = FSMBK_OFFSET(nk);
_fsm_del_fbk2(fsm, nn);
if (nlength > length_blk) { /* re-save rest of free-space */
if (!(opts & IWFSM_ALLOC_NO_OVERALLOCATE) && fsm->crznum) {
/* todo use lognormal distribution? */
double_t d = ((double_t) fsm->crzsum / (double_t) fsm->crznum) /*avg*/
- (double) (nlength - length_blk); /*rest blk size*/
double_t s = ((double_t) fsm->crzvar / (double_t) fsm->crznum) * 6.0; /* blk size dispersion * 6 */
if ((s > 1) && (d > 0) && (d * d > s)) {
/* its better to attach rest of block to
the record */
*olength_blk = nlength;
} else {
_fsm_put_fbk(fsm, (*offset_blk + length_blk), (nlength - length_blk));
}
} else {
_fsm_put_fbk(fsm, (*offset_blk + length_blk), (nlength - length_blk));
}
}
} else {
if (opts & IWFSM_ALLOC_NO_EXTEND) {
return IWFS_ERROR_NO_FREE_SPACE;
}
rc = _fsm_resize_fsm_bitmap_lw(fsm, fsm->bmlen << 1);
RCRET(rc);
goto start;
}
if (fsm->oflags & IWFSM_STRICT) {
bopts |= FSM_BM_STRICT;
}
rc = _fsm_set_bit_status_lw(fsm, *offset_blk, *olength_blk, 1, bopts);
if (!rc && !(opts & IWFSM_ALLOC_NO_STATS)) {
double_t avg;
/* Update allocation statistics */
if (fsm->crznum > FSM_MAX_STATS_COUNT) {
fsm->crznum = 0;
fsm->crzsum = 0;
fsm->crzvar = 0;
}
++fsm->crznum;
fsm->crzsum += length_blk;
avg = (double_t) fsm->crzsum / (double_t) fsm->crznum; /* average */
fsm->crzvar
+= (uint64_t) (((double_t) length_blk - avg) * ((double_t) length_blk - avg) + 0.5L); /* variance */
}
if (!rc && (opts & IWFSM_SOLID_ALLOCATED_SPACE)) {
uint64_t bs = *offset_blk;
int64_t bl = *olength_blk;
rc = _fsm_ensure_size_lw(fsm, (bs << fsm->bpow) + (bl << fsm->bpow));
}
if (!rc && (opts & IWFSM_SYNC_BMAP)) {
uint64_t *bmptr;
if (!_fsm_bmptr(fsm, &bmptr)) {
IWFS_EXT *pool = &fsm->pool;
rc = pool->sync_mmap(pool, fsm->bmoff, IWFS_SYNCDEFAULT);
}
}
return rc;
}
/**
* @brief Remove all free blocks from the and of file and trim its size.
*/
static iwrc _fsm_trim_tail_lw(struct fsm *fsm) {
iwrc rc;
int hasleft;
uint64_t length, lastblk, *bmptr;
IWFS_EXT_STATE fstate;
uint64_t offset = 0;
if (!(fsm->omode & IWFS_OWRITE)) {
return 0;
}
/* find free space for fsm with lesser offset than actual */
rc = _fsm_blk_allocate_aligned_lw(
fsm, (fsm->bmlen >> fsm->bpow), &offset, &length, (fsm->bmoff >> fsm->bpow),
IWFSM_ALLOC_NO_EXTEND | IWFSM_ALLOC_NO_OVERALLOCATE | IWFSM_ALLOC_NO_STATS);
if (rc && (rc != IWFS_ERROR_NO_FREE_SPACE)) {
return rc;
}
if (rc) {
rc = 0;
} else if ((offset << fsm->bpow) < fsm->bmoff) {
offset = offset << fsm->bpow;
length = length << fsm->bpow;
assert(offset != fsm->bmoff);
fsm->pool.add_mmap(&fsm->pool, offset, length, fsm->mmap_opts);
RCC(rc, finish, _fsm_init_lw(fsm, offset, length));
} else {
/* shoud never be reached */
assert(0);
RCC(rc, finish, _fsm_blk_deallocate_lw(fsm, offset, length));
}
RCC(rc, finish, _fsm_bmptr(fsm, &bmptr)); // -V519
lastblk = (fsm->bmoff + fsm->bmlen) >> fsm->bpow;
offset = _fsm_find_prev_set_bit(bmptr, (fsm->bmlen << 3), lastblk, &hasleft);
if (hasleft) {
lastblk = offset + 1;
}
rc = fsm->pool.state(&fsm->pool, &fstate);
if (!rc && (fstate.fsize > (lastblk << fsm->bpow))) {
rc = fsm->pool.truncate(&fsm->pool, lastblk << fsm->bpow);
}
finish:
return rc;
}
static iwrc _fsm_init_impl(struct fsm *fsm, const IWFS_FSM_OPTS *opts) {
fsm->oflags = opts->oflags;
fsm->aunit = iwp_alloc_unit();
fsm->bpow = opts->bpow;
fsm->mmap_all = opts->mmap_all;
if (!fsm->bpow) {
fsm->bpow = 6; // 64bit block
} else if (fsm->bpow > FSM_MAX_BLOCK_POW) {
return IWFS_ERROR_INVALID_BLOCK_SIZE;
} else if ((1U << fsm->bpow) > fsm->aunit) {
return IWFS_ERROR_PLATFORM_PAGE;
}
return 0;
}
static iwrc _fsm_init_locks(struct fsm *fsm, const IWFS_FSM_OPTS *opts) {
if (opts->oflags & IWFSM_NOLOCKS) {
fsm->ctlrwlk = 0;
return 0;
}
fsm->ctlrwlk = calloc(1, sizeof(*fsm->ctlrwlk));
if (!fsm->ctlrwlk) {
return iwrc_set_errno(IW_ERROR_ALLOC, errno);
}
int rci = pthread_rwlock_init(fsm->ctlrwlk, 0);
if (rci) {
free(fsm->ctlrwlk);
fsm->ctlrwlk = 0;
return iwrc_set_errno(IW_ERROR_THREADING_ERRNO, rci);
}
return 0;
}
static iwrc _fsm_destroy_locks(struct fsm *fsm) {
if (!fsm->ctlrwlk) {
return 0;
}
iwrc rc = 0;
int rci = pthread_rwlock_destroy(fsm->ctlrwlk);
if (rci) {
IWRC(iwrc_set_errno(IW_ERROR_THREADING_ERRNO, rci), rc);
}
free(fsm->ctlrwlk);
fsm->ctlrwlk = 0;
return rc;
}
static iwrc _fsm_read_meta_lr(struct fsm *fsm) {
iwrc rc;
uint32_t lv;
uint64_t llv;
size_t sp, rp = 0;
uint8_t hdr[IWFSM_CUSTOM_HDR_DATA_OFFSET] = { 0 };
/*
[FSM_CTL_MAGICK u32][block pow u8]
[bmoffset u64][bmlength u64]
[u64 crzsum][u32 crznum][u64 crszvar][u256 reserved]
[custom header size u32][custom header data...]
[fsm data...]
*/
rc = fsm->pool.read(&fsm->pool, 0, hdr, IWFSM_CUSTOM_HDR_DATA_OFFSET, &sp);
if (rc) {
iwlog_ecode_error3(rc);
return rc;
}
/* Magic */
memcpy(&lv, hdr + rp, sizeof(lv)); // -V512
lv = IW_ITOHL(lv);
if (lv != IWFSM_MAGICK) {
rc = IWFS_ERROR_INVALID_FILEMETA;
iwlog_ecode_error2(rc, "Invalid file magic number");
return rc;
}
rp += sizeof(lv);
/* Block pow */
memcpy(&fsm->bpow, hdr + rp, sizeof(fsm->bpow));
rp += sizeof(fsm->bpow);
if (fsm->bpow > FSM_MAX_BLOCK_POW) {
rc = IWFS_ERROR_INVALID_FILEMETA;
iwlog_ecode_error(rc, "Invalid file blocks pow: %u", fsm->bpow);
return rc;
}
if ((1U << fsm->bpow) > fsm->aunit) {
rc = IWFS_ERROR_PLATFORM_PAGE;
iwlog_ecode_error(rc, "Block size: %u must not be greater than system page size: %zu",
(1U << fsm->bpow), fsm->aunit);
}
/* Free-space bitmap offset */
memcpy(&llv, hdr + rp, sizeof(llv));
llv = IW_ITOHLL(llv);
fsm->bmoff = llv;
rp += sizeof(llv);
/* Free-space bitmap length */
memcpy(&llv, hdr + rp, sizeof(llv));
llv = IW_ITOHLL(llv);
fsm->bmlen = llv;
if (llv & (64 - 1)) {
rc = IWFS_ERROR_INVALID_FILEMETA;
iwlog_ecode_error(rc, "Free-space bitmap length is not 64bit aligned: %" PRIuMAX "", fsm->bmlen);
}
rp += sizeof(llv);
/* Cumulative sum of record sizes acquired by `allocate` */
memcpy(&llv, hdr + rp, sizeof(llv));
llv = IW_ITOHLL(llv);
fsm->crzsum = llv;
rp += sizeof(llv);
/* Cumulative number of records acquired by `allocated` */
memcpy(&lv, hdr + rp, sizeof(lv));
lv = IW_ITOHL(lv);
fsm->crznum = lv;
rp += sizeof(lv);
/* Record sizes standard variance (deviation^2 * N) */
memcpy(&llv, hdr + rp, sizeof(llv));
llv = IW_ITOHLL(llv);
fsm->crzvar = llv;
rp += sizeof(llv);
/* Reserved */
rp += 32;
/* Header size */
memcpy(&lv, hdr + rp, sizeof(lv));
lv = IW_ITOHL(lv);
fsm->hdrlen = lv;
rp += sizeof(lv);
assert(rp == IWFSM_CUSTOM_HDR_DATA_OFFSET);
return rc;
}
static iwrc _fsm_init_new_lw(struct fsm *fsm, const IWFS_FSM_OPTS *opts) {
FSM_ENSURE_OPEN(fsm);
iwrc rc;
uint64_t bmlen, bmoff;
IWFS_EXT *pool = &fsm->pool;
assert(fsm->aunit && fsm->bpow);
fsm->hdrlen = opts->hdrlen + IWFSM_CUSTOM_HDR_DATA_OFFSET;
fsm->hdrlen = IW_ROUNDUP(fsm->hdrlen, 1ULL << fsm->bpow);
bmlen = opts->bmlen > 0 ? IW_ROUNDUP(opts->bmlen, fsm->aunit) : fsm->aunit;
bmoff = IW_ROUNDUP(fsm->hdrlen, fsm->aunit);
if (fsm->mmap_all) {
/* mmap whole file */
rc = pool->add_mmap(pool, 0, SIZE_T_MAX, fsm->mmap_opts);
RCRET(rc);
} else {
/* mmap header */
rc = pool->add_mmap(pool, 0, fsm->hdrlen, fsm->mmap_opts);
RCRET(rc);
/* mmap the fsm bitmap index */
rc = pool->add_mmap(pool, bmoff, bmlen, fsm->mmap_opts);
RCRET(rc);
}
return _fsm_init_lw(fsm, bmoff, bmlen);
}
static iwrc _fsm_init_existing_lw(struct fsm *fsm) {
FSM_ENSURE_OPEN(fsm);
iwrc rc;
size_t sp;
uint8_t *mm;
IWFS_EXT *pool = &fsm->pool;
RCC(rc, finish, _fsm_read_meta_lr(fsm));
if (fsm->mmap_all) {
/* mmap the whole file */
RCC(rc, finish, pool->add_mmap(pool, 0, SIZE_T_MAX, fsm->mmap_opts));
RCC(rc, finish, pool->probe_mmap(pool, 0, &mm, &sp));
if (sp < fsm->bmoff + fsm->bmlen) {
rc = IWFS_ERROR_NOT_MMAPED;
goto finish;
} else {
mm += fsm->bmoff;
}
} else {
/* mmap the header of file */
RCC(rc, finish, pool->add_mmap(pool, 0, fsm->hdrlen, fsm->mmap_opts));
/* mmap the fsm bitmap index */
RCC(rc, finish, pool->add_mmap(pool, fsm->bmoff, fsm->bmlen, fsm->mmap_opts));
RCC(rc, finish, pool->probe_mmap(pool, fsm->bmoff, &mm, &sp));
if (sp < fsm->bmlen) {
rc = IWFS_ERROR_NOT_MMAPED;
goto finish;
}
}
_fsm_load_fsm_lw(fsm, mm, fsm->bmlen);
finish:
return rc;
}
/**
* @brief Check if all blocks within the specified range have been `allocated`.
*
* @param fsm `struct fsm`
* @param offset_blk Starting block number of the specified range.
* @param length_blk Range size in blocks.
* @param [out] ret Checking result.
*/
static iwrc _fsm_is_fully_allocated_lr(struct fsm *fsm, uint64_t offset_blk, uint64_t length_blk, int *ret) {
uint64_t end = offset_blk + length_blk;
*ret = 1;
if ((length_blk < 1) || (end < offset_blk) || (end > (fsm->bmlen << 3))) {
*ret = 0;
return 0;
}
iwrc rc = _fsm_set_bit_status_lw(fsm, offset_blk, length_blk, 0, FSM_BM_DRY_RUN | FSM_BM_STRICT);
if (rc == IWFS_ERROR_FSM_SEGMENTATION) {
*ret = 0;
return 0;
}
return rc;
}
/*************************************************************************************************
* Public API *
*************************************************************************************************/
static iwrc _fsm_write(struct IWFS_FSM *f, off_t off, const void *buf, size_t siz, size_t *sp) {
FSM_ENSURE_OPEN2(f);
struct fsm *fsm = f->impl;
iwrc rc = _fsm_ctrl_rlock(fsm);
RCRET(rc);
if (fsm->oflags & IWFSM_STRICT) {
int allocated = 0;
IWRC(_fsm_is_fully_allocated_lr(fsm,
(uint64_t) off >> fsm->bpow,
IW_ROUNDUP(siz, 1ULL << fsm->bpow) >> fsm->bpow,
&allocated), rc);
if (!rc) {
if (!allocated) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
} else {
rc = fsm->pool.write(&fsm->pool, off, buf, siz, sp);
}
}
} else {
rc = fsm->pool.write(&fsm->pool, off, buf, siz, sp);
}
_fsm_ctrl_unlock(fsm);
return rc;
}
static iwrc _fsm_read(struct IWFS_FSM *f, off_t off, void *buf, size_t siz, size_t *sp) {
FSM_ENSURE_OPEN2(f);
struct fsm *fsm = f->impl;
iwrc rc = _fsm_ctrl_rlock(fsm);
RCRET(rc);
if (fsm->oflags & IWFSM_STRICT) {
int allocated = 0;
IWRC(_fsm_is_fully_allocated_lr(fsm, (uint64_t) off >> fsm->bpow,
IW_ROUNDUP(siz, 1ULL << fsm->bpow) >> fsm->bpow,
&allocated), rc);
if (!rc) {
if (!allocated) {
rc = IWFS_ERROR_FSM_SEGMENTATION;
} else {
rc = fsm->pool.read(&fsm->pool, off, buf, siz, sp);
}
}
} else {
rc = fsm->pool.read(&fsm->pool, off, buf, siz, sp);
}
_fsm_ctrl_unlock(fsm);
return rc;
}
static iwrc _fsm_sync(struct IWFS_FSM *f, iwfs_sync_flags flags) {
FSM_ENSURE_OPEN2(f);
iwrc rc = _fsm_ctrl_rlock(f->impl);
RCRET(rc);
IWRC(_fsm_write_meta_lw(f->impl), rc);
IWRC(f->impl->pool.sync(&f->impl->pool, flags), rc);
IWRC(_fsm_ctrl_unlock(f->impl), rc);
return rc;
}
static iwrc _fsm_close(struct IWFS_FSM *f) {
if (!f || !f->impl) {
return 0;
}
iwrc rc = 0;
struct fsm *fsm = f->impl;
IWRC(_fsm_ctrl_wlock(fsm), rc);
if (fsm->root && (fsm->omode & IWFS_OWRITE)) {
if (!(fsm->oflags & IWFSM_NO_TRIM_ON_CLOSE)) {
IWRC(_fsm_trim_tail_lw(fsm), rc);
}
IWRC(_fsm_write_meta_lw(fsm), rc);
if (!fsm->dlsnr) {
IWRC(fsm->pool.sync(&fsm->pool, IWFS_SYNCDEFAULT), rc);
}
}
IWRC(fsm->pool.close(&fsm->pool), rc);
_fsm_node_destroy(fsm->root);
IWRC(_fsm_ctrl_unlock(fsm), rc);
IWRC(_fsm_destroy_locks(fsm), rc);
f->impl = 0;
free(fsm);
return rc;
}
IW_INLINE iwrc _fsm_ensure_size_lw(struct fsm *fsm, off_t size) {
return fsm->pool.ensure_size(&fsm->pool, size);
}
static iwrc _fsm_ensure_size(struct IWFS_FSM *f, off_t size) {
FSM_ENSURE_OPEN2(f);
iwrc rc = _fsm_ctrl_rlock(f->impl);
RCRET(rc);
if (f->impl->bmoff + f->impl->bmlen > size) {
rc = IWFS_ERROR_RESIZE_FAIL;
goto finish;
}
rc = _fsm_ensure_size_lw(f->impl, size);
finish:
IWRC(_fsm_ctrl_unlock(f->impl), rc);
return rc;
}
static iwrc _fsm_add_mmap(struct IWFS_FSM *f, off_t off, size_t maxlen, iwfs_ext_mmap_opts_t opts) {
FSM_ENSURE_OPEN2(f);
return f->impl->pool.add_mmap(&f->impl->pool, off, maxlen, opts);
}
static iwrc _fsm_remap_all(struct IWFS_FSM *f) {
FSM_ENSURE_OPEN2(f);
return f->impl->pool.remap_all(&f->impl->pool);
}
iwrc _fsm_acquire_mmap(struct IWFS_FSM *f, off_t off, uint8_t **mm, size_t *sp) {
return f->impl->pool.acquire_mmap(&f->impl->pool, off, mm, sp);
}
iwrc _fsm_release_mmap(struct IWFS_FSM *f) {
return f->impl->pool.release_mmap(&f->impl->pool);
}
static iwrc _fsm_probe_mmap(struct IWFS_FSM *f, off_t off, uint8_t **mm, size_t *sp) {
FSM_ENSURE_OPEN2(f);
return f->impl->pool.probe_mmap(&f->impl->pool, off, mm, sp);
}
static iwrc _fsm_remove_mmap(struct IWFS_FSM *f, off_t off) {
FSM_ENSURE_OPEN2(f);
return f->impl->pool.remove_mmap(&f->impl->pool, off);
}
static iwrc _fsm_sync_mmap(struct IWFS_FSM *f, off_t off, iwfs_sync_flags flags) {
FSM_ENSURE_OPEN2(f);
return f->impl->pool.sync_mmap(&f->impl->pool, off, flags);
}
static iwrc _fsm_allocate(struct IWFS_FSM *f, off_t len, off_t *oaddr, off_t *olen, iwfs_fsm_aflags opts) {
FSM_ENSURE_OPEN2(f);
iwrc rc;
uint64_t sbnum, nlen;
struct fsm *fsm = f->impl;
*olen = 0;
if (!(fsm->omode & IWFS_OWRITE)) {
return IW_ERROR_READONLY;
}
if (len <= 0) {
return IW_ERROR_INVALID_ARGS;
}
/* Required blocks number */
sbnum = (uint64_t) *oaddr >> fsm->bpow;
len = IW_ROUNDUP(len, 1ULL << fsm->bpow);
rc = _fsm_ctrl_wlock(fsm);
RCRET(rc);
rc = _fsm_blk_allocate_lw(f->impl, (uint64_t) len >> fsm->bpow, &sbnum, &nlen, opts);
if (!rc) {
*olen = (nlen << fsm->bpow);
*oaddr = (sbnum << fsm->bpow);
}
IWRC(_fsm_ctrl_unlock(fsm), rc);
return rc;
}
static iwrc _fsm_reallocate(struct IWFS_FSM *f, off_t nlen, off_t *oaddr, off_t *olen, iwfs_fsm_aflags opts) {
FSM_ENSURE_OPEN2(f);
iwrc rc;
struct fsm *fsm = f->impl;
if (!(fsm->omode & IWFS_OWRITE)) {
return IW_ERROR_READONLY;
}
if ((*oaddr & ((1ULL << fsm->bpow) - 1)) || (*olen & ((1ULL << fsm->bpow) - 1))) {
return IWFS_ERROR_RANGE_NOT_ALIGNED;
}
uint64_t sp;
uint64_t nlen_blk = IW_ROUNDUP((uint64_t) nlen, 1ULL << fsm->bpow) >> fsm->bpow;
uint64_t olen_blk = (uint64_t) *olen >> fsm->bpow;
uint64_t oaddr_blk = (uint64_t) *oaddr >> fsm->bpow;
uint64_t naddr_blk = oaddr_blk;
if (nlen_blk == olen_blk) {
return 0;
}
rc = _fsm_ctrl_wlock(fsm);
RCRET(rc);
if (nlen_blk < olen_blk) {
rc = _fsm_blk_deallocate_lw(fsm, oaddr_blk + nlen_blk, olen_blk - nlen_blk);
if (!rc) {
*oaddr = oaddr_blk << fsm->bpow;
*olen = nlen_blk << fsm->bpow;
}
} else {
RCC(rc, finish, _fsm_blk_allocate_lw(fsm, nlen_blk, &naddr_blk, &sp, opts));
if (naddr_blk != oaddr_blk) {
RCC(rc, finish, fsm->pool.copy(&fsm->pool, *oaddr, (size_t) *olen, naddr_blk << fsm->bpow));
}
RCC(rc, finish, _fsm_blk_deallocate_lw(fsm, oaddr_blk, olen_blk));
*oaddr = naddr_blk << fsm->bpow;
*olen = sp << fsm->bpow;
}
finish:
IWRC(_fsm_ctrl_unlock(fsm), rc);
return rc;
}
static iwrc _fsm_deallocate(struct IWFS_FSM *f, off_t addr, off_t len) {
FSM_ENSURE_OPEN2(f);
iwrc rc;
struct fsm *fsm = f->impl;
off_t offset_blk = (uint64_t) addr >> fsm->bpow;
off_t length_blk = (uint64_t) len >> fsm->bpow;
if (!(fsm->omode & IWFS_OWRITE)) {
return IW_ERROR_READONLY;
}
if (addr & ((1ULL << fsm->bpow) - 1)) {
return IWFS_ERROR_RANGE_NOT_ALIGNED;
}
rc = _fsm_ctrl_wlock(fsm);
RCRET(rc);
if ( IW_RANGES_OVERLAP(offset_blk, offset_blk + length_blk, 0, (fsm->hdrlen >> fsm->bpow))
|| IW_RANGES_OVERLAP(offset_blk, offset_blk + length_blk, (fsm->bmoff >> fsm->bpow),
(fsm->bmoff >> fsm->bpow) + (fsm->bmlen >> fsm->bpow))) {
// Deny deallocations in header or free-space bitmap itself
IWRC(_fsm_ctrl_unlock(fsm), rc);
return IWFS_ERROR_FSM_SEGMENTATION;
}
rc = _fsm_blk_deallocate_lw(fsm, (uint64_t) offset_blk, (uint64_t) length_blk);
IWRC(_fsm_ctrl_unlock(fsm), rc);
return rc;
}
static iwrc _fsm_check_allocation_status(struct IWFS_FSM *f, off_t addr, off_t len, bool allocated) {
struct fsm *fsm = f->impl;
if ((addr & ((1ULL << fsm->bpow) - 1)) || (len & ((1ULL << fsm->bpow) - 1))) {
return IWFS_ERROR_RANGE_NOT_ALIGNED;
}
iwrc rc = _fsm_ctrl_rlock(fsm);
RCRET(rc);
off_t offset_blk = (uint64_t) addr >> fsm->bpow;
off_t length_blk = (uint64_t) len >> fsm->bpow;
if ( IW_RANGES_OVERLAP(offset_blk, offset_blk + length_blk, 0, (fsm->hdrlen >> fsm->bpow))
|| IW_RANGES_OVERLAP(offset_blk, offset_blk + length_blk, (fsm->bmoff >> fsm->bpow),
(fsm->bmoff >> fsm->bpow) + (fsm->bmlen >> fsm->bpow))) {
IWRC(_fsm_ctrl_unlock(fsm), rc);
return IWFS_ERROR_FSM_SEGMENTATION;
}
rc = _fsm_set_bit_status_lw(fsm, (uint64_t) offset_blk, (uint64_t) length_blk,
allocated ? 0 : 1, FSM_BM_DRY_RUN | FSM_BM_STRICT);
IWRC(_fsm_ctrl_unlock(fsm), rc);
return rc;
}
static iwrc _fsm_writehdr(struct IWFS_FSM *f, off_t off, const void *buf, off_t siz) {
FSM_ENSURE_OPEN2(f);
iwrc rc;
uint8_t *mm;
if (siz < 1) {
return 0;
}
struct fsm *fsm = f->impl;
if ((IWFSM_CUSTOM_HDR_DATA_OFFSET + off + siz) > fsm->hdrlen) {
return IW_ERROR_OUT_OF_BOUNDS;
}
rc = fsm->pool.acquire_mmap(&fsm->pool, 0, &mm, 0);
if (!rc) {
if (fsm->dlsnr) {
rc = fsm->dlsnr->onwrite(fsm->dlsnr, IWFSM_CUSTOM_HDR_DATA_OFFSET + off, buf, siz, 0);
}
memmove(mm + IWFSM_CUSTOM_HDR_DATA_OFFSET + off, buf, (size_t) siz);
IWRC(fsm->pool.release_mmap(&fsm->pool), rc);
}
return rc;
}
static iwrc _fsm_readhdr(struct IWFS_FSM *f, off_t off, void *buf, off_t siz) {
FSM_ENSURE_OPEN2(f);
iwrc rc;
uint8_t *mm;
if (siz < 1) {
return 0;
}
struct fsm *fsm = f->impl;
if ((IWFSM_CUSTOM_HDR_DATA_OFFSET + off + siz) > fsm->hdrlen) {
return IW_ERROR_OUT_OF_BOUNDS;
}
rc = fsm->pool.acquire_mmap(&fsm->pool, 0, &mm, 0);
if (!rc) {
memmove(buf, mm + IWFSM_CUSTOM_HDR_DATA_OFFSET + off, (size_t) siz);
rc = fsm->pool.release_mmap(&fsm->pool);
}
return rc;
}
static iwrc _fsm_clear(struct IWFS_FSM *f, iwfs_fsm_clrfalgs clrflags) {
FSM_ENSURE_OPEN2(f);
struct fsm *fsm = f->impl;
uint64_t bmoff, bmlen;
iwrc rc = _fsm_ctrl_wlock(fsm);
bmlen = fsm->bmlen;
if (!bmlen) {
goto finish;
}
if (!fsm->mmap_all && fsm->bmoff) {
IWRC(fsm->pool.remove_mmap(&fsm->pool, fsm->bmoff), rc);
}
bmoff = IW_ROUNDUP(fsm->hdrlen, fsm->aunit);
if (!fsm->mmap_all) {
IWRC(fsm->pool.add_mmap(&fsm->pool, bmoff, bmlen, fsm->mmap_opts), rc);
}
RCGO(rc, finish);
fsm->bmlen = 0;
fsm->bmoff = 0;
rc = _fsm_init_lw(fsm, bmoff, bmlen);
if (!rc && (clrflags & IWFSM_CLEAR_TRIM)) {
rc = _fsm_trim_tail_lw(fsm);
}
finish:
IWRC(_fsm_ctrl_unlock(fsm), rc);
return rc;
}
static iwrc _fsm_extfile(struct IWFS_FSM *f, IWFS_EXT **ext) {
FSM_ENSURE_OPEN2(f);
*ext = &f->impl->pool;
return 0;
}
static iwrc _fsm_state(struct IWFS_FSM *f, IWFS_FSM_STATE *state) {
FSM_ENSURE_OPEN2(f);
struct fsm *fsm = f->impl;
iwrc rc = _fsm_ctrl_rlock(fsm);
memset(state, 0, sizeof(*state));
IWRC(fsm->pool.state(&fsm->pool, &state->exfile), rc);
state->block_size = 1U << fsm->bpow;
state->oflags = fsm->oflags;
state->hdrlen = fsm->hdrlen;
state->blocks_num = fsm->bmlen << 3;
state->free_segments_num = fsm->fsmnum;
state->avg_alloc_size = fsm->crznum > 0 ? (double_t) fsm->crzsum / (double_t) fsm->crznum : 0;
state->alloc_dispersion = fsm->crznum > 0 ? (double_t) fsm->crzvar / (double_t) fsm->crznum : 0;
IWRC(_fsm_ctrl_unlock(fsm), rc);
return rc;
}
iwrc iwfs_fsmfile_open(IWFS_FSM *f, const IWFS_FSM_OPTS *opts) {
assert(f && opts);
iwrc rc = 0;
IWFS_EXT_STATE fstate = { 0 };
const char *path = opts->exfile.file.path;
memset(f, 0, sizeof(*f));
RCC(rc, finish, iwfs_fsmfile_init());
f->write = _fsm_write;
f->read = _fsm_read;
f->close = _fsm_close;
f->sync = _fsm_sync;
f->state = _fsm_state;
f->ensure_size = _fsm_ensure_size;
f->add_mmap = _fsm_add_mmap;
f->remap_all = _fsm_remap_all;
f->acquire_mmap = _fsm_acquire_mmap;
f->probe_mmap = _fsm_probe_mmap;
f->release_mmap = _fsm_release_mmap;
f->remove_mmap = _fsm_remove_mmap;
f->sync_mmap = _fsm_sync_mmap;
f->allocate = _fsm_allocate;
f->reallocate = _fsm_reallocate;
f->deallocate = _fsm_deallocate;
f->check_allocation_status = _fsm_check_allocation_status;
f->writehdr = _fsm_writehdr;
f->readhdr = _fsm_readhdr;
f->clear = _fsm_clear;
f->extfile = _fsm_extfile;
if (!path) {
return IW_ERROR_INVALID_ARGS;
}
struct fsm *fsm = f->impl = calloc(1, sizeof(*f->impl));
if (!fsm) {
return iwrc_set_errno(IW_ERROR_ALLOC, errno);
}
fsm->f = f;
fsm->dlsnr = opts->exfile.file.dlsnr; // Copy data changes listener address
fsm->mmap_opts = opts->mmap_opts;
IWFS_EXT_OPTS rwl_opts = opts->exfile;
rwl_opts.use_locks = !(opts->oflags & IWFSM_NOLOCKS);
RCC(rc, finish, _fsm_init_impl(fsm, opts));
RCC(rc, finish, _fsm_init_locks(fsm, opts));
RCC(rc, finish, iwfs_exfile_open(&fsm->pool, &rwl_opts));
RCC(rc, finish, fsm->pool.state(&fsm->pool, &fstate));
fsm->omode = fstate.file.opts.omode;
if (fstate.file.ostatus & IWFS_OPEN_NEW) {
rc = _fsm_init_new_lw(fsm, opts);
} else {
rc = _fsm_init_existing_lw(fsm);
}
finish:
if (rc) {
if (f->impl) {
IWRC(_fsm_destroy_locks(f->impl), rc); // we are not locked
IWRC(_fsm_close(f), rc);
}
}
return rc;
}
static const char* _fsmfile_ecodefn(locale_t locale, uint32_t ecode) {
if (!((ecode > _IWFS_FSM_ERROR_START) && (ecode < _IWFS_FSM_ERROR_END))) {
return 0;
}
switch (ecode) {
case IWFS_ERROR_NO_FREE_SPACE:
return "No free space. (IWFS_ERROR_NO_FREE_SPACE)";
case IWFS_ERROR_INVALID_BLOCK_SIZE:
return "Invalid block size specified. (IWFS_ERROR_INVALID_BLOCK_SIZE)";
case IWFS_ERROR_RANGE_NOT_ALIGNED:
return "Specified range/offset is not aligned with page/block. "
"(IWFS_ERROR_RANGE_NOT_ALIGNED)";
case IWFS_ERROR_FSM_SEGMENTATION:
return "Free-space map segmentation error. (IWFS_ERROR_FSM_SEGMENTATION)";
case IWFS_ERROR_INVALID_FILEMETA:
return "Invalid file metadata. (IWFS_ERROR_INVALID_FILEMETA)";
case IWFS_ERROR_PLATFORM_PAGE:
return "The block size incompatible with platform page size, data "
"migration required. (IWFS_ERROR_PLATFORM_PAGE)";
case IWFS_ERROR_RESIZE_FAIL:
return "Failed to resize file, "
"conflicting with free-space map location (IWFS_ERROR_RESIZE_FAIL)";
default:
break;
}
return 0;
}
iwrc iwfs_fsmfile_init(void) {
static int _fsmfile_initialized = 0;
iwrc rc = iw_init();
RCRET(rc);
if (!__sync_bool_compare_and_swap(&_fsmfile_initialized, 0, 1)) {
return 0; // initialized already
}
return iwlog_register_ecodefn(_fsmfile_ecodefn);
}
/*************************************************************************************************
* Debug API *
*************************************************************************************************/
uint64_t iwfs_fsmdbg_number_of_free_areas(IWFS_FSM *f) {
struct fsm *fsm = f->impl;
return fsm->fsmnum;
}
uint64_t iwfs_fsmdbg_find_next_set_bit(
const uint64_t *addr, uint64_t offset_bit, uint64_t max_offset_bit,
int *found
) {
return _fsm_find_next_set_bit(addr, offset_bit, max_offset_bit, found);
}
uint64_t iwfs_fsmdbg_find_prev_set_bit(
const uint64_t *addr, uint64_t offset_bit, uint64_t min_offset_bit,
int *found
) {
return _fsm_find_prev_set_bit(addr, offset_bit, min_offset_bit, found);
}
void iwfs_fsmdbg_dump_fsm_tree(IWFS_FSM *f, const char *hdr) {
assert(f);
struct fsm *fsm = f->impl;
fprintf(stderr, "FSM TREE: %s\n", hdr);
if (!fsm->root) {
fprintf(stderr, "NONE\n");
return;
}
for (struct iwavl_node *n = iwavl_first_in_order(fsm->root); n; n = iwavl_next_in_order(n)) {
struct bkey *k = &BKEY(n);
uint64_t koff = FSMBK_OFFSET(k);
uint64_t klen = FSMBK_LENGTH(k);
fprintf(stderr, "[%" PRIu64 " %" PRIu64 "]\n", koff, klen);
}
}
const char* byte_to_binary(int x) {
static char b[9];
b[0] = '\0';
int z;
for (z = 1; z <= 128; z <<= 1) {
strcat(b, ((x & z) == z) ? "1" : "0");
}
return b;
}
iwrc iwfs_fsmdb_dump_fsm_bitmap(IWFS_FSM *f) {
assert(f);
size_t sp;
uint8_t *mm;
struct fsm *fsm = f->impl;
iwrc rc;
if (fsm->mmap_all) {
rc = fsm->pool.probe_mmap(&fsm->pool, 0, &mm, &sp);
if (!rc) {
if (sp <= fsm->bmoff) {
rc = IWFS_ERROR_NOT_MMAPED;
} else {
mm += fsm->bmoff;
sp = sp - fsm->bmoff;
}
}
} else {
rc = fsm->pool.probe_mmap(&fsm->pool, fsm->bmoff, &mm, &sp);
}
if (rc) {
iwlog_ecode_error3(rc);
return rc;
}
int i = ((fsm->hdrlen >> fsm->bpow) >> 3);
// if (impl->bmoff == impl->aunit) {
// i += ((impl->bmlen >> impl->bpow) >> 3);
// }
for ( ; i < sp && i < fsm->bmlen; ++i) {
uint8_t b = *(mm + i);
fprintf(stderr, "%s", byte_to_binary(b));
}
printf("\n");
return 0;
}
iwrc iwfs_fsmdbg_state(IWFS_FSM *f, IWFS_FSMDBG_STATE *d) {
FSM_ENSURE_OPEN2(f);
struct fsm *fsm = f->impl;
iwrc rc = _fsm_ctrl_rlock(fsm);
memset(d, 0, sizeof(*d));
IWRC(fsm->pool.state(&fsm->pool, &d->state.exfile), rc);
d->state.block_size = 1U << fsm->bpow;
d->state.oflags = fsm->oflags;
d->state.hdrlen = fsm->hdrlen;
d->state.blocks_num = fsm->bmlen << 3;
d->state.free_segments_num = fsm->fsmnum;
d->state.avg_alloc_size = fsm->crznum > 0 ? (double_t) fsm->crzsum / (double_t) fsm->crznum : 0;
d->state.alloc_dispersion = fsm->crznum > 0 ? (double_t) fsm->crzvar / (double_t) fsm->crznum : 0;
d->bmoff = fsm->bmoff;
d->bmlen = fsm->bmlen;
d->lfbkoff = fsm->lfbkoff;
d->lfbklen = fsm->lfbklen;
IWRC(_fsm_ctrl_unlock(fsm), rc);
return rc;
}
|
fb79710f0b6c32e8b81ce350e9fb94740ba26b75 | b8b37e49af322dea81c0bfb4cc0c5700532d0836 | /utils/ft_lstnew_kv.c | 4ebc1fdc85189cac2dd73a9569472d181de854cc | [] | no_license | romanwrites/minishell | 7a274797572b15e3012a713307a16aceb5172fa4 | 33e4803a426cc86a04cecdd1b6f30355949f49c8 | refs/heads/master | 2023-03-23T20:56:54.400139 | 2021-03-16T19:13:49 | 2021-03-16T19:13:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,292 | c | ft_lstnew_kv.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstnew_kv.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lhelper <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/05/13 00:20:01 by mkristie #+# #+# */
/* Updated: 2020/10/14 13:30:50 by lhelper ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
#include "minishell.h"
/*
** Allocates (with malloc(3)) and returns a new element.
** content is initialized with the value of the parameter ’content’.
** The variable ’next’ is initialized to NULL
*/
t_list *ft_lstnew_kv(void *content)
{
t_list *new;
if (!(new = malloc(sizeof(t_list))))
return (NULL);
new->content = content;
new->next = NULL;
return (new);
}
|
621e00270ea997e030bc4b6c2de90e2cf70f5036 | 598737b786a20889dc6acd468478baf4972535b3 | /src/sys/arch/powerpc/include/pte.h | 92fe6f414110c891a5d72cf1ca9b73b7c04758a9 | [] | no_license | shisa/shisa-netbsd | 5c8e289de2a48b6d8f39bd3add9ca4ea48fec1da | 28d999d1c25107c126e0a458a97b9397aae592ef | refs/heads/master | 2021-01-01T05:33:32.619808 | 2008-05-26T04:27:54 | 2008-05-26T04:27:54 | 32,793,680 | 1 | 2 | null | null | null | null | UTF-8 | C | false | false | 161 | h | pte.h | /* $NetBSD: pte.h,v 1.7 2005/01/16 21:35:59 chs Exp $ */
#ifdef _KERNEL_OPT
#include "opt_ppcarch.h"
#endif
#ifdef PPC_OEA
#include <powerpc/oea/pte.h>
#endif
|
29271d81298342d830f0340f1e754e6ff33ffdd5 | 5e8183906f7f52a4c84fcdc582910ff124b0d004 | /dph/icebox/examples/dotp/legacy/dotprod.h | 7fe0e002afc60211e01c80ca5b1bae678e59fddb | [] | no_license | bzhkl/haskellStudy | 26a6d0d4b552b2cfb16489abbbac6894b786a3c4 | 9ccd617fb2f96fa94d91d1625893e6ee7f53a46c | refs/heads/master | 2021-01-12T07:50:24.309341 | 2017-03-13T11:06:54 | 2017-03-13T11:06:54 | 77,039,493 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 92 | h | dotprod.h | #ifndef DOTPROD_H
#define DOTPROD_H
float cvectorDP (float *v1, float *v2, int n);
#endif
|
e01643f53c3ffa18b3e171d1f291641e1dede018 | 3773c7971cdf5baa316fa69c4859d411e03d7ded | /5/exercises/sum_sequence.c | c6189f90e7574630875f25e4ec7e0aeb42bbcf1d | [] | no_license | stepan163/Lessons | c338652a3368c6d1362c2b1f4327b534cd10b442 | 4baab86a084b80af27ace3f71120bde9d870c5e8 | refs/heads/master | 2020-11-24T14:58:16.899911 | 2020-03-18T19:43:10 | 2020-03-18T19:43:10 | 228,204,377 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 368 | c | sum_sequence.c | #include <stdio.h>
#include <stdlib.h>
int main(void)
{
unsigned int i, repeat;
int num, total;
repeat = total = 0;
scanf("%d", &repeat);
for (i = 0; i < repeat; ++i) {
scanf("%d", &num);
total = total + num;
}
printf("Total is %d\n", total);
return EXIT_SUCCESS;
}
|
7bba2d2358e8536ba399689128cedf7555f9af0e | 72d1c7fee2524f43c54df4054abd4ea166722c72 | /main.c | 8f4f57a0a555f3a37e9fa5ce2da46c314163f08e | [] | no_license | ssulca/Tp_mpi | d1c484adbd426e556b1af9571e7d79541737768a | 845b2980730c4b398eb909678149e2560d30a096 | refs/heads/master | 2021-10-23T09:10:28.906904 | 2019-03-16T13:28:24 | 2019-03-16T13:28:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 7,839 | c | main.c | #include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#define SIZE 2000
#define HALF_SIZE SIZE/2
#define MASTER 0
#define TAG_A 1
#define TAG_B 2
#define TAG_C 3
#define ERROR 1
#define SUCCESS 0
#define COLOR_GREEN "\x1b[1;32m"
#define COLOR_RESET "\x1b[0m"
typedef int32_t my_matrix_t [SIZE][SIZE];
typedef int32_t my_sub_a_t [HALF_SIZE][SIZE];
typedef int32_t my_sub_b_t [SIZE][HALF_SIZE];
typedef int32_t my_sub_c_t [HALF_SIZE][HALF_SIZE];
int control(int32_t **matrix, int32_t size);
int main(int argc, char** argv) {
int32_t rank;
register int32_t tmp;
double start_time;
double start;
my_matrix_t* matrix_a;
my_matrix_t* matrix_b;
my_matrix_t* matrix_c;
my_sub_c_t* sub_c;
my_sub_a_t* sub_a;
my_sub_b_t* sub_b;
MPI_Init(NULL, NULL); // Initialize the MPI environment
MPI_Comm_rank(MPI_COMM_WORLD, &rank); // Get the rank of the process
/**#################################################################
###################### INICIALIZACION ###########################
##################################################################**/
sub_a = (my_sub_a_t*) malloc((HALF_SIZE)*SIZE*sizeof(int32_t)+4);
sub_b = (my_sub_b_t*) malloc(SIZE*(HALF_SIZE)*sizeof(int32_t));
sub_c = (my_sub_c_t*) malloc((HALF_SIZE)*(HALF_SIZE)*sizeof(int32_t));
if(rank == MASTER){
start = omp_get_wtime();
start_time = start;
printf("RANK %d: size: %d\n", rank, SIZE);
matrix_a = (my_matrix_t*) malloc(SIZE*SIZE*sizeof(int32_t));
matrix_b = (my_matrix_t*) calloc(SIZE*SIZE, sizeof(int32_t));
matrix_c = (my_matrix_t*) malloc(SIZE*SIZE*sizeof(int32_t));
for (int32_t j = 0; j < SIZE; ++j) {
for (int32_t i = 0; i < SIZE; ++i) {
(*matrix_a)[i][j]=j+i*SIZE;
}
}
for (int32_t i = 0; i < SIZE; ++i) {
(*matrix_b)[i][i] = 1; //matriz identidad
}
// el master copia los valores a la sub_matrix
for (int32_t j = 0; j <HALF_SIZE ; j++) {
for (int32_t i = 0; i < HALF_SIZE ; ++i) {
(*sub_a)[i][j] = (*matrix_a)[i][j];
(*sub_b)[i][j] = (*matrix_b)[i][j];
}
}
printf("TIME: iniciar la matriz: %f\n",omp_get_wtime()-start);
/**#################################################################
################# FRACCIONAMIENTO DE MATRICES ###################
##################################################################**/
start = omp_get_wtime();
for (int32_t j = 0; j < HALF_SIZE; j++) {
MPI_Send(&((*matrix_a)[j][HALF_SIZE]), HALF_SIZE, MPI_INT32_T,1, TAG_A, MPI_COMM_WORLD);
MPI_Send(&((*matrix_b)[j][HALF_SIZE]), HALF_SIZE, MPI_INT32_T,1, TAG_B, MPI_COMM_WORLD);
MPI_Send(&((*matrix_a)[j + HALF_SIZE][0]), HALF_SIZE, MPI_INT32_T, 2, TAG_A, MPI_COMM_WORLD);
MPI_Send(&((*matrix_b)[j + HALF_SIZE][0]), HALF_SIZE, MPI_INT32_T, 2, TAG_B, MPI_COMM_WORLD);
MPI_Send(&((*matrix_a)[j + HALF_SIZE][HALF_SIZE]), HALF_SIZE, MPI_INT32_T, 3, TAG_A, MPI_COMM_WORLD);
MPI_Send(&((*matrix_b)[j + HALF_SIZE][HALF_SIZE]), HALF_SIZE, MPI_INT32_T, 3, TAG_B, MPI_COMM_WORLD);
}
printf("TIME: fraccionar: %f\n",omp_get_wtime()-start);
}
else{
for (int32_t j = 0; j <HALF_SIZE ; j++) {
MPI_Recv(&((*sub_a)[j][(rank & 1) * HALF_SIZE]), HALF_SIZE, MPI_INT32_T, MASTER, TAG_A, MPI_COMM_WORLD,
MPI_STATUS_IGNORE);
MPI_Recv((*sub_b)[j + (rank > 2) * HALF_SIZE], HALF_SIZE, MPI_INT32_T, MASTER, TAG_B, MPI_COMM_WORLD,
MPI_STATUS_IGNORE);
}
}
/**#################################################################
####################### ENVIO DE SUB MATRICES ###################
##################################################################**/
if(!(rank & 1)){ //is rank es par para A
for (int32_t j = 0; j < HALF_SIZE; ++j) {
MPI_Sendrecv((*sub_a)+j, HALF_SIZE, MPI_INT32_T, rank+1, TAG_A,&((*sub_a)[j][HALF_SIZE]),HALF_SIZE, MPI_INT32_T,
rank+1, TAG_A, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
}
else{
for (int32_t j = 0; j < HALF_SIZE; ++j) {
MPI_Sendrecv(&((*sub_a)[j][HALF_SIZE]), HALF_SIZE, MPI_INT32_T, rank-1, TAG_A, (*sub_a)+j, HALF_SIZE, MPI_INT32_T,
rank-1,TAG_A, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
}
if(!(rank >> 1)){ // Pasaje de Matrix B (rank >> 1) -> rank/2
for (int32_t j = 0; j < HALF_SIZE; ++j) {
MPI_Sendrecv((*sub_b)+j, HALF_SIZE, MPI_INT32_T, rank+2, TAG_B, (*sub_b)+j+HALF_SIZE, HALF_SIZE, MPI_INT32_T,
rank+2, TAG_B, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
}
else{
for (int32_t j = 0; j < HALF_SIZE; ++j) {
MPI_Sendrecv((*sub_b)+j+HALF_SIZE, HALF_SIZE, MPI_INT32_T, rank-2, TAG_B, (*sub_b)+j, HALF_SIZE, MPI_INT32_T,
rank-2,TAG_B, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
}
printf("RANK %d: fin de subenvios\n", rank);
/**#################################################################
####################### PROCESAMIENTO #########################
##################################################################**/
// PROUCTO dejando fija la columna de B
for (int32_t i=0; i<HALF_SIZE; i++){ //i para las filas de la matriz resultante
for (int32_t j=0; j<HALF_SIZE ;j++){ // i para las columnas de la matriz resultante
tmp = 0 ;
for (int32_t k=0; k<SIZE; k++){ //k para realizar la multiplicacion de los elementos
tmp += (*sub_a)[j][k] * (*sub_b)[k][i];
}
(*sub_c)[j][i] = tmp;
}
}
printf("RANK %d: procesar todo\n",rank);
/**#################################################################
############################ RESULTADO #########################
##################################################################**/
if(rank == MASTER) {
start = omp_get_wtime();
for (int32_t j=0; j<HALF_SIZE; ++j) {
MPI_Recv(&((*matrix_c)[j][HALF_SIZE]), HALF_SIZE, MPI_INT32_T, 1, TAG_C, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv((*matrix_c)+j+HALF_SIZE, HALF_SIZE, MPI_INT32_T, 2, TAG_C, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&((*matrix_c)[j+HALF_SIZE][HALF_SIZE]), HALF_SIZE, MPI_INT32_T, 3, TAG_C, MPI_COMM_WORLD,
MPI_STATUS_IGNORE);
}
printf("RANK %d: Termino todo\n",rank);
for (int32_t i = 0; i < HALF_SIZE ; ++i) {
for (int32_t j = 0; j <HALF_SIZE ; j++) {
(*matrix_c)[i][j] = (*sub_c)[i][j];
}
}
printf("TIME: construir C: %f\n", omp_get_wtime() - start);
printf("%sTIME: Total: %f%s\n", COLOR_GREEN, omp_get_wtime() - start_time, COLOR_RESET);
free(matrix_a);
free(matrix_b);
// COMPROBACION
if(control((int32_t**)matrix_c,SIZE*SIZE)==SUCCESS)
printf("CHECK: Todo OK wacho!\n");
else
printf("CHECK: SE PUDRIO TODO!\n");
free(matrix_c);
}
else {
for (int32_t j = 0; j < HALF_SIZE; ++j) {
MPI_Send((*sub_c)+j, HALF_SIZE, MPI_INT32_T, MASTER, TAG_C, MPI_COMM_WORLD);
}
printf("RANK %d: Termino todo\n",rank);
}
free(sub_a);
free(sub_b);
free(sub_c);
MPI_Finalize();
exit(EXIT_SUCCESS);
}
int control(int32_t **matrix, int32_t size) {
int32_t* aux= (int32_t*)matrix;
for(int32_t i=0; i<size-1 ;i++){
if(*(aux+i) >= *(aux+i+1)) return ERROR;
}
return SUCCESS;
}
|
b4fb189e29d3cad9c4cc86fda367846d95dd9d99 | 2d07a646d50c6cc1547b069ecd27c512623d8574 | /src/core/os.h | 4a26c2c8fc5aeb21fa29b70a144247c7922f17b0 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | bjornbytes/lovr | da40e59eb9c42debbc6e22356d55194283740323 | 072452a4dafb466e8af9a4bc546b60ae077f8566 | refs/heads/master | 2023-08-16T13:42:30.581144 | 2023-07-29T10:37:18 | 2023-07-29T10:37:18 | 62,519,414 | 1,699 | 164 | MIT | 2023-09-13T22:21:32 | 2016-07-03T23:36:45 | C | UTF-8 | C | false | false | 3,311 | h | os.h | #include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#pragma once
typedef struct os_window_config {
uint32_t width;
uint32_t height;
bool fullscreen;
bool resizable;
const char* title;
struct {
void* data;
uint32_t width;
uint32_t height;
} icon;
} os_window_config;
typedef enum {
MOUSE_LEFT,
MOUSE_RIGHT
} os_mouse_button;
typedef enum {
MOUSE_MODE_NORMAL,
MOUSE_MODE_GRABBED
} os_mouse_mode;
typedef enum {
KEY_A,
KEY_B,
KEY_C,
KEY_D,
KEY_E,
KEY_F,
KEY_G,
KEY_H,
KEY_I,
KEY_J,
KEY_K,
KEY_L,
KEY_M,
KEY_N,
KEY_O,
KEY_P,
KEY_Q,
KEY_R,
KEY_S,
KEY_T,
KEY_U,
KEY_V,
KEY_W,
KEY_X,
KEY_Y,
KEY_Z,
KEY_0,
KEY_1,
KEY_2,
KEY_3,
KEY_4,
KEY_5,
KEY_6,
KEY_7,
KEY_8,
KEY_9,
KEY_SPACE,
KEY_ENTER,
KEY_TAB,
KEY_ESCAPE,
KEY_BACKSPACE,
KEY_UP,
KEY_DOWN,
KEY_LEFT,
KEY_RIGHT,
KEY_HOME,
KEY_END,
KEY_PAGE_UP,
KEY_PAGE_DOWN,
KEY_INSERT,
KEY_DELETE,
KEY_F1,
KEY_F2,
KEY_F3,
KEY_F4,
KEY_F5,
KEY_F6,
KEY_F7,
KEY_F8,
KEY_F9,
KEY_F10,
KEY_F11,
KEY_F12,
KEY_BACKTICK,
KEY_MINUS,
KEY_EQUALS,
KEY_LEFT_BRACKET,
KEY_RIGHT_BRACKET,
KEY_BACKSLASH,
KEY_SEMICOLON,
KEY_APOSTROPHE,
KEY_COMMA,
KEY_PERIOD,
KEY_SLASH,
KEY_LEFT_CONTROL,
KEY_LEFT_SHIFT,
KEY_LEFT_ALT,
KEY_LEFT_OS,
KEY_RIGHT_CONTROL,
KEY_RIGHT_SHIFT,
KEY_RIGHT_ALT,
KEY_RIGHT_OS,
KEY_CAPS_LOCK,
KEY_SCROLL_LOCK,
KEY_NUM_LOCK,
KEY_COUNT
} os_key;
typedef enum {
BUTTON_PRESSED,
BUTTON_RELEASED
} os_button_action;
typedef enum {
OS_PERMISSION_AUDIO_CAPTURE
} os_permission;
typedef void fn_gl_proc(void);
typedef void fn_quit(void);
typedef void fn_focus(bool focused);
typedef void fn_resize(uint32_t width, uint32_t height);
typedef void fn_key(os_button_action action, os_key key, uint32_t scancode, bool repeat);
typedef void fn_text(uint32_t codepoint);
typedef void fn_permission(os_permission permission, bool granted);
bool os_init(void);
void os_destroy(void);
const char* os_get_name(void);
uint32_t os_get_core_count(void);
void os_open_console(void);
double os_get_time(void);
void os_sleep(double seconds);
void os_request_permission(os_permission permission);
void* os_vm_init(size_t size);
bool os_vm_free(void* p, size_t size);
bool os_vm_commit(void* p, size_t size);
bool os_vm_release(void* p, size_t size);
void os_poll_events(void);
void os_on_quit(fn_quit* callback);
void os_on_focus(fn_focus* callback);
void os_on_resize(fn_resize* callback);
void os_on_key(fn_key* callback);
void os_on_text(fn_text* callback);
void os_on_permission(fn_permission* callback);
bool os_window_open(const os_window_config* config);
bool os_window_is_open(void);
void os_window_get_size(uint32_t* width, uint32_t* height);
float os_window_get_pixel_density(void);
size_t os_get_home_directory(char* buffer, size_t size);
size_t os_get_data_directory(char* buffer, size_t size);
size_t os_get_working_directory(char* buffer, size_t size);
size_t os_get_executable_path(char* buffer, size_t size);
size_t os_get_bundle_path(char* buffer, size_t size, const char** root);
void os_get_mouse_position(double* x, double* y);
void os_set_mouse_mode(os_mouse_mode mode);
bool os_is_mouse_down(os_mouse_button button);
bool os_is_key_down(os_key key);
|
84bb138e9b2e3a9749288a6b68a7decc68975e68 | 61116383ca5188ffe58af12328277f4def861a2c | /fs/xfsd_dir2_sf.c | 6656bd55eee42ea1d700c2b7c378a180886d5c7e | [] | no_license | ditsing/xfsd | e59a6dae4fbb7a6471bab94eb42dc1e21d13742a | fa99ab5aed1d6d094058517227bf034587f12f84 | refs/heads/master | 2021-01-17T10:38:08.097415 | 2013-06-22T03:46:10 | 2013-06-22T03:46:10 | 4,847,186 | 2 | 0 | null | null | null | null | UTF-8 | C | false | false | 12,239 | c | xfsd_dir2_sf.c | /*
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
* All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "xfsd.h"
#include "xfsd_types.h"
#include "xfs/xfs_fs.h"
#include "xfs/xfs_types.h"
#include "xfs/xfs_log.h"
#include "xfs/xfs_trans.h"
#include "xfs/xfs_sb.h"
#include "xfs/xfs_ag.h"
#include "xfs/xfs_mount.h"
#include "xfs/xfs_da_btree.h"
#include "xfs/xfs_bmap_btree.h"
#include "xfs/xfs_dinode.h"
#include "xfs/xfs_inode.h"
#include "xfs/xfs_inode_item.h"
#include "xfs/xfs_error.h"
#include "xfs/xfs_dir2.h"
#include "xfs/xfs_dir2_format.h"
#include "xfs/xfs_dir2_priv.h"
#include "xfsd_trace.h"
#ifdef DEBUG
static void xfs_dir2_sf_check(xfs_da_args_t *args);
#else
#define xfs_dir2_sf_check(args)
#endif /* DEBUG */
/*
* Inode numbers in short-form directories can come in two versions,
* either 4 bytes or 8 bytes wide. These helpers deal with the
* two forms transparently by looking at the headers i8count field.
*
* For 64-bit inode number the most significant byte must be zero.
*/
static xfs_ino_t
xfs_dir2_sf_get_ino(
struct xfs_dir2_sf_hdr *hdr,
xfs_dir2_inou_t *from)
{
if (hdr->i8count)
return get_unaligned_be64(&from->i8.i) & 0x00ffffffffffffffULL;
else
return get_unaligned_be32(&from->i4.i);
}
static void
xfs_dir2_sf_put_ino(
struct xfs_dir2_sf_hdr *hdr,
xfs_dir2_inou_t *to,
xfs_ino_t ino)
{
ASSERT((ino & 0xff00000000000000ULL) == 0);
if (hdr->i8count)
put_unaligned_be64(ino, &to->i8.i);
else
put_unaligned_be32(ino, &to->i4.i);
}
xfs_ino_t
xfs_dir2_sf_get_parent_ino(
struct xfs_dir2_sf_hdr *hdr)
{
return xfs_dir2_sf_get_ino(hdr, &hdr->parent);
}
static void
xfs_dir2_sf_put_parent_ino(
struct xfs_dir2_sf_hdr *hdr,
xfs_ino_t ino)
{
xfs_dir2_sf_put_ino(hdr, &hdr->parent, ino);
}
/*
* In short-form directory entries the inode numbers are stored at variable
* offset behind the entry name. The inode numbers may only be accessed
* through the helpers below.
*/
static xfs_dir2_inou_t *
xfs_dir2_sfe_inop(
struct xfs_dir2_sf_entry *sfep)
{
return (xfs_dir2_inou_t *)&sfep->name[sfep->namelen];
}
xfs_ino_t
xfs_dir2_sfe_get_ino(
struct xfs_dir2_sf_hdr *hdr,
struct xfs_dir2_sf_entry *sfep)
{
return xfs_dir2_sf_get_ino(hdr, xfs_dir2_sfe_inop(sfep));
}
static void
xfs_dir2_sfe_put_ino(
struct xfs_dir2_sf_hdr *hdr,
struct xfs_dir2_sf_entry *sfep,
xfs_ino_t ino)
{
xfs_dir2_sf_put_ino(hdr, xfs_dir2_sfe_inop(sfep), ino);
}
/*
* Given a block directory (dp/block), calculate its size as a shortform (sf)
* directory and a header for the sf directory, if it will fit it the
* space currently present in the inode. If it won't fit, the output
* size is too big (but not accurate).
*/
int /* size for sf form */
xfs_dir2_block_sfsize(
xfs_inode_t *dp, /* incore inode pointer */
xfs_dir2_data_hdr_t *hdr, /* block directory data */
xfs_dir2_sf_hdr_t *sfhp) /* output: header for sf form */
{
xfs_dir2_dataptr_t addr; /* data entry address */
xfs_dir2_leaf_entry_t *blp; /* leaf area of the block */
xfs_dir2_block_tail_t *btp; /* tail area of the block */
int count; /* shortform entry count */
xfs_dir2_data_entry_t *dep; /* data entry in the block */
int i; /* block entry index */
int i8count; /* count of big-inode entries */
int isdot; /* entry is "." */
int isdotdot; /* entry is ".." */
xfs_mount_t *mp; /* mount structure pointer */
int namelen; /* total name bytes */
xfs_ino_t parent = 0; /* parent inode number */
int size=0; /* total computed size */
mp = dp->i_mount;
count = i8count = namelen = 0;
btp = xfs_dir2_block_tail_p(mp, hdr);
blp = xfs_dir2_block_leaf_p(btp);
/*
* Iterate over the block's data entries by using the leaf pointers.
*/
for (i = 0; i < be32_to_cpu(btp->count); i++) {
if ((addr = be32_to_cpu(blp[i].address)) == XFS_DIR2_NULL_DATAPTR)
continue;
/*
* Calculate the pointer to the entry at hand.
*/
dep = (xfs_dir2_data_entry_t *)
((char *)hdr + xfs_dir2_dataptr_to_off(mp, addr));
/*
* Detect . and .., so we can special-case them.
* . is not included in sf directories.
* .. is included by just the parent inode number.
*/
isdot = dep->namelen == 1 && dep->name[0] == '.';
isdotdot =
dep->namelen == 2 &&
dep->name[0] == '.' && dep->name[1] == '.';
#if XFS_BIG_INUMS
if (!isdot)
i8count += be64_to_cpu(dep->inumber) > XFS_DIR2_MAX_SHORT_INUM;
#endif
if (!isdot && !isdotdot) {
count++;
namelen += dep->namelen;
} else if (isdotdot)
parent = be64_to_cpu(dep->inumber);
/*
* Calculate the new size, see if we should give up yet.
*/
size = xfs_dir2_sf_hdr_size(i8count) + /* header */
count + /* namelen */
count * (uint)sizeof(xfs_dir2_sf_off_t) + /* offset */
namelen + /* name */
(i8count ? /* inumber */
(uint)sizeof(xfs_dir2_ino8_t) * count :
(uint)sizeof(xfs_dir2_ino4_t) * count);
if (size > XFS_IFORK_DSIZE(dp))
return size; /* size value is a failure */
}
/*
* Create the output header, if it worked.
*/
sfhp->count = count;
sfhp->i8count = i8count;
xfs_dir2_sf_put_parent_ino(sfhp, parent);
return size;
}
#ifdef DEBUG
/*
* Check consistency of shortform directory, assert if bad.
*/
static void
xfs_dir2_sf_check(
xfs_da_args_t *args) /* operation arguments */
{
xfs_inode_t *dp; /* incore directory inode */
int i; /* entry number */
int i8count; /* number of big inode#s */
xfs_ino_t ino; /* entry inode number */
int offset; /* data offset */
xfs_dir2_sf_entry_t *sfep; /* shortform dir entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
dp = args->dp;
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
offset = XFS_DIR2_DATA_FIRST_OFFSET;
ino = xfs_dir2_sf_get_parent_ino(sfp);
i8count = ino > XFS_DIR2_MAX_SHORT_INUM;
for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp);
i < sfp->count;
i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep)) {
ASSERT(xfs_dir2_sf_get_offset(sfep) >= offset);
ino = xfs_dir2_sfe_get_ino(sfp, sfep);
i8count += ino > XFS_DIR2_MAX_SHORT_INUM;
offset =
xfs_dir2_sf_get_offset(sfep) +
xfs_dir2_data_entsize(sfep->namelen);
}
ASSERT(i8count == sfp->i8count);
ASSERT(XFS_BIG_INUMS || i8count == 0);
ASSERT((char *)sfep - (char *)sfp == dp->i_d.di_size);
ASSERT(offset +
(sfp->count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t) +
(uint)sizeof(xfs_dir2_block_tail_t) <=
dp->i_mount->m_dirblksize);
}
#endif /* DEBUG */
int /* error */
xfs_dir2_sf_getdents(
xfs_inode_t *dp, /* incore directory inode */
void *dirent,
xfs_off_t *offset,
filldir_t filldir)
{
int i; /* shortform entry number */
xfs_mount_t *mp; /* filesystem mount point */
xfs_dir2_dataptr_t off; /* current entry's offset */
xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
xfs_dir2_dataptr_t dot_offset;
xfs_dir2_dataptr_t dotdot_offset;
xfs_ino_t ino;
mp = dp->i_mount;
ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
/*
* Give up if the directory is way too short.
*/
if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
ASSERT(XFS_FORCED_SHUTDOWN(mp));
return XFS_ERROR(EIO);
}
ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
ASSERT(dp->i_df.if_u1.if_data != NULL);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
/*
* If the block number in the offset is out of range, we're done.
*/
if (xfs_dir2_dataptr_to_db(mp, *offset) > mp->m_dirdatablk)
return 0;
/*
* Precalculate offsets for . and .. as we will always need them.
*
* XXX(hch): the second argument is sometimes 0 and sometimes
* mp->m_dirdatablk.
*/
dot_offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
XFS_DIR2_DATA_DOT_OFFSET);
dotdot_offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
XFS_DIR2_DATA_DOTDOT_OFFSET);
/*
* Put . entry unless we're starting past it.
*/
if (*offset <= dot_offset) {
if (filldir(dirent, ".", 1, dot_offset & 0x7fffffff, dp->i_ino, DT_DIR)) {
*offset = dot_offset & 0x7fffffff;
return 0;
}
}
/*
* Put .. entry unless we're starting past it.
*/
if (*offset <= dotdot_offset) {
ino = xfs_dir2_sf_get_parent_ino(sfp);
if (filldir(dirent, "..", 2, dotdot_offset & 0x7fffffff, ino, DT_DIR)) {
*offset = dotdot_offset & 0x7fffffff;
return 0;
}
}
/*
* Loop while there are more entries and put'ing works.
*/
sfep = xfs_dir2_sf_firstentry(sfp);
for (i = 0; i < sfp->count; i++) {
off = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
xfs_dir2_sf_get_offset(sfep));
if (*offset > off) {
sfep = xfs_dir2_sf_nextentry(sfp, sfep);
continue;
}
ino = xfs_dir2_sfe_get_ino(sfp, sfep);
if (filldir(dirent, (char *)sfep->name, sfep->namelen,
off & 0x7fffffff, ino, DT_UNKNOWN)) {
*offset = off & 0x7fffffff;
return 0;
}
sfep = xfs_dir2_sf_nextentry(sfp, sfep);
}
*offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0) &
0x7fffffff;
return 0;
}
/*
* Lookup an entry in a shortform directory.
* Returns EEXIST if found, ENOENT if not found.
*/
int /* error */
xfs_dir2_sf_lookup(
xfs_da_args_t *args) /* operation arguments */
{
xfs_inode_t *dp; /* incore directory inode */
int i; /* entry index */
int error;
xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
enum xfs_dacmp cmp; /* comparison result */
xfs_dir2_sf_entry_t *ci_sfep; /* case-insens. entry */
trace_xfs_dir2_sf_lookup(args);
xfs_dir2_sf_check(args);
dp = args->dp;
ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
/*
* Bail out if the directory is way too short.
*/
if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
return XFS_ERROR(EIO);
}
ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
ASSERT(dp->i_df.if_u1.if_data != NULL);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
/*
* Special case for .
*/
if (args->namelen == 1 && args->name[0] == '.') {
args->inumber = dp->i_ino;
args->cmpresult = XFS_CMP_EXACT;
return XFS_ERROR(EEXIST);
}
/*
* Special case for ..
*/
if (args->namelen == 2 &&
args->name[0] == '.' && args->name[1] == '.') {
args->inumber = xfs_dir2_sf_get_parent_ino(sfp);
args->cmpresult = XFS_CMP_EXACT;
return XFS_ERROR(EEXIST);
}
/*
* Loop over all the entries trying to match ours.
*/
ci_sfep = NULL;
for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp); i < sfp->count;
i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep)) {
/*
* Compare name and if it's an exact match, return the inode
* number. If it's the first case-insensitive match, store the
* inode number and continue looking for an exact match.
*/
cmp = dp->i_mount->m_dirnameops->compname(args, sfep->name,
sfep->namelen);
if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
args->cmpresult = cmp;
args->inumber = xfs_dir2_sfe_get_ino(sfp, sfep);
if (cmp == XFS_CMP_EXACT)
return XFS_ERROR(EEXIST);
ci_sfep = sfep;
}
}
ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
/*
* Here, we can only be doing a lookup (not a rename or replace).
* If a case-insensitive match was not found, return ENOENT.
*/
if (!ci_sfep)
return XFS_ERROR(ENOENT);
/* otherwise process the CI match as required by the caller */
error = xfs_dir_cilookup_result(args, ci_sfep->name, ci_sfep->namelen);
return XFS_ERROR(error);
}
|
b3522fa4a08c5c42bd126b44f35f07c0efa1e455 | 0716b8210c6009e55f7aa618be8e19a7b2313e30 | /TMarcoDemo/Pods/Headers/Private/StreamKit/UISearchBar+ReactiveX.h | 404f61830f17b80f51f8288de6ee3da4b4b985b9 | [
"MIT"
] | permissive | geniustag/TMarco | 69ddca6f8fa5bcbe0108767e521095169ce3958b | 8c41ffe34d0bebb5289cbc429ce478e3dcf77d7b | refs/heads/master | 2020-12-30T16:58:57.292948 | 2018-12-05T03:16:14 | 2018-12-05T03:16:14 | 91,044,237 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 61 | h | UISearchBar+ReactiveX.h | ../../../StreamKit/StreamKit/Reactive/UISearchBar+ReactiveX.h |
4e4680b7532ae499afa74363f24b4c778742f29e | 725d4b726baf3e423e681774333a743b1a5ad319 | /trunk/core/ds/graph/graph.h | 91fd42f4cd705baffe4a265b8f7a647b81146544 | [] | no_license | BackupTheBerlios/ku2-svn | 395bb032b7f4a8dd785d0fe211092d91ec8e2bc4 | 49a908c4e7d9497db06ff4e12ffd34ece6fb179a | refs/heads/master | 2021-01-02T22:17:31.434324 | 2011-05-01T12:01:49 | 2011-05-01T12:01:49 | 40,802,671 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 5,297 | h | graph.h | /*
* core:ds:graph:graph.c
*
* This file is the part of Kane Utilities 2.
* See licensing agreement in a root directory for more details.
* http://developer.berlios.de/projects/ku2/
*
* Copyright, 2007+
* J. Anton (Jeļkins Antons) aka Kane
* [email protected]
*/
/*!
\file
\brief Linked graph.
This is the realisation of linked graphs.
\author J. Anton
*/
#ifndef KU__GRAPH_H__
#define KU__GRAPH_H__
#include "ku2/host.h"
#include "ku2/types.h"
#include "ds/abtree/abtree.h"
KU_BEGIN_DECLS
//! Identifier of the graph node.
typedef
uint graph_node_id_t;
//! Graph vertex.
typedef
struct STRUCT_GRAPH_VERTEX
{
uint id; //!< Vertex number/id.
void *data; //!< With vertex assotiated data.
int tmp; //!< Temporally data for usage by external algorithms.
//!< Note: algorith should set zeros after its work.
union
{
struct
{
uint next_cnt,
//!< Count of next graph vertexes.
prev_cnt;
//!< Count of previous graph vertexes.
struct STRUCT_GRAPH_VERTEX
**next,
//!< Next graph vertexes.
**prev;
//!< Previous graph vertexes.
};
struct
{
uint near_cnt;
//!< Count of linked (near) graph vertexes.
struct STRUCT_GRAPH_VERTEX
**near;
//!< Linked (near) graph vertexes.
};
};
} ku_graph_vertex_t;
//! Graph.
typedef
struct STRUCT_GRAPH
{
int directed; //!< Is this graph oriented?
ku_comp_f cmpf; //!< Comparing function.
ku_tree_t *vertexes;
//!< List of vertexes, indexed by id.
ku_graph_vertex_t *cur;
//!< Current vertex.
} ku_graph_t;
//! \name Graph flags.
//! \{
/*!
* Assume default graph behaviour.
*/
#define KUF_GRAPH_DEFAULT 0
/*!
Graph should be directed. \n
Used in ku_graph_create().
*/
#define KUF_GRAPH_DIRECTED 1
/*!
- Create links in both directions when linking.
Has effect only if graph is directed. \n
Used in ku_graph_link().
- Remove links in both directions when unlinking.
Has effect only if graph is directed. \n
Used in ku_graph_ulink().
*/
#define KUF_GRAPH_DBL_LINK 2
/*!
When removing the vertex from the graph, transpose the links, where
it is possible, for example if:
- three vertexes are connected as folowing: A -> B -> C.
- B is being deleted.
then there will be link A -> C is after the operation if this flag is used.
If this flag is not used then the links will be simply deleted. \n
Used in ku_graph_rem().
*/
#define KUF_GRAPH_TRANSP 4
/*!
Remove all links between two vertexes rather then only one. \n
Used in ku_graph_ulink().
*/
#define KUF_GRAPH_ALL_LINK 8
//! \}
//! Create a graph instance.
ku_graph_t *ku_graph_create( ku_comp_f func, ku_flag32_t flags );
//! Free a graph instance.
kucode_t ku_graph_free( ku_graph_t *graph, ku_act_f freef );
//! Remove all vertexes from the graph.
kucode_t ku_graph_clear( ku_graph_t *graph, ku_act_f freef );
//! Insert the data to the graph.
/*!
Creates a vertex with data and inserts it into the graph. New vertex
is not linked to any other.
\param graph Graph to deal with.
\param data Data to be inserted.
\return ID of the created vertex, or (uint)-1 if failed and \ref kucode is
set to the valid value: \n
- \e KE_FULL There is no free ID. \n
- \e KE_MEMORY Failed to allocate space for vertex. \n
- Any ku_abtree_ins() error.
*/
uint ku_graph_ins( ku_graph_t *graph, const void *data );
//! Remove a particular vertex (using its ID) from the graph.
/*!
Removes a vertex with specified ID from the graph.
\param graph Graph to deal with.
\param id Vertex ID to be deleted.
\param freef Function to free vertex data, \e NULL for doing nothing.
\param flags Flags. \n Valid flags are: \ref KUF_GRAPH_TRANSP.
\retval KE_NONE No error.
\retval KE_NOTFOUND No vertex with specified ID was found.
\retval KE_MEMORY Failed to reallocate space for list of linked vertexes.
*/
kucode_t ku_graph_rem( ku_graph_t *graph, uint id,
ku_act_f freef, ku_flag32_t flags );
//! Link two vertexes together (using their IDs).
/*!
Links two vertexes together (using their IDs).
\param graph Graph to deal with.
\param start_node ID of the linking start node.
\param end_node ID of the end node:
the node to which start node is linked.
\param flags Flags. \n Valid flags are: \ref KUF_GRAPH_DBL_LINK.
\retval KE_NONE No error.
\retval KE_NOTFOUND No vertex with specified ID was found.
\retval KE_MEMORY Failed to reallocate space for list of linked vertexes.
*/
kucode_t ku_graph_link( ku_graph_t *graph,
uint start_node, uint end_node, ku_flag32_t flags );
//! Unlink two linked vertexes (using their IDs).
kucode_t ku_graph_ulink( ku_graph_t *graph,
uint start_node, uint end_node, ku_flag32_t flags );
kucode_t ku_graph_push( ku_graph_t *graph );
kucode_t ku_graph_pop( ku_graph_t *graph );
void *ku_graph_push_goto_next( ku_graph_t *graph, uint index );
void *ku_graph_goto_next( ku_graph_t *graph, uint index );
void *ku_graph_push_goto_prev( ku_graph_t *graph, uint index );
void *ku_graph_goto_prev( ku_graph_t *graph, uint index );
void *ku_graph_search( ku_graph_t *graph, uint id );
void *ku_graph_search_by_data( ku_graph_t *graph, const void *data );
ku_graph_vertex_t *ku_graph_get_vertex( ku_graph_t *graph, uint id );
void ku_graph_printout( ku_graph_t *graph, ku_actP_f outf );
KU_END_DECLS
#endif
|
6fbbfc68aeec93b74fa54d6fce7739930281edb4 | 69400ba40238c48a7e45684ca7ddbe065551286a | /l3gd20spi.h | 7098bd99761c81f8a4a4ccbcbe1d3bf8ac259375 | [] | no_license | ictu-dungnt98/MCUCollectionLibrary | bd8544178d430fb21241e21164c412c59e53c614 | 2295d3d485230a478781f488bc6958d93f915140 | refs/heads/master | 2023-03-16T09:56:30.439978 | 2020-06-30T05:33:19 | 2020-06-30T05:33:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 2,108 | h | l3gd20spi.h | #ifndef _L3GD20SPI_H
#define _L3GD20SPI_H
#include "gpio.h" //we use gpio
#include "spi_sw.h" //we use software spi
//hardware configuration
#define L3GD20CS_PORT GPIOE
#define L3GD20CS_DDR GPIOE
#define L3GD20CS (1<<3)
//end hardware configuration
#define l3gd20_deselect(cs) do {IO_SET(L3GD20CS_PORT, cs); IO_OUT(L3GD20CS_PORT, cs);} while (0)
#define l3gd20_select(cs) do {IO_CLR(L3GD20CS_PORT, cs); IO_OUT(L3GD20CS_PORT, cs);} while (0)
typedef struct {
//int16_t ACCEL_X, ACCEL_Y, ACCEL_Z; //accelerometer readings on 3 axies
int16_t GYRO_X, GYRO_Y, GYRO_Z; //accelerometer readings on 3 axies
int8_t TEMP; //temperature readings
uint8_t STATUS;
} L3GD20_T;
//global defines
//read / write bit
#define L3GD20_READ 0x80 //read
#define L3GD20_WRITE 0x00 //write
#define L3GD20_INC 0x40 //address auto increments for multi-byte read/write
#define L3GD20_STAY 0x00 //address does not increment
//register map
#define L3GD20_WHO_AM_I 0x0f
#define L3GD20_CTRL_REG1 0x20
#define L3GD20_CTRL_REG2 0x21
#define L3GD20_CTRL_REG3 0x22
#define L3GD20_CTRL_REG4 0x23
#define L3GD20_CTRL_REG5 0x24
#define L3GD20_REFERENCE 0x25
#define L3GD20_OUT_TEMP 0x26
#define L3GD20_STATUS_REG 0x27
#define L3GD20_OUT_X_L 0x28
#define L3GD20_OUT_X_H 0x29
#define L3GD20_OUT_Y_L 0x2a
#define L3GD20_OUT_Y_H 0x2b
#define L3GD20_OUT_Z_L 0x2c
#define L3GD20_OUT_Z_H 0x2d
#define L3GD20_FIFO_CTRL_REG 0x2e
#define L3GD20_FIFO_SRC_REG 0x2f
#define L3GD20_INT1_CFG 0x30
#define L3GD20_INT1_SRC 0x31
#define L3GD20_INT1_TSH_XH 0x32
#define L3GD20_INT1_TSH_XL 0x33
#define L3GD20_INT1_TSH_YH 0x34
#define L3GD20_INT1_TSH_YL 0x35
#define L3GD20_INT1_TSH_ZH 0x36
#define L3GD20_INT1_TSH_ZL 0x37
#define L3GD20_INT1_DURATION 0x38
//global variable
//initialize l3gd20
void l3gd20_init(void);
//read from l3gd20 accelerometer
L3GD20_T *l3gd20a_read(L3GD20_T *l3gd);
//read from l3gd20 temperature
L3GD20_T *l3gd20t_read(L3GD20_T *l3gd);
//read l3gd20 accelerometer + status + temperature
L3GD20_T *l3gd20_read(L3GD20_T *l3gd);
#endif
|
6a1842f8c8892a1bef14f10df134a43c16c10f12 | 976f5e0b583c3f3a87a142187b9a2b2a5ae9cf6f | /source/freebsd/contrib/ntp/ntpq/extr_ntpq-subs.c_prettyinterval.c | c5d654253b289c265bfb07f31871084252e251fe | [] | no_license | isabella232/AnghaBench | 7ba90823cf8c0dd25a803d1688500eec91d1cf4e | 9a5f60cdc907a0475090eef45e5be43392c25132 | refs/heads/master | 2023-04-20T09:05:33.024569 | 2021-05-07T18:36:26 | 2021-05-07T18:36:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,362 | c | extr_ntpq-subs.c_prettyinterval.c | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
scalar_t__ floor (long) ;
int /*<<< orphan*/ snprintf (char*,size_t,char*,unsigned int) ;
int /*<<< orphan*/ strlcpy (char*,char*,size_t) ;
__attribute__((used)) static char *
prettyinterval(
char *buf,
size_t cb,
long diff
)
{
if (diff <= 0) {
buf[0] = '-';
buf[1] = 0;
return buf;
}
if (diff <= 2048) {
snprintf(buf, cb, "%u", (unsigned int)diff);
return buf;
}
diff = (diff + 29) / 60;
if (diff <= 300) {
snprintf(buf, cb, "%um", (unsigned int)diff);
return buf;
}
diff = (diff + 29) / 60;
if (diff <= 96) {
snprintf(buf, cb, "%uh", (unsigned int)diff);
return buf;
}
diff = (diff + 11) / 24;
if (diff <= 999) {
snprintf(buf, cb, "%ud", (unsigned int)diff);
return buf;
}
/* years are only approximated... */
diff = (long)floor(diff / 365.25 + 0.5);
if (diff <= 999) {
snprintf(buf, cb, "%uy", (unsigned int)diff);
return buf;
}
/* Ok, this amounts to infinity... */
strlcpy(buf, "INF", cb);
return buf;
} |
6df1e42f167cab88d4e891c9895692fbe22e8f2c | c2cedcf36667730f558ab354bea4505b616c90d2 | /players/nooneelse/mon/bear.c | 79081b7d1c260e18d7e7c179158149143cf9d3f8 | [] | no_license | wugouzi/Nirvlp312mudlib | 965ed876c7080ab00e28c5d8cd5ea9fc9e46258f | 616cad7472279cc97c9693f893940f5336916ff8 | refs/heads/master | 2023-03-16T03:45:05.510851 | 2017-09-21T17:05:00 | 2017-09-21T17:05:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 777 | c | bear.c | /*
bear.c
*/
inherit "obj/monster";
reset(arg) {
object obj;
if (arg) return 0;
::reset();
set_name("bear");
set_level(17);
set_alias("nooneelsebear");
set_race("bear");
set_hp(400);
set_al(0);
set_short("A bear");
set_long("A HUGE female grizzly bear!\n");
set_wc(19);
set_ac(7);
set_aggressive(1);
set_gender("female");
obj=clone_object("obj/money");
obj->set_money(2000);
move_object(obj, this_object());
obj=clone_object("players/nooneelse/obj/bear_skin");
move_object(obj, this_object());
}
heart_beat() {
if (query_attack() && random(100) < 25) {
tell_room(environment(this_object()),
"She slams down with both massive paws!\n");
query_attack()->hit_player(15);
return 0;
}
::heart_beat();
}
|
973474f3024000db1296e32836fb7b3e9ae372cc | 2f557f60fc609c03fbb42badf2c4f41ef2e60227 | /RecoVertex/KinematicFitPrimitives/interface/Matrices.h | 6af8568d29f13524b15bf57b79a57d1722547ef8 | [
"Apache-2.0"
] | permissive | CMS-TMTT/cmssw | 91d70fc40a7110832a2ceb2dc08c15b5a299bd3b | 80cb3a25c0d63594fe6455b837f7c3cbe3cf42d7 | refs/heads/TMTT_1060 | 2020-03-24T07:49:39.440996 | 2020-03-04T17:21:36 | 2020-03-04T17:21:36 | 142,576,342 | 3 | 5 | Apache-2.0 | 2019-12-05T21:16:34 | 2018-07-27T12:48:13 | C++ | UTF-8 | C | false | false | 581 | h | Matrices.h | #ifndef _Kinefit_SMATRIX_H_
#define _Kinefit_SMATRIX_H_
#define SMATRIX_USE_CONSTEXPR
#include <Math/SVector.h>
#include <Math/SMatrix.h>
typedef ROOT::Math::SVector<double,7> AlgebraicVector7;
typedef ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> > AlgebraicSymMatrix77;
typedef ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> > AlgebraicMatrix77;
typedef ROOT::Math::SMatrix<double,6,7,ROOT::Math::MatRepStd<double,6,7> > AlgebraicMatrix67;
typedef ROOT::Math::SMatrix<double,7,6,ROOT::Math::MatRepStd<double,7,6> > AlgebraicMatrix76;
#endif
|
d4389a710d7a73149d780354705e913ffe0e4b84 | 948f96c249692c26a53eb0509dc522fa9bd7bd95 | /readkey.c | b284b6610a46599031f2f21a1350fc783d854946 | [
"CC-BY-4.0"
] | permissive | michael105/readkey | af0af0968ef4dcd1bd130a36cfdd8913975d850c | 7815b5ba58793dd5563fedf29ed2807b76a170f7 | refs/heads/master | 2020-04-22T17:51:45.537303 | 2019-08-26T04:29:53 | 2019-08-26T04:29:53 | 170,556,525 | 6 | 0 | null | null | null | null | UTF-8 | C | false | false | 14,725 | c | readkey.c | #ifdef MLIB
#include "minilib.h"
#else
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/select.h>
#include <sys/ioctl.h>
#include <sys/termios.h>
#endif
#define TTY struct termio
/* Add definitions to make termio look like termios.
* But ifdef it, since there are some implementations
* that try to do this for us in a fake <termio.h>.
*/
#if 0
#ifndef TCSANOW
#define TCSANOW TIOCSETA
#endif
#ifndef TCSADRAIN
#define TCSADRAIN TCSETAW
#endif
#ifndef TCSAFLUSH
#define TCSAFLUSH TCSETAF
#endif
#ifndef tcsetattr
#define tcsetattr(fd, cmd, arg) ioctl(fd, cmd, arg)
#endif
#ifndef tcgetattr
#define tcgetattr(fd, arg) ioctl(fd, TIOCGETA, arg)
#endif
#endif
#ifndef NULL
#define NULL 0
#endif
#ifndef POINTER
// amd64
#define POINTER long unsigned int
#endif
char *modifiers[] = { "CTRL", "ALT", "", "SHIFT" };
char *keys[] = {"", "?", "F%u", "ESC", "INS",
"POS1", "END", "PGUP", "PGDOWN",
"RET", "DEL", "BACKSPACE", "TAB",
"UP", "DOWN", "LEFT", "RIGHT" };
enum MODIFIERS { CTRL=1, ALT=2, SHIFT=4 };
enum KEYS { NOKEY, UNKNOWN, FKEY, ESC, INS, POS1, END, PGUP, PGDOWN, RET, DEL, BACKSPACE, TAB, UP, DOWN, LEFT, RIGHT };
int pmod = 0;
char keybuf[16];
int keycount = 0;
//Args
char debug=0;
char ret_modifier=0;
char print_modifier=0;
char only_key=0;
char repeat=0;
int key_output(int pmod,int pkey, int f,char*pstring){
int i=0,ret=0;
/*if ( debug )
printf("pmod: %d, pkey: %d, f: %d\n",pmod,pkey,f);*/
if ( pkey == UNKNOWN ){
fputs("Unknown keycode: ", stderr);
for (i=0;i<keycount;i++){
fprintf(stderr,"%u ",keybuf[i]);
}
fputs("",stderr);
return(253);
}
if ( only_key== 0 ){
for ( i=1; i<5; i<<=1 ){
if ( i & pmod ){
fprintfs( stdout, "%s+", modifiers[i-1] );
}
}
}
if ( f ){
printf(keys[FKEY], f );
} else {
if ( (pkey > 0) && (pkey < 17) ){
print(keys[pkey]);
} else {
if ( pkey ){
printf("%c",pkey);
} else {
if ( pstring!=0){
prints(pstring);
}
}
}
}
if(debug!=0){ // print the whole sequence
printf("\n");
if ( i )
prints("Sequence: ");
else
prints("Key: ");
for (i=0;i<keycount;i++){
printf("%d ",keybuf[i]);
}
prints("\n");
}
if ( ret_modifier )
ret=pmod;
return(ret);
}
#define K(code,key) case code: pkey=key;break;
#define S(code,string) case code: pstring=string;break;
#define M(code,modifier) case code: pmod=pmod|modifier;break;
#define F(code,fkeynumber) case code: fkey=fkeynumber;break;
// Read a key, wait for wait seconds, usecs microseconds.
// returns: -1 on error
// 0 on timeout
// otherwise the scancode of the key
char readkey_usecs( int wait, int usecs ){
struct timeval tv;
void *p = &tv;
fd_set set;
char c;
tv.tv_sec = wait;
tv.tv_usec = usecs;
FD_ZERO( &set );
FD_SET( fileno( stdin ), &set );
if ( wait == -1 )
p = NULL;
int res = 0;
#ifndef X64
res = select( fileno( stdin )+1, &set, NULL,NULL, p );
#else
register long int r10 asm ("r10") = 0 ;
register long int r8 asm ("r8") = (long int) p ;
asm volatile ("syscall" : "=a" (res) : "a" ( SCALL(select) ) , "D" (fileno(stdin)+1), "S" (&set), "d" (0), "r" (r10), "r" (r8) : "memory" );
#endif
//asm volatile ("syscall" : "=a" (ret) : "a" ( (23 | 0 ) ) , "D" (&fd), "S" (readfd), "d" (writefd), "r" (r10), "r" (r8) : "memory" );
if ( debug )
printf("res 1: %d %d\n",13,res);
if ( res > 0 ){
read( fileno( stdin ), (POINTER*)&c, 1 );
keybuf[keycount] = c;
keycount++;
if ( debug )
printf("readkey 1: %u\n",c);
return c;
}
if ( debug )
printf("res 2: %d\n",res);
if ( res == 0 ) // timeout
return 0;
perror( "select error" );
return -1;
}
// Read a key, wait for wait seconds.
// set wait to -1 to wait forever
//
// returns: -1 on error
// 0 on timeout
// otherwise the scancode of the key
char readkey( int wait ){
return readkey_usecs( wait, 0 );
}
// read a key, show dots dots per second
char readkey_dots( int wait, int dots ){
int a;
int usecs = 0;
int res = 0;
int loops = wait;
wait = 1;
if ( dots > 1 ){ // more dots per second..
wait = 0;
usecs = 1000000 / dots;
loops *= dots;
//printf("usecs: %d\n", usecs );
}
for ( a = 0; a < loops; a++ ){
fprint( stderr, "." );
res = readkey_usecs( wait, usecs );
if ( res != 0 ){ // got a result, could also be -1 (means error)
fputs( "", stderr );
return( res );
}
}
fputs( "", stderr );
return( res );
}
// Read an extended modifier keycode
char read_mod(){
char mod;
mod=readkey(0);
if ( mod == 59 )
mod = readkey(0);
// } else{
switch (mod){
M(50,SHIFT);
M(51,ALT);
M(52,ALT|SHIFT);
M(53,CTRL);
M(54,CTRL|SHIFT);
M(55,CTRL|ALT);
M(56,CTRL|ALT|SHIFT);
case 126:
return(126);
default:
//printf("mod2: %u\n",mod);
return(mod);
}
mod = readkey(0);
// else {
//printf("mod3: %u\n",mod);
return(mod);
//}
}
int main( int argc, char *argv[])
{
int wait = 0;
int dots = 0;
int pkey = 0;
int fkey = 0;
char *pstring=0;
//pstring[0] = 0;
// Parse Arguments
int a;
int b = 1; // show help?
for ( a=1; a < argc; a++) {
//mprintsl("Arg:",argv[a]);
if ( strcmp(argv[a], "-b" )==0 ) {
b = 0;
wait = -1;
} else
if ( strcmp(argv[a], "-n" )==0 ) {
b = 0;
wait = 0;
} else
if ( strcmp(argv[a], "-w")==0 ){
if ( (a+1 < argc ) && ( atoi(argv[a+1]) >0 ) ){
wait = atoi(argv[a+1]);
//printf("wait: %d\n",wait);
a++;
b = 0;
} else {
wait=0;
b=0;
}
} else
if ( strcmp(argv[a], "-d" )==0 ) {
dots = 1;
if ( (a+1 < argc ) && ( atoi(argv[a+1]) >0 ) ){
dots = atoi(argv[a+1]);
//printf("dots: %d\n",dots);
a++;
}
} else
if ( strcmp(argv[a], "--debug")==0)
debug=1;
else
if ( strcmp(argv[a], "--ret-modifier")==0)
ret_modifier=1;
else
if ( strcmp(argv[a], "--only-key")==0)
only_key = 1;
else
if ( strcmp(argv[a], "--repeat")==0)
repeat = 1;
}
// Show usage
if ( b ) {
int it=0;
const char* helpstring[] = {
"Usage: readkey [-b] [-w secs] [-d [dotrate]]",
"",
"Small program to wait for a key.",
"",
"The key/modifier is printed to stdout,",
"the return code is either the error code or",
"a value describing the modifier keys.",
"",
"parameters:",
"-b : block until a key is pressed.",
"-w [secs] : wait for [secs] (default 0) seconds for input.",
"-d [dotrate] : show 1 dot per second waiting, optional [dotrate] dots per second",
"--ret-modifier : return the pressed modifier - A value composed by these or´ed values: CTRL=1 | ALT=2 | SHIFT=4.",
"--only-key : Don´t print the modifier. (Doesn´t affect --ret-modifier)",
"--debug : Debug, print the full scancode",
"",
"Returns 255: unknown (most possibly related to select) error",
" 254: timeout.",
" 253: Unknown Scancode",
" 0: Ok / No modifier",
"",
"Example: key=`readkey -w 5`",
"echo $key",
"CC-BY 4.0",
"Michael Misc Myer www.github.com/michael105/readkey"
};
// tcsetattr( fileno( stdin ), TCSANOW, &oldSettings );
while (helpstring[it] != 0 ){
fprint(stderr,helpstring[it++]);
fprint(stderr,"\n");
}
return(0);
}
struct termios oldSettings, newSettings;
char c,c2;
int ret = 0;
tcgetattr( fileno( stdin ), &oldSettings );
newSettings = oldSettings;
newSettings.c_lflag &= (~ICANON & ~ECHO );
tcsetattr( fileno( stdin ), TCSANOW, &newSettings );
//ioctl( fileno( stdin ), TIOCSETA, &newSettings );
do{
if ( dots ) {
c = readkey_dots( wait, dots );
} else {
c = readkey( wait );
}
if ( debug ){
printf("c: %d\n",c);
}
AGAIN:
switch ( c )
{
case 0 : //printf("0\n");
exit(254); // timeout
break;
case -1 :
fprint(stderr,"Readkey: An unknown error occured");
exit(255); // select error
break;
K(9,TAB);
K(10,RET);
K(127,BACKSPACE);
case -61:
c=readkey(0);
if(debug) printf("c2: %d\n",c);
switch (c){
S(-68,"ü");
S(-74,"ö");
S(-92,"ä");
S(-100,"Ü");
S(-106,"Ö");
S(-124,"Ä");
S(-97,"ß");
}
break;
case 27 : {
c = readkey(0);
switch ( c ){
K(0,ESC);
case 79 : { //F1..F4
AG79:
c = readkey(0);
switch ( c ){
K(0,UNKNOWN);
F(80,1);
F(81,2);
F(82,3);
F(83,4);
case 50: pmod |= SHIFT;
goto AG79;
case 77:
pmod |= SHIFT;
pkey = RET;
break;
default:
pkey=UNKNOWN;
}
break;
}
case 91 : {
c = readkey(0);
AG91:
switch ( c ){
case 51 :{
c = readkey(0);
switch ( c ){
K(126,DEL);
case 59 : read_mod();
pkey=DEL;
break;
case 49:
case 50:
case 51:
case 52: // Terminal, F5-F8
read_mod();
pmod |= SHIFT;
fkey = c-44;
//printf("SHIFT+F%c",c+4);
break;
default:
pkey=UNKNOWN;
}
break;
}
K(65,UP);
K(66,DOWN);
K(67,RIGHT);
K(68,LEFT);
K(70,END);
K(72,POS1);
case 52: read_mod();
pkey=END;
break;
case 53 : //printf("-53");
read_mod();
pkey=PGUP;
break;
case 54 : read_mod();
pkey=PGDOWN;
break;
case 55 : pmod |= CTRL | ALT;
c = readkey(0);
goto AG91;
case 90 : pmod |= SHIFT;
pkey = TAB;
break;
case 50 : // F5..F8
c = readkey(0);
switch(c){
case 1:
case 2:
//printf("91- 50/49 - 1/2 - %u",c);
pkey=UNKNOWN;
break;
default:
c2 = read_mod();
switch ( c ){
F(48,9);
F(49,10);
F(51,11);
F(52,12);
case 53: fkey=1;
pmod=SHIFT;
break;
case 54: fkey=2;
pmod=SHIFT;
break;
case 56: fkey=3;
pmod=SHIFT;
break;
case 57: fkey=4;
pmod=SHIFT;
break;
K(126,INS);
default:
//printf("91- 50/49 - %u\n",c);
c=c2;
goto AG91;
}
}
break;
case 49 : // F9..F12
//printf("u: %u\n",c);
c = readkey(0);
switch(c){
case 1:
case 2:
//printf("91- 50/49 - 1/2 - %u",c);
pkey=UNKNOWN;
break;
default:
c2 = read_mod();
switch ( c ){
F(53,5);
F(55,6);
F(56,7);
F(57,8);
K(126,INS);
default:
//printf("91- 50/49 - %u\n",c);
c=c2;
goto AG91;
}
}
break;
K(126,INS);
case 91:
c = readkey(0);
if ( (c>64) && ( c<70 ) )
fkey = c - 64;
else
pkey=UNKNOWN;
//printf("91 - 91 - %u",c);
break;
default:
pkey=UNKNOWN;
}
break;
}
default :
//printf( "E: %u %c",c,c );
pmod |= ALT;
goto AGAIN;
}
break;
}
default: {
if ( (c>0) && (c < 27) ){
pmod |= CTRL;
pkey=c+64;
break;
}
pkey = c;
}
}
if ( (pkey | fkey) != 0 || ( pstring!=0))
ret=key_output(pmod,pkey,fkey,pstring);
keycount=0;
fkey=0;
pkey=0;
pstring=0;
pmod=0;
} while ( repeat==1 );
tcsetattr( fileno( stdin ), TCSANOW, &oldSettings );
return(ret);
//exit(ret);
}
|
f7468ac70a5778ce5b83c0f09a0ee7a0b6fb9f50 | 9228f98ba91cd33f374075e6381b385fd504e9ed | /Pods/Ads-CN/PangleSDK/BUFoundation.framework/Versions/A/Headers/bu_os.h | 83a47f02b40f0f14bd826adb14c5c65871c5f7f6 | [
"MIT"
] | permissive | lenbolan/zrmgz | b44e55e5ad2370fabdf2fc80a7161e9cbae6c0ee | 39ee3bbed011a002408e33911320b56ea5177f59 | refs/heads/main | 2023-04-18T09:23:23.732939 | 2021-05-05T02:30:08 | 2021-05-05T02:30:08 | 363,888,485 | 0 | 0 | MIT | 2021-05-05T02:30:09 | 2021-05-03T10:08:02 | Swift | UTF-8 | C | false | false | 5,523 | h | bu_os.h | /* bu_os.h -- System functions
Version 2.9.2, February 12, 2020
part of the MiniZip project
Copyright (C) 2010-2020 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
*/
#ifndef bu_OS_H
#define bu_OS_H
#ifdef __cplusplus
extern "C" {
#endif
/***************************************************************************/
#if defined(__APPLE__)
# define bu_VERSION_MADEBY_HOST_SYSTEM (bu_HOST_SYSTEM_OSX_DARWIN)
#elif defined(__riscos__)
# define bu_VERSION_MADEBY_HOST_SYSTEM (bu_HOST_SYSTEM_RISCOS)
#elif defined(__unix__)
# define bu_VERSION_MADEBY_HOST_SYSTEM (bu_HOST_SYSTEM_UNIX)
#elif defined(_WIN32)
# define bu_VERSION_MADEBY_HOST_SYSTEM (bu_HOST_SYSTEM_WINDOWS_NTFS)
#endif
#if defined(HAVE_LZMA)
# define bu_VERSION_MADEBY_ZIP_VERSION (63)
#elif defined(HAVE_WZAES)
# define bu_VERSION_MADEBY_ZIP_VERSION (51)
#elif defined(HAVE_BZIP2)
# define bu_VERSION_MADEBY_ZIP_VERSION (46)
#else
# define bu_VERSION_MADEBY_ZIP_VERSION (45)
#endif
#define bu_VERSION_MADEBY ((bu_VERSION_MADEBY_HOST_SYSTEM << 8) | \
(bu_VERSION_MADEBY_ZIP_VERSION))
#define bu_PATH_SLASH_UNIX ('/')
#if defined(_WIN32)
# define bu_PATH_SLASH_PLATFORM ('\\')
#else
# define bu_PATH_SLASH_PLATFORM (bu_PATH_SLASH_UNIX)
#endif
/***************************************************************************/
#if defined(_WIN32)
struct dirent {
char d_name[256];
};
typedef void* DIR;
#else
#include <dirent.h>
#endif
/***************************************************************************/
/* Shared functions */
int32_t bu_path_combine(char *path, const char *join, int32_t max_path);
/* Combines two paths */
int32_t bu_path_append_slash(char *path, int32_t max_path, char slash);
/* Appends a path slash on to the end of the path */
int32_t bu_path_remove_slash(char *path);
/* Removes a path slash from the end of the path */
int32_t bu_path_has_slash(const char *path);
/* Returns whether or not the path ends with slash */
int32_t bu_path_convert_slashes(char *path, char slash);
/* Converts the slashes in a path */
int32_t bu_path_compare_wc(const char *path, const char *wildcard, uint8_t ignore_case);
/* Compare two paths with wildcard */
int32_t bu_path_resolve(const char *path, char *target, int32_t max_target);
/* Resolves path */
int32_t bu_path_remove_filename(char *path);
/* Remove the filename from a path */
int32_t bu_path_remove_extension(char *path);
/* Remove the extension from a path */
int32_t bu_path_get_filename(const char *path, const char **filename);
/* Get the filename from a path */
int32_t bu_dir_make(const char *path);
/* Creates a directory recursively */
int32_t bu_file_get_crc(const char *path, uint32_t *result_crc);
/* Gets the crc32 hash of a file */
/***************************************************************************/
/* Platform specific functions */
wchar_t *bu_os_unicode_string_create(const char *string, int32_t encoding);
/* Create unicode string from a utf8 string */
void bu_os_unicode_string_delete(wchar_t **string);
/* Delete a unicode string that was created */
uint8_t *bu_os_utf8_string_create(const char *string, int32_t encoding);
/* Create a utf8 string from a string with another encoding */
void bu_os_utf8_string_delete(uint8_t **string);
/* Delete a utf8 string that was created */
int32_t bu_os_rand(uint8_t *buf, int32_t size);
/* Random number generator (not cryptographically secure) */
int32_t bu_os_rename(const char *source_path, const char *target_path);
/* Rename a file */
int32_t bu_os_unlink(const char *path);
/* Delete an existing file */
int32_t bu_os_file_exists(const char *path);
/* Check to see if a file exists */
int64_t bu_os_get_file_size(const char *path);
/* Gets the length of a file */
int32_t bu_os_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date);
/* Gets a file's modified, access, and creation dates if supported */
int32_t bu_os_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date);
/* Sets a file's modified, access, and creation dates if supported */
int32_t bu_os_get_file_attribs(const char *path, uint32_t *attributes);
/* Gets a file's attributes */
int32_t bu_os_set_file_attribs(const char *path, uint32_t attributes);
/* Sets a file's attributes */
int32_t bu_os_make_dir(const char *path);
/* Recursively creates a directory */
DIR* bu_os_open_dir(const char *path);
/* Opens a directory for listing */
struct
dirent* bu_os_read_dir(DIR *dir);
/* Reads a directory listing entry */
int32_t bu_os_close_dir(DIR *dir);
/* Closes a directory that has been opened for listing */
int32_t bu_os_is_dir(const char *path);
/* Checks to see if path is a directory */
int32_t bu_os_is_symlink(const char *path);
/* Checks to see if path is a symbolic link */
int32_t bu_os_make_symlink(const char *path, const char *target_path);
/* Creates a symbolic link pointing to a target */
int32_t bu_os_read_symlink(const char *path, char *target_path, int32_t max_target_path);
/* Gets the target path for a symbolic link */
uint64_t bu_os_ms_time(void);
/* Gets the time in milliseconds */
/***************************************************************************/
#ifdef __cplusplus
}
#endif
#endif
|
37d358523926de8c1afdc1ea09bd610ec83ae06f | 416f7d52e495daf5d9297373bb100d8217bdc511 | /src/display_tetris.c | 84c7a80c6597d70141d05034cdb82988b1136116 | [] | no_license | NicolasC27/tetris | 7a92244bbad854506e261d8a1e5edebf3c363f13 | d932e8435fbd4d1d8c7abff02156ea23c8323843 | refs/heads/master | 2021-01-18T22:04:10.416006 | 2017-05-25T15:19:47 | 2017-05-25T15:19:47 | 92,416,373 | 0 | 2 | null | null | null | null | UTF-8 | C | false | false | 2,492 | c | display_tetris.c | /*
** display_tetris.c for tetris in /home/samuel_r/EPITECH/PSU/PSU_2015_tetris
**
** Made by romain samuel
** Login <[email protected]>
**
** Started on Thu Mar 17 01:01:27 2016 romain samuel
** Last update Thu Mar 17 16:05:14 2016 romain samuel
*/
#include "tetris.h"
void display_t_letter(WINDOW *win, int x, int color)
{
wattron(win, COLOR_PAIR(color));
wmove(win, 1, 1 + x);
waddch(win, ' ');
waddch(win, ' ');
waddch(win, ' ');
wmove(win, 2, 2 + x);
waddch(win, ' ');
wmove(win, 3, 2 + x);
waddch(win, ' ');
wmove(win, 4, 2 + x);
waddch(win, ' ');
wmove(win, 5, 2 + x);
waddch(win, ' ');
wattroff(win, COLOR_PAIR(color));
}
void display_e_letter(WINDOW *win, int x, int color)
{
wattron(win, COLOR_PAIR(color));
wmove(win, 1, 5 + x);
waddch(win, ' ');
waddch(win, ' ');
waddch(win, ' ');
wmove(win, 2, 5 + x);
waddch(win, ' ');
wmove(win, 3, 5 + x);
waddch(win, ' ');
waddch(win, ' ');
wmove(win, 4, 5 + x);
waddch(win, ' ');
wmove(win, 5, 5 + x);
waddch(win, ' ');
waddch(win, ' ');
waddch(win, ' ');
wattroff(win, COLOR_PAIR(color));
}
void display_r_letter(WINDOW *win, int x, int color)
{
wattron(win, COLOR_PAIR(color));
wmove(win, 1, 13 + x);
waddch(win, ' ');
waddch(win, ' ');
waddch(win, ' ');
wmove(win, 2, 13 + x);
waddch(win, ' ');
wmove(win, 2, 15 + x);
waddch(win, ' ');
wmove(win, 3, 13 + x);
waddch(win, ' ');
waddch(win, ' ');
wmove(win, 4, 13 + x);
waddch(win, ' ');
wmove(win, 4, 15 + x);
waddch(win, ' ');
wmove(win, 5, 13 + x);
waddch(win, ' ');
wmove(win, 5, 15 + x);
waddch(win, ' ');
wattroff(win, COLOR_PAIR(color));
}
void display_i_letter(WINDOW *win, int x, int color)
{
wattron(win, COLOR_PAIR(color));
wmove(win, 1, 17 + x);
waddch(win, ' ');
wmove(win, 2, 17 + x);
waddch(win, ' ');
wmove(win, 3, 17 + x);
waddch(win, ' ');
wmove(win, 4, 17 + x);
waddch(win, ' ');
wmove(win, 5, 17 + x);
waddch(win, ' ');
wattroff(win, COLOR_PAIR(color));
}
void display_s_letter(WINDOW *win, int x, int color)
{
wattron(win, COLOR_PAIR(color));
wmove(win, 1, 19 + x);
waddch(win, ' ');
waddch(win, ' ');
waddch(win, ' ');
wmove(win, 2, 19 + x);
waddch(win, ' ');
wmove(win, 3, 19 + x);
waddch(win, ' ');
waddch(win, ' ');
waddch(win, ' ');
wmove(win, 4, 21 + x);
waddch(win, ' ');
wmove(win, 5, 19 + x);
waddch(win, ' ');
waddch(win, ' ');
waddch(win, ' ');
wattroff(win, COLOR_PAIR(color));
}
|
d2fcd79007c146b412886c2a8f2c8a3b6ba985a7 | e7826ba886c001221974f7b258a1321e5670e5df | /ft_ls_main.c | 2886f9f856243828aa679a5912dccd9727e1d1f1 | [] | no_license | brendenScussel/ft_ls | a564bb23062fdb00c91e6be53e4a0f4bd8699fd3 | 6a695a7507719ac3359be51a72c877b50189f990 | refs/heads/master | 2022-04-08T18:59:18.910478 | 2020-03-10T00:07:00 | 2020-03-10T00:07:00 | 239,066,653 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 2,975 | c | ft_ls_main.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ls_main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bscussel <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/01/25 20:54:05 by bscussel #+# #+# */
/* Updated: 2020/03/07 23:28:08 by bscussel ### ########.fr */
/* */
/* ************************************************************************** */
#include "./ft_ls.h"
char *arg_path(char *arg)
{
if ((arg[0] == '/') || ft_strncmp(arg, "./", 2) == 0)
return (ft_strdup(arg));
else
return (ft_strjoin("./", arg));
return (NULL);
}
int is_slash(char *str)
{
if (ft_strlen(str) != 1)
return (0);
if (str[0] != '/')
return (0);
if (str[1] != '\0')
return (0);
return (1);
}
void check_flags(t_vars *var, char *arg)
{
arg++;
while (*arg)
{
if (*arg == 'a')
var->flag.a = 1;
else if (*arg == 'l')
var->flag.l = 1;
else if (*arg == 'r')
var->flag.r = 1;
else if (*arg == 't')
var->flag.t = 1;
else if (*arg == 'R')
var->flag.recur = 1;
else if (*arg == 'F')
var->flag.f = 1;
else
{
ft_printf("ft_ls -%s: Invalid flag\n%s\n", arg, USAGE);
exit_ls(var, NULL);
}
arg++;
}
}
/*
** ==__==__==__==__==__==__==__==__==__==__==__==__==__==__==__==__==__==__==
** parse the given arguements
** if '-' is present, a flag is assumed and searched
** invalid flags will result in termination of program
** else the mpath is joined with the arguement to create the assumed path
** validity is checked later, and the path is ignored if not valid
** no flags results in flag.none being true
** likewise, if flag.none is true, the arguement variable is NULL
** ==__==__==__==__==__==__==__==__==__==__==__==__==__==__==__==__==__==__==
*/
void find_arg(t_vars *v, char **av)
{
v->i = 0;
v->d_arg = 0;
while ((int)v->i++ < v->argc)
{
if (*av[v->i] == '-')
check_flags(v, av[v->i]);
else
{
v->argv[v->d_arg] = (is_slash(av[v->i]) == 0) ?
arg_path(av[v->i]) : ft_strdup("/");
v->d_arg++;
}
}
if (v->d_arg == 0)
{
if (v->argv != NULL)
free(v->argv);
v->argv = NULL;
}
v->i = 0;
o_dir(v);
}
int main(int ac, char **av)
{
t_vars *var;
var = (t_vars *)malloc(sizeof(t_vars));
ft_bzero(&var->flag, sizeof(t_flag));
var->argc = ac - 1;
var->dcnt = 0;
var->argv = (ac > 1) ? (char **)malloc(sizeof(char *) * ac) : NULL;
var->entry = NULL;
var->size = 0;
var->dir_blocks = 0;
find_arg(var, av);
exit_ls(var, NULL);
return (0);
}
|
1af8753df7a1b62da84fc9b5063e9f20978ba2a4 | 6d42fe75d4c32a1bfb04a4b07f0899002a5e1b4d | /DrawingMachine/Configuration.h | edf7cb9f099fcdfa810270525025776f8a679243 | [] | no_license | brentyi/drawing_machine_firmware | 694184ea3fcc3c385341dc358ebc62b05b8f8c0e | 966abf461427e445dbc8584ea850ef927233f98d | refs/heads/master | 2021-01-10T23:38:40.728981 | 2016-12-20T02:00:29 | 2016-12-20T02:09:48 | 70,411,588 | 3 | 1 | null | null | null | null | UTF-8 | C | false | false | 933 | h | Configuration.h | /*
Drawing machine configuration file
Standard units: millimeters, radians
*/
/// Physical properties
#define TABLE_DIAMETER 251
#define STEPS_PER_MM 1600 // 200 steps per revolution * 16 microsteps / 2mm per revolution
#define STEPS_PER_RADIAN 4309.42615 // 200 steps per revolution * 16 microsteps * 110 / 13 gear ratio / 2pi
/// Directions
#define LINEAR_DIR 1
#define ROTARY_DIR 1
/// Movement
#define LINEAR_HOMESPEED 30000
#define LINEAR_MAXSPEED 30000
#define ROTARY_MAXSPEED 2000
#define LINEAR_ACCEL 50000
#define ROTARY_ACCEL 50000
#define SEGMENTATION_LENGTH 1
/// Pin configuration
#define PIN_ROTARY_STEP 2
#define PIN_ROTARY_DIR 3
#define PIN_LINEAR_STEP 5
#define PIN_LINEAR_DIR 4
#define PIN_ENABLE 12
#define PIN_LINEAR_MINSTOP A0
#define PIN_SOLENOID 6
#define PIN_LED_BLUE A1
#define PIN_LED_RED A2
#define PIN_BUTTON A3
/// Firmware-y constants
#define BAUDRATE 115200
#define BUFFER_LENGTH 100
|
8a84d18a6fb155007defd5d5ebdb43d8ec125f46 | 601815dcb8fd135d3199e5358a75fc6694d91843 | /src/GeneralInclude/ForwardDeclarations.h | fda6267fc12b1595354c45f94cf4b1bb97fd3bf9 | [] | no_license | Gyumeijie/ObsFramework | 695b9b92bf33c901aec83653322e502a78df0158 | ee2b3ed9009b3f7f8dcc01766b2bfddc597616ee | refs/heads/master | 2018-12-25T03:18:52.359782 | 2018-10-18T06:35:20 | 2018-10-18T06:35:20 | 116,783,750 | 4 | 0 | null | null | null | null | UTF-8 | C | false | false | 17,398 | h | ForwardDeclarations.h | //
//
// ForwardDeclarations.h
//
/**
* @file ForwardDeclarations.h
* This file defines all forward declarations used in the OBS Framework.
*/
#ifndef FORWARDDECLARATIONS_H
#define FORWARDDECLARATIONS_H
///////////////////////////////////////////////////////////////////////////////
//
// types of obsframework
//
///////////////////////////////////////////////////////////////////////////////
typedef struct CC_TelemetryPacketFactory CC_TelemetryPacketFactory;
typedef struct CC_TelemetryPacketFactoryClass CC_TelemetryPacketFactoryClass;
typedef struct CC_ManoeuvreFactory CC_ManoeuvreFactory;
typedef struct CC_ManoeuvreFactoryClass CC_ManoeuvreFactoryClass;
typedef struct CC_TelecommandFactory CC_TelecommandFactory;
typedef struct CC_TelecommandFactoryClass CC_TelecommandFactoryClass;
typedef struct DataPool DataPool;
typedef struct DataPoolClass DataPoolClass;
typedef struct DC_BasicDataPool DC_BasicDataPool;
typedef struct DC_BasicDataPoolClass DC_BasicDataPoolClass;
typedef struct DC_DummyDataPool DC_DummyDataPool;
typedef struct DC_DummyDataPoolClass DC_DummyDataPoolClass;
typedef struct DC_SampleFullDataPool DC_SampleFullDataPool;
typedef struct DC_SampleFullDataPoolClass DC_SampleFullDataPoolClass;
typedef struct CC_RootObject CC_RootObject;
typedef struct CC_RootObjectClass CC_RootObjectClass;
typedef struct DC_BasicPUSTcLoader DC_BasicPUSTcLoader;
typedef struct DC_BasicPUSTcLoaderClass DC_BasicPUSTcLoaderClass;
typedef struct DC_DataItem DC_DataItem;
typedef struct DC_DataItemClass DC_DataItemClass;
typedef struct DC_RawDataItem DC_RawDataItem;
typedef struct DC_RawDataItemClass DC_RawDataItemClass;
typedef struct ControlBlock ControlBlock;
typedef struct ControlBlockClass ControlBlockClass;
typedef struct CopyControlBlock CopyControlBlock;
typedef struct CopyControlBlockClass CopyControlBlockClass;
typedef struct DC_DummyCopyControlBlock DC_DummyCopyControlBlock;
typedef struct DC_DummyCopyControlBlockClass DC_DummyCopyControlBlockClass;
typedef struct PointerControlBlock PointerControlBlock;
typedef struct PointerControlBlockClass PointerControlBlockClass;
typedef struct DC_DummyPointerControlBlock DC_DummyPointerControlBlock;
typedef struct DC_DummyPointerControlBlockClass DC_DummyPointerControlBlockClass;
typedef struct DataItemControlBlock DataItemControlBlock;
typedef struct DataItemControlBlockClass DataItemControlBlockClass;
typedef struct DC_DummyDataItemControlBlock DC_DummyDataItemControlBlock;
typedef struct DC_DummyDataItemControlBlockClass DC_DummyDataItemControlBlockClass;
typedef struct DataPoolControlBlock DataPoolControlBlock;
typedef struct DataPoolControlBlockClass DataPoolControlBlockClass;
typedef struct DC_DummyDataPoolControlBlock DC_DummyDataPoolControlBlock;
typedef struct DC_DummyDataPoolControlBlockClass DC_DummyDataPoolControlBlockClass;
typedef struct DC_DummyTelemetryPacket DC_DummyTelemetryPacket;
typedef struct DC_DummyTelemetryPacketClass DC_DummyTelemetryPacketClass;
typedef struct PunctualAction PunctualAction;
typedef struct PunctualActionClass PunctualActionClass;
typedef struct ConditionalPunctualAction ConditionalPunctualAction;
typedef struct ConditionalPunctualActionClass ConditionalPunctualActionClass;
typedef struct DC_DummyConditionalPunctualAction DC_DummyConditionalPunctualAction;
typedef struct DC_DummyConditionalPunctualActionClass DC_DummyConditionalPunctualActionClass;
typedef struct DC_ControlAction DC_ControlAction;
typedef struct DC_ControlActionClass DC_ControlActionClass;
typedef struct DC_ControlList DC_ControlList;
typedef struct DC_ControlListClass DC_ControlListClass;
typedef struct DC_DataPoolMonitor DC_DataPoolMonitor;
typedef struct DC_DataPoolMonitorClass DC_DataPoolMonitorClass;
typedef struct DC_DummyPunctualAction DC_DummyPunctualAction;
typedef struct DC_DummyPunctualActionClass DC_DummyPunctualActionClass;
typedef struct DC_ManoeuvrePunctualAction DC_ManoeuvrePunctualAction;
typedef struct DC_ManoeuvrePunctualActionClass DC_ManoeuvrePunctualActionClass;
typedef struct RecoveryAction RecoveryAction;
typedef struct RecoveryActionClass RecoveryActionClass;
typedef struct DC_DummyRecoveryAction DC_DummyRecoveryAction;
typedef struct DC_DummyRecoveryActionClass DC_DummyRecoveryActionClass;
typedef struct DC_SettableDataItem DC_SettableDataItem;
typedef struct DC_SettableDataItemClass DC_SettableDataItemClass;
typedef struct CC_FSM CC_FSM;
typedef struct CC_FSMClass CC_FSMClass;
typedef struct FsmState FsmState;
typedef struct FsmStateClass FsmStateClass;
typedef struct DC_DummyFsmState DC_DummyFsmState;
typedef struct DC_DummyFsmStateClass DC_DummyFsmStateClass;
typedef struct DC_DummyConfigurableFsmState DC_DummyConfigurableFsmState;
typedef struct DC_DummyConfigurableFsmStateClass DC_DummyConfigurableFsmStateClass;
typedef struct DC_UnstableFsmState DC_UnstableFsmState;
typedef struct DC_UnstableFsmStateClass DC_UnstableFsmStateClass;
typedef struct DC_NestedFsmActivator DC_NestedFsmActivator;
typedef struct DC_NestedFsmActivatorClass DC_NestedFsmActivatorClass;
typedef struct DC_NestedFsmActivatorWithEndState DC_NestedFsmActivatorWithEndState;
typedef struct DC_NestedFsmActivatorWithEndStateClass DC_NestedFsmActivatorWithEndStateClass;
typedef struct DC_NestedFsmActivatorWithExitCheck DC_NestedFsmActivatorWithExitCheck;
typedef struct DC_NestedFsmActivatorWithExitCheckClass DC_NestedFsmActivatorWithExitCheckClass;
typedef struct DC_FsmEvent DC_FsmEvent;
typedef struct DC_FsmEventClass DC_FsmEventClass;
typedef struct DC_FromFsmEvent DC_FromFsmEvent;
typedef struct DC_FromFsmEventClass DC_FromFsmEventClass;
typedef struct CC_TelecommandManager CC_TelecommandManager;
typedef struct CC_TelecommandManagerClass CC_TelecommandManagerClass;
typedef struct CC_TelemetryManager CC_TelemetryManager;
typedef struct CC_TelemetryManagerClass CC_TelemetryManagerClass;
typedef struct CC_ManoeuvreManager CC_ManoeuvreManager;
typedef struct CC_ManoeuvreManagerClass CC_ManoeuvreManagerClass;
typedef struct DC_DummyObsClock DC_DummyObsClock;
typedef struct DC_DummyObsClockClass DC_DummyObsClockClass;
typedef struct DC_EventRepository DC_EventRepository;
typedef struct DC_EventRepositoryClass DC_EventRepositoryClass;
typedef struct DC_Event DC_Event;
typedef struct DC_EventClass DC_EventClass;
typedef struct DC_FdirCheck DC_FdirCheck;
typedef struct DC_FdirCheckClass DC_FdirCheckClass;
typedef struct DC_NullRecoveryAction DC_NullRecoveryAction;
typedef struct DC_NullRecoveryActionClass DC_NullRecoveryActionClass;
typedef struct Manoeuvre Manoeuvre;
typedef struct ManoeuvreClass ManoeuvreClass;
typedef struct DC_DummyConfigurableManoeuvre DC_DummyConfigurableManoeuvre;
typedef struct DC_DummyConfigurableManoeuvreClass DC_DummyConfigurableManoeuvreClass;
typedef struct DC_DummyManoeuvre DC_DummyManoeuvre;
typedef struct DC_DummyManoeuvreClass DC_DummyManoeuvreClass;
typedef struct DC_DummyTelecommand DC_DummyTelecommand;
typedef struct DC_DummyTelecommandClass DC_DummyTelecommandClass;
typedef struct DC_DummyPUSTelecommand DC_DummyPUSTelecommand;
typedef struct DC_DummyPUSTelecommandClass DC_DummyPUSTelecommandClass;
typedef struct CriticalTelecommand CriticalTelecommand;
typedef struct CriticalTelecommandClass CriticalTelecommandClass;
typedef struct DC_DummyCriticalTelecommand DC_DummyCriticalTelecommand;
typedef struct DC_DummyCriticalTelecommandClass DC_DummyCriticalTelecommandClass;
typedef struct PUSTelemetryPacket PUSTelemetryPacket;
typedef struct PUSTelemetryPacketClass PUSTelemetryPacketClass;
typedef struct PUSDumpMemory PUSDumpMemory;
typedef struct PUSDumpMemoryClass PUSDumpMemoryClass;
typedef struct DC_DummyPUSTelemetryPacket DC_DummyPUSTelemetryPacket;
typedef struct DC_DummyPUSTelemetryPacketClass DC_DummyPUSTelemetryPacketClass;
typedef struct DC_PUSControlDataReporting DC_PUSControlDataReporting;
typedef struct DC_PUSControlDataReportingClass DC_PUSControlDataReportingClass;
typedef struct DC_PUSDataReportingPacket DC_PUSDataReportingPacket;
typedef struct DC_PUSDataReportingPacketClass DC_PUSDataReportingPacketClass;
typedef struct DC_PUSDefineDataReporting DC_PUSDefineDataReporting;
typedef struct DC_PUSDefineDataReportingClass DC_PUSDefineDataReportingClass;
typedef struct DC_PUSDumpMemoryAbsolute DC_PUSDumpMemoryAbsolute;
typedef struct DC_PUSDumpMemoryAbsoluteClass DC_PUSDumpMemoryAbsoluteClass;
typedef struct DC_PUSDumpMemoryOffset DC_PUSDumpMemoryOffset;
typedef struct DC_PUSDumpMemoryOffsetClass DC_PUSDumpMemoryOffsetClass;
typedef struct DC_PUSEventRepository DC_PUSEventRepository;
typedef struct DC_PUSEventRepositoryClass DC_PUSEventRepositoryClass;
typedef struct PUSMemoryDump PUSMemoryDump;
typedef struct PUSMemoryDumpClass PUSMemoryDumpClass;
typedef struct DC_PUSMemoryDumpAbsolute DC_PUSMemoryDumpAbsolute;
typedef struct DC_PUSMemoryDumpAbsoluteClass DC_PUSMemoryDumpAbsoluteClass;
typedef struct DC_PUSMemoryDumpOffset DC_PUSMemoryDumpOffset;
typedef struct DC_PUSMemoryDumpOffsetClass DC_PUSMemoryDumpOffsetClass;
typedef struct PUSMemoryLoad PUSMemoryLoad;
typedef struct PUSMemoryLoadClass PUSMemoryLoadClass;
typedef struct DC_PUSMemoryLoadAbsolute DC_PUSMemoryLoadAbsolute;
typedef struct DC_PUSMemoryLoadAbsoluteClass DC_PUSMemoryLoadAbsoluteClass;
typedef struct DC_PUSMemoryLoadOffset DC_PUSMemoryLoadOffset;
typedef struct DC_PUSMemoryLoadOffsetClass DC_PUSMemoryLoadOffsetClass;
typedef struct DC_PUSTcVerificationPacket DC_PUSTcVerificationPacket;
typedef struct DC_PUSTcVerificationPacketClass DC_PUSTcVerificationPacketClass;
typedef struct StructuredTelemetryPacket StructuredTelemetryPacket;
typedef struct StructuredTelemetryPacketClass StructuredTelemetryPacketClass;
typedef struct DC_DataItem16TmWord DC_DataItem16TmWord;
typedef struct DC_DataItem16TmWordClass DC_DataItem16TmWordClass;
typedef struct TelemetryStream TelemetryStream;
typedef struct TelemetryStreamClass TelemetryStreamClass;
typedef struct DC_ByteArrayTelemetryStream DC_ByteArrayTelemetryStream;
typedef struct DC_ByteArrayTelemetryStreamClass DC_ByteArrayTelemetryStreamClass;
typedef struct DC_DummyTelemetryStream DC_DummyTelemetryStream;
typedef struct DC_DummyTelemetryStreamClass DC_DummyTelemetryStreamClass;
typedef struct DC_CycleDataItem16TmStream DC_CycleDataItem16TmStream;
typedef struct DC_CycleDataItem16TmStreamClass DC_CycleDataItem16TmStreamClass;
typedef struct DC_BasicPUSTmStream DC_BasicPUSTmStream;
typedef struct DC_BasicPUSTmStreamClass DC_BasicPUSTmStreamClass;
typedef struct DC_FileTelemetryStream DC_FileTelemetryStream;
typedef struct DC_FileTelemetryStreamClass DC_FileTelemetryStreamClass;
typedef struct ModeManager ModeManager;
typedef struct ModeManagerClass ModeManagerClass;
typedef struct DC_DummyModeManager DC_DummyModeManager;
typedef struct DC_DummyModeManagerClass DC_DummyModeManagerClass;
typedef struct PunctualActionModeManager PunctualActionModeManager;
typedef struct PunctualActionModeManagerClass PunctualActionModeManagerClass;
typedef struct PunctualActionListModeManager PunctualActionListModeManager;
typedef struct PunctualActionListModeManagerClass PunctualActionListModeManagerClass;
typedef struct DC_CyclingPunctualActionModeManager DC_CyclingPunctualActionModeManager;
typedef struct DC_CyclingPunctualActionModeManagerClass DC_CyclingPunctualActionModeManagerClass;
typedef struct DC_SimplePunctualActionModeManagerClass DC_SimplePunctualActionModeManagerClass;
typedef struct DC_SimplePunctualActionModeManager DC_SimplePunctualActionModeManager;
typedef struct TelemetryModeManager TelemetryModeManager;
typedef struct TelemetryModeManagerClass TelemetryModeManagerClass;
typedef struct DC_PUSTelemetryModeManager DC_PUSTelemetryModeManager;
typedef struct DC_PUSTelemetryModeManagerClass DC_PUSTelemetryModeManagerClass;
typedef struct TelemetryListModeManager TelemetryListModeManager;
typedef struct TelemetryListModeManagerClass TelemetryListModeManagerClass;
typedef struct DC_SimpleTelemetryModeManager DC_SimpleTelemetryModeManager;
typedef struct DC_SimpleTelemetryModeManagerClass DC_SimpleTelemetryModeManagerClass;
typedef struct DC_CyclingTelemetryModeManager DC_CyclingTelemetryModeManager;
typedef struct DC_CyclingTelemetryModeManagerClass DC_CyclingTelemetryModeManagerClass;
typedef struct DC_PUSTmLogger DC_PUSTmLogger;
typedef struct DC_PUSTmLoggerClass DC_PUSTmLoggerClass;
typedef struct DC_TestPUSConfigurableManoeuvre DC_TestPUSConfigurableManoeuvre;
typedef struct DC_TestPUSConfigurableManoeuvreClass DC_TestPUSConfigurableManoeuvreClass;
typedef struct DC_PUSClearDataReporting DC_PUSClearDataReporting;
typedef struct DC_PUSClearDataReportingClass DC_PUSClearDataReportingClass;
typedef struct DC_TestPUSTelecommand DC_TestPUSTelecommand;
typedef struct DC_TestPUSTelecommandClass DC_TestPUSTelecommandClass;
typedef struct MonitoringProfile MonitoringProfile;
typedef struct MonitoringProfileClass MonitoringProfileClass;
typedef struct DC_NullProfile DC_NullProfile;
typedef struct DC_NullProfileClass DC_NullProfileClass;
typedef struct DC_ForbiddenValueProfile DC_ForbiddenValueProfile;
typedef struct DC_ForbiddenValueProfileClass DC_ForbiddenValueProfileClass;
typedef struct DC_DeltaProfile DC_DeltaProfile;
typedef struct DC_DeltaProfileClass DC_DeltaProfileClass;
typedef struct DC_StuckDataProfile DC_StuckDataProfile;
typedef struct DC_StuckDataProfileClass DC_StuckDataProfileClass;
typedef struct RangeProfile RangeProfile;
typedef struct RangeProfileClass RangeProfileClass;
typedef struct DC_InRangeProfile DC_InRangeProfile;
typedef struct DC_InRangeProfileClass DC_InRangeProfileClass;
typedef struct DC_OutOfRangeProfile DC_OutOfRangeProfile;
typedef struct DC_OutOfRangeProfileClass DC_OutOfRangeProfileClass;
typedef struct DC_ProfileList DC_ProfileList;
typedef struct DC_ProfileListClass DC_ProfileListClass;
typedef struct DC_SimpleChangeProfile DC_SimpleChangeProfile;
typedef struct DC_SimpleChangeProfileClass DC_SimpleChangeProfileClass;
typedef struct ObsClock ObsClock;
typedef struct ObsClockClass ObsClockClass;
typedef struct ParameterDatabase ParameterDatabase;
typedef struct ParameterDatabaseClass ParameterDatabaseClass;
typedef struct DC_BasicDatabase DC_BasicDatabase;
typedef struct DC_BasicDatabaseClass DC_BasicDatabaseClass;
typedef struct DC_DummyDatabase DC_DummyDatabase;
typedef struct DC_DummyDatabaseClass DC_DummyDatabaseClass;
typedef struct PUSTelecommand PUSTelecommand;
typedef struct PUSTelecommandClass PUSTelecommandClass;
typedef struct PUSTcManoeuvre PUSTcManoeuvre;
typedef struct PUSTcManoeuvreClass PUSTcManoeuvreClass;
typedef struct Telecommand Telecommand;
typedef struct TelecommandClass TelecommandClass;
typedef struct PUSFunctionManagement PUSFunctionManagement;
typedef struct PUSFunctionManagementClass PUSFunctionManagementClass;
typedef struct TelecommandLoader TelecommandLoader;
typedef struct TelecommandLoaderClass TelecommandLoaderClass;
typedef struct DC_DummyTelecommandLoader DC_DummyTelecommandLoader;
typedef struct DC_DummyTelecommandLoaderClass DC_DummyTelecommandLoaderClass;
typedef struct TelemetryPacket TelemetryPacket;
typedef struct TelemetryPacketClass TelemetryPacketClass;
typedef struct Tracer Tracer;
typedef struct TracerClass TracerClass;
typedef struct DC_DummyTracer DC_DummyTracer;
typedef struct DC_DummyTracerClass DC_DummyTracerClass;
typedef struct DC_TestTracer DC_TestTracer;
typedef struct DC_TestTracerClass DC_TestTracerClass;
typedef struct CC_IntStack CC_IntStack;
typedef struct CC_IntStackClass CC_IntStackClass;
typedef struct CC_RootObjectStack CC_RootObjectStack;
typedef struct CC_RootObjectStackClass CC_RootObjectStackClass;
typedef struct DC_BasicReconfigurer DC_BasicReconfigurer;
typedef struct DC_BasicReconfigurerClass DC_BasicReconfigurerClass;
typedef struct CC_PunctualActionManager CC_PunctualActionManager;
typedef struct CC_PunctualActionManagerClass CC_PunctualActionManagerClass;
///////////////////////////////////////////////////////////////////////////////
//
// types of unit test
//
///////////////////////////////////////////////////////////////////////////////
typedef struct TestCase TestCase;
typedef struct TestCaseClass TestCaseClass;
typedef struct TestCaseGenericSetUp TestCaseGenericSetUp;
typedef struct TestCaseGenericSetUpClass TestCaseGenericSetUpClass;
typedef struct TestSuite TestSuite;
typedef struct TestSuiteClass TestSuiteClass;
typedef struct TestCaseWithEvtCheck TestCaseWithEvtCheck;
typedef struct TestCaseWithEvtCheckClass TestCaseWithEvtCheckClass;
typedef struct TestCaseWithFactories TestCaseWithFactories;
typedef struct TestCaseWithFactoriesClass TestCaseWithFactoriesClass;
typedef struct TestCasePUSFull TestCasePUSFull;
typedef struct TestCasePUSFullClass TestCasePUSFullClass;
#endif
|
ed9e9f138f4383b3634f955e24609f0782b6fbef | 46979906b331cc10c7f0f009a158ce0996f14097 | /dynchk/libs/libglib-2.0/g_logv.c | a65b848411841ba43a48e5070155de76d1d870e3 | [] | no_license | mwichmann/lsb-checkers | 2f6a9674c9a23e39d69d35e8d2457c7a5b3881dc | 1170e4486085731b129cbb060c693e7e6ebca027 | refs/heads/master | 2020-06-11T00:07:56.105656 | 2016-12-08T19:30:39 | 2016-12-08T19:30:39 | 75,857,254 | 3 | 3 | null | null | null | null | UTF-8 | C | false | false | 1,261 | c | g_logv.c | // Generated by gen_lib.pl
#include "../../tests/type_tests.h"
#include "../../misc/lsb_output.h"
#include "stdlib.h"
#include <glib-2.0/glib.h>
#include <stdarg.h>
#undef g_logv
static void(*funcptr) (const gchar * , GLogLevelFlags , const gchar * , va_list ) = 0;
extern int __lsb_check_params;
void g_logv (const gchar * arg0 , GLogLevelFlags arg1 , const gchar * arg2 , va_list arg3 )
{
int reset_flag = __lsb_check_params;
__lsb_output(4, "Invoking wrapper for g_logv()");
if(!funcptr)
funcptr = dlsym(RTLD_NEXT, "g_logv");
if(!funcptr) {
__lsb_output(-1, "Failed to load g_logv. Probably the library was loaded using dlopen, we don't support this at the moment.");
exit(1);
}
if(__lsb_check_params)
{
__lsb_check_params=0;
__lsb_output(4, "g_logv() - validating");
if( arg0 ) {
validate_Rdaddress( arg0, "g_logv - arg0 (log_domain)");
}
validate_NULL_TYPETYPE( arg0, "g_logv - arg0 (log_domain)");
validate_NULL_TYPETYPE( arg1, "g_logv - arg1 (log_level)");
if( arg2 ) {
validate_Rdaddress( arg2, "g_logv - arg2 (format)");
}
validate_NULL_TYPETYPE( arg2, "g_logv - arg2 (format)");
validate_NULL_TYPETYPE( arg3, "g_logv - arg3 (args)");
}
funcptr(arg0, arg1, arg2, arg3);
__lsb_check_params = reset_flag;
}
|
4838327727b65d749adbd45ef40e4ceb3e51cc4a | eaae3529ea65c9be62e4b177a498dd0459396052 | /modified_vars_lib_ws/JimMeyering_test-sigpipe.c | f319d91684fd67a7561213fc03aec77182cae586 | [] | no_license | mgsanusi/blame-dodger | badac55079b0bc84c1c3ddff9357caffd480b512 | c8b1f19d48e09200c9d59f3dda3b298ced7103d7 | refs/heads/master | 2021-01-20T04:50:14.975609 | 2018-01-12T00:02:14 | 2018-01-12T00:02:14 | 89,739,285 | 3 | 0 | null | null | null | null | UTF-8 | C | false | false | 201 | c | JimMeyering_test-sigpipe.c | #include <config.h>
#include <signal.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void new_exit (int status);
void
new_exit (int status)
{
return exit (status);
}
|
94a76dc61f38ef2556caf5eb95df5fafb377ac4c | caf081f26fc5d72b0d2749dc7751de32ac8214a7 | /chapter6/getword.c | 89e656575db8615406d074d438114e4fd71b2797 | [] | no_license | MDNobu/KRBook | f236797662bf6eb6650af5edd4452cdca9bb372e | e76d5563088a202a85f46ddf26c5d58603a2d0f6 | refs/heads/master | 2021-12-24T12:27:11.704196 | 2013-03-03T02:15:54 | 2013-03-03T02:15:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 368 | c | getword.c | #include "string.h"
#include "ctype.h"
int getch();
void ungetch(int c);
int getword(char *word, int limit) {
int c;
char *base = word;
while((c = getch()) == ' ' || c == '\t')
;
*word++ = c;
limit--;
if(!isalpha(c)) {
*word = '\0';
return c;
}
while(isalnum(c = getch()) && --limit > 0)
*word++ = c;
ungetch(c);
*word = '\0';
return word[0];
} |
57b62626efd4681f3be7fd5c8899d6b09b1896ab | 9b40e59b80d669ab9e1bb5a30afb81f571041b3c | /reptools/GSSAPI/src/toto-client-gss.c | 404e83700d18d03c50c339da59fb06ab51da2d51 | [] | no_license | bongiojp/nfs-ganesha | 2f5280c9df53b9134c816e7813c320bd1b9228b5 | 18a5f3e8eda6439a6b9a71ed5d3b047553992049 | refs/heads/master | 2016-09-03T06:43:16.015674 | 2013-03-01T22:57:23 | 2013-03-01T22:57:23 | 949,126 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 17,231 | c | toto-client-gss.c | /*
*
* Les sources du client du serveur toto
*
*/
char rcsid[] = "$Id: toto-client-gss.c,v 1.3 2003/10/02 13:57:45 deniel Exp $" ;
/* Un tas d'include pour avoir les bindings standards */
#include <sys/time.h>
#include <sys/types.h>
#include <sys/param.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <gssapi/gssapi.h> /* Header de la gssapi */
#ifdef HAVE_KRB5
#include <gssapi/gssapi_krb5.h> /* Header de la gssapi */
#endif
#define TOKEN_NOOP (1<<0)
#define TOKEN_CONTEXT (1<<1)
#define TOKEN_DATA (1<<2)
#define TOKEN_MIC (1<<3)
#define TOKEN_CONTEXT_NEXT (1<<4)
#define TOKEN_WRAPPED (1<<5)
#define TOKEN_ENCRYPTED (1<<6)
#define TOKEN_SEND_MIC (1<<7)
void sperror_gss( char * str, OM_uint32 major, OM_uint32 minor ) ;
int write_tok( int s, gss_buffer_t tok ) ;
int read_tok( int s, gss_buffer_t tok ) ;
#define LENMSG 256
#define TraduireAdresse( adresse, dest ) \
sprintf( dest, "%d.%d.%d.%d", \
( ntohl( adresse ) & 0xFF000000 ) >> 24, \
( ntohl( adresse ) & 0x00FF0000 ) >> 16, \
( ntohl( adresse ) & 0x0000FF00 ) >> 8, \
( ntohl( adresse ) & 0x000000FF ) )
#define SNAME_DEFAUT "toto"
/* les options pour getopt */
char options[] = "hd:P:M:S:" ;
/* L'aide en ligne */
char utilisation[] =
"Utilisation: %s [-hdPM] message\n"
"\t[-h] affiche cet aide en ligbe\n"
"\t[-d <machine>] indique la machine serveur\n"
"\t[-P <port ou service>] le port ou le service ou le daemon ecoute\n"
"\t[-M <Mecanisme Auth>] le mecanisme utilise par ls GSS-API\n"
"\t[-S <Mecanisme Auth>] le service utilise par ls GSS-API\n" ;
/* Quelques variables d'etat pour la GSSAPI */
OM_uint32 deleg_flag = 0 ;
gss_ctx_id_t gss_context ;
gss_OID g_mechOid ;
char sname[256] ;
/* Cette routine alloue une adresse et la lie a son point d'entree */
/* La valeur retournee est le descripteur de socket ou une valeur negative si erreur */
/* si port == 0, on choisit dynamiquement le port */
/* adresse et port sont au format NET */
int CreerSocket( unsigned int adresse, unsigned short port )
{
int socket_fd ;
struct sockaddr_in addr ;
/* 1- On cree la socket */
if( ( socket_fd = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1 )
{
fprintf( stderr, "error socket: errno=%u|%s\n", errno, strerror( errno ) ) ;
return -1 ;
}
/* 2- On remplit l'adresse */
memset( &addr, 0, sizeof( addr ) ) ;
addr.sin_family = AF_INET ;
addr.sin_addr.s_addr = adresse ;
addr.sin_port = port ;
/* 3- On bind la socket sur l'adresse */
if( bind( socket_fd, (struct sockaddr *)&addr, sizeof( addr ) ) == -1 )
{
fprintf( stderr, "error socket: errno=%u|%s\n", errno, strerror( errno ) ) ;
return -1 ;
}
/* 4- on s'en va */
return socket_fd ;
} /* CreerSocket */
/*
* La routine de negociation avec le serveur sous GSSAPI
*/
int negociation_client( int sockfd, char * service_name, gss_OID oid )
{
gss_buffer_desc send_tok ;
gss_buffer_desc recv_tok ;
gss_buffer_desc * token_ptr ;
gss_name_t tname ;
OM_uint32 maj_stat, min_stat, init_sec_min_stat ;
OM_uint32 ret_flags ;
int token_flags;
char strerrgss[256] ;
gss_buffer_desc empty_token = { 0, (void *) "" };
/* Je dois construire le target name dans un format GSSAPI compliant */
fprintf( stderr, "Negociation pour acceder au service '%s'\n", service_name ) ;
send_tok.value = service_name ;
send_tok.length = strlen( service_name ) + 1 ;
/* Instanciation du nom GSSAPI du service */
if( ( maj_stat = gss_import_name( &min_stat, &send_tok,
(gss_OID)GSS_C_NT_HOSTBASED_SERVICE, &tname ) ) != GSS_S_COMPLETE )
{
sperror_gss( strerrgss, maj_stat, min_stat ) ;
fprintf( stderr, "gss_import_name: %s\n", strerrgss ) ;
exit( 1 ) ;
}
/* 0- On envoie un toekn vide pour commencer, juste histoire de donner des flags */
if (send_token(sockfd, TOKEN_NOOP|TOKEN_CONTEXT_NEXT, &empty_token) < 0)
{
fprintf( stderr, "send_token: errno=%d\n", errno ) ;
(void) gss_release_name(&min_stat, &tname);
exit( 1 ) ;
}
/* Boucle d'etablissement du contexte */
token_ptr = GSS_C_NO_BUFFER ;
gss_context = GSS_C_NO_CONTEXT ;
do
{
/* On cree un context que l'on va envoyer au serveur */
maj_stat = gss_init_sec_context( &init_sec_min_stat,
GSS_C_NO_CREDENTIAL,
&gss_context,
tname,
oid,
GSS_C_MUTUAL_FLAG | GSS_C_REPLAY_FLAG | deleg_flag,
0,
GSS_C_NO_CHANNEL_BINDINGS, /* no channel bindings */
token_ptr, /* ignore mech type */
NULL,
&send_tok,
(int *)&ret_flags,
NULL ) ; /* ignore time_rec */
if( token_ptr != GSS_C_NO_BUFFER )
(void) gss_release_buffer( &min_stat, &recv_tok ) ;
if( send_tok.length != 0 )
{
fprintf( stderr, "Envoie du contexte initial, taille=%d\n", send_tok.length ) ;
if( send_token( sockfd, TOKEN_CONTEXT, &send_tok ) < 0 )
{
fprintf( stderr, "Erreur a l'envoie du contexte initiale\n" ) ;
(void) gss_release_buffer(&min_stat, &send_tok);
(void) gss_release_name(&min_stat, &tname);
exit( 1 ) ;
}
}
else
fprintf( stderr, "Le contexte intiale a une taille nulle\n" ) ;
/* Maintenant que send_tok est envoye, je le relache */
(void) gss_release_buffer(&min_stat, &send_tok);
if( maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED )
{
/* Une erreur a eu lieu dans gss_init_sec_context */
sperror_gss( strerrgss, maj_stat, init_sec_min_stat ) ;
fprintf( stderr, "gss_init_sec_context: %s\n", strerrgss ) ;
(void) gss_release_name( &min_stat, &tname ) ;
return -1 ;
}
/* Est ce que j'ai besoin de continuer ? */
if( maj_stat == GSS_S_CONTINUE_NEEDED )
{
fprintf( stderr, "Une autre passe est necessaire\n" ) ;
/* Je recupere dans recv_tok les infos venues du serveur */
if( recv_token( sockfd, &token_flags, &recv_tok ) < 0 )
{
fprintf( stderr, "Erreur de recv_token sur la socket du serveur\n" ) ;
gss_release_name( &min_stat, &tname ) ;
return -1 ;
}
/* Sinon, on utilise ce token recue pour la passe d'apres */
token_ptr = &recv_tok ;
}
} while( maj_stat == GSS_S_CONTINUE_NEEDED ) ;
fprintf( stdout, "Contexte de securite negocie...\n" ) ;
/* Un peu de menage */
(void) gss_release_name(&min_stat, &tname);
return 0 ;
} /* negociation */
/* Le main .... Et Loire (desole) */
int main( int argc, char * argv[] )
{
int c ; /* pour getopt */
unsigned int adresse_serveur ; /* Au format NET */
struct hostent * hp ;
char nom_exec[MAXPATHLEN] ;
char machine_locale[256] ;
char * tempo_nom_exec = NULL ;
struct sockaddr_in addr_serveur ;
int sockfd ;
unsigned short serveur_port ;
struct servent * service ;
char straddr[100] ;
char msg[LENMSG] ;
int rc = 0 ;
gss_buffer_desc tokoid ;
OM_uint32 maj_stat, min_stat ;
char strerrgss[256] ;
char * mechstr = 0 ;
char * cp ;
gss_name_t src_name, targ_name;
gss_buffer_desc s_name, t_name;
OM_uint32 lifetime;
OM_uint32 context_flags;
gss_OID mechanism, name_type;
int is_local, is_open ;
gss_buffer_desc oid_name ;
gss_OID_set mech_names ;
int i ;
char serr[1024] ;
/* On recupere le nom de l'executable */
if( ( tempo_nom_exec = strrchr( argv[0], '/' ) ) != NULL )
strcpy( (char *)nom_exec, tempo_nom_exec + 1 ) ;
/* Valeur par defaut */
strcpy( sname, SNAME_DEFAUT ) ;
while( ( c = getopt( argc, argv, options ) ) != EOF )
{
switch( c )
{
case 'd':
/* Cette option permet de recuperer un nom pour la machine distante */
if( isalpha( *optarg ) )
{
/* Recuperation de l'adresse de la machine serveur */
if( ( hp = gethostbyname( optarg ) ) == NULL )
{
fprintf( stderr, "Error gethostbyname: errno=%u|%s\n", errno, strerror( errno ) ) ;
exit( 1 ) ;
}
memcpy( &adresse_serveur, hp->h_addr, hp->h_length ) ;
}
else
{
adresse_serveur = inet_addr( optarg ) ;
}
break;
case 'P':
/* Je m'enregistre sur un port fixe (pour eviter le portmapper) */
/* Le numero de port peut etre un numero de port ou un service */
/* On a une valeur au format NET */
if( isalpha( *optarg ) )
{
/* C'est un service car ca commence par une lettre */
if( ( service = getservbyname( optarg, "tcp" ) ) == NULL )
{
/* Ca marche pas en tcp, j'essaye en udp */
if( ( service = getservbyname( optarg, "udp" ) ) == NULL )
{
fprintf( stderr, "Error getservbyname: errno=%u|%s\n", errno, strerror( errno ) ) ;
}
else
{
serveur_port = service->s_port ;
}
}
else
{
serveur_port = service->s_port ;
}
}
else
{
/* C'est un numero de port */
serveur_port = htons( (unsigned short)atoi( optarg ) ) ;
}
break ;
case 'S':
/* Nom de service GSSAPI */
strcpy( sname, optarg ) ;
break ;
case 'h':
case '?':
default:
/* Affichage de l'aide en ligne */
fprintf( stderr, utilisation, nom_exec ) ;
exit( 0 ) ;
break ;
} /* switch( c ) */
} /* while( getopt( ... ) ) */
if( argc - optind != 1 )
{
fprintf( stderr, utilisation, nom_exec ) ;
fprintf( stderr,"Un seul argument additionel: le message\n" ) ;
exit( 1 ) ;
}
/* Je garde le message */
strncpy( msg, argv[optind], LENMSG ) ;
/* Obtention du nom de la machine */
if( gethostname( machine_locale, sizeof( machine_locale ) ) != 0 )
{
fprintf( stderr, "Error gethostname: errno=%u|%s\n", errno, strerror( errno ) ) ;
exit( 1 ) ;
}
/* Qui est ce que je veux contacter ? */
TraduireAdresse( adresse_serveur , straddr ) ;
fprintf( stderr, "Je cherche a joindre %s:%d\n", straddr, ntohs( serveur_port ) ) ;
/* Je creer une socket */
if( ( sockfd = CreerSocket( htonl( INADDR_ANY ) , 0 ) ) == -1 )
{
fprintf( stderr, "Creation de la socket impossible, abandon...\n" ) ;
exit( 1 ) ;
}
/* Je me connecte sur le serveur */
addr_serveur.sin_family = AF_INET ;
addr_serveur.sin_port = serveur_port ;
addr_serveur.sin_addr.s_addr = adresse_serveur ;
if( connect( sockfd, (struct sockaddr *)&addr_serveur, sizeof( addr_serveur ) ) )
{
fprintf( stderr, "Error connect: errno=%u|%s\n", errno, strerror( errno ) ) ;
fprintf( stderr, "Le serveur est indisponible\n" ) ;
exit( 1 ) ;
}
/* Si je suis ici, j'ai un connect correct */
fprintf( stderr, "Connexion ok sur le serveur" ) ;
/* Negociation avec la GSS-API */
if( negociation_client( sockfd, sname, g_mechOid ) <0 )
{
fprintf( stderr, "Erreur de negociation avec le serveur, sortie\n" ) ;
exit( 1 ) ;
}
else
fprintf( stderr, "Negociation ok\n" ) ;
maj_stat = gss_inquire_context( &min_stat,
gss_context,
&src_name,
&targ_name,
&lifetime,
&mechanism,
&context_flags,
&is_local,
&is_open);
if (maj_stat != GSS_S_COMPLETE)
{
fprintf( stderr, "inquiring context %d|%d\n", maj_stat, min_stat);
exit( 1 ) ;
}
maj_stat = gss_display_name(&min_stat, src_name, &s_name, &name_type);
if (maj_stat != GSS_S_COMPLETE)
{
fprintf( stderr, "displaying source name %d|%d\n", maj_stat, min_stat);
exit( 1 ) ;
}
maj_stat = gss_display_name(&min_stat, targ_name, &t_name,
(gss_OID *) NULL);
if (maj_stat != GSS_S_COMPLETE)
{
fprintf( stderr, "displaying target name %d|%d\n", maj_stat, min_stat);
exit( 1 ) ;
}
fprintf( stdout, "\"%.*s\" to \"%.*s\", lifetime %d, flags %x, %s, %s\n",
(int) s_name.length, (char *) s_name.value,
(int) t_name.length, (char *) t_name.value, lifetime,
context_flags,
(is_local) ? "locally initiated" : "remotely initiated",
(is_open) ? "open" : "closed");
(void) gss_release_name(&min_stat, &src_name);
(void) gss_release_name(&min_stat, &targ_name);
(void) gss_release_buffer(&min_stat, &s_name);
(void) gss_release_buffer(&min_stat, &t_name);
maj_stat = gss_oid_to_str(&min_stat, name_type, &oid_name);
if (maj_stat != GSS_S_COMPLETE)
{
fprintf( stderr, "converting oid->string %d|%d\n", maj_stat, min_stat);
exit( 1 ) ;
}
fprintf( stdout, "Name type of source name is %.*s.\n",
(int) oid_name.length, (char *) oid_name.value);
(void) gss_release_buffer(&min_stat, &oid_name);
/* Now get the names supported by the mechanism */
maj_stat = gss_inquire_names_for_mech(&min_stat,
mechanism, &mech_names);
if (maj_stat != GSS_S_COMPLETE)
{
fprintf( stdout, "inquiring mech names %d|%d\n", maj_stat, min_stat);
exit( 1 ) ;
}
maj_stat = gss_oid_to_str(&min_stat, mechanism, &oid_name);
if (maj_stat != GSS_S_COMPLETE)
{
fprintf( stdout, "converting oid->string %d|%d\n", maj_stat, min_stat);
exit( 1 ) ;
}
fprintf( stdout, "Mechanism %.*s supports %d names\n",
(int) oid_name.length, (char *) oid_name.value,
(int) mech_names->count);
(void) gss_release_buffer(&min_stat, &oid_name);
for (i = 0; i < mech_names->count; i++)
{
maj_stat = gss_oid_to_str(&min_stat,
&mech_names->elements[i], &oid_name);
if (maj_stat != GSS_S_COMPLETE)
{
fprintf( stderr, "converting oid->string %d|%d\n", maj_stat, min_stat);
exit( 1 ) ;
}
fprintf( stdout, " %d: %.*s\n", (int) i,
(int) oid_name.length, (char *) oid_name.value);
(void) gss_release_buffer(&min_stat, &oid_name);
}
(void)gss_release_oid_set(&min_stat, &mech_names);
/* Envoi du message */
/* if( ( rc = write( sockfd, msg, LENMSG ) ) != LENMSG ) */
if( send_msg( sockfd, msg, gss_context, serr ) < 0 )
{
fprintf( stderr, "Error send: errno=%u|%s\n", errno, strerror( errno ) ) ;
fprintf( stderr, "%d octets envoyes au lieu de %d\n", rc, LENMSG ) ;
exit( 1 ) ;
}
fprintf( stderr, "Envoi du message #%s#\n", msg ) ;
/* if( ( rc = read( sockfd, msg, LENMSG ) ) != LENMSG ) */
if( recv_msg( sockfd, msg, gss_context, serr ) < 0 )
{
fprintf( stderr, "Error recv: errno=%u|%s\n", errno, strerror( errno ) ) ;
fprintf( stderr, "%d octets emis au lieu de %d\n", rc, LENMSG ) ;
exit( 1 ) ;
}
fprintf( stderr, "En retour j'ai le message #%s#\n", msg ) ;
/* fin */
close( sockfd ) ;
return 0 ;
}
|
ba860e21ddf98a0f48607c78df7cdb6135000970 | c381efc8fe4fae0ed541800e9ea869e2f88a8142 | /1014 - Consumo.c | 43d264999971f879fe97e688518075898da22ed9 | [] | no_license | leilaapsilva/Exercicios-URI | d58cf500d2db80a737b7bd7c335709192de27b71 | d58030f5ca3b5e199bb29888c7dd20a98ba21227 | refs/heads/master | 2021-06-04T08:46:24.205894 | 2018-06-15T19:38:21 | 2018-06-15T19:38:21 | 59,297,063 | 2 | 0 | null | null | null | null | UTF-8 | C | false | false | 263 | c | 1014 - Consumo.c | //https://www.urionlinejudge.com.br/judge/pt/problems/view/1014
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
int x;
double y, cons;
scanf("%d", &x);
scanf("%lf", &y);
cons = x/y;
printf("%.3lf km/l\n", cons);
return 0;
}
|
5a5ad71a38c9f1a3f35dba251bc06bce38c9ffa4 | c8639e2b4bb7116d7dd66acaa769c30d7bb479f7 | /world/daemon/condition/birthday.c | 7fb1f16bf2c281a39a3d8e3b02f505cac0049793 | [] | no_license | ninemoon/mhxy2002 | 43bc9759bbde56e2c49c524514f3dc4f83fbe932 | 76e0fa31cd662864bd55168e2fdf986622ed510e | refs/heads/master | 2021-09-06T10:05:19.812948 | 2018-02-05T09:57:57 | 2018-02-05T09:57:57 | 120,064,608 | 0 | 0 | null | 2018-02-03T06:07:09 | 2018-02-03T06:07:08 | null | GB18030 | C | false | false | 685 | c | birthday.c | // snake_poison.c
#include <ansi.h>
int update_condition(object me, int duration)
{
int sec, min, hrs, day, mon, age;
age = (int)me->query("mud_age");
sec = age % 60;
age /= 60;
min = age % 60;
age /= 60;
hrs = age % 24;
age /= 24;
day = age % 30;
if(day == 0 && ! me->query("birth_yn"))
{
tell_object(me, BLINK HIW "你的生日到了，快去人间仙境领自己的生日礼物吧！\n" NOR );
me->set("birth_yn",1);
// me->set("birth_notice",1);
}
me->apply_condition("birthday", 10);
return 1;
}
|
e704b9e01e78378db29f39a037c80ab743cc3a6a | a33aac97878b2cb15677be26e308cbc46e2862d2 | /program_data/PKU_raw/15/2216.c | 33a82f3e878392c94e50a13d64f9e2e3da68958c | [] | no_license | GabeOchieng/ggnn.tensorflow | f5d7d0bca52258336fc12c9de6ae38223f28f786 | 7c62c0e8427bea6c8bec2cebf157b6f1ea70a213 | refs/heads/master | 2022-05-30T11:17:42.278048 | 2020-05-02T11:33:31 | 2020-05-02T11:33:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 550 | c | 2216.c | int main()
{
int board[500][500], n, i, j, r1, c1, r2, c2;
int *p = *board;
cin >> n;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
cin >> *(p + i * 500 + j);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (*(p + i * 500 + j) == 0)
{
r1 = i;
c1 = j;
i = 9999;
break;
}
for (i = n - 1; i >= 0; i--)
for (j = n - 1; j >= 0; j--)
if (*(p + i * 500 + j) == 0)
{
r2 = i;
c2 = j;
i = -1;
break;
}
cout << (r2 - r1 - 1) * (c2 - c1 - 1) << endl;
return 0;
} |
a1aee79ddf15cb27f84758385f9e4d000cd653fb | 2bc03c4d46cf6c7ad86e9fa6d29a5eec9e072222 | /Classes/MIRHudLayer.h | 2f0791e21f03e3a68cb40286d2d47ae8ef8d8772 | [] | no_license | k2inGitHub/MakeItRain | 15398ce23b6c08820e372f34c39ba9e7db44d01a | f6b1ffc539a3eb7fa9b69df74d216552293946a6 | refs/heads/master | 2021-01-01T05:22:55.571143 | 2016-05-11T07:18:28 | 2016-05-11T07:18:28 | 58,522,579 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 219 | h | MIRHudLayer.h | //
// MIRHudLayer.h
// MakeItRain
//
// Created by SongYang on 14-5-7.
//
//
#ifndef __MakeItRain__MIRHudLayer__
#define __MakeItRain__MIRHudLayer__
//#include ""
#endif /* defined(__MakeItRain__MIRHudLayer__) */
|
5589f2654bf425b7a45eb19dfa706067d6289f5c | 85ad6ef3ff24f277c7e373ad76c9211b310e2f56 | /events.h | f9c7e2a9c2fb25a6a85289aa3fdf4be58c2985af | [] | no_license | chP6/Konzept_ErstesBeispiel | bba27be1e0c6998d7379dbfdf1df52263fa3695e | b401c79f13c3276e1b7575bf097ecde0ab902438 | refs/heads/master | 2020-05-02T06:34:36.878479 | 2019-10-26T08:15:47 | 2019-10-26T08:15:47 | 177,798,605 | 0 | 0 | null | 2019-10-26T08:15:48 | 2019-03-26T13:53:51 | C++ | UTF-8 | C | false | false | 1,974 | h | events.h | #ifndef EVENTS_H
#define EVENTS_H
#define E_NULLEVENT 0
#define E_INCREASE 1
#define E_CLEAR 2
#define E_SET_TILT 3
#define E_TX_SERV_WATCHDOG 4
#define E_RX_SERV_WATCHDOG 5
#define E_RX_CAMERA 6
#define E_STORE_PRESET 7
#define E_PRESET_CHANGE 8
#define E_CAMERA_CHANGE 9
#define E_FOCUS_CHANGE 10
#define E_SET_ZOOM 11
#define E_RX_CAMERA_WATCHDOG 12
#define E_IRIS_CHANGE 13
#define E_PED_CHANGE 14
#define E_WBLUE_CHANGE 15
#define E_WRED_CHANGE 16
#define E_BBLUE_CHANGE 17
#define E_BRED_CHANGE 18
#define E_GAIN_CHANGE 19
#define E_SHUTTER_CHANGE 20
#define E_AUTOFOCUS 21
#define E_AUTOFOCUS_ANSWER 22
#define E_FAST_TRANS 23
#define E_BOUNCE 24
#define E_WIDESET 25
#define E_CAMERA_ANSWER 26
#define E_SETUP_HEAD 27
#define E_CALIB_HEAD 28
#define E_SET_UPPER_LIMIT 29
#define E_SET_LOWER_LIMIT 30
#define E_CLEAR_LIMIT 31
#define E_BOUNCE_BLINK 32
#define E_SPP_START 33
#define E_SPP_ABORT 34
#define E_SPP_WAIT_DONE 35
#define E_PRESET_REACHED 36
#define E_XPT_CONNECT 37
#define E_XPT_WATCHDOG 38
#define E_RX_ADJ_RCP_CMD 39
#define E_REQ_SETTINGS_TIMER 40
#define E_REQUEST_SETTINGS 41
#define E_EXT_PRESET_CHANGE 42
#define E_FAST_IRIS 43
#define E_USB_OCP_CHANGE 46
#define E_CONTROL_INPUT 44
#define E_SEND_AXES_UPDATES 45
#define E_STORE_PRESET_DEBUG 102
#define E_GOTO_PRESET 101
#define E_WRITE_SAVEFILE 103
#define E_LOAD_SAVEFILE 104
#define E_WRITE_AUTOSAVE 105
#define E_LOAD_AUTOSAVE 106
//Debug
#define E_REQ_TEST 111
#endif // EVENTS_H
|
89a93d237d1ee96908af30d3ef35af8711449602 | 7edc02a3a6eead9ee380f8e6d92e3d071fd084fe | /QuadCopter.c | e2233d0b2c636228f4ec2c46ebbb4424818bbb56 | [] | no_license | MouradRashwan/Quadcopter_Project_TM4C123 | 72b5a68a24ee5ea323ce6c4f62c385a232079a89 | 74a81668c4348e539a61581882e2dd9103223a72 | refs/heads/master | 2021-07-11T11:57:07.069333 | 2020-11-19T00:47:24 | 2020-11-19T00:47:24 | 220,254,253 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 34,037 | c | QuadCopter.c | /*
*
* QuadCopter Main Program
*
*/
#include <math.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdbool.h>
#include "inc/hw_memmap.h"
#include "driverlib/fpu.h"
#include "driverlib/gpio.h"
#include "driverlib/timer.h"
#include "driverlib/sysctl.h"
#include "driverlib/pin_map.h"
#include "driverlib/eeprom.h"
#include "MCAL_layer/COMMON_driver/COMMON_driver.h"
#include "MCAL_layer/EEPROM_driver/EEPROM_driver.h"
#include "HAL_layer/MPU_driver/MPU_driver.h"
#include "HAL_layer/MOTOR_driver/MOTOR_driver.h"
#include "HAL_layer/DEBUG_driver/DEBUG_driver.h"
#include "HAL_layer/REMOTE_driver/REMOTE_driver.h"
#include "APP_layer/PID_driver/PID_driver.h"
#include "APP_layer/SensorFusion_driver/SensorFusion_driver.h"
/*
*
* Constants Definitions
*
*/
#define ALTITUDE_BMP280_ENABLE 0
#define ORIENTATION_MPU9250_ENABLE 0
#define CALIBRATION_ENABLE 0
#define FILTERING_MODE 3 /* 1 -> Mahony [Less Accurate Less Power] || 2 -> Madgwick [More Accurate More Power] || 3 -> Mahony & Madgwick */
#define DEBUG_ENABLE 1
#define DEBUG_MAIN_WAIT_LOOPS 10
#define MOTOR_DELTA_MICROS 100U /* for Increase/Decrease Motor speed in us */
#define DEBUG_UART_BUADRATE 115200U
#define REMOTE_UART_BUADRATE 115200U
#define EEPROM_FLAG_ADDRESS 0
#define EEPROM_DATA_ADDRESS 4U
#define EEPROM_FLAG_VAL 0xABCDEF00U /* Change this value to write the below PID values to the EEPROM */
#define ROLL_PID_KP (1.1f)
#define ROLL_PID_KI (2.2f)
#define ROLL_PID_KD (3.3f)
#define ROLL_PID_MODE (MODE_PID)
#define ROLL_PID_OUT_MIN (-25000.0f)
#define ROLL_PID_OUT_MAX (25000.0f)
#define PITCH_PID_KP (1.1f)
#define PITCH_PID_KI (2.2f)
#define PITCH_PID_KD (3.3f)
#define PITCH_PID_MODE (MODE_PID)
#define PITCH_PID_OUT_MIN (-25000.0f)
#define PITCH_PID_OUT_MAX (25000.0f)
#define YAW_PID_KP (1.1f)
#define YAW_PID_KI (2.2f)
#define YAW_PID_KD (3.3f)
#define YAW_PID_MODE (MODE_PID)
#define YAW_PID_OUT_MIN (-25000.0f)
#define YAW_PID_OUT_MAX (25000.0f)
#define ALTITUDE_PID_KP (1.1f)
#define ALTITUDE_PID_KI (2.2f)
#define ALTITUDE_PID_KD (3.3f)
#define ALTITUDE_PID_MODE (MODE_PID)
#define ALTITUDE_PID_OUT_MIN (-25000.0f)
#define ALTITUDE_PID_OUT_MAX (25000.0f)
/*
*
* Macro Functions
*
*/
#define SYS_GET_SECONDS_FROM_TICKS(TICKS) ((TICKS) * (1.0f / SysCtlClockGet()))
/*
*
* Structure Definitions
*
*/
typedef struct IntGain
{
uint32_t ui32KP;
uint32_t ui32KI;
uint32_t ui32KD;
} IntGain_t;
typedef struct IntGains
{
IntGain_t tIntGainROLL;
IntGain_t tIntGainPITCH;
IntGain_t tIntGainYAW;
IntGain_t tIntGainALTITUDE;
} IntGains_t; /* Size of 48 Bytes */
typedef struct FloatGains
{
PIDgain_t tPIDgainROLL;
PIDgain_t tPIDgainPITCH;
PIDgain_t tPIDgainYAW;
PIDgain_t tPIDgainALTITUDE;
} FloatGains_t; /* Size of 48 Bytes */
/*
*
* APIs Declarations
*
*/
void Tiva_init(void);
void LEDs_init(void);
void WTimer0A_init(void);
void EEPROM_initReadWrite(IntGains_t * ptIntGains, FloatGains_t * ptFloatGains);
void MOTOR_init(void);
void MPU_init(void);
void LED_setOFF(void);
void LED_setRED(void);
void LED_setBLUE(void);
void LED_setGREEN(void);
void LED_toggleGREEN(void);
uint64_t WTimer0A_getCurrent(void);
void GAIN_FloatToInt(IntGains_t *ptIntGains, FloatGains_t *tpPIDgains);
void GAIN_IntToFloat(FloatGains_t *ptFloatGains, IntGains_t *ptIntGains);
void REMOTE_process(const int32_t i32Command);
DataStatus_t MPU_readRawData(MPU9AxisRawData_t * const ptMPU9AxisRawData,
BMP280Press_t * const ptBMP280Press);
void PID_updateInput(const YawPitchRoll_t * const ptActualYPR,
const BMP280AltitudeInM_t * const ptActualAltitude);
void PID_updateOutput(const float dPeriodInSec);
void QUAD_updateOutput(void);
/*
*
* Operations Status - Desired Altitude - Desired Orientation - PID Objects - PID Gains
*
*/
uint32_t g_ui32OperationFlag = 0;
BMP280AltitudeInM_t g_tDesiredAltitude = { 1.0f };
YawPitchRoll_t g_tDesiredYPR = { 0.0f, 0.0f, 0.0f };
PIDobject_t g_tPIDobjectROLL, g_tPIDobjectPITCH, g_tPIDobjectYAW,
g_tPIDobjectALTITUDE;
IntGains_t g_tIntGains;
FloatGains_t g_tFloatGains = { { ROLL_PID_KP, ROLL_PID_KI, ROLL_PID_KD }, {
PITCH_PID_KP, PITCH_PID_KI, PITCH_PID_KD },
{ YAW_PID_KP, YAW_PID_KI, YAW_PID_KD }, {
ALTITUDE_PID_KP, ALTITUDE_PID_KI,
ALTITUDE_PID_KD } };
/************************************* MAIN-PROGRAM ************************************************/
void main(void)
{
uint32_t ui32WaitLoops = 0;
int32_t i32Command = -1;
PIgain_t tPIgain = { 10.0f, 0.0f };
float dPeriodInSec, dGyroMeasError;
uint64_t ui64Current, ui64Last = UINT64_MAX;
MPU9AxisRawData_t tMPU9AxisRawData;
MPU9AxisInUnits_t tMPU9AxisInUnits1, tMPU9AxisInUnits2;
BMP280Press_t tPressRawData;
BMP280PressInMBar_t tBMP280PressInMBar;
YawPitchRoll_t tActualYPR, tActualYPRMahony, tActualYPRMadgwick;
BMP280AltitudeInM_t tActualAltitude = { 0 };
Quaternion_t tQuaternionMahony, tQuaternionMadgwick;
PIDmode_t tPIDmodeROLL = ROLL_PID_MODE, tPIDmodePITCH = PITCH_PID_MODE,
tPIDmodeYAW = YAW_PID_MODE, tPIDmodeALTITUDE = ALTITUDE_PID_MODE;
PIDoutBound_t tPIDoutBoundROLL = { ROLL_PID_OUT_MIN, ROLL_PID_OUT_MAX },
tPIDoutBoundPITCH = { PITCH_PID_OUT_MIN, PITCH_PID_OUT_MAX },
tPIDoutBoundYAW = { YAW_PID_OUT_MIN, YAW_PID_OUT_MAX },
tPIDoutBoundALTITUDE =
{ ALTITUDE_PID_OUT_MIN, ALTITUDE_PID_OUT_MAX };
/* Initialize System clock to 25 MHz */
Tiva_init();
/* Initialize PORTF pins F1 & F2 & F3 OUTPUTS */
LEDs_init();
/* Initialize Debug port UART0 Buadrate to 115200 */
DEBUG_init(DEBUG_UART_BUADRATE);
#if(DEBUG_ENABLE == 1)
DEBUG_print("SYSTEM STARTED ... \n\n");
delayMillis(1000);
#endif
/* Initialize MOTOR module */
MOTOR_init();
/* Initialize REMOTE module UART3 Buadrate to 115200 */
REMOTE_init(REMOTE_UART_BUADRATE);
#if(ORIENTATION_MPU9250_ENABLE == 1)
/* Initialize, Self-test and Calibrate all MPUs */
MPU_init();
#endif
/* Get gyroscope measure error to be used in MPU Fusion algorithm */
dGyroMeasError = MPU9250_getGyroMeasError();
/* Initialize Quaternion */
#if(FILTERING_MODE == 1)
SensorFusion_initQuaternion(&tQuaternionMahony);
#elif(FILTERING_MODE == 2)
SensorFusion_initQuaternion(&tQuaternionMadgwick);
#elif(FILTERING_MODE == 3)
SensorFusion_initQuaternion(&tQuaternionMahony);
SensorFusion_initQuaternion(&tQuaternionMadgwick);
#else
#error("Please Set a Correct Filtering Mode of [1 or 2 or 3] ");
#endif
/* Initialize EEPROM, Check If erased then write the default PID gains | If not erased then check the first word flag then read/write PID gains */
EEPROM_initReadWrite(&g_tIntGains, &g_tFloatGains);
/* Initialize PID for ROLL & PITCH & YAW */
PID_init(&g_tPIDobjectROLL, tPIDmodeROLL, g_tFloatGains.tPIDgainROLL,
tPIDoutBoundROLL);
PID_init(&g_tPIDobjectPITCH, tPIDmodePITCH, g_tFloatGains.tPIDgainPITCH,
tPIDoutBoundPITCH);
PID_init(&g_tPIDobjectYAW, tPIDmodeYAW, g_tFloatGains.tPIDgainYAW,
tPIDoutBoundYAW);
PID_init(&g_tPIDobjectALTITUDE, tPIDmodeALTITUDE,
g_tFloatGains.tPIDgainALTITUDE, tPIDoutBoundALTITUDE);
/* Initialize and Start 64-bit WTimer0 that will never reset */
WTimer0A_init();
/************************************************* EMBEDDED-LOOP ***************************************************/
while (1)
{
/* Get period in seconds within loop */
ui64Current = WTimer0A_getCurrent();
dPeriodInSec = SYS_GET_SECONDS_FROM_TICKS(ui64Last - ui64Current);
ui64Last = ui64Current;
i32Command = REMOTE_receiveByte();
REMOTE_process(i32Command);
#if(ALTITUDE_BMP280_ENABLE == 1)
BMP280_getPressInMBar(&tBMP280PressInMBar, &tPressRawData);
BMP280_getAltitudeInM(&tActualAltitude, &tBMP280PressInMBar);
#endif
#if(ORIENTATION_MPU9250_ENABLE == 1)
while (MPU_readRawData(&tMPU9AxisRawData, &tPressRawData) == DATA_BUSY)
{
}
MPU9250_get9AxisInUnits(&tMPU9AxisInUnits1, &tMPU9AxisRawData);
MPU9250_get9AxisInUnitsModified(&tMPU9AxisInUnits2, &tMPU9AxisInUnits1);
#endif
#if(FILTERING_MODE == 1)
SensorFusion_MahonyUpdate(&tQuaternionMahony,
(SensorFusion9Axis_t *) &tMPU9AxisInUnits2,
tPIgain, dPeriodInSec);
SensorFusion_getYawPitchRoll(&tActualYPRMahony, &tQuaternionMahony);
tActualYPR = tActualYPRMahony;
#elif(FILTERING_MODE == 2)
SensorFusion_MadgwickUpdate(&tQuaternionMadgwick,
(SensorFusion9Axis_t *) &tMPU9AxisInUnits2,
dGyroMeasError, dPeriodInSec);
SensorFusion_getYawPitchRoll(&tActualYPRMadgwick, &tQuaternionMadgwick);
tActualYPR = tActualYPRMadgwick;
#elif(FILTERING_MODE == 3)
SensorFusion_MahonyUpdate(&tQuaternionMahony,
(SensorFusion9Axis_t *) &tMPU9AxisInUnits2,
tPIgain, dPeriodInSec);
SensorFusion_MadgwickUpdate(&tQuaternionMadgwick,
(SensorFusion9Axis_t *) &tMPU9AxisInUnits2,
dGyroMeasError, dPeriodInSec);
SensorFusion_getYawPitchRoll(&tActualYPRMahony, &tQuaternionMahony);
SensorFusion_getYawPitchRoll(&tActualYPRMadgwick, &tQuaternionMadgwick);
tActualYPR.dYaw = (tActualYPRMahony.dYaw + tActualYPRMadgwick.dYaw) / 2;
tActualYPR.dPitch =
(tActualYPRMahony.dPitch + tActualYPRMadgwick.dPitch) / 2;
tActualYPR.dRoll = (tActualYPRMahony.dRoll + tActualYPRMadgwick.dRoll)
/ 2;
#else
#error("Please Set a Correct Filtering Mode of [1 or 2 or 3]");
#endif
/************************************* OPERATION-SECTION *******************************************************/
if (g_ui32OperationFlag == 1)
{
PID_updateInput(&tActualYPR, &tActualAltitude);
PID_updateOutput(dPeriodInSec);
QUAD_updateOutput();
}
/************************************* END OF OPERATION-SECTION ************************************************/
/************************************* DEBUG-MSG-SECTION *******************************************************/
ui32WaitLoops += 1;
if (ui32WaitLoops == DEBUG_MAIN_WAIT_LOOPS)
{
ui32WaitLoops = 0;
/* Heart beat GREEN_LED */
LED_toggleGREEN();
/* Print Angle Values */
#if(DEBUG_ENABLE == 1)
DEBUG_print(
"ROLL: %d | PITCH: %d | YAW: %d | ALTITUDE: %u m | PERIOD: %u ms \n\n",
lrintf(tActualYPR.dRoll), lrintf(tActualYPR.dPitch),
lrintf(tActualYPR.dYaw), lrintf(tActualAltitude.dAltitude),
lrintf(dPeriodInSec * 1000));
#endif
}
/************************************* END OF DEBUG-MSG-SECTION ************************************************/
}
/************************************* END OF EMBEDDED-LOOP ********************************************************/
}
/************************************* END OF MAIN-PROGRAM *************************************************************/
/*
*
* Initialize Tiva MCU
*
*/
void Tiva_init(void)
{
SysCtlClockSet(
SYSCTL_SYSDIV_8 | SYSCTL_XTAL_16MHZ | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN); /* 25 MHz */
FPULazyStackingEnable();
FPUEnable();
}
/*
*
* Initialize LEDs
*
*/
void LEDs_init(void)
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
while (!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF))
{
}
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,
GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3,
GPIO_PIN_TYPE_STD_WPD);
}
/*
*
* Initialize WideTimer 64-bit
*
*/
void WTimer0A_init(void)
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_WTIMER0);
while (!SysCtlPeripheralReady(SYSCTL_PERIPH_WTIMER0))
{
}
TimerConfigure(WTIMER0_BASE, TIMER_CFG_PERIODIC); // full-width periodic with timeout interrupt for timer3A & in disabled state
TimerClockSourceSet(WTIMER0_BASE, TIMER_CLOCK_SYSTEM); // set the input clock to the system clock
TimerControlStall(WTIMER0_BASE, TIMER_A, false); // continue counting while in debug mode
TimerLoadSet64(WTIMER0_BASE, UINT64_MAX); // 1 tick = 12.5 ns // so // 80000000 ticks = 1 sec
TimerEnable(WTIMER0_BASE, TIMER_A);
}
void EEPROM_initReadWrite(IntGains_t * ptIntGains, FloatGains_t * ptFloatGains)
{
uint32_t ui32EEPROMflag;
if (EEPROM_init() != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [EEPROM INIT failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
if (EEPROM_isErased(EEPROM_FLAG_ADDRESS,
(sizeof(FloatGains_t) + sizeof(uint32_t))) == true)
{
ui32EEPROMflag = EEPROM_FLAG_VAL;
if (EEPROM_writeData(EEPROM_FLAG_ADDRESS, &ui32EEPROMflag,
sizeof(ui32EEPROMflag)) != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [EEPROM WRITE failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
GAIN_FloatToInt(ptIntGains, ptFloatGains);
if (EEPROM_writeData(EEPROM_DATA_ADDRESS, ptIntGains,
sizeof(*ptIntGains)) != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [EEPROM WRITE failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
}
else
{
if (EEPROM_readData(EEPROM_FLAG_ADDRESS, &ui32EEPROMflag,
sizeof(ui32EEPROMflag)) != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [EEPROM READ failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
if (ui32EEPROMflag == EEPROM_FLAG_VAL)
{
if (EEPROM_readData(EEPROM_DATA_ADDRESS, ptIntGains,
sizeof(*ptIntGains)) != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [EEPROM READ failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
GAIN_IntToFloat(ptFloatGains, ptIntGains);
}
else
{
ui32EEPROMflag = EEPROM_FLAG_VAL;
if (EEPROM_writeData(EEPROM_FLAG_ADDRESS, &ui32EEPROMflag,
sizeof(ui32EEPROMflag)) != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [EEPROM WRITE failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
GAIN_FloatToInt(ptIntGains, ptFloatGains);
if (EEPROM_writeData(EEPROM_DATA_ADDRESS, ptIntGains,
sizeof(*ptIntGains)) != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [EEPROM WRITE failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
}
}
}
/*
*
* Initialize Motors
*
*/
void MOTOR_init(void)
{
if (MOTOR_PWM_init() != MOTOR_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [Setting PWM frequency failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
/* Set QuadPWM to 2000 us */
MOTOR_setSpeedFULL();
delayMillis(4000);
MOTOR_setSpeedOFF();
}
/*
*
* Initialize MPU Sensors
*
*/
void MPU_init(void)
{
float adDeviations[6];
uint8_t ui8ID, ui8DevicesNum = 0;
MPUCalibParam_t tMPUCalibParam;
ui8DevicesNum = MPU_I2C_initScan();
#if(DEBUG_ENABLE == 1)
DEBUG_print("MPU Start with %u devices. \n\n", ui8DevicesNum);
delayMillis(1000);
#endif
if (MPU9250_getID(&ui8ID) != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [MPU9250 disconnected] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#if(DEBUG_ENABLE == 1)
DEBUG_print("[MPU9250 connected with ID: 0x%02X]. \n\n", ui8ID);
delayMillis(1000);
#endif
if (MPU9250_SelfTest(adDeviations) != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [MPU9250 SelfTest failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#if(DEBUG_ENABLE == 1)
DEBUG_print("[MPU9250 SelfTest done]. \n\n");
delayMillis(1000);
#endif
#if (CALIBRATION_ENABLE == 1)
if (MPU9250_calibrateAccelGyro() != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [MPU9250 Calibration failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#if(DEBUG_ENABLE == 1)
DEBUG_print("[MPU9250 Calibration done]. \n\n");
delayMillis(1000);
#endif
#endif
if (MPU9250_init() != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [MPU9250 Initialization failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#if(DEBUG_ENABLE == 1)
DEBUG_print("[MPU9250 Initialization done]. \n\n");
delayMillis(1000);
#endif
if (AK8963_getID(&ui8ID) != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [AK8963 disconnected] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#if(DEBUG_ENABLE == 1)
DEBUG_print("[AK8963 connected with ID: 0x%02X]. \n\n", ui8ID);
delayMillis(1000);
#endif
if (AK8963_init() != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [AK8963 Initialization failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#if(DEBUG_ENABLE == 1)
DEBUG_print("[AK8963 Initialization done]. \n\n");
delayMillis(1000);
#endif
#if (CALIBRATION_ENABLE == 1)
LED_setBLUE();
#if(DEBUG_ENABLE == 1)
DEBUG_print("[AK8963 Magnetometer Started (Move it in 8 Shape) ...]. \n\n");
#endif
if (AK8963_calibrateMag() != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [AK8963 Calibration failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
LED_setOFF();
#if(DEBUG_ENABLE == 1)
MPU9250_getCalibParam(&tMPUCalibParam);
DEBUG_print("[AK8963 Calibration done]. \n\n");
delayMillis(1000);
#endif
#endif
#if(ALTITUDE_BMP280_ENABLE == 1)
if (BMP280_getID(&ui8ID) != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [BMP280 disconnected] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#if(DEBUG_ENABLE == 1)
DEBUG_print("[BMP280 connected with ID: 0x%02X]. \n\n", ui8ID);
delayMillis(1000);
#endif
if (BMP280_init() != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [BMP280 Initialization failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#if(DEBUG_ENABLE == 1)
DEBUG_print("[BMP280 Initialization done]. \n\n");
delayMillis(1000);
#endif
#endif
}
/*
*
* Turn OFF LEDs
*
*/
void LED_setOFF(void)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, ~GPIO_PIN_1);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, ~GPIO_PIN_2);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, ~GPIO_PIN_3);
}
/*
*
* Turn ON RED_LED
*
*/
void LED_setRED(void)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PIN_1);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, ~GPIO_PIN_2);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, ~GPIO_PIN_3);
}
/*
*
* Turn ON BLUE_LED
*
*/
void LED_setBLUE(void)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, ~GPIO_PIN_1);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, ~GPIO_PIN_3);
}
/*
*
* Turn ON GREEN_LED
*
*/
void LED_setGREEN(void)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, ~GPIO_PIN_1);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, ~GPIO_PIN_2);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3);
}
/*
*
* Toggle GREEN_LED
*
*/
void LED_toggleGREEN(void)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3,
~GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_3));
}
/*
*
* Read WideTimer Value
*
*/
uint64_t WTimer0A_getCurrent(void)
{
return TimerValueGet64(WTIMER0_BASE);
}
/*
*
* Read MPU Sensors RawData
*
*/
DataStatus_t MPU_readRawData(MPU9AxisRawData_t * const ptMPU9AxisRawData,
BMP280Press_t * const ptBMP280Press)
{
DataStatus_t tMPUDataStatus = DATA_BUSY;
if (MPU9250_isDataReady() == DATA_READY)
{
if (MPU9250_readAccelGyroRawData(ptMPU9AxisRawData) != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [MPU9250 reading failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
if (AK8963_isDataReady() == DATA_READY)
{
if (AK8963_readMagRawData(ptMPU9AxisRawData) != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [AK8963 reading failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
tMPUDataStatus = DATA_READY;
}
#if(ALTITUDE_BMP280_ENABLE == 1)
if (BMP280_readPressRawData(ptBMP280Press) != MPU_SUCCESS)
{
LED_setRED();
DEBUG_print("*** ERROR *** [BMP280 reading failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
#endif
}
return tMPUDataStatus;
}
/*
*
* Convert FLoat gains to Integer by Multiplying * 1000
*
*/
void GAIN_FloatToInt(IntGains_t *ptIntGains, FloatGains_t *ptFloatGains)
{
uint32_t i;
for (i = 0; i < (sizeof(FloatGains_t) / sizeof(float)); i++)
{
((uint32_t *) ptIntGains)[i] = ((float *) ptFloatGains)[i] * 1000U;
}
}
/*
*
* Convert Integer gains to Float by Dividing / 1000
*
*/
void GAIN_IntToFloat(FloatGains_t *ptFloatGains, IntGains_t *ptIntGains)
{
uint32_t i;
for (i = 0; i < (sizeof(IntGains_t) / sizeof(uint32_t)); i++)
{
((float *) ptFloatGains)[i] = ((uint32_t *) ptIntGains)[i] / 1000.0f;
}
}
/*
*
* Process REMOTE Commands
*
*/
void REMOTE_process(const int32_t i32Command)
{
static uint32_t s_ui32PIDTuningFlag = 0;
static PIDobject_t * s_ptPIDobject = 0;
if (s_ptPIDobject == 0)
{
s_ptPIDobject = &g_tPIDobjectROLL;
}
switch (i32Command)
{
case 0x000000FF:
if ((g_ui32OperationFlag == 0) && (s_ui32PIDTuningFlag == 0))
{
g_ui32OperationFlag = 1;
MOTOR_setSpeedON();
}
break;
case 0x00000000:
if ((g_ui32OperationFlag == 1) && (s_ui32PIDTuningFlag == 0))
{
g_ui32OperationFlag = 0;
MOTOR_setSpeedOFF();
}
break;
case '*':
if ((s_ui32PIDTuningFlag == 0) && (g_ui32OperationFlag == 0))
{
if (EEPROM_readData(EEPROM_DATA_ADDRESS, &g_tIntGains,
sizeof(g_tFloatGains)) != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [EEPROM READ failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
REMOTE_transmitData(&g_tIntGains, sizeof(g_tIntGains));
s_ui32PIDTuningFlag = 1;
g_ui32OperationFlag = 1;
MOTOR_setSpeedON();
}
break;
case '/':
if ((s_ui32PIDTuningFlag == 1) && (g_ui32OperationFlag == 1))
{
g_tFloatGains.tPIDgainROLL = g_tPIDobjectROLL.tPIDgain;
g_tFloatGains.tPIDgainPITCH = g_tPIDobjectPITCH.tPIDgain;
g_tFloatGains.tPIDgainYAW = g_tPIDobjectYAW.tPIDgain;
g_tFloatGains.tPIDgainALTITUDE = g_tPIDobjectALTITUDE.tPIDgain;
GAIN_FloatToInt(&g_tIntGains, &g_tFloatGains);
if (EEPROM_writeData(EEPROM_DATA_ADDRESS, &g_tIntGains,
sizeof(g_tIntGains)) != EEPROM_SUCCESS)
{
LED_setRED();
DEBUG_print(
"*** ERROR *** [EEPROM WRITE failed] at line: %u. \n\n",
__LINE__);
while (1)
;
}
s_ui32PIDTuningFlag = 0;
g_ui32OperationFlag = 0;
MOTOR_setSpeedOFF();
}
break;
default:
if (g_ui32OperationFlag == 1)
{
switch (i32Command)
{
case '+':
MOTOR_increaseSpeed(MOTOR_DELTA_MICROS); /* Increase Micros */
break;
case '-':
MOTOR_decreaseSpeed(MOTOR_DELTA_MICROS); /* Decrease Micros */
break;
case 0x00000001:
g_tDesiredYPR.dPitch = 20.0f;
break;
case 0x00000002:
g_tDesiredYPR.dPitch = -20.0f;
break;
case 0x00000003:
g_tDesiredYPR.dPitch = 0.0f;
break;
case 0x00000004:
g_tDesiredYPR.dRoll = 20.0f;
break;
case 0x00000005:
g_tDesiredYPR.dRoll = -20.0f;
break;
case 0x00000006:
g_tDesiredYPR.dRoll = 0.0f;
break;
case 'w':
break;
case 'W':
break;
case 's':
break;
case 'S':
break;
case 'a':
break;
case 'A':
break;
case 'd':
break;
case 'D':
break;
default:
break;
}
}
if (s_ui32PIDTuningFlag == 1)
{
switch (i32Command)
{
case 'r':
s_ptPIDobject = &g_tPIDobjectROLL;
break;
case 'p':
s_ptPIDobject = &g_tPIDobjectPITCH;
break;
case 'y':
s_ptPIDobject = &g_tPIDobjectYAW;
break;
case 'h':
s_ptPIDobject = &g_tPIDobjectALTITUDE;
break;
case '4':
s_ptPIDobject->tPIDgain.dKP += 0.1f;
break;
case '1':
s_ptPIDobject->tPIDgain.dKP -= 0.1f;
if (s_ptPIDobject->tPIDgain.dKP < 0.0f)
{
s_ptPIDobject->tPIDgain.dKP = 0.0f;
}
break;
case '5':
s_ptPIDobject->tPIDgain.dKI += 0.001f;
break;
case '2':
s_ptPIDobject->tPIDgain.dKI -= 0.001f;
if (s_ptPIDobject->tPIDgain.dKI < 0.00f)
{
s_ptPIDobject->tPIDgain.dKI = 0.00f;
}
break;
case '6':
s_ptPIDobject->tPIDgain.dKD += 0.1f;
break;
case '3':
s_ptPIDobject->tPIDgain.dKD -= 0.1f;
if (s_ptPIDobject->tPIDgain.dKD < 0.0f)
{
s_ptPIDobject->tPIDgain.dKD = 0.0f;
}
break;
default:
break;
}
// PID_reset(s_ptPIDobject);
}
break;
}
}
/*
*
* Update PID Inputs
*
*/
void PID_updateInput(const YawPitchRoll_t * const ptActualYPR,
const BMP280AltitudeInM_t * const ptActualAltitude)
{
PID_setDesiredVal(&g_tPIDobjectROLL, g_tDesiredYPR.dRoll);
PID_setActualVal(&g_tPIDobjectROLL, ptActualYPR->dRoll);
PID_setDesiredVal(&g_tPIDobjectPITCH, g_tDesiredYPR.dPitch);
PID_setActualVal(&g_tPIDobjectPITCH, ptActualYPR->dPitch);
PID_setDesiredVal(&g_tPIDobjectYAW, g_tDesiredYPR.dYaw);
PID_setActualVal(&g_tPIDobjectYAW, ptActualYPR->dYaw);
#if(ALTITUDE_BMP280_ENABLE == 1)
PID_setDesiredVal(&g_tPIDobjectALTITUDE, g_tDesiredAltitude.dAltitude);
PID_setActualVal(&g_tPIDobjectALTITUDE, ptActualAltitude->dAltitude);
#endif
}
/*
*
* Update PID Outputs
*
*/
void PID_updateOutput(const float dPeriodInSec)
{
PID_update(&g_tPIDobjectROLL, dPeriodInSec);
PID_update(&g_tPIDobjectPITCH, dPeriodInSec);
PID_update(&g_tPIDobjectYAW, dPeriodInSec);
#if(ALTITUDE_BMP280_ENABLE == 1)
PID_update(&g_tPIDobjectALTITUDE, dPeriodInSec);
#endif
}
/*
*
* Update QUAD Outputs
*
*/
void QUAD_updateOutput(void)
{
PulseWidth_t tPulseWidth;
float dPIDOutROLL, dPIDOutPITCH, dPIDOutYAW, dPIDOutALTITUDE;
int32_t i32DeltaOutInTicksROLL, i32DeltaOutInTicksPITCH,
i32DeltaOutInTicksYAW, i32DeltaOutInTicksALTITUDE;
/* Read the PID output */
dPIDOutROLL = PID_getOut(&g_tPIDobjectROLL);
dPIDOutPITCH = PID_getOut(&g_tPIDobjectPITCH);
dPIDOutYAW = PID_getOut(&g_tPIDobjectYAW);
dPIDOutALTITUDE = PID_getOut(&g_tPIDobjectALTITUDE);
/* Map the PID output to the delta output in ticks */
i32DeltaOutInTicksROLL = ((PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MAX_MICROS)
- PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MIN_MICROS)) * dPIDOutROLL)
/ ROLL_PID_OUT_MAX;
i32DeltaOutInTicksPITCH = ((PWM_GET_TICKS_FROM_MICROS(
MOTOR_PULSE_MAX_MICROS)
- PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MIN_MICROS)) * dPIDOutPITCH)
/ PITCH_PID_OUT_MAX;
i32DeltaOutInTicksYAW = ((PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MAX_MICROS)
- PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MIN_MICROS)) * dPIDOutYAW)
/ YAW_PID_OUT_MAX;
i32DeltaOutInTicksALTITUDE = ((PWM_GET_TICKS_FROM_MICROS(
MOTOR_PULSE_MAX_MICROS)
- PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MIN_MICROS))
* dPIDOutALTITUDE) / ALTITUDE_PID_OUT_MAX;
/* Read the current actuator output */
QuadPWM_getPulses(&tPulseWidth);
/*Add the delta output to the current actuator output*/
tPulseWidth.ui32PulseInTicks1 += i32DeltaOutInTicksROLL; /* Stabilize ROLL */
tPulseWidth.ui32PulseInTicks2 += i32DeltaOutInTicksPITCH; /* Stabilize PITCH */
tPulseWidth.ui32PulseInTicks1 += i32DeltaOutInTicksYAW; /* Stabilize YAW */
tPulseWidth.ui32PulseInTicks3 += i32DeltaOutInTicksYAW;
#if(ALTITUDE_BMP280_ENABLE == 1)
tPulseWidth.ui32PulseInTicks1 += i32DeltaOutInTicksALTITUDE; /* Stabilize ALTITUDE */
tPulseWidth.ui32PulseInTicks2 += i32DeltaOutInTicksALTITUDE;
tPulseWidth.ui32PulseInTicks3 += i32DeltaOutInTicksALTITUDE;
tPulseWidth.ui32PulseInTicks4 += i32DeltaOutInTicksALTITUDE;
#endif
/* Get value within boundaries [MOTOR_PULSE_MAX_MICROS & MOTOR_PULSE_MIN_MICROS] */
getValueWithinLimits(&tPulseWidth.ui32PulseInTicks1,
PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MAX_MICROS),
PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MIN_MICROS));
getValueWithinLimits(&tPulseWidth.ui32PulseInTicks2,
PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MAX_MICROS),
PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MIN_MICROS));
getValueWithinLimits(&tPulseWidth.ui32PulseInTicks3,
PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MAX_MICROS),
PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MIN_MICROS));
getValueWithinLimits(&tPulseWidth.ui32PulseInTicks4,
PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MAX_MICROS),
PWM_GET_TICKS_FROM_MICROS(MOTOR_PULSE_MIN_MICROS));
/* Update Motors */
MOTOR_update(&tPulseWidth);
}
|
89e27cf7a667c60350ca1005f7552c88e2c8cf7b | 1c8608baefd215d21e89a03a078f48086824c708 | /bin/xgr/window.c | 66f589ee29a5c12f5ab721e048a13e0f0027af19 | [
"BSD-3-Clause"
] | permissive | r9y9/SPTK | 828bae95f167c83231f61d9ecb4b371f8dce8737 | 2accca99be205d10fde0a4b9969cc3eba7ad930e | refs/heads/master | 2022-06-17T19:42:24.311418 | 2022-06-05T13:59:53 | 2022-06-05T14:07:09 | 14,833,669 | 90 | 27 | NOASSERTION | 2021-01-31T19:43:55 | 2013-12-01T04:41:05 | C | UTF-8 | C | false | false | 13,218 | c | window.c | /* ----------------------------------------------------------------- */
/* The Speech Signal Processing Toolkit (SPTK) */
/* developed by SPTK Working Group */
/* http://sp-tk.sourceforge.net/ */
/* ----------------------------------------------------------------- */
/* */
/* Copyright (c) 1984-2007 Tokyo Institute of Technology */
/* Interdisciplinary Graduate School of */
/* Science and Engineering */
/* */
/* 1996-2014 Nagoya Institute of Technology */
/* Department of Computer Science */
/* */
/* 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. */
/* - Neither the name of the SPTK working group nor the names of its */
/* contributors may be used to endorse or promote products derived */
/* from this software without specific prior written permission. */
/* */
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND */
/* CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS */
/* 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. */
/* ----------------------------------------------------------------- */
/****************************************************************
* Setup Window for xgr. *
****************************************************************/
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/cursorfont.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef HAVE_STRING_H
# include <string.h>
#else
# include <strings.h>
# ifndef HAVE_STRRCHR
# define strrchr rindex
# endif
#endif
#include "gcdata.h"
#include "xgr.h"
Display *display;
Window main_window;
int screen;
GC gc, pixmapGC;
unsigned long forepix, backpix, highpix, brdrpix, mouspix;
static XSizeHints xsh;
/* static Atom property; */
static Pixmap pixmap;
static Cursor watch_cur;
static XGCValues gcval;
static Font font;
static XEvent ev;
static XSetWindowAttributes winatt;
static XWindowAttributes wa;
long pixmap_w, pixmap_h;
long origin_x = 0, origin_y = 0;
long window_x, window_y, window_w, window_h;
int bwidth = 2;
extern float shrink;
extern int landscape;
extern int reverse, c_flg;
extern int fno;
extern char *fore_color, *back_color;
extern char *high_color, *brdr_color, *mous_color;
extern char *geometry;
extern char *dpy;
extern char *cmnd, *windowtitle;
void open_display(char *display_name)
{
if ((display = XOpenDisplay(display_name)) == NULL) {
fprintf(stderr, "%s: Can't open display '%s'\n",
cmnd, XDisplayName(display_name));
exit(2);
}
}
void init_window(int argc, char *argv[])
{
unsigned long get_color_pix(char *color_name);
screen = DefaultScreen(display);
#if defined(HAVE_BZERO) && !defined(HAVE_MEMSET)
bzero(&xsh, sizeof(xsh));
#else
memset(&xsh, 0, sizeof(xsh));
#endif
if (geometry) {
int bitmask;
bitmask = XGeometry(display, screen, geometry, NULL,
bwidth, 1, 1, 1, 1,
&(xsh.x), &(xsh.y), &(xsh.width), &(xsh.height));
if (bitmask & (XValue | YValue)) {
xsh.flags |= USPosition;
}
if (bitmask & (WidthValue | HeightValue)) {
xsh.flags |= USSize;
}
} else {
xsh.flags = USPosition | PSize;
if (!landscape) {
xsh.width = XLENG / shrink;
xsh.height = YLENG / shrink;
xsh.x = X0;
xsh.y = Y0;
} else {
xsh.width = YLENG / shrink;
xsh.height = XLENG / shrink;
xsh.x = X0_LAND;
xsh.y = Y0;
}
}
/** Color **/
#ifdef COLOR_BUG
reverse = 1;
#endif
if (DisplayPlanes(display, screen) >= 3) {
c_flg = 1;
if (!reverse) {
forepix = get_color_pix(fore_color);
backpix = get_color_pix(back_color);
highpix = get_color_pix(high_color);
brdrpix = get_color_pix(brdr_color);
mouspix = get_color_pix(mous_color);
} else {
forepix = get_color_pix(back_color);
backpix = get_color_pix(fore_color);
highpix = get_color_pix(high_color);
brdrpix = get_color_pix(brdr_color);
mouspix = get_color_pix(mous_color);
}
} else {
if (!reverse) {
forepix = BlackPixel(display, screen);
highpix = BlackPixel(display, screen);
backpix = WhitePixel(display, screen);
brdrpix = BlackPixel(display, screen);
mouspix = BlackPixel(display, screen);
} else {
forepix = WhitePixel(display, screen);
highpix = WhitePixel(display, screen);
backpix = BlackPixel(display, screen);
brdrpix = WhitePixel(display, screen);
mouspix = WhitePixel(display, screen);
}
}
/** Generate Window **/
main_window = XCreateSimpleWindow(display, DefaultRootWindow(display),
xsh.x, xsh.y, xsh.width, xsh.height,
bwidth, brdrpix, backpix);
XSetStandardProperties(display, main_window, windowtitle, windowtitle,
None, argv, argc, &xsh);
/* winatt.bit_gravity = SouthWestGravity; */
XChangeWindowAttributes(display, main_window, CWBitGravity, &winatt);
/** Map Window **/
XSelectInput(display, main_window, StructureNotifyMask);
XMapWindow(display, main_window);
for (;;) {
XNextEvent(display, &ev);
if (ev.type == MapNotify)
break;
}
XSelectInput(display, main_window,
ButtonPressMask | PointerMotionMask | KeyPressMask |
ExposureMask);
/* KeyReleaseMask|ExposureMask|StructureNotifyMask);
*/
/** Cursor **/
watch_cur = XCreateFontCursor(display, XC_watch);
XDefineCursor(display, main_window, watch_cur);
/** GC **/
gcval.line_width = 1;
gc = XCreateGC(display, main_window, GCLineWidth, &gcval);
XSetFunction(display, gc, GXcopy);
XSetGraphicsExposures(display, gc, False);
XSetForeground(display, gc, forepix);
XSetBackground(display, gc, backpix);
font = XLoadFont(display, f_name[fno]);
XSetFont(display, gc, font);
}
void init_pixmap(void)
{
if (!landscape) {
pixmap_w = XLENG / shrink;
pixmap_h = YLENG / shrink;
} else {
pixmap_w = YLENG / shrink;
pixmap_h = XLENG / shrink;
}
pixmap = XCreatePixmap(display, main_window, pixmap_w, pixmap_h,
DefaultDepth(display, screen));
pixmapGC = XCreateGC(display, pixmap, 0L, &gcval);
XFillRectangle(display, pixmap, pixmapGC, 0, 0, pixmap_w, pixmap_h);
XSetFunction(display, pixmapGC, GXcopy);
XSetFillStyle(display, pixmapGC, FillSolid);
XSetForeground(display, pixmapGC, forepix);
XSetBackground(display, pixmapGC, backpix);
}
void close_window(void)
{
XFreeCursor(display, watch_cur);
XFreeGC(display, gc);
XFreeGC(display, pixmapGC);
XFreePixmap(display, pixmap);
XDestroyWindow(display, main_window);
/**/ exit(0);
/**/ XCloseDisplay(display); /* this function case an error !! */
}
void main_loop(void)
{
char key;
int paper_w, paper_h;
long diff;
if (!landscape) {
paper_w = XLENG / shrink;
paper_h = YLENG / shrink;
} else {
paper_w = YLENG / shrink;
paper_h = XLENG / shrink;
}
set_all();
XUndefineCursor(display, main_window);
for (;;) {
XNextEvent(display, &ev);
switch (ev.type) {
case Expose:
if (ev.xexpose.count == 0)
get_window_size();
realize_part(ev.xexpose.x, ev.xexpose.y,
ev.xexpose.width, ev.xexpose.height,
ev.xexpose.x, ev.xexpose.y);
break;
case MappingNotify:
/* XRefreshKeyboardMapping(&ev);
*/
XRefreshKeyboardMapping((XMappingEvent *) & ev);
break;
/* case ConfigureNotify:
get_window_size();
shr_w = paper_w / window_w;
shr_h = paper_h / window_h;
shrink = (shr_w >= shr_h) ? shr_w :shr_h;
rewind(stdin);
plot();
main_loop();
origin_x += window_x;
origin_y += window_y;
realize();
realize_part(origin_x, origin_y, window_w, window_h,
origin_x, origin_y);
origin_x = paper_w - xsh.width;
origin_y = paper_h - xsh.height;
origin_x += xsh.x;
origin_y += xsh.y;
break;
*/
case MotionNotify:
break;
case ButtonPress:
break;
case KeyPress:
get_window_size();
XLookupString(&ev.xkey, &key, 1, NULL, NULL);
switch (key) {
case 'j':
diff = paper_h - window_h;
if (origin_y >= diff) {
beep();
break;
}
origin_y += window_h / 4;
if (origin_y > diff)
origin_y = diff;
if (origin_y < 0)
origin_y = 0;
realize();
continue;
break;
case 'k':
if (origin_y <= 0) {
beep();
break;
}
origin_y -= window_h / 4;
if (origin_y < 0)
origin_y = 0;
realize();
continue;
break;
case 'l':
diff = paper_w - window_w;
if (origin_x >= diff) {
beep();
break;
}
origin_x += window_w / 4;
if (origin_x > diff)
origin_x = diff;
if (origin_x < 0)
origin_x = 0;
realize();
continue;
break;
case 'h':
if (origin_x <= 0) {
beep();
break;
}
origin_x -= window_w / 4;
if (origin_x < 0)
origin_x = 0;
realize();
continue;
break;
case 'q':
case '\003': /* control-C */
case '\004': /* control-D */
close_window();
break;
default:
beep();
break;
}
break;
default:
break;
}
}
}
void realize(void)
{
realize_part(origin_x, origin_y, xsh.width, xsh.height, 0, 0);
}
void realize_part(int src_x, int src_y, int width, int height, int dest_x,
int dest_y)
{
XDefineCursor(display, main_window, watch_cur);
XCopyArea(display, pixmap, main_window, gc,
src_x, src_y, width, height, dest_x, dest_y);
XUndefineCursor(display, main_window);
}
void set_all(void)
{
XCopyArea(display, main_window, pixmap, pixmapGC,
0, 0, xsh.width, xsh.height, 0, 0);
}
void beep(void)
{
XBell(display, 100);
}
void get_window_size(void)
{
XGetWindowAttributes(display, main_window, &wa);
window_x = wa.x;
window_y = wa.y;
window_w = wa.width;
window_h = wa.height;
}
unsigned long get_color_pix(char *color_name)
{
Colormap cmap;
XColor color, exact;
cmap = DefaultColormap(display, screen);
XAllocNamedColor(display, cmap, color_name, &color, &exact);
return (color.pixel);
}
|
2d453a3fcd37c21619a5b94f338fe58138e8be5f | cd5ebce7962024d3d0ecf07e6668ee6972edc74a | /deps/util-linux-2.39.0/libsmartcols/samples/wrap.c | 795bef7140630dd75c25552f9ce9f1f172bda599 | [
"LGPL-2.0-or-later",
"LGPL-2.1-or-later",
"BSD-4-Clause-UC",
"GPL-2.0-only",
"LicenseRef-scancode-public-domain",
"GPL-3.0-or-later",
"BSD-2-Clause",
"GPL-2.0-or-later",
"BSD-3-Clause",
"Apache-2.0"
] | permissive | snowflakedb/libsnowflakeclient | 890777b09e0445787022bbf23a9e7318933d4e7a | 22a4b14c1f8014a76f91971fffe611246c0eeb86 | refs/heads/master | 2023-08-18T00:49:45.030170 | 2023-08-18T00:37:12 | 2023-08-18T00:37:12 | 118,542,136 | 18 | 34 | Apache-2.0 | 2023-09-12T23:33:23 | 2018-01-23T01:53:43 | C | UTF-8 | C | false | false | 2,687 | c | wrap.c | /*
* Copyright (C) 2010-2014 Karel Zak <[email protected]>
*
* This file may be redistributed under the terms of the
* GNU Lesser General Public License.
*/
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <getopt.h>
#include "c.h"
#include "nls.h"
#include "strutils.h"
#include "xalloc.h"
#include "libsmartcols.h"
enum { COL_NAME, COL_DESC, COL_FOO, COL_LIKE, COL_TEXT };
/* add columns to the @tb */
static void setup_columns(struct libscols_table *tb)
{
if (!scols_table_new_column(tb, "NAME", 0, SCOLS_FL_TREE))
goto fail;
if (!scols_table_new_column(tb, "DESC", 0, 0))
goto fail;
if (!scols_table_new_column(tb, "FOO", 0, SCOLS_FL_WRAP))
goto fail;
if (!scols_table_new_column(tb, "LIKE", 0, SCOLS_FL_RIGHT))
goto fail;
if (!scols_table_new_column(tb, "TEXT", 0, SCOLS_FL_WRAP))
goto fail;
return;
fail:
scols_unref_table(tb);
err(EXIT_FAILURE, "failed to create output columns");
}
static char *gen_text(const char *prefix, const char *sub_prefix, char *buf, size_t sz)
{
int x = snprintf(buf, sz, "%s-%s-", prefix, sub_prefix);
for ( ; (size_t)x < sz - 1; x++)
buf[x] = *prefix;
buf[x++] = 'x';
buf[x] = '\0';
return buf;
}
static struct libscols_line * add_line( struct libscols_table *tb,
struct libscols_line *parent,
const char *prefix)
{
char buf[BUFSIZ];
struct libscols_line *ln = scols_table_new_line(tb, parent);
if (!ln)
err(EXIT_FAILURE, "failed to create output line");
if (scols_line_set_data(ln, COL_NAME, gen_text(prefix, "N", buf, 15)))
goto fail;
if (scols_line_set_data(ln, COL_DESC, gen_text(prefix, "D", buf, 10)))
goto fail;
if (scols_line_set_data(ln, COL_FOO, gen_text(prefix, "U", buf, 55)))
goto fail;
if (scols_line_set_data(ln, COL_LIKE, "1"))
goto fail;
if (scols_line_set_data(ln, COL_TEXT, gen_text(prefix, "T", buf, 50)))
goto fail;
return ln;
fail:
scols_unref_table(tb);
err(EXIT_FAILURE, "failed to create output line");
}
int main(int argc, char *argv[])
{
struct libscols_table *tb;
struct libscols_line *ln, *xln;
setlocale(LC_ALL, ""); /* just to have enable UTF8 chars */
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "failed to create output table");
scols_table_enable_colors(tb, isatty(STDOUT_FILENO));
setup_columns(tb);
ln = add_line(tb, NULL, "A");
add_line(tb, ln, "aa");
add_line(tb, ln, "ab");
ln = add_line(tb, NULL, "B");
xln = add_line(tb, ln, "ba");
add_line(tb, xln, "baa");
add_line(tb, xln, "bab");
add_line(tb, ln, "bb");
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
|
3ce174791acfe7ae842d69120a077991730feab5 | 1a47e55435223ae34775cf8b04a2cc495eeb9a5b | /get_next_line.h | e9ca8179d569f0ef3bb98fdad7de9b6b0edfebb3 | [] | no_license | taisei-13046/get_next_line | a7976c08dea3a4dd0ff54d91ab27e229e097d71e | 7e28db63ed9e966479f7236a6980bdbf435c1846 | refs/heads/main | 2023-05-10T12:48:24.640742 | 2021-06-27T15:44:17 | 2021-06-27T15:44:17 | 362,145,969 | 2 | 0 | null | null | null | null | UTF-8 | C | false | false | 315 | h | get_next_line.h | #ifndef GET_NEXT_LINE_H
# define GET_NEXT_LINE_H
# include <string.h>
# include <fcntl.h>
# include <unistd.h>
# include <stdlib.h>
int get_next_line(int fd, char **line);
size_t ft_strlen(const char *str);
char *ft_strdup(char *str);
int ft_strchr(char *save);
char *ft_strjoin(char *save, char *buf);
#endif
|
cbd3c285f0126f7b6e43f33e2b2254fe2c59a6dd | e5b8febd2fccb7474bbb04a9ac98699b84ff3dae | /map2.c | f1c15ce489de459363d27bd1421cc7b79fe8c4c9 | [] | no_license | tobias-x/KD-Tree-Business-Finder | 6dcc0f36c49a784d6944d63c1aae0e44dc9f8f40 | 25407e52501748966adb9dc201ac77809937dee4 | refs/heads/main | 2023-01-24T10:56:56.719086 | 2020-11-26T02:37:18 | 2020-11-26T02:37:18 | 316,104,522 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,493 | c | map2.c | /*map2.c
*
* Created by Edward Tobias Franks ([email protected])
* 17/09/2020
*
* Builds a 2-dimensional 'KD Tree' of locations specified in csv file
* using kdbuilder.c. Then prints the details of all locations within
* a specified radius of a location inputted by the user.
*
* To run the program, compile and then type:
* ./map2 {input}.csv {ouptput}.txt
*
* Parameters such as MAX_ENTRY_LENGTH and MAX_LINE_LENGTH can be adjusted
* in "kdbuilder.h". This program must be run in the same directory as
* "kdbuilder.h" and "kdbuilder.c".
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "kdbuilder.h"
#include "kdbuilder.c"
void main(int argc, char **argv) {
//Builds a KD Tree using the values stored in the CSV file
busList* kdRoot = buildKD(argv[1]);
double total;
double counter;
//Open output file in order to write to it
FILE *outputFile = fopen(argv[2], "w");
safemalloc(outputFile);
printf("Please search query:\n");
/*Searches for all businesses within each of the radii specified and
prints to output*/
double xCor, yCor, radius;
while(scanf("%lf %lf %lf",&xCor,&yCor,&radius)==3) {
resultsCount=0;
total = total + keyComparison;
counter=counter+1;
keyComparison=0;
scanAlternator=1;
searchRadius(outputFile,radius,xCor,yCor,kdRoot);
}
double average = total/counter;
printf("%lf",average);
//Closes the output file now that search is complete
fclose(outputFile);
freeKD(kdRoot);
} |
ba605be68477fc3d14851cd49fe6dbd202c1a0d5 | 4668c7b278ca466cde48540c9fc9dc7faa3ba586 | /libft/srcs/get_next_scan.c | d0805a24e21fea86d4ad25e84dfc6d52e141f7fd | [] | no_license | okovko/42-printf | 46aef0890bbcdd8f58a954562e6303b408169a55 | 161b885501d2af4457171d3968fcd3bb141958b2 | refs/heads/master | 2021-07-07T19:07:09.199865 | 2017-10-03T00:29:37 | 2017-10-03T00:29:37 | 100,328,815 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,217 | c | get_next_scan.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_scan.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: olkovale <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/09/08 04:23:16 by olkovale #+# #+# */
/* Updated: 2017/09/08 04:23:16 by olkovale ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
int get_next_scan(const char *buf, const char *dlm, char **out)
{
int sz;
if (NULL == buf || NULL == out || NULL == dlm)
return (-1);
sz = ft_strcspn(buf, dlm);
if (NULL == (*out = malloc(sz)))
return (-1);
*out = ft_memcpy((void *)*out, (void *)buf, sz);
return (sz);
}
|
a670f23ad3a9c1728b8c08203acde2093cc73415 | fc9e9ba45de41dd4099875fba62c45f2a451f652 | /log/include/log/detail/log.h | 8f4b37c93ef2b80a082af96b44c127d9f6580923 | [
"BSD-2-Clause",
"BSD-3-Clause"
] | permissive | AktivCo/rtuart | 47270c6dcc2cd2c727b3a80f13222572819558eb | b41214c8d266128d950e16de4350850577e147cd | refs/heads/master | 2022-12-18T19:07:09.336217 | 2020-03-26T12:12:36 | 2020-03-26T13:18:37 | 297,648,428 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 874 | h | log.h | // Copyright (C) 2020, Aktiv-Soft JSC. All rights reserved.
// This file is part of rtuart project licensed under the terms of the 2-clause
// BSD license. See the LICENSE file found in the top-level directory of this
// distribution.
#pragma once
log_level_t log_get_log_level();
log_msg_function log_get_log_msg_function();
log_convert_to_priority_function log_get_log_convert_to_priority_function();
#define DO_LOG_MESSAGE_IMPL(logLevel, format, ...) \
do { \
if (!(logLevel & log_get_log_level())) break; \
log_get_log_msg_function()(log_get_log_convert_to_priority_function()(logLevel), format, __VA_ARGS__); \
} while (0)
|
7347adcb2a33b367cedbf05d65714e21608c745c | 73dd302d61abef70efecd0c41e00559f6fba20f2 | /SimpleXlsx/Source/tchar.h | ae7be7d4adae01075318cf5ea32968a3b82aee56 | [
"BSD-3-Clause"
] | permissive | tudodetalhado/varios | 8c18473a0d6f923db4c7e2cfde77047ec45a041e | 19de3719e02537375944d449fae5ea3b6bd12920 | refs/heads/master | 2020-12-02T18:01:00.070678 | 2017-07-15T04:07:32 | 2017-07-15T04:07:32 | 96,461,245 | 3 | 1 | null | null | null | null | UTF-8 | C | false | false | 6,007 | h | tchar.h | /*
* tchar.h
*
* Unicode mapping layer for the standard C library. By including this
* file and using the 't' names for string functions
* (eg. _tprintf) you can make code which can be easily adapted to both
* Unicode and non-unicode environments. In a unicode enabled compile define
* _UNICODE before including tchar.h, otherwise the standard non-unicode
* library functions will be used.
*
* Note that you still need to include string.h or stdlib.h etc. to define
* the appropriate functions. Also note that there are several defines
* included for non-ANSI functions which are commonly available (but using
* the convention of prepending an underscore to non-ANSI library function
* names).
*
* This file is part of the Mingw32 package.
*
* Contributors:
* Created by Colin Peters <[email protected]>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* $Revision: 1.1.1.1 $
* $Author: brandon6684 $
* $Date: 2001/12/18 22:54:08 $
*
*/
#ifndef _TCHAR_H_
#define _TCHAR_H_
/*
* NOTE: This tests _UNICODE, which is different from the UNICODE define
* used to differentiate Win32 API calls.
*/
#ifdef _UNICODE
/*
* Use TCHAR instead of char or wchar_t. It will be appropriately translated
* if _UNICODE is correctly defined (or not).
*/
#ifndef _TCHAR_DEFINED
#ifndef RC_INVOKED
typedef wchar_t TCHAR;
#endif /* Not RC_INVOKED */
#define _TCHAR_DEFINED
#endif
/*
* Enclose constant strings and literal characters in the _TEXT and _T macro to make
* them unicode constant strings when _UNICODE is defined.
*/
#define _TEXT(x) L ## x
#define _T(x) L ## x
/*
* Unicode functions
*/
#define _tprintf wprintf
#define _ftprintf fwprintf
#define _stprintf swprintf
#define _sntprintf _snwprintf
#define _vtprintf vwprintf
#define _vftprintf vfwprintf
#define _vstprintf vswprintf
#define _vsntprintf _vsnwprintf
#define _tscanf wscanf
#define _ftscanf fwscanf
#define _stscanf swscanf
#define _fgettc fgetwc
#define _fgettchar _fgetwchar
#define _fgetts fgetws
#define _fputtc fputwc
#define _fputtchar _fputwchar
#define _fputts fputws
#define _gettc getwc
#define _getts getws
#define _puttc putwc
#define _putts putws
#define _ungettc ungetwc
#define _tcstod wcstod
#define _tcstol wcstol
#define _tcstoul wcstoul
#define _tcscat wcscat
#define _tcschr wcschr
#define _tcscmp wcscmp
#define _tcscpy wcscpy
#define _tcscspn wcscspn
#define _tcslen wcslen
#define _tcsncat wcsncat
#define _tcsncmp wcsncmp
#define _tcsncpy wcsncpy
#define _tcspbrk wcspbrk
#define _tcsrchr wcsrchr
#define _tcsspn wcsspn
#define _tcsstr wcsstr
#define _tcstok wcstok
#define _tcsdup _wcsdup
#define _tcsicmp _wcsicmp
#define _tcsnicmp _wcsnicmp
#define _tcsnset _wcsnset
#define _tcsrev _wcsrev
#define _tcsset _wcsset
#define _tcslwr _wcslwr
#define _tcsupr _wcsupr
#define _tcsxfrm wcsxfrm
#define _tcscoll wcscoll
#define _tcsicoll _wcsicoll
#define _istalpha iswalpha
#define _istupper iswupper
#define _istlower iswlower
#define _istdigit iswdigit
#define _istxdigit iswxdigit
#define _istspace iswspace
#define _istpunct iswpunct
#define _istalnum iswalnum
#define _istprint iswprint
#define _istgraph iswgraph
#define _istcntrl iswcntrl
#define _istascii iswascii
#define _totupper towupper
#define _totlower towlower
#define _ttoi _wtoi
#define _tcsftime wcsftime
#define _tmkdir _wmkdir
#define _trmdir _wrmdir
#define _tremove _wremove
#define _tgetenv _wgetenv
#else /* Not _UNICODE */
/*
* TCHAR, the type you should use instead of char.
*/
#ifndef _TCHAR_DEFINED
#ifndef RC_INVOKED
typedef char TCHAR;
#endif
#define _TCHAR_DEFINED
#endif
/*
* Enclose constant strings and characters in the _TEXT and _T macro.
*/
#define _TEXT(x) x
#define _T(x) x
/*
* Non-unicode (standard) functions
*/
#define _tprintf printf
#define _ftprintf fprintf
#define _stprintf sprintf
#define _sntprintf _snprintf
#define _vtprintf vprintf
#define _vftprintf vfprintf
#define _vstprintf vsprintf
#define _vsntprintf _vsnprintf
#define _tscanf scanf
#define _ftscanf fscanf
#define _stscanf sscanf
#define _fgettc fgetc
#define _fgettchar _fgetchar
#define _fgetts fgets
#define _fputtc fputc
#define _fputtchar _fputchar
#define _fputts fputs
#define _gettc getc
#define _getts gets
#define _puttc putc
#define _putts puts
#define _ungettc ungetc
#define _tcstod strtod
#define _tcstol strtol
#define _tcstoul strtoul
#define _tcscat strcat
#define _tcschr strchr
#define _tcscmp strcmp
#define _tcscpy strcpy
#define _tcscspn strcspn
#define _tcslen strlen
#define _tcsncat strncat
#define _tcsncmp strncmp
#define _tcsncpy strncpy
#define _tcspbrk strpbrk
#define _tcsrchr strrchr
#define _tcsspn strspn
#define _tcsstr strstr
#define _tcstok strtok
#define _tcsdup _strdup
#define _tcsicmp strcasecmp
#define _tcsnicmp _strnicmp
#define _tcsnset _strnset
#define _tcsrev _strrev
#define _tcsset _strset
#define _tcslwr _strlwr
#define _tcsupr _strupr
#define _tcsxfrm strxfrm
#define _tcscoll strcoll
#define _tcsicoll _stricoll
#define _istalpha isalpha
#define _istupper isupper
#define _istlower islower
#define _istdigit isdigit
#define _istxdigit isxdigit
#define _istspace isspace
#define _istpunct ispunct
#define _istalnum isalnum
#define _istprint isprint
#define _istgraph isgraph
#define _istcntrl iscntrl
#define _istascii isascii
#define _totupper toupper
#define _totlower tolower
#define _ttoi atoi
#define _tcsftime strftime
#define _tmkdir mkdir
#define _trmdir rmdir
#define _tremove remove
#define _tgetenv getenv
#endif /* Not _UNICODE */
#endif /* Not _TCHAR_H_ */
|
957df7694f6c12b280e18b5d35e297104a2623b1 | d2dde8d20b858e24a8e02228f2c28a43a33ebee6 | /euler6.c | eb2b1eaf3a378ba85bf1f919b9a02bdcc4c01efa | [] | no_license | andreas9000/Project-Euler | 33f9006ffb40043f69e51ed29152475a5479174a | ea0973b27034faeed654c6d2aea17d032973fa33 | refs/heads/master | 2020-04-19T00:31:48.032251 | 2019-01-27T19:31:54 | 2019-01-27T19:31:54 | 167,849,411 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 132 | c | euler6.c | #include <stdio.h>
int main()
{
int s = 0, i;
for (i = 1; i <= 100; i++)
s += (i * i);
printf("%d\n", (5050 * 5050) - s);
}
|
3352f94c23e34c929e28dba373d43ee889abdbc9 | ad5883d00acce2ba8a24b09f9b82a7c71ec7b04a | /TME 1/c/exo2.l | 8cfa687dd76e6e2f1d1e15e1da0286d115cb66a4 | [] | no_license | Mistergix/3i018 | 672cd493087ed4dd2f796f0bf15d02f6aa5ee69b | 9773dcdc3df08b90acd3c683be726009983a86e9 | refs/heads/master | 2020-12-22T12:14:58.970543 | 2020-01-28T16:06:20 | 2020-01-28T16:06:20 | 236,776,737 | 0 | 0 | null | 2020-10-13T19:07:18 | 2020-01-28T16:06:36 | Java | UTF-8 | C | false | false | 3,335 | l | exo2.l | /* -*- mode: C; -*-
* lex -oexo2.c exo2.l
* gcc -o exo2 exo2.c -ll
* ./exo2
*/
%{
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
enum _token {
TYPE_a, TYPE_b, TYPE_c, TYPE_d, TYPE_e, TYPE_f, TYPE_g, TYPE_h, TYPE_i,
TYPE_j, TYPE_k, TYPE_l, TYPE_m, TYPE_n, FIN
};
long yylval;
%}
SEPARATEUR [ \n\t]
Ra [bB][eE][gG][iI][nN]
Rb (0|1)+
Rc 0[0-7]*
Rd -?(\.[0-9]+|[0-9]+\.|[0-9]+|[0-9]+\.[0-9]+)([eE][\+\-]?[0-9]+)?
Re [a-z]*1[a-z]*2[a-z]*3[a-z]*4[a-z]*
Rf [e-z]*a[e-z]*b[e-z]*c[e-z]*d[e-z]*
Rg [abd-z][a-z]*
Rh ([a-z][0-9])+
Ri ([a-df-z]|ee)+
Rj (ee)?([a-df-z]+(ee)?)+|ee
Rk "/*"([^*]*|"*"+[^*/]+)*"*"+"/"
Rl [ac-z]+|[b-z]+
Rm [a-df-zA-DF-Z]+|[a-df-zA-DF-Z]*(e|E)[a-df-zA-DF-Z]*
Rn [d-z]*a?[d-z]*b?[d-z]*c?[d-z]*
%%
{SEPARATEUR}+ {}
{Ra} {
yylval = (long)strdup( yytext);
return(TYPE_a);
}
{Rb} {
yylval = (long)strdup( yytext);
return(TYPE_b);
}
{Rc} {
yylval = (long)strdup( yytext);
return(TYPE_c);
}
{Rd} {
yylval = (long)strdup(yytext);
return(TYPE_d);
}
{Re} {
yylval = (long)strdup( yytext);
return(TYPE_e);
}
{Rf} {
yylval = (long)strdup( yytext);
return(TYPE_f);
}
{Rg} {
yylval = (long)strdup( yytext);
return(TYPE_g);
}
{Rh} {
yylval = (long)strdup( yytext);
return(TYPE_h);
}
{Rj} { /* Warning repéré par lex : plus particulier que Ri.
A mettre donc devant Ri */
yylval = (long)strdup( yytext);
return(TYPE_j);
}
{Ri} {
yylval = (long)strdup( yytext);
return(TYPE_i);
}
{Rk} {
yylval = (long)strdup( yytext);
return(TYPE_k);
}
{Rl} {
yylval = (long)strdup( yytext);
return(TYPE_l);
}
{Rm} {
yylval = (long)strdup( yytext);
return(TYPE_m);
}
{Rn} {
yylval = (long)strdup( yytext);
return(TYPE_n);
}
<<EOF>> {
return(FIN);
}
%%
int main (void) {
for (;;) {
switch (yylex()) {
case TYPE_a :
printf("Expression Rationnelle Ra pour %s.\n", (char *)yylval);
break;
case TYPE_b :
printf("Expression Rationnelle Rb pour %s.\n", (char *)yylval);
break;
case TYPE_c :
printf("Expression Rationnelle Rc pour %s.\n", (char *)yylval);
break;
case TYPE_d :
printf("Expression Rationnelle Rd pour %s.\n", (char *)yylval);
break;
case TYPE_e :
printf("Expression Rationnelle Re pour %s.\n", (char *)yylval);
break;
case TYPE_f :
printf("Expression Rationnelle Rf pour %s.\n", (char *)yylval);
break;
case TYPE_g :
printf("Expression Rationnelle Rg pour %s.\n", (char *)yylval);
break;
case TYPE_h :
printf("Expression Rationnelle Rh pour %s.\n", (char *)yylval);
break;
case TYPE_i :
printf("Expression Rationnelle Ri pour %s.\n", (char *)yylval);
break;
case TYPE_j :
printf("Expression Rationnelle Rj pour %s.\n", (char *)yylval);
break;
case TYPE_k :
printf("Expression Rationnelle Rk pour %s.\n", (char *)yylval);
break;
case TYPE_l :
printf("Expression Rationnelle Rl pour %s.\n", (char *)yylval);
break;
case TYPE_m :
printf("Expression Rationnelle Rm pour %s.\n", (char *)yylval);
break;
case TYPE_n :
printf("Expression Rationnelle Rn pour %s.\n", (char *)yylval);
break;
case FIN :
printf("Il n'y a plus rien à lire.\n");
return 0;
break;
default:;
}
}
}
|
a70e251ad31b0a3176a82e4f41cbfef3d3b48c72 | 0f4b65bdd99e642402d489fdd662a7dc1d1441f5 | /testsuite/EXP_4/test752.c | 71a79f0a258364f86ba3a1a1d44af4b184322d13 | [
"MIT"
] | permissive | matthiaskrgr/CF3 | 157e4967f12a6e6a0eee0fa9421f7855d24047c5 | 981a49c2b1f0fb80e1d1778beb3f3ce8578338c3 | refs/heads/master | 2021-01-01T06:02:05.773732 | 2017-07-15T20:15:36 | 2017-07-15T20:15:36 | 97,335,407 | 0 | 0 | null | 2017-07-15T18:41:20 | 2017-07-15T18:41:20 | null | UTF-8 | C | false | false | 51,684 | c | test752.c |
/*
CF3
Copyright (c) 2015 ishiura-lab.
Released under the MIT license.
https://github.com/ishiura-compiler/CF3/MIT-LICENSE.md
*/
#include<stdio.h>
#include<stdint.h>
#include<stdlib.h>
#include"test1.h"
uint64_t x6 = 67530220LLU;
uint16_t x8 = UINT16_MAX;
uint8_t x10 = UINT8_MAX;
int16_t x11 = -10;
volatile int32_t t3 = 22523;
static volatile int64_t x25 = -8718694187929994LL;
uint32_t x26 = UINT32_MAX;
uint16_t x36 = 3U;
int32_t x39 = INT32_MIN;
static uint8_t x46 = 2U;
uint32_t x48 = UINT32_MAX;
volatile uint8_t x52 = 79U;
int64_t x56 = INT64_MIN;
static int32_t t16 = 4;
int16_t x71 = -654;
volatile int32_t t17 = 4359;
int16_t x74 = INT16_MAX;
int64_t x76 = INT64_MIN;
static int64_t x77 = 787132668718LL;
int32_t t19 = -48355;
static int8_t x82 = -21;
static int32_t t22 = 33324;
volatile int32_t t23 = 186;
uint32_t x101 = UINT32_MAX;
volatile int16_t x102 = INT16_MIN;
volatile uint32_t x105 = 2U;
int32_t x109 = INT32_MIN;
int64_t x114 = -732LL;
int32_t t27 = 58201639;
uint16_t x117 = UINT16_MAX;
int16_t x120 = INT16_MIN;
int8_t x121 = INT8_MIN;
static int32_t t29 = -34;
int8_t x125 = INT8_MIN;
int32_t x128 = 14204231;
int64_t x132 = -1LL;
int32_t x133 = -5573;
volatile uint64_t x136 = 529970681LLU;
int16_t x139 = INT16_MIN;
static volatile int64_t x152 = 172147021LL;
uint16_t x154 = 17U;
volatile int32_t t38 = -26916;
int32_t x161 = INT32_MAX;
uint16_t x171 = UINT16_MAX;
volatile int32_t t41 = 7;
static uint64_t x174 = UINT64_MAX;
int32_t t42 = 61;
int32_t x178 = INT32_MIN;
static uint16_t x184 = 1U;
static uint8_t x186 = 96U;
static int32_t x188 = INT32_MIN;
int64_t x190 = INT64_MIN;
int64_t x192 = -1LL;
volatile uint16_t x193 = 53U;
int8_t x199 = -1;
uint8_t x206 = 1U;
int16_t x210 = -9805;
volatile uint16_t x214 = 1U;
int32_t t52 = 1;
int32_t t53 = 2;
static int16_t x235 = -1;
static int32_t x251 = -1;
uint64_t x262 = UINT64_MAX;
static uint16_t x265 = 191U;
volatile uint8_t x269 = 37U;
int32_t x270 = 1;
static volatile int16_t x271 = -1;
int32_t x298 = -1;
volatile int32_t t72 = -629505417;
int16_t x316 = 202;
uint64_t x318 = UINT64_MAX;
static int64_t x319 = INT64_MIN;
static int16_t x321 = -1;
volatile int32_t x322 = INT32_MIN;
static int8_t x325 = INT8_MAX;
int16_t x328 = -1640;
int32_t t77 = 638;
static int16_t x333 = INT16_MIN;
uint8_t x339 = 62U;
int32_t t80 = -6019;
int16_t x355 = -1;
uint32_t x358 = 22501U;
uint32_t x359 = UINT32_MAX;
static uint8_t x360 = 1U;
volatile int32_t t84 = -432117733;
int64_t x361 = INT64_MIN;
uint64_t x365 = UINT64_MAX;
uint8_t x370 = UINT8_MAX;
static volatile int32_t t87 = -63616;
int32_t x374 = INT32_MIN;
volatile int64_t x375 = 54598696262550395LL;
int16_t x377 = INT16_MAX;
int16_t x379 = -1;
static int32_t t89 = 34826767;
uint16_t x390 = 758U;
int16_t x391 = INT16_MAX;
uint32_t x392 = UINT32_MAX;
int32_t x395 = INT32_MIN;
int64_t x396 = -45086132769LL;
int32_t t93 = -1116;
volatile int32_t t94 = 3;
volatile uint8_t x401 = UINT8_MAX;
uint16_t x405 = 7U;
int32_t x406 = -18547107;
static uint64_t x418 = UINT64_MAX;
static uint16_t x420 = UINT16_MAX;
static int8_t x428 = 38;
int32_t x431 = -283;
volatile uint32_t x440 = 127764U;
static int32_t t102 = 0;
int64_t x446 = INT64_MIN;
int64_t x451 = INT64_MAX;
int16_t x452 = INT16_MIN;
int16_t x454 = -1;
static int32_t x456 = INT32_MIN;
uint8_t x462 = 1U;
volatile int64_t x477 = INT64_MIN;
volatile int32_t x479 = INT32_MIN;
int16_t x481 = -1;
static volatile int8_t x482 = -1;
static uint32_t x486 = UINT32_MAX;
int32_t t114 = 479266;
int8_t x493 = INT8_MIN;
static int32_t x498 = -43678359;
static uint64_t x499 = 4045159877LLU;
volatile int32_t t116 = -276;
uint8_t x511 = 2U;
int32_t t120 = 6;
volatile int8_t x521 = -1;
int8_t x531 = 6;
uint8_t x532 = 9U;
int32_t x533 = INT32_MIN;
int8_t x535 = INT8_MIN;
int32_t x540 = -8;
uint8_t x545 = UINT8_MAX;
volatile int16_t x555 = INT16_MIN;
static uint64_t x557 = UINT64_MAX;
volatile int8_t x561 = INT8_MIN;
static int32_t t131 = -972657;
volatile int32_t t132 = 26088;
static int32_t t133 = -4;
int8_t x579 = -5;
int8_t x582 = INT8_MAX;
int64_t x591 = 85846721033795LL;
int64_t x592 = -620860204148LL;
int16_t x598 = INT16_MAX;
volatile int16_t x604 = INT16_MIN;
int32_t t139 = -572511336;
int8_t x611 = -1;
int32_t x615 = INT32_MAX;
int8_t x623 = INT8_MIN;
static int16_t x624 = INT16_MIN;
static int64_t x628 = 67917627573633LL;
uint8_t x630 = UINT8_MAX;
int8_t x638 = INT8_MIN;
volatile int32_t x640 = -1;
int32_t t148 = -7286922;
int32_t x648 = -92213921;
int32_t x652 = 37;
int64_t x655 = INT64_MAX;
volatile int32_t t152 = 0;
int16_t x657 = INT16_MAX;
uint32_t x662 = 75740904U;
volatile int8_t x666 = 20;
static int32_t t155 = -15919;
static int8_t x675 = -1;
static volatile int16_t x682 = INT16_MAX;
static int32_t x685 = INT32_MAX;
uint32_t x686 = 1082740932U;
volatile uint8_t x690 = 5U;
int16_t x695 = INT16_MAX;
int64_t x707 = -1947572407038765354LL;
int16_t x710 = -1;
uint8_t x713 = 20U;
int64_t x716 = INT64_MIN;
int32_t t167 = -108355408;
volatile int32_t x719 = INT32_MIN;
uint16_t x721 = 2207U;
static int16_t x722 = INT16_MIN;
static int16_t x724 = INT16_MIN;
volatile int32_t t169 = 27329;
volatile int64_t x731 = 6241900306LL;
int64_t x740 = 92693746529052LL;
volatile int32_t t173 = -138272703;
static uint64_t x741 = UINT64_MAX;
volatile uint64_t x742 = 31220LLU;
uint32_t x743 = UINT32_MAX;
volatile int16_t x744 = INT16_MIN;
int64_t x748 = INT64_MAX;
int16_t x754 = -1;
int8_t x757 = INT8_MIN;
int8_t x759 = INT8_MIN;
uint16_t x762 = UINT16_MAX;
volatile int32_t t179 = 16;
volatile int32_t t180 = -102747;
static int32_t x790 = -12;
uint64_t x792 = 1467371936LLU;
int64_t x795 = INT64_MAX;
volatile int32_t t188 = 4;
static volatile int32_t t189 = -53128051;
uint32_t x805 = UINT32_MAX;
static int8_t x806 = INT8_MAX;
uint32_t x807 = 551U;
volatile int16_t x813 = -1;
volatile int32_t t193 = 34651;
int64_t x826 = 4428LL;
uint32_t x827 = UINT32_MAX;
int32_t x838 = INT32_MIN;
static volatile int32_t x839 = INT32_MIN;
uint64_t x842 = 2938495LLU;
int8_t x843 = 1;
void f0(void) {
uint32_t x1 = UINT32_MAX;
volatile int8_t x2 = INT8_MAX;
int32_t x3 = INT32_MIN;
static int16_t x4 = INT16_MIN;
int32_t t0 = -8;
t0 = (x1<=(x2&(x3/x4)));
if (t0 != 0) { NG(); } else { ; }
}
void f1(void) {
static int8_t x5 = INT8_MIN;
int16_t x7 = INT16_MIN;
static int32_t t1 = 560037;
t1 = (x5<=(x6&(x7/x8)));
if (t1 != 0) { NG(); } else { ; }
}
void f2(void) {
int16_t x9 = 335;
uint32_t x12 = 1U;
int32_t t2 = -1926330;
t2 = (x9<=(x10&(x11/x12)));
if (t2 != 0) { NG(); } else { ; }
}
void f3(void) {
static int32_t x13 = 15816761;
volatile int8_t x14 = INT8_MAX;
uint64_t x15 = 1908LLU;
int64_t x16 = INT64_MIN;
t3 = (x13<=(x14&(x15/x16)));
if (t3 != 0) { NG(); } else { ; }
}
void f4(void) {
volatile uint16_t x17 = 284U;
volatile int16_t x18 = INT16_MIN;
static int16_t x19 = -3324;
uint8_t x20 = 43U;
int32_t t4 = 462;
t4 = (x17<=(x18&(x19/x20)));
if (t4 != 0) { NG(); } else { ; }
}
void f5(void) {
uint64_t x21 = 48935532696LLU;
uint16_t x22 = UINT16_MAX;
uint8_t x23 = UINT8_MAX;
uint64_t x24 = 14LLU;
static volatile int32_t t5 = 0;
t5 = (x21<=(x22&(x23/x24)));
if (t5 != 0) { NG(); } else { ; }
}
void f6(void) {
int64_t x27 = INT64_MIN;
int64_t x28 = INT64_MIN;
static volatile int32_t t6 = -3836393;
t6 = (x25<=(x26&(x27/x28)));
if (t6 != 1) { NG(); } else { ; }
}
void f7(void) {
uint32_t x29 = 7U;
int64_t x30 = INT64_MIN;
uint32_t x31 = 260739U;
int16_t x32 = INT16_MIN;
static volatile int32_t t7 = 889884;
t7 = (x29<=(x30&(x31/x32)));
if (t7 != 0) { NG(); } else { ; }
}
void f8(void) {
uint32_t x33 = 1755U;
int64_t x34 = INT64_MIN;
int8_t x35 = -1;
volatile int32_t t8 = 124;
t8 = (x33<=(x34&(x35/x36)));
if (t8 != 0) { NG(); } else { ; }
}
void f9(void) {
uint64_t x37 = 56920524387LLU;
int32_t x38 = INT32_MAX;
int8_t x40 = INT8_MAX;
int32_t t9 = -8;
t9 = (x37<=(x38&(x39/x40)));
if (t9 != 0) { NG(); } else { ; }
}
void f10(void) {
int16_t x41 = INT16_MAX;
int8_t x42 = -1;
uint64_t x43 = 877260LLU;
volatile uint32_t x44 = 16688043U;
volatile int32_t t10 = -15219;
t10 = (x41<=(x42&(x43/x44)));
if (t10 != 0) { NG(); } else { ; }
}
void f11(void) {
static volatile uint64_t x45 = 0LLU;
static int8_t x47 = -1;
volatile int32_t t11 = 3520;
t11 = (x45<=(x46&(x47/x48)));
if (t11 != 1) { NG(); } else { ; }
}
void f12(void) {
int64_t x49 = 108635705951LL;
int64_t x50 = INT64_MIN;
static int32_t x51 = INT32_MIN;
int32_t t12 = 190987;
t12 = (x49<=(x50&(x51/x52)));
if (t12 != 0) { NG(); } else { ; }
}
void f13(void) {
int64_t x53 = INT64_MAX;
int8_t x54 = INT8_MIN;
volatile uint8_t x55 = 7U;
static volatile int32_t t13 = -114651925;
t13 = (x53<=(x54&(x55/x56)));
if (t13 != 0) { NG(); } else { ; }
}
void f14(void) {
volatile int64_t x57 = INT64_MIN;
int32_t x58 = INT32_MAX;
volatile int16_t x59 = INT16_MIN;
int16_t x60 = -1;
static int32_t t14 = 3;
t14 = (x57<=(x58&(x59/x60)));
if (t14 != 1) { NG(); } else { ; }
}
void f15(void) {
int8_t x61 = 1;
int32_t x62 = -32009863;
int8_t x63 = INT8_MAX;
int64_t x64 = -1LL;
static int32_t t15 = 154077;
t15 = (x61<=(x62&(x63/x64)));
if (t15 != 0) { NG(); } else { ; }
}
void f16(void) {
static uint32_t x65 = 446933U;
volatile uint32_t x66 = 14516373U;
volatile uint64_t x67 = UINT64_MAX;
static int64_t x68 = -663LL;
t16 = (x65<=(x66&(x67/x68)));
if (t16 != 0) { NG(); } else { ; }
}
void f17(void) {
static uint8_t x69 = 23U;
volatile int32_t x70 = INT32_MIN;
uint16_t x72 = UINT16_MAX;
t17 = (x69<=(x70&(x71/x72)));
if (t17 != 0) { NG(); } else { ; }
}
void f18(void) {
int64_t x73 = INT64_MAX;
static int16_t x75 = 15313;
int32_t t18 = 52;
t18 = (x73<=(x74&(x75/x76)));
if (t18 != 0) { NG(); } else { ; }
}
void f19(void) {
static volatile int8_t x78 = -18;
uint64_t x79 = UINT64_MAX;
int8_t x80 = INT8_MIN;
t19 = (x77<=(x78&(x79/x80)));
if (t19 != 0) { NG(); } else { ; }
}
void f20(void) {
static uint16_t x81 = 1208U;
volatile int32_t x83 = INT32_MIN;
int64_t x84 = -1LL;
volatile int32_t t20 = -3;
t20 = (x81<=(x82&(x83/x84)));
if (t20 != 1) { NG(); } else { ; }
}
void f21(void) {
uint32_t x89 = 32281U;
static int8_t x90 = -14;
uint16_t x91 = 508U;
uint32_t x92 = UINT32_MAX;
static volatile int32_t t21 = -558;
t21 = (x89<=(x90&(x91/x92)));
if (t21 != 0) { NG(); } else { ; }
}
void f22(void) {
static int32_t x93 = INT32_MAX;
int16_t x94 = INT16_MIN;
uint8_t x95 = UINT8_MAX;
uint64_t x96 = 182060016LLU;
t22 = (x93<=(x94&(x95/x96)));
if (t22 != 0) { NG(); } else { ; }
}
void f23(void) {
int64_t x97 = -152LL;
uint8_t x98 = 1U;
uint16_t x99 = 1893U;
volatile int32_t x100 = INT32_MIN;
t23 = (x97<=(x98&(x99/x100)));
if (t23 != 1) { NG(); } else { ; }
}
void f24(void) {
volatile uint16_t x103 = 548U;
int32_t x104 = 4975220;
volatile int32_t t24 = 419329;
t24 = (x101<=(x102&(x103/x104)));
if (t24 != 0) { NG(); } else { ; }
}
void f25(void) {
int64_t x106 = INT64_MIN;
uint32_t x107 = UINT32_MAX;
volatile int32_t x108 = INT32_MAX;
static volatile int32_t t25 = 59282260;
t25 = (x105<=(x106&(x107/x108)));
if (t25 != 0) { NG(); } else { ; }
}
void f26(void) {
uint64_t x110 = 13695LLU;
uint32_t x111 = 2U;
int64_t x112 = INT64_MIN;
int32_t t26 = 107;
t26 = (x109<=(x110&(x111/x112)));
if (t26 != 0) { NG(); } else { ; }
}
void f27(void) {
int64_t x113 = 30360457228LL;
int32_t x115 = INT32_MAX;
volatile uint32_t x116 = UINT32_MAX;
t27 = (x113<=(x114&(x115/x116)));
if (t27 != 0) { NG(); } else { ; }
}
void f28(void) {
int16_t x118 = INT16_MIN;
static volatile int8_t x119 = 52;
volatile int32_t t28 = 28326;
t28 = (x117<=(x118&(x119/x120)));
if (t28 != 0) { NG(); } else { ; }
}
void f29(void) {
int8_t x122 = INT8_MAX;
static uint16_t x123 = 30508U;
uint16_t x124 = 217U;
t29 = (x121<=(x122&(x123/x124)));
if (t29 != 1) { NG(); } else { ; }
}
void f30(void) {
int8_t x126 = INT8_MIN;
uint32_t x127 = 1155691332U;
static volatile int32_t t30 = -7089800;
t30 = (x125<=(x126&(x127/x128)));
if (t30 != 0) { NG(); } else { ; }
}
void f31(void) {
static volatile uint64_t x129 = 0LLU;
uint32_t x130 = 46390693U;
int8_t x131 = 19;
int32_t t31 = 12934;
t31 = (x129<=(x130&(x131/x132)));
if (t31 != 1) { NG(); } else { ; }
}
void f32(void) {
int32_t x134 = INT32_MAX;
static int16_t x135 = INT16_MIN;
volatile int32_t t32 = 1318;
t32 = (x133<=(x134&(x135/x136)));
if (t32 != 0) { NG(); } else { ; }
}
void f33(void) {
volatile int32_t x137 = INT32_MIN;
uint16_t x138 = 1213U;
int32_t x140 = INT32_MAX;
static int32_t t33 = 28458;
t33 = (x137<=(x138&(x139/x140)));
if (t33 != 1) { NG(); } else { ; }
}
void f34(void) {
int32_t x141 = INT32_MIN;
volatile int8_t x142 = INT8_MAX;
static int64_t x143 = -11294080734884LL;
int8_t x144 = INT8_MIN;
volatile int32_t t34 = -5979470;
t34 = (x141<=(x142&(x143/x144)));
if (t34 != 1) { NG(); } else { ; }
}
void f35(void) {
int32_t x145 = INT32_MIN;
int8_t x146 = 8;
static int16_t x147 = INT16_MAX;
uint64_t x148 = UINT64_MAX;
static int32_t t35 = -1093529;
t35 = (x145<=(x146&(x147/x148)));
if (t35 != 0) { NG(); } else { ; }
}
void f36(void) {
int8_t x149 = INT8_MIN;
uint8_t x150 = 2U;
int32_t x151 = -1;
int32_t t36 = 702945;
t36 = (x149<=(x150&(x151/x152)));
if (t36 != 1) { NG(); } else { ; }
}
void f37(void) {
volatile uint8_t x153 = 2U;
volatile int64_t x155 = -363611LL;
volatile int16_t x156 = -31;
int32_t t37 = -24044;
t37 = (x153<=(x154&(x155/x156)));
if (t37 != 1) { NG(); } else { ; }
}
void f38(void) {
volatile int16_t x157 = INT16_MAX;
volatile uint64_t x158 = UINT64_MAX;
uint64_t x159 = 129893919614138261LLU;
uint32_t x160 = 33838U;
t38 = (x157<=(x158&(x159/x160)));
if (t38 != 1) { NG(); } else { ; }
}
void f39(void) {
volatile uint64_t x162 = 491LLU;
int16_t x163 = INT16_MIN;
uint32_t x164 = UINT32_MAX;
volatile int32_t t39 = 130920707;
t39 = (x161<=(x162&(x163/x164)));
if (t39 != 0) { NG(); } else { ; }
}
void f40(void) {
int8_t x165 = INT8_MIN;
uint32_t x166 = 7U;
int16_t x167 = INT16_MIN;
int16_t x168 = 14;
volatile int32_t t40 = -461318218;
t40 = (x165<=(x166&(x167/x168)));
if (t40 != 0) { NG(); } else { ; }
}
void f41(void) {
volatile int16_t x169 = -388;
static int64_t x170 = 15095984LL;
int8_t x172 = 15;
t41 = (x169<=(x170&(x171/x172)));
if (t41 != 1) { NG(); } else { ; }
}
void f42(void) {
int64_t x173 = -1LL;
int8_t x175 = INT8_MAX;
uint16_t x176 = 9801U;
t42 = (x173<=(x174&(x175/x176)));
if (t42 != 0) { NG(); } else { ; }
}
void f43(void) {
uint64_t x177 = 1776040LLU;
uint64_t x179 = UINT64_MAX;
int8_t x180 = INT8_MAX;
int32_t t43 = 5668379;
t43 = (x177<=(x178&(x179/x180)));
if (t43 != 1) { NG(); } else { ; }
}
void f44(void) {
uint8_t x181 = UINT8_MAX;
static uint8_t x182 = 5U;
int8_t x183 = INT8_MIN;
volatile int32_t t44 = 6280;
t44 = (x181<=(x182&(x183/x184)));
if (t44 != 0) { NG(); } else { ; }
}
void f45(void) {
int8_t x185 = 12;
int16_t x187 = -1;
int32_t t45 = -323761;
t45 = (x185<=(x186&(x187/x188)));
if (t45 != 0) { NG(); } else { ; }
}
void f46(void) {
static uint32_t x189 = 3U;
int64_t x191 = -1LL;
int32_t t46 = 22582;
t46 = (x189<=(x190&(x191/x192)));
if (t46 != 0) { NG(); } else { ; }
}
void f47(void) {
uint8_t x194 = 123U;
uint8_t x195 = 0U;
int16_t x196 = 736;
int32_t t47 = -28750;
t47 = (x193<=(x194&(x195/x196)));
if (t47 != 0) { NG(); } else { ; }
}
void f48(void) {
uint32_t x197 = 914229351U;
static int8_t x198 = INT8_MAX;
uint8_t x200 = 74U;
volatile int32_t t48 = 15;
t48 = (x197<=(x198&(x199/x200)));
if (t48 != 0) { NG(); } else { ; }
}
void f49(void) {
int32_t x201 = INT32_MIN;
uint16_t x202 = UINT16_MAX;
int16_t x203 = -1;
int64_t x204 = INT64_MIN;
int32_t t49 = -513125726;
t49 = (x201<=(x202&(x203/x204)));
if (t49 != 1) { NG(); } else { ; }
}
void f50(void) {
uint64_t x205 = 4271736940994LLU;
uint64_t x207 = 160566572998LLU;
int8_t x208 = -1;
int32_t t50 = -133931274;
t50 = (x205<=(x206&(x207/x208)));
if (t50 != 0) { NG(); } else { ; }
}
void f51(void) {
static int16_t x209 = 3007;
int64_t x211 = -7001133047915828LL;
uint32_t x212 = 15468765U;
volatile int32_t t51 = 42633;
t51 = (x209<=(x210&(x211/x212)));
if (t51 != 0) { NG(); } else { ; }
}
void f52(void) {
int16_t x213 = 1;
static int64_t x215 = -193046LL;
int8_t x216 = INT8_MIN;
t52 = (x213<=(x214&(x215/x216)));
if (t52 != 0) { NG(); } else { ; }
}
void f53(void) {
int64_t x217 = -80LL;
static int16_t x218 = -3;
int16_t x219 = -1;
int64_t x220 = INT64_MAX;
t53 = (x217<=(x218&(x219/x220)));
if (t53 != 1) { NG(); } else { ; }
}
void f54(void) {
static uint32_t x221 = 320272864U;
static uint16_t x222 = UINT16_MAX;
static uint32_t x223 = UINT32_MAX;
int16_t x224 = INT16_MIN;
int32_t t54 = -9794;
t54 = (x221<=(x222&(x223/x224)));
if (t54 != 0) { NG(); } else { ; }
}
void f55(void) {
static int32_t x225 = INT32_MAX;
int16_t x226 = INT16_MIN;
static int16_t x227 = INT16_MIN;
int64_t x228 = INT64_MIN;
static volatile int32_t t55 = 16560532;
t55 = (x225<=(x226&(x227/x228)));
if (t55 != 0) { NG(); } else { ; }
}
void f56(void) {
uint8_t x229 = UINT8_MAX;
int16_t x230 = -229;
int16_t x231 = -1;
int8_t x232 = -1;
int32_t t56 = -3328032;
t56 = (x229<=(x230&(x231/x232)));
if (t56 != 0) { NG(); } else { ; }
}
void f57(void) {
static int8_t x233 = INT8_MIN;
static uint16_t x234 = UINT16_MAX;
int32_t x236 = -42294434;
int32_t t57 = -169;
t57 = (x233<=(x234&(x235/x236)));
if (t57 != 1) { NG(); } else { ; }
}
void f58(void) {
int64_t x241 = -1LL;
int64_t x242 = -1LL;
uint64_t x243 = UINT64_MAX;
int32_t x244 = -1;
volatile int32_t t58 = 7675;
t58 = (x241<=(x242&(x243/x244)));
if (t58 != 0) { NG(); } else { ; }
}
void f59(void) {
static int8_t x249 = INT8_MIN;
volatile int32_t x250 = INT32_MIN;
int64_t x252 = INT64_MIN;
volatile int32_t t59 = -16662075;
t59 = (x249<=(x250&(x251/x252)));
if (t59 != 1) { NG(); } else { ; }
}
void f60(void) {
uint8_t x257 = UINT8_MAX;
static int64_t x258 = -1185916LL;
int32_t x259 = -423354;
volatile int8_t x260 = -2;
volatile int32_t t60 = 392459;
t60 = (x257<=(x258&(x259/x260)));
if (t60 != 1) { NG(); } else { ; }
}
void f61(void) {
volatile int16_t x261 = INT16_MIN;
uint16_t x263 = 4394U;
volatile int8_t x264 = 7;
volatile int32_t t61 = -1044412493;
t61 = (x261<=(x262&(x263/x264)));
if (t61 != 0) { NG(); } else { ; }
}
void f62(void) {
int32_t x266 = INT32_MIN;
uint8_t x267 = 56U;
uint64_t x268 = 10700593589251968LLU;
volatile int32_t t62 = 29497929;
t62 = (x265<=(x266&(x267/x268)));
if (t62 != 0) { NG(); } else { ; }
}
void f63(void) {
int8_t x272 = INT8_MIN;
int32_t t63 = -1014;
t63 = (x269<=(x270&(x271/x272)));
if (t63 != 0) { NG(); } else { ; }
}
void f64(void) {
int16_t x273 = INT16_MAX;
int64_t x274 = 1993254191235855LL;
int16_t x275 = INT16_MIN;
int8_t x276 = 1;
static volatile int32_t t64 = 63;
t64 = (x273<=(x274&(x275/x276)));
if (t64 != 1) { NG(); } else { ; }
}
void f65(void) {
int64_t x277 = 1592988565LL;
int32_t x278 = 662974;
volatile int16_t x279 = -1;
uint64_t x280 = UINT64_MAX;
int32_t t65 = 106;
t65 = (x277<=(x278&(x279/x280)));
if (t65 != 0) { NG(); } else { ; }
}
void f66(void) {
volatile int8_t x281 = -7;
uint64_t x282 = 264LLU;
uint32_t x283 = 30U;
int8_t x284 = 1;
int32_t t66 = -107128783;
t66 = (x281<=(x282&(x283/x284)));
if (t66 != 0) { NG(); } else { ; }
}
void f67(void) {
uint16_t x285 = UINT16_MAX;
static int32_t x286 = INT32_MIN;
volatile uint8_t x287 = 1U;
uint32_t x288 = 1296U;
int32_t t67 = -298294556;
t67 = (x285<=(x286&(x287/x288)));
if (t67 != 0) { NG(); } else { ; }
}
void f68(void) {
int8_t x289 = -1;
uint64_t x290 = 1610493244LLU;
uint32_t x291 = 28826U;
int8_t x292 = INT8_MIN;
volatile int32_t t68 = 224;
t68 = (x289<=(x290&(x291/x292)));
if (t68 != 0) { NG(); } else { ; }
}
void f69(void) {
int8_t x293 = INT8_MAX;
static uint16_t x294 = 22U;
int64_t x295 = 219LL;
volatile int8_t x296 = INT8_MIN;
int32_t t69 = 76535882;
t69 = (x293<=(x294&(x295/x296)));
if (t69 != 0) { NG(); } else { ; }
}
void f70(void) {
volatile uint16_t x297 = 47U;
volatile int64_t x299 = 3158625967120310LL;
static int32_t x300 = INT32_MAX;
volatile int32_t t70 = 0;
t70 = (x297<=(x298&(x299/x300)));
if (t70 != 1) { NG(); } else { ; }
}
void f71(void) {
int32_t x301 = INT32_MIN;
uint16_t x302 = 0U;
uint64_t x303 = UINT64_MAX;
int32_t x304 = -640;
int32_t t71 = -3;
t71 = (x301<=(x302&(x303/x304)));
if (t71 != 0) { NG(); } else { ; }
}
void f72(void) {
int8_t x305 = -1;
uint32_t x306 = 668U;
int8_t x307 = INT8_MIN;
volatile int8_t x308 = INT8_MIN;
t72 = (x305<=(x306&(x307/x308)));
if (t72 != 0) { NG(); } else { ; }
}
void f73(void) {
volatile int16_t x309 = INT16_MAX;
volatile int16_t x310 = INT16_MIN;
static int8_t x311 = INT8_MIN;
static int16_t x312 = -510;
volatile int32_t t73 = 4204877;
t73 = (x309<=(x310&(x311/x312)));
if (t73 != 0) { NG(); } else { ; }
}
void f74(void) {
int32_t x313 = INT32_MIN;
volatile int16_t x314 = INT16_MIN;
int8_t x315 = INT8_MIN;
static volatile int32_t t74 = -10;
t74 = (x313<=(x314&(x315/x316)));
if (t74 != 1) { NG(); } else { ; }
}
void f75(void) {
uint16_t x317 = 1U;
volatile uint32_t x320 = UINT32_MAX;
int32_t t75 = -124;
t75 = (x317<=(x318&(x319/x320)));
if (t75 != 1) { NG(); } else { ; }
}
void f76(void) {
uint64_t x323 = 95824691447978LLU;
int16_t x324 = INT16_MIN;
volatile int32_t t76 = -3184;
t76 = (x321<=(x322&(x323/x324)));
if (t76 != 0) { NG(); } else { ; }
}
void f77(void) {
int32_t x326 = INT32_MIN;
static volatile uint32_t x327 = 0U;
t77 = (x325<=(x326&(x327/x328)));
if (t77 != 0) { NG(); } else { ; }
}
void f78(void) {
volatile uint8_t x329 = 123U;
uint64_t x330 = UINT64_MAX;
volatile int64_t x331 = -2265042900258272LL;
static int8_t x332 = 1;
int32_t t78 = 5;
t78 = (x329<=(x330&(x331/x332)));
if (t78 != 1) { NG(); } else { ; }
}
void f79(void) {
uint8_t x334 = 3U;
int8_t x335 = -1;
static int64_t x336 = INT64_MIN;
volatile int32_t t79 = -1198;
t79 = (x333<=(x334&(x335/x336)));
if (t79 != 1) { NG(); } else { ; }
}
void f80(void) {
volatile int8_t x337 = INT8_MIN;
int8_t x338 = INT8_MAX;
int32_t x340 = 642738;
t80 = (x337<=(x338&(x339/x340)));
if (t80 != 1) { NG(); } else { ; }
}
void f81(void) {
uint32_t x345 = 66U;
uint64_t x346 = 172019484392588LLU;
volatile int64_t x347 = INT64_MIN;
volatile int16_t x348 = INT16_MIN;
int32_t t81 = -30598;
t81 = (x345<=(x346&(x347/x348)));
if (t81 != 0) { NG(); } else { ; }
}
void f82(void) {
static int16_t x349 = -205;
static int8_t x350 = INT8_MAX;
volatile uint8_t x351 = 5U;
int8_t x352 = 3;
int32_t t82 = 15;
t82 = (x349<=(x350&(x351/x352)));
if (t82 != 1) { NG(); } else { ; }
}
void f83(void) {
volatile int64_t x353 = 1397LL;
static uint16_t x354 = 641U;
volatile int64_t x356 = -285577840LL;
static int32_t t83 = 723208969;
t83 = (x353<=(x354&(x355/x356)));
if (t83 != 0) { NG(); } else { ; }
}
void f84(void) {
int64_t x357 = INT64_MIN;
t84 = (x357<=(x358&(x359/x360)));
if (t84 != 1) { NG(); } else { ; }
}
void f85(void) {
int32_t x362 = -1;
static uint16_t x363 = 58U;
int32_t x364 = -14;
static int32_t t85 = 3226702;
t85 = (x361<=(x362&(x363/x364)));
if (t85 != 1) { NG(); } else { ; }
}
void f86(void) {
volatile int16_t x366 = 0;
int64_t x367 = INT64_MAX;
uint64_t x368 = 13814893LLU;
volatile int32_t t86 = 22629;
t86 = (x365<=(x366&(x367/x368)));
if (t86 != 0) { NG(); } else { ; }
}
void f87(void) {
int32_t x369 = INT32_MIN;
static volatile uint32_t x371 = UINT32_MAX;
static volatile int16_t x372 = 13917;
t87 = (x369<=(x370&(x371/x372)));
if (t87 != 0) { NG(); } else { ; }
}
void f88(void) {
uint8_t x373 = UINT8_MAX;
static uint32_t x376 = UINT32_MAX;
static int32_t t88 = 246673220;
t88 = (x373<=(x374&(x375/x376)));
if (t88 != 0) { NG(); } else { ; }
}
void f89(void) {
int64_t x378 = 314LL;
static int16_t x380 = INT16_MAX;
t89 = (x377<=(x378&(x379/x380)));
if (t89 != 0) { NG(); } else { ; }
}
void f90(void) {
uint8_t x381 = 22U;
volatile int32_t x382 = -1;
int32_t x383 = INT32_MIN;
int32_t x384 = INT32_MIN;
static volatile int32_t t90 = 30127194;
t90 = (x381<=(x382&(x383/x384)));
if (t90 != 0) { NG(); } else { ; }
}
void f91(void) {
volatile int16_t x385 = INT16_MIN;
static volatile int32_t x386 = -579408702;
int64_t x387 = INT64_MAX;
int64_t x388 = INT64_MAX;
int32_t t91 = 6665;
t91 = (x385<=(x386&(x387/x388)));
if (t91 != 1) { NG(); } else { ; }
}
void f92(void) {
int8_t x389 = 18;
int32_t t92 = 53176;
t92 = (x389<=(x390&(x391/x392)));
if (t92 != 0) { NG(); } else { ; }
}
void f93(void) {
uint8_t x393 = 92U;
uint16_t x394 = 3501U;
t93 = (x393<=(x394&(x395/x396)));
if (t93 != 0) { NG(); } else { ; }
}
void f94(void) {
int32_t x397 = 29098;
int32_t x398 = INT32_MAX;
int16_t x399 = 0;
int16_t x400 = -1;
t94 = (x397<=(x398&(x399/x400)));
if (t94 != 0) { NG(); } else { ; }
}
void f95(void) {
int32_t x402 = -12;
static volatile uint16_t x403 = 7711U;
int64_t x404 = INT64_MIN;
volatile int32_t t95 = 1;
t95 = (x401<=(x402&(x403/x404)));
if (t95 != 0) { NG(); } else { ; }
}
void f96(void) {
int64_t x407 = INT64_MIN;
volatile int32_t x408 = -58;
int32_t t96 = 1;
t96 = (x405<=(x406&(x407/x408)));
if (t96 != 1) { NG(); } else { ; }
}
void f97(void) {
uint16_t x409 = 10U;
int16_t x410 = 11;
uint16_t x411 = 5U;
uint32_t x412 = UINT32_MAX;
static volatile int32_t t97 = -635;
t97 = (x409<=(x410&(x411/x412)));
if (t97 != 0) { NG(); } else { ; }
}
void f98(void) {
volatile int64_t x413 = INT64_MIN;
static volatile uint64_t x414 = UINT64_MAX;
int64_t x415 = -1LL;
volatile int32_t x416 = INT32_MIN;
volatile int32_t t98 = 22;
t98 = (x413<=(x414&(x415/x416)));
if (t98 != 0) { NG(); } else { ; }
}
void f99(void) {
static volatile uint64_t x417 = UINT64_MAX;
volatile int16_t x419 = 254;
int32_t t99 = 1;
t99 = (x417<=(x418&(x419/x420)));
if (t99 != 0) { NG(); } else { ; }
}
void f100(void) {
static uint64_t x425 = 109802LLU;
int16_t x426 = INT16_MIN;
int16_t x427 = INT16_MAX;
int32_t t100 = 80031;
t100 = (x425<=(x426&(x427/x428)));
if (t100 != 0) { NG(); } else { ; }
}
void f101(void) {
uint16_t x429 = UINT16_MAX;
uint64_t x430 = 145895831LLU;
volatile uint64_t x432 = 3772829415LLU;
volatile int32_t t101 = 6304;
t101 = (x429<=(x430&(x431/x432)));
if (t101 != 1) { NG(); } else { ; }
}
void f102(void) {
static int16_t x437 = INT16_MIN;
uint64_t x438 = 42706LLU;
uint8_t x439 = 9U;
t102 = (x437<=(x438&(x439/x440)));
if (t102 != 0) { NG(); } else { ; }
}
void f103(void) {
uint8_t x441 = 32U;
int64_t x442 = INT64_MIN;
int32_t x443 = -1012692236;
int8_t x444 = INT8_MAX;
static int32_t t103 = -114;
t103 = (x441<=(x442&(x443/x444)));
if (t103 != 0) { NG(); } else { ; }
}
void f104(void) {
volatile uint64_t x445 = UINT64_MAX;
static volatile uint64_t x447 = 1391103LLU;
int64_t x448 = 241847LL;
volatile int32_t t104 = -39;
t104 = (x445<=(x446&(x447/x448)));
if (t104 != 0) { NG(); } else { ; }
}
void f105(void) {
uint32_t x449 = UINT32_MAX;
int8_t x450 = 0;
volatile int32_t t105 = -20718;
t105 = (x449<=(x450&(x451/x452)));
if (t105 != 0) { NG(); } else { ; }
}
void f106(void) {
uint8_t x453 = 60U;
uint8_t x455 = 2U;
int32_t t106 = 1;
t106 = (x453<=(x454&(x455/x456)));
if (t106 != 0) { NG(); } else { ; }
}
void f107(void) {
volatile uint64_t x457 = 54093250462389LLU;
int8_t x458 = 6;
volatile int64_t x459 = INT64_MIN;
volatile uint8_t x460 = 11U;
static int32_t t107 = -1760215;
t107 = (x457<=(x458&(x459/x460)));
if (t107 != 0) { NG(); } else { ; }
}
void f108(void) {
int32_t x461 = -34318;
static int64_t x463 = INT64_MAX;
int32_t x464 = -1;
static int32_t t108 = -1;
t108 = (x461<=(x462&(x463/x464)));
if (t108 != 1) { NG(); } else { ; }
}
void f109(void) {
static uint8_t x465 = 5U;
int32_t x466 = -1;
uint64_t x467 = 1019896499991LLU;
volatile int64_t x468 = INT64_MIN;
volatile int32_t t109 = -318790130;
t109 = (x465<=(x466&(x467/x468)));
if (t109 != 0) { NG(); } else { ; }
}
void f110(void) {
volatile uint16_t x469 = 1U;
int64_t x470 = -30LL;
uint32_t x471 = 60U;
uint64_t x472 = UINT64_MAX;
volatile int32_t t110 = 91;
t110 = (x469<=(x470&(x471/x472)));
if (t110 != 0) { NG(); } else { ; }
}
void f111(void) {
uint16_t x478 = 2118U;
uint64_t x480 = 10LLU;
int32_t t111 = 1338793;
t111 = (x477<=(x478&(x479/x480)));
if (t111 != 0) { NG(); } else { ; }
}
void f112(void) {
int16_t x483 = INT16_MIN;
int64_t x484 = -1LL;
int32_t t112 = -22580;
t112 = (x481<=(x482&(x483/x484)));
if (t112 != 1) { NG(); } else { ; }
}
void f113(void) {
int16_t x485 = INT16_MIN;
static volatile int8_t x487 = INT8_MIN;
static int16_t x488 = 33;
static volatile int32_t t113 = -99;
t113 = (x485<=(x486&(x487/x488)));
if (t113 != 1) { NG(); } else { ; }
}
void f114(void) {
int16_t x489 = -1;
int8_t x490 = -13;
uint64_t x491 = 87LLU;
uint16_t x492 = 11U;
t114 = (x489<=(x490&(x491/x492)));
if (t114 != 0) { NG(); } else { ; }
}
void f115(void) {
volatile int8_t x494 = INT8_MIN;
int32_t x495 = -44142128;
static int32_t x496 = -20613;
volatile int32_t t115 = -1;
t115 = (x493<=(x494&(x495/x496)));
if (t115 != 1) { NG(); } else { ; }
}
void f116(void) {
int8_t x497 = -4;
uint64_t x500 = 16099100805052LLU;
t116 = (x497<=(x498&(x499/x500)));
if (t116 != 0) { NG(); } else { ; }
}
void f117(void) {
static int8_t x505 = INT8_MIN;
int64_t x506 = INT64_MIN;
uint8_t x507 = 0U;
static int8_t x508 = INT8_MAX;
int32_t t117 = -43383;
t117 = (x505<=(x506&(x507/x508)));
if (t117 != 1) { NG(); } else { ; }
}
void f118(void) {
volatile int32_t x509 = INT32_MAX;
uint8_t x510 = UINT8_MAX;
int32_t x512 = INT32_MIN;
volatile int32_t t118 = 1027842;
t118 = (x509<=(x510&(x511/x512)));
if (t118 != 0) { NG(); } else { ; }
}
void f119(void) {
int16_t x513 = INT16_MIN;
int8_t x514 = -1;
int8_t x515 = 0;
static int8_t x516 = -2;
volatile int32_t t119 = -7604;
t119 = (x513<=(x514&(x515/x516)));
if (t119 != 1) { NG(); } else { ; }
}
void f120(void) {
uint8_t x517 = 0U;
int8_t x518 = INT8_MAX;
int64_t x519 = 6627545858332770LL;
volatile uint32_t x520 = 3U;
t120 = (x517<=(x518&(x519/x520)));
if (t120 != 1) { NG(); } else { ; }
}
void f121(void) {
int16_t x522 = -1;
volatile int8_t x523 = -1;
volatile int8_t x524 = 1;
int32_t t121 = -38;
t121 = (x521<=(x522&(x523/x524)));
if (t121 != 1) { NG(); } else { ; }
}
void f122(void) {
int64_t x525 = 154644063LL;
int8_t x526 = INT8_MIN;
int8_t x527 = INT8_MAX;
uint8_t x528 = 25U;
int32_t t122 = -62;
t122 = (x525<=(x526&(x527/x528)));
if (t122 != 0) { NG(); } else { ; }
}
void f123(void) {
uint64_t x529 = 43021714478979200LLU;
uint32_t x530 = 994U;
volatile int32_t t123 = -29001844;
t123 = (x529<=(x530&(x531/x532)));
if (t123 != 0) { NG(); } else { ; }
}
void f124(void) {
uint64_t x534 = 3341016472LLU;
uint64_t x536 = 13458682296253905LLU;
volatile int32_t t124 = 1;
t124 = (x533<=(x534&(x535/x536)));
if (t124 != 0) { NG(); } else { ; }
}
void f125(void) {
uint32_t x537 = 2103908646U;
int32_t x538 = 225008;
volatile uint16_t x539 = UINT16_MAX;
static int32_t t125 = -56590370;
t125 = (x537<=(x538&(x539/x540)));
if (t125 != 0) { NG(); } else { ; }
}
void f126(void) {
int64_t x541 = INT64_MIN;
int8_t x542 = INT8_MAX;
volatile uint64_t x543 = 987066LLU;
int32_t x544 = 13;
volatile int32_t t126 = -10541;
t126 = (x541<=(x542&(x543/x544)));
if (t126 != 0) { NG(); } else { ; }
}
void f127(void) {
uint64_t x546 = 479774856LLU;
uint8_t x547 = 6U;
int8_t x548 = 3;
volatile int32_t t127 = 3;
t127 = (x545<=(x546&(x547/x548)));
if (t127 != 0) { NG(); } else { ; }
}
void f128(void) {
static uint8_t x553 = UINT8_MAX;
static int32_t x554 = -1;
uint32_t x556 = UINT32_MAX;
int32_t t128 = 487;
t128 = (x553<=(x554&(x555/x556)));
if (t128 != 0) { NG(); } else { ; }
}
void f129(void) {
uint8_t x558 = 0U;
uint32_t x559 = UINT32_MAX;
int64_t x560 = 26192596LL;
int32_t t129 = 328;
t129 = (x557<=(x558&(x559/x560)));
if (t129 != 0) { NG(); } else { ; }
}
void f130(void) {
static int64_t x562 = INT64_MIN;
int8_t x563 = INT8_MIN;
static uint8_t x564 = 43U;
volatile int32_t t130 = -143;
t130 = (x561<=(x562&(x563/x564)));
if (t130 != 0) { NG(); } else { ; }
}
void f131(void) {
int64_t x565 = -5807809061530845LL;
int64_t x566 = INT64_MIN;
volatile int16_t x567 = INT16_MIN;
int16_t x568 = -36;
t131 = (x565<=(x566&(x567/x568)));
if (t131 != 1) { NG(); } else { ; }
}
void f132(void) {
static int64_t x569 = INT64_MIN;
uint16_t x570 = UINT16_MAX;
volatile int16_t x571 = -1;
int16_t x572 = -5;
t132 = (x569<=(x570&(x571/x572)));
if (t132 != 1) { NG(); } else { ; }
}
void f133(void) {
volatile int64_t x573 = INT64_MIN;
uint16_t x574 = 3728U;
int16_t x575 = -1;
uint8_t x576 = 30U;
t133 = (x573<=(x574&(x575/x576)));
if (t133 != 1) { NG(); } else { ; }
}
void f134(void) {
int8_t x577 = INT8_MAX;
int32_t x578 = 4034239;
uint64_t x580 = 958LLU;
int32_t t134 = -120749534;
t134 = (x577<=(x578&(x579/x580)));
if (t134 != 1) { NG(); } else { ; }
}
void f135(void) {
int16_t x581 = INT16_MIN;
volatile int64_t x583 = INT64_MIN;
int32_t x584 = 1035038415;
int32_t t135 = 19;
t135 = (x581<=(x582&(x583/x584)));
if (t135 != 1) { NG(); } else { ; }
}
void f136(void) {
static int8_t x589 = 1;
static int64_t x590 = INT64_MIN;
int32_t t136 = -441760;
t136 = (x589<=(x590&(x591/x592)));
if (t136 != 0) { NG(); } else { ; }
}
void f137(void) {
int64_t x593 = 15206085LL;
volatile uint64_t x594 = UINT64_MAX;
int8_t x595 = 10;
int64_t x596 = -1LL;
int32_t t137 = -6;
t137 = (x593<=(x594&(x595/x596)));
if (t137 != 1) { NG(); } else { ; }
}
void f138(void) {
int8_t x597 = INT8_MIN;
int64_t x599 = INT64_MAX;
static uint64_t x600 = UINT64_MAX;
int32_t t138 = 4;
t138 = (x597<=(x598&(x599/x600)));
if (t138 != 0) { NG(); } else { ; }
}
void f139(void) {
int32_t x601 = INT32_MIN;
int16_t x602 = INT16_MAX;
uint64_t x603 = 15LLU;
t139 = (x601<=(x602&(x603/x604)));
if (t139 != 0) { NG(); } else { ; }
}
void f140(void) {
static uint32_t x605 = 50150U;
static int8_t x606 = 1;
uint64_t x607 = UINT64_MAX;
static uint16_t x608 = 24U;
volatile int32_t t140 = 34553;
t140 = (x605<=(x606&(x607/x608)));
if (t140 != 0) { NG(); } else { ; }
}
void f141(void) {
int32_t x609 = -1;
int64_t x610 = 239677543228330LL;
static volatile int8_t x612 = INT8_MIN;
volatile int32_t t141 = 1473;
t141 = (x609<=(x610&(x611/x612)));
if (t141 != 1) { NG(); } else { ; }
}
void f142(void) {
int8_t x613 = INT8_MIN;
volatile int8_t x614 = 1;
int8_t x616 = -1;
int32_t t142 = -371993;
t142 = (x613<=(x614&(x615/x616)));
if (t142 != 1) { NG(); } else { ; }
}
void f143(void) {
volatile int64_t x617 = -11951707LL;
uint64_t x618 = UINT64_MAX;
static uint64_t x619 = UINT64_MAX;
int8_t x620 = -7;
volatile int32_t t143 = -433369592;
t143 = (x617<=(x618&(x619/x620)));
if (t143 != 0) { NG(); } else { ; }
}
void f144(void) {
static int16_t x621 = -1;
int32_t x622 = INT32_MIN;
volatile int32_t t144 = 173;
t144 = (x621<=(x622&(x623/x624)));
if (t144 != 1) { NG(); } else { ; }
}
void f145(void) {
int8_t x625 = INT8_MIN;
static volatile int32_t x626 = -294680;
static uint16_t x627 = 36U;
static int32_t t145 = 15970;
t145 = (x625<=(x626&(x627/x628)));
if (t145 != 1) { NG(); } else { ; }
}
void f146(void) {
uint32_t x629 = 6136624U;
volatile int16_t x631 = INT16_MIN;
int8_t x632 = 23;
volatile int32_t t146 = 230761;
t146 = (x629<=(x630&(x631/x632)));
if (t146 != 0) { NG(); } else { ; }
}
void f147(void) {
static uint8_t x633 = 48U;
volatile int64_t x634 = INT64_MIN;
int64_t x635 = -4017720897LL;
int32_t x636 = -1;
static int32_t t147 = 25387;
t147 = (x633<=(x634&(x635/x636)));
if (t147 != 0) { NG(); } else { ; }
}
void f148(void) {
int32_t x637 = -5;
static int16_t x639 = INT16_MIN;
t148 = (x637<=(x638&(x639/x640)));
if (t148 != 1) { NG(); } else { ; }
}
void f149(void) {
static int8_t x641 = INT8_MIN;
uint16_t x642 = 59U;
int64_t x643 = INT64_MIN;
uint32_t x644 = UINT32_MAX;
int32_t t149 = -903316712;
t149 = (x641<=(x642&(x643/x644)));
if (t149 != 1) { NG(); } else { ; }
}
void f150(void) {
uint64_t x645 = 5272198556182LLU;
uint64_t x646 = 5726767645LLU;
volatile int32_t x647 = 0;
int32_t t150 = -18396;
t150 = (x645<=(x646&(x647/x648)));
if (t150 != 0) { NG(); } else { ; }
}
void f151(void) {
uint8_t x649 = 18U;
volatile int8_t x650 = -1;
volatile int64_t x651 = 844585390822823LL;
int32_t t151 = -95606301;
t151 = (x649<=(x650&(x651/x652)));
if (t151 != 1) { NG(); } else { ; }
}
void f152(void) {
int64_t x653 = 1LL;
int64_t x654 = -1LL;
static int64_t x656 = 93583199991668857LL;
t152 = (x653<=(x654&(x655/x656)));
if (t152 != 1) { NG(); } else { ; }
}
void f153(void) {
int64_t x658 = INT64_MIN;
uint64_t x659 = 31481LLU;
volatile int64_t x660 = -55648LL;
volatile int32_t t153 = 470854212;
t153 = (x657<=(x658&(x659/x660)));
if (t153 != 0) { NG(); } else { ; }
}
void f154(void) {
uint64_t x661 = 2806285309LLU;
volatile uint16_t x663 = 4386U;
uint16_t x664 = 55U;
static volatile int32_t t154 = 4729;
t154 = (x661<=(x662&(x663/x664)));
if (t154 != 0) { NG(); } else { ; }
}
void f155(void) {
int32_t x665 = -438;
static int32_t x667 = INT32_MIN;
static uint16_t x668 = 394U;
t155 = (x665<=(x666&(x667/x668)));
if (t155 != 1) { NG(); } else { ; }
}
void f156(void) {
int8_t x669 = -1;
static uint16_t x670 = UINT16_MAX;
uint32_t x671 = 2705U;
static int8_t x672 = 1;
volatile int32_t t156 = 10;
t156 = (x669<=(x670&(x671/x672)));
if (t156 != 0) { NG(); } else { ; }
}
void f157(void) {
int8_t x673 = INT8_MIN;
volatile int32_t x674 = INT32_MIN;
uint16_t x676 = 29U;
int32_t t157 = 19;
t157 = (x673<=(x674&(x675/x676)));
if (t157 != 1) { NG(); } else { ; }
}
void f158(void) {
uint8_t x677 = UINT8_MAX;
volatile int32_t x678 = 710142123;
volatile int8_t x679 = INT8_MAX;
static uint32_t x680 = 793887078U;
int32_t t158 = 5;
t158 = (x677<=(x678&(x679/x680)));
if (t158 != 0) { NG(); } else { ; }
}
void f159(void) {
int64_t x681 = INT64_MAX;
static int64_t x683 = INT64_MAX;
static uint64_t x684 = UINT64_MAX;
volatile int32_t t159 = -2789750;
t159 = (x681<=(x682&(x683/x684)));
if (t159 != 0) { NG(); } else { ; }
}
void f160(void) {
int32_t x687 = -59;
uint64_t x688 = 7553817118920283LLU;
int32_t t160 = -547128;
t160 = (x685<=(x686&(x687/x688)));
if (t160 != 0) { NG(); } else { ; }
}
void f161(void) {
static volatile int8_t x689 = 25;
static int64_t x691 = -1LL;
int64_t x692 = INT64_MAX;
static int32_t t161 = 286;
t161 = (x689<=(x690&(x691/x692)));
if (t161 != 0) { NG(); } else { ; }
}
void f162(void) {
int8_t x693 = INT8_MAX;
int16_t x694 = -1;
int64_t x696 = -1LL;
volatile int32_t t162 = 21619087;
t162 = (x693<=(x694&(x695/x696)));
if (t162 != 0) { NG(); } else { ; }
}
void f163(void) {
static uint16_t x697 = 1946U;
uint8_t x698 = 0U;
uint16_t x699 = 129U;
int64_t x700 = INT64_MAX;
int32_t t163 = 684611425;
t163 = (x697<=(x698&(x699/x700)));
if (t163 != 0) { NG(); } else { ; }
}
void f164(void) {
uint32_t x701 = 3694843U;
uint8_t x702 = 3U;
int32_t x703 = INT32_MAX;
int32_t x704 = -1;
int32_t t164 = -9612871;
t164 = (x701<=(x702&(x703/x704)));
if (t164 != 0) { NG(); } else { ; }
}
void f165(void) {
volatile uint64_t x705 = 560LLU;
static uint8_t x706 = 17U;
static int64_t x708 = INT64_MAX;
static int32_t t165 = -20246;
t165 = (x705<=(x706&(x707/x708)));
if (t165 != 0) { NG(); } else { ; }
}
void f166(void) {
int8_t x709 = -1;
uint32_t x711 = 1594797436U;
uint16_t x712 = UINT16_MAX;
volatile int32_t t166 = -17;
t166 = (x709<=(x710&(x711/x712)));
if (t166 != 0) { NG(); } else { ; }
}
void f167(void) {
int8_t x714 = INT8_MIN;
int32_t x715 = INT32_MAX;
t167 = (x713<=(x714&(x715/x716)));
if (t167 != 0) { NG(); } else { ; }
}
void f168(void) {
int32_t x717 = INT32_MAX;
int32_t x718 = INT32_MIN;
int64_t x720 = INT64_MIN;
volatile int32_t t168 = 37340733;
t168 = (x717<=(x718&(x719/x720)));
if (t168 != 0) { NG(); } else { ; }
}
void f169(void) {
int64_t x723 = INT64_MAX;
t169 = (x721<=(x722&(x723/x724)));
if (t169 != 0) { NG(); } else { ; }
}
void f170(void) {
int64_t x725 = 3164LL;
volatile int8_t x726 = INT8_MIN;
static int8_t x727 = INT8_MIN;
uint16_t x728 = 353U;
volatile int32_t t170 = 26;
t170 = (x725<=(x726&(x727/x728)));
if (t170 != 0) { NG(); } else { ; }
}
void f171(void) {
volatile int16_t x729 = INT16_MIN;
int8_t x730 = INT8_MIN;
volatile uint16_t x732 = 5U;
static volatile int32_t t171 = -426;
t171 = (x729<=(x730&(x731/x732)));
if (t171 != 1) { NG(); } else { ; }
}
void f172(void) {
int32_t x733 = -14;
uint8_t x734 = UINT8_MAX;
volatile int64_t x735 = INT64_MAX;
static volatile int64_t x736 = -31633962100659LL;
volatile int32_t t172 = 1575277;
t172 = (x733<=(x734&(x735/x736)));
if (t172 != 1) { NG(); } else { ; }
}
void f173(void) {
volatile uint64_t x737 = UINT64_MAX;
uint32_t x738 = 219686U;
uint64_t x739 = UINT64_MAX;
t173 = (x737<=(x738&(x739/x740)));
if (t173 != 0) { NG(); } else { ; }
}
void f174(void) {
int32_t t174 = -851;
t174 = (x741<=(x742&(x743/x744)));
if (t174 != 0) { NG(); } else { ; }
}
void f175(void) {
uint16_t x745 = 696U;
int16_t x746 = INT16_MAX;
int16_t x747 = 9371;
volatile int32_t t175 = -698;
t175 = (x745<=(x746&(x747/x748)));
if (t175 != 0) { NG(); } else { ; }
}
void f176(void) {
uint16_t x749 = UINT16_MAX;
volatile uint64_t x750 = 57745413734373LLU;
uint32_t x751 = 1U;
static int64_t x752 = 180637659LL;
volatile int32_t t176 = 38;
t176 = (x749<=(x750&(x751/x752)));
if (t176 != 0) { NG(); } else { ; }
}
void f177(void) {
int32_t x753 = -1;
volatile int32_t x755 = INT32_MAX;
int32_t x756 = INT32_MAX;
int32_t t177 = 0;
t177 = (x753<=(x754&(x755/x756)));
if (t177 != 1) { NG(); } else { ; }
}
void f178(void) {
int16_t x758 = -1;
int8_t x760 = INT8_MAX;
int32_t t178 = -27425;
t178 = (x757<=(x758&(x759/x760)));
if (t178 != 1) { NG(); } else { ; }
}
void f179(void) {
static volatile int32_t x761 = INT32_MIN;
static uint8_t x763 = 9U;
static int64_t x764 = -1LL;
t179 = (x761<=(x762&(x763/x764)));
if (t179 != 1) { NG(); } else { ; }
}
void f180(void) {
int32_t x765 = -1;
volatile int8_t x766 = -1;
int64_t x767 = -1LL;
uint16_t x768 = 18U;
t180 = (x765<=(x766&(x767/x768)));
if (t180 != 1) { NG(); } else { ; }
}
void f181(void) {
int16_t x769 = -1;
uint8_t x770 = UINT8_MAX;
uint8_t x771 = 22U;
static uint16_t x772 = 69U;
int32_t t181 = -1399096;
t181 = (x769<=(x770&(x771/x772)));
if (t181 != 1) { NG(); } else { ; }
}
void f182(void) {
int64_t x773 = -17LL;
uint16_t x774 = UINT16_MAX;
static volatile uint8_t x775 = 106U;
int32_t x776 = INT32_MIN;
volatile int32_t t182 = 7;
t182 = (x773<=(x774&(x775/x776)));
if (t182 != 1) { NG(); } else { ; }
}
void f183(void) {
static int64_t x777 = INT64_MAX;
static volatile uint8_t x778 = 72U;
volatile uint8_t x779 = UINT8_MAX;
int32_t x780 = -1;
static volatile int32_t t183 = -630;
t183 = (x777<=(x778&(x779/x780)));
if (t183 != 0) { NG(); } else { ; }
}
void f184(void) {
volatile int8_t x781 = INT8_MAX;
int16_t x782 = -1;
uint16_t x783 = 1U;
uint16_t x784 = 15U;
static volatile int32_t t184 = 56295;
t184 = (x781<=(x782&(x783/x784)));
if (t184 != 0) { NG(); } else { ; }
}
void f185(void) {
volatile uint16_t x785 = 66U;
int64_t x786 = INT64_MIN;
int32_t x787 = INT32_MIN;
int32_t x788 = INT32_MIN;
int32_t t185 = 82206;
t185 = (x785<=(x786&(x787/x788)));
if (t185 != 0) { NG(); } else { ; }
}
void f186(void) {
int16_t x789 = -1;
int64_t x791 = INT64_MIN;
static int32_t t186 = 54756224;
t186 = (x789<=(x790&(x791/x792)));
if (t186 != 0) { NG(); } else { ; }
}
void f187(void) {
static int8_t x793 = 41;
int16_t x794 = INT16_MIN;
uint8_t x796 = 48U;
int32_t t187 = 1;
t187 = (x793<=(x794&(x795/x796)));
if (t187 != 1) { NG(); } else { ; }
}
void f188(void) {
static volatile uint8_t x797 = 24U;
int32_t x798 = INT32_MAX;
int8_t x799 = -1;
int32_t x800 = -1;
t188 = (x797<=(x798&(x799/x800)));
if (t188 != 0) { NG(); } else { ; }
}
void f189(void) {
static int16_t x801 = 8;
uint64_t x802 = 36LLU;
uint64_t x803 = 4285670011771630LLU;
static int32_t x804 = INT32_MIN;
t189 = (x801<=(x802&(x803/x804)));
if (t189 != 0) { NG(); } else { ; }
}
void f190(void) {
uint8_t x808 = 30U;
int32_t t190 = -620113059;
t190 = (x805<=(x806&(x807/x808)));
if (t190 != 0) { NG(); } else { ; }
}
void f191(void) {
volatile uint32_t x809 = 296815841U;
static int8_t x810 = INT8_MAX;
static volatile uint8_t x811 = 29U;
int64_t x812 = INT64_MIN;
volatile int32_t t191 = -243;
t191 = (x809<=(x810&(x811/x812)));
if (t191 != 0) { NG(); } else { ; }
}
void f192(void) {
volatile int16_t x814 = 26;
uint32_t x815 = 790076974U;
static int64_t x816 = INT64_MAX;
volatile int32_t t192 = 101418;
t192 = (x813<=(x814&(x815/x816)));
if (t192 != 1) { NG(); } else { ; }
}
void f193(void) {
static uint32_t x817 = 1011U;
static uint16_t x818 = 129U;
int16_t x819 = 0;
static uint8_t x820 = 7U;
t193 = (x817<=(x818&(x819/x820)));
if (t193 != 0) { NG(); } else { ; }
}
void f194(void) {
int16_t x821 = -4462;
static int64_t x822 = INT64_MIN;
static volatile int16_t x823 = INT16_MIN;
int64_t x824 = INT64_MAX;
static volatile int32_t t194 = 6070274;
t194 = (x821<=(x822&(x823/x824)));
if (t194 != 1) { NG(); } else { ; }
}
void f195(void) {
int32_t x825 = INT32_MAX;
int64_t x828 = INT64_MIN;
int32_t t195 = -7;
t195 = (x825<=(x826&(x827/x828)));
if (t195 != 0) { NG(); } else { ; }
}
void f196(void) {
uint64_t x829 = 96LLU;
uint16_t x830 = 0U;
int8_t x831 = -1;
int64_t x832 = -1LL;
static volatile int32_t t196 = 7604;
t196 = (x829<=(x830&(x831/x832)));
if (t196 != 0) { NG(); } else { ; }
}
void f197(void) {
uint32_t x833 = 77U;
static int64_t x834 = INT64_MAX;
uint16_t x835 = UINT16_MAX;
int8_t x836 = INT8_MAX;
volatile int32_t t197 = -1424654;
t197 = (x833<=(x834&(x835/x836)));
if (t197 != 1) { NG(); } else { ; }
}
void f198(void) {
static int32_t x837 = -208258;
int64_t x840 = 65LL;
int32_t t198 = 241534;
t198 = (x837<=(x838&(x839/x840)));
if (t198 != 0) { NG(); } else { ; }
}
void f199(void) {
uint32_t x841 = UINT32_MAX;
uint16_t x844 = UINT16_MAX;
volatile int32_t t199 = 3;
t199 = (x841<=(x842&(x843/x844)));
if (t199 != 0) { NG(); } else { ; }
}
int main(void) {
f0();
f1();
f2();
f3();
f4();
f5();
f6();
f7();
f8();
f9();
f10();
f11();
f12();
f13();
f14();
f15();
f16();
f17();
f18();
f19();
f20();
f21();
f22();
f23();
f24();
f25();
f26();
f27();
f28();
f29();
f30();
f31();
f32();
f33();
f34();
f35();
f36();
f37();
f38();
f39();
f40();
f41();
f42();
f43();
f44();
f45();
f46();
f47();
f48();
f49();
f50();
f51();
f52();
f53();
f54();
f55();
f56();
f57();
f58();
f59();
f60();
f61();
f62();
f63();
f64();
f65();
f66();
f67();
f68();
f69();
f70();
f71();
f72();
f73();
f74();
f75();
f76();
f77();
f78();
f79();
f80();
f81();
f82();
f83();
f84();
f85();
f86();
f87();
f88();
f89();
f90();
f91();
f92();
f93();
f94();
f95();
f96();
f97();
f98();
f99();
f100();
f101();
f102();
f103();
f104();
f105();
f106();
f107();
f108();
f109();
f110();
f111();
f112();
f113();
f114();
f115();
f116();
f117();
f118();
f119();
f120();
f121();
f122();
f123();
f124();
f125();
f126();
f127();
f128();
f129();
f130();
f131();
f132();
f133();
f134();
f135();
f136();
f137();
f138();
f139();
f140();
f141();
f142();
f143();
f144();
f145();
f146();
f147();
f148();
f149();
f150();
f151();
f152();
f153();
f154();
f155();
f156();
f157();
f158();
f159();
f160();
f161();
f162();
f163();
f164();
f165();
f166();
f167();
f168();
f169();
f170();
f171();
f172();
f173();
f174();
f175();
f176();
f177();
f178();
f179();
f180();
f181();
f182();
f183();
f184();
f185();
f186();
f187();
f188();
f189();
f190();
f191();
f192();
f193();
f194();
f195();
f196();
f197();
f198();
f199();
return 0;
}
|
ade45a8e495ea7ac312b48034668f855ebff3927 | d60621521bd22327b070ed9a6a4428eb4515db34 | /Graphics/animal3D-SDK/animal3D-SDK/source/animal3D-DemoPlugin/A3_DEMO/_a3_demo_utilities/_src/animation/a3_Kinematics.c | e6f0f40a7a0b9f5f525992e2690a9ac12bf1ccb4 | [
"Apache-2.0"
] | permissive | Bcoop098/Portfolio | a75126422ab20d24717a4e9e39b01a8b3a8d0150 | b0774cddaa5f308b5bf0f3eec76005dd62348783 | refs/heads/master | 2023-01-06T03:12:15.442278 | 2022-12-22T18:08:19 | 2022-12-22T18:08:19 | 241,497,263 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,013 | c | a3_Kinematics.c | /*
Copyright 2011-2019 Daniel S. Buckstein
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/*
animal3D SDK: Minimal 3D Animation Framework
By Daniel S. Buckstein
a3_Kinematics.c
Implementation of kinematics solvers.
*/
#include "../../animation/a3_Kinematics.h"
//-----------------------------------------------------------------------------
// FK solver
extern inline a3i32 a3kinematicsSolveForward(const a3_HierarchyState *hierarchyState)
{
return a3kinematicsSolveForwardPartial(hierarchyState, 0, hierarchyState->poseGroup->hierarchy->numNodes);
}
// partial FK solver
extern inline a3i32 a3kinematicsSolveForwardPartial(const a3_HierarchyState* hierarchyState, const a3ui32 firstIndex, const a3ui32 nodeCount)
{
if (hierarchyState && hierarchyState->poseGroup &&
firstIndex < hierarchyState->poseGroup->hierarchy->numNodes && nodeCount)
{
a3i32 parentIndex;
a3ui32 i, end = firstIndex + nodeCount;
end = a3minimum(end, hierarchyState->poseGroup->hierarchy->numNodes);
for (i = firstIndex; i < end; ++i)
{
parentIndex = hierarchyState->poseGroup->hierarchy->nodes[i].parentIndex;
if (parentIndex != -1)
{
a3real4x4Product(hierarchyState->objectSpace->transform[i].m, hierarchyState->objectSpace->transform[parentIndex].m,
hierarchyState->localSpace->transform[i].m);
}
else
{
hierarchyState->objectSpace->transform[i] = hierarchyState->localSpace->transform[i];
}
}
// done, return number of nodes updated
return (end - firstIndex);
}
return -1;
}
//-----------------------------------------------------------------------------
// IK solver
extern inline a3i32 a3kinematicsSolveInverse(const a3_HierarchyState *hierarchyState)
{
return a3kinematicsSolveInversePartial(hierarchyState, 0, hierarchyState->poseGroup->hierarchy->numNodes);
}
// partial IK solver
extern inline a3i32 a3kinematicsSolveInversePartial(const a3_HierarchyState *hierarchyState, const a3ui32 firstIndex, const a3ui32 nodeCount)
{
if (hierarchyState && hierarchyState->poseGroup &&
firstIndex < hierarchyState->poseGroup->hierarchy->numNodes && nodeCount)
{
// a3i32 parentIndex;
a3ui32 i, end = firstIndex + nodeCount;
end = a3minimum(end, hierarchyState->poseGroup->hierarchy->numNodes);
for (i = firstIndex; i < end; ++i)
{
// ****TO-DO: implement inverse kinematics algorithm
}
// done, return number of nodes updated
return (end - firstIndex);
}
return -1;
}
//-----------------------------------------------------------------------------
|
818b6a8ffebeeaddff2113056912405f1a61fa42 | 22814ef40b6a8ec624e93a08c2cb016e61926795 | /LISTA 2/Exercicio_5.c | 4718c0e5e63edd633b1e94d51c93dcbc92646b44 | [] | no_license | Nicolaiko/exercisesC | 4e3fa42f71bf5f752934f43c9f31d55afe44543a | 069f41250e51dcc892b26a0410bfe8547d817191 | refs/heads/master | 2021-08-22T22:21:42.612202 | 2017-12-01T13:13:49 | 2017-12-01T13:13:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 791 | c | Exercicio_5.c | #include <stdio.h>
void main() {
int nota1, nota2, opt;
float media;
media = 0;
nota1 = 0;
nota2 = 0;
opt = 0;
printf("Escreva a nota da sua primeira avaliacao:\n");
scanf("%d",¬a1);
printf("Escreva a nota da sua segunda avaliacao:\n");
scanf("%d",¬a2);
printf("Escreva a nota da sua avaliacao optativa. Caso nao exista, insira um valor negativo:\n");
scanf("%d",&opt);
if (opt>=0) {
if (nota1<nota2) {
nota1 = opt;
} else if (nota2<nota1) {
nota2 = opt;
} else {
nota2 = nota1;
}
}
media = ((float)nota1+(float)nota2)/2;
printf("Sua media final: %.1f ---",media);
if (media>=70) {
printf(" APROVADO\n");
} else if ((media<70) && (media>=50)) {
printf(" EXAME\n");
} else {
printf(" REPROVADO\n");
}
}
|
d3b0fc93f0e08ab9a436c7804c754de2306221fa | 6290bb622e77dd32035787b15eebddfa9191bcac | /lab3/htable.c | 67a9d1fb3b14f08afd9fdf569837b31edaa57865 | [] | no_license | lnlawson/cpe357 | f6c84d1b85ad6d73307640727b38be6c7e12d7de | c1748bb6d3fcced50d659e5c6647a3852b379458 | refs/heads/master | 2020-03-08T16:50:16.923299 | 2018-05-14T20:37:18 | 2018-05-14T20:37:18 | 128,251,841 | 0 | 2 | null | null | null | null | UTF-8 | C | false | false | 8,092 | c | htable.c | #include <stdio.h>
#include <stdlib.h>
#include "htable.h"
int main(int argc, char **argv){
FILE *file = NULL;
int countVal = 0;
int *count = &countVal;
treeNode **treeList = NULL;
char **codeTable = NULL;
initTable();
if (NULL == (file = fopen(argv[1], "r"))){
perror(argv[1]);
}
else{
fillTable(file);
treeList = buildList(treeList, count);
qsort(treeList, *count, sizeof(treeNode*), compFunction1);
// for (int i = 0; i < *count; i++){
// // printf("table[%d] : occur %d character %c\n", i, treeList[i]->val, treeList[i]->character);
// }
treeList = buildTree(treeList, count);
codeTable = encodeTable(treeList[0]);
}
// for (int i = 0; i < 1; i++){
// printf("table[%d] : occur %d character %c left %c right %c\n", i, treeList[i]->val, treeList[i]->character,
// treeList[i]->left->character, treeList[i]->right->character);
// }
for (int i = 0; i < 256; i++){
if (codeTable[i] != NULL){
printf("table[%d] : huffVal %s character %c\n", i, codeTable[i], i);
}
}
fclose(file);
//FreeTable(table, 127);
}
//Function for initializing the whole table to 0s
void initTable(void){
for (int i = 0; i < 256; i++){
table[i] = 0;
}
}
void fillTable(FILE *file){
int temp = getc(file);
while (temp != EOF){
if (temp < 0 || temp > 255){
temp = getc(file);
continue;
}
table[temp] += 1;
temp = getc(file);
}
}
treeNode **buildList(treeNode **list, int *count){
// int count = 0;
int buffSize = 40;
treeNode **treeList = list;
treeNode *tempNode = NULL;
if( NULL==(treeList=realloc(treeList, buffSize * sizeof(treeNode*))) ) {
perror(__FUNCTION__);
exit(-1);
}
for (int i = 0; i < 256; ++i){
if (table[i] > 0){
if( NULL==(tempNode=malloc(sizeof(treeNode))) ) {
perror(__FUNCTION__);
exit(-1);
}
treeList[*count] = tempNode;
treeList[*count]->character = (char)i;
treeList[*count]->val = table[i];
treeList[*count]->left = NULL;
treeList[*count]->right = NULL;
*count += 1;
if ((*count) == buffSize){
buffSize *=2;
if( NULL==(treeList=realloc(treeList, buffSize * sizeof(treeNode*))) ) {
perror(__FUNCTION__);
exit(-1);
}
}
}
}
if( NULL==(treeList=realloc(treeList, *count * sizeof(treeNode*))) ) {
perror(__FUNCTION__);
exit(-1);
}
return treeList;
}
treeNode **buildTree(treeNode **list, int *count){
treeNode **treeList = list;
int tempCount = *count;
// printf("%d\n", tempCount);
treeNode *tempNode = NULL;
treeNode *tempA = NULL;
treeNode *tempB = NULL;
char topChar;
// int sum;
while (tempCount > 1){
tempA = treeList[0];
tempB = treeList[1];
if( NULL==(tempNode=malloc(sizeof(treeNode))) ) {
perror(__FUNCTION__);
exit(-1);
}
tempNode->val = (tempA->val + tempB->val);
// printf("sum: %d\n", tempNode->val);
if ((tempA->character - tempB->character) < 0){
topChar = tempA->character;
} else { topChar = tempB->character;}
tempNode->character = topChar;
tempNode->left = tempA;
tempNode->right = tempB;
tempCount -= 1;
treeList[0] = tempNode;
treeList[1] = NULL;
qsort(treeList, *count, sizeof(treeNode*), compFunction2);
// for (int i = 0; i < tempCount; i++){
// printf("table[%d] : occur %d character %c\n", i, treeList[i]->val, treeList[i]->character);
// }
// printf("\n");
// printf("%d\n", tempCount);
}
treeList = realloc(treeList, tempCount * sizeof(treeNode*));
return treeList;
}
char **encodeTable(treeNode *list){
char **codeTable = calloc( 256, sizeof(char*));
for (int i = 0; i < 256; ++i){
if (table[i] > 0){
codeTable[i] = malloc(256 * sizeof(char*));
codeTable[i] = getPath(list, i, codeTable[i], 0);
printf("0x%02x: %s\n", i, codeTable[i]);
} else {
codeTable[i] = NULL;
}
}
return codeTable;
}
char *getPath(treeNode *node, char character, char *path, int index){
char *p;
if (node->character == character && node->left == NULL && node->right == NULL){
path[index] = '\0';
return path;
}
if (node->left != NULL){
path[index] = '0';
p = getPath(node->left, character, path, index + 1);
if (p != NULL){
return p;
}
}
path[index] = '1';
if (node->right != NULL) {
return getPath(node->right, character, path, index + 1);
}
return NULL;
}
int compFunction1(const void *a, const void *b){
int result;
treeNode *A = (*(treeNode **)a);
treeNode *B = (*(treeNode **)b);
if (A == NULL && B == NULL){
return 0;
} else if (A != NULL && B == NULL){
return -1;
} else if (A == NULL && B != NULL){
return 1;
}
//printf("A: %d\n",A->occur);
//printf("B: %d\n",B->occur);
if (B->val == A->val){
result = A->character - B->character;
// result = -1;
} else{result = (A->val - B->val);}
return result;
}
int compFunction2(const void *a, const void *b){
int result;
treeNode *A = (*(treeNode **)a);
treeNode *B = (*(treeNode **)b);
if (A == NULL && B == NULL){
return 0;
} else if (A != NULL && B == NULL){
return -1;
} else if (A == NULL && B != NULL){
return 1;
}
//printf("A: %d\n",A->occur);
//printf("B: %d\n",B->occur);
if (B->val == A->val){
// result = A->character - B->character;
result = -1;
} else{result = (A->val - B->val);}
return result;
}
// aaaabbbbccddiiLLk
//////////////////////////////////LINKED LIST/////////////////////////////////
/*Item *createItem(int val, int occur){
Item *new_i = malloc(sizeof(Item*));
(new_i)->val = val;
(new_i)->occur = occur;
return new_i;
}*/
/////////////////////////////////FROM STATIC TABLE IMPLEMENTATION
/*int main(int argc, char **argv){
FILE *file = NULL;
List *list = NULL;
initTable();
if (NULL == (file = fopen(argv[1], "r"))){
perror(argv[1]);
}
else{
fillTable(file);
}
for (int i = 0; i < 127; i++){
printf("table[%d] : %d\n", i, table[i]);
}
list = buildLList(list);
Node *temp = list->head;
Item *tempi = NULL;
while (temp->next != NULL){
tempi = (Item*)temp->item;
printf("val: %d, occur: %d\n", tempi->val, tempi->occur);
temp = temp->next;
}
fclose(file);
//FreeTable(table, 127);
}*/
/*List *buildLList(List *list){
for (int i = 0; i < 127; i++){
if(table[i] != 0){
list = insertNode(list, createItem(i, table[i]));
}
}
return list;
}*/
/*List *insertNode(List *list, Item *item){
Node *curr = NULL;
Node *new_n = malloc(sizeof(Node*));
new_n->item = item;
new_n->next = NULL;
if (list == NULL){
list->head = new_n;
}
else{
curr = list->head;
while (curr->next != NULL){
if(((curr->next)->item)->occur > item->occur){
new_n->next = curr->next;
curr->next = new_n;
}
curr = curr->next;
}
}
return list;
}*/
/*int Comparator(const void *p, const void *q){
return (int)(*p) - (int)(*q);
}*/
/*int Comparator(const void *a, const void *b){
int result;
if (a == NULL && b == NULL){
return 0;
} else if (a != NULL && b == NULL){
return -1;
} else if (a == NULL && b != NULL){
return 1;
}
TableItem *A = (*(TableItem **)a);
TableItem *B = (*(TableItem **)b);
//printf("A: %d\n",A->occur);
//printf("B: %d\n",B->occur);
if (B->occur == A->occur){
result = B->val - -A->val ;
}
else{result = (B->occur - A->occur);}
return result;
}
//Function for filling the table with letter occurences
void fillTable(FILE *file, TableItem **table){
table = (TableItem**)(calloc(127, sizeof(TableItem*)));
if(table == NULL){
printf("Failed Calloc in fillTable\n");
perror(__FUNCTION__);
exit(-1);
}
temp = getc(file);
while (temp != EOF){
if (table[int(temp)] != NULL){
table[(int)temp]->occur += 1;
}
else{
createItem(table, int(temp));
}
temp = getc(file);
}
}
void createItem(Tableitem **table, int val){
table[val] = malloc(sizeof(TableItem));
if (table[val] == NULL){
printf("Failed Malloc in createItem\n");
perror(__FUNCTION__);
exit(-1);
}
else{
(table[val])->val = val;
(table[val])->occur = 1;
return;
}
}
void FreeTable(TableItem **table, int size){
for (int i = 0; i < size; i++){
free(table[i]);
}
}
*/
|
963085282006dab1990d8a0526436f5234bde293 | 7aee658d7aa851a310d30ae9445649e6e4b61c34 | /include/bitarray.h | a7423a05731704496fab7493aa46ec187b59f3ad | [] | no_license | caron1211/Data-structures-in-c | 32de896f953b7db2df2872ac05724826ba3c9ac1 | c089cfc4ed39d73ac820dffeca5ac87bcffc45fa | refs/heads/main | 2023-08-11T07:38:27.195615 | 2021-10-02T18:23:03 | 2021-10-02T18:23:03 | 412,878,764 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 5,260 | h | bitarray.h | #ifndef __BITARRAY_H__
#define __BITARRAY_H__
#include <stddef.h>/*size_t*/
typedef size_t bitarray_t;
typedef enum {
BIT_OFF = 0,
BIT_ON = 1
} bitstate_t;
/*Description: The function set 'on' the bit in position of bit_index.
@params: The function gets bit_index needs to be between 0 and 63 (included)
and bitarray.
@return: The function return bitarray_t that bit_index is on.
@errors: No errors.
*/
bitarray_t BitArrSetBitOn(bitarray_t bitarray, size_t bit_index);
/*Description: The function set 'off' the bit in position of bit_index.
@params: The function gets bit_index needs to be between 0 and 63 (included)
and bitarray.
@return: The function returns bitarray_t that bit_index is on.
@errors: No errors.
*/
bitarray_t BitArrSetBitOff(bitarray_t bitarray, size_t bit_index);
/*Description: The function set value to bit in position of bit_index.
@params: The function gets bit_index needs to be between 0 and 63 (included)
and set_to is '1' for every value unless its '0' and bitarray_t.
@return: The function returns bitarray_t that bit_index is set to set_to.
@errors: No errors.
*/
bitarray_t BitArrSetBit(bitarray_t bitarray, size_t bit_index, int set_to);
/*Description: The function flip value of bit_index.
@params: The function gets bit_index needs to be between 0 and 63 (included)
and bitarray.
@return: The function returns bitarray_t that bit_index is fliped.
@errors: No errors.
*/
bitarray_t BitArrFlipBit(bitarray_t bitarray, size_t bit_index);
/*Description: check if bit_index is 'on'.
@params: The function gets bit_index needs to be between 0 and 63 (included).
@return: The function returns 1 if the bit_index is on, otherwise return 0.
@errors: No errors.
*/
int BitArrIsBitOn(bitarray_t bitarray, size_t bit_index);
/*Description: check if bit_index is 'off'.
@params: The function gets bit_index needs to be between 0 and 63 (included)
and bitarray.
@return: The function returns 1 if the bit_index is off, otherwise return 0.
@errors: No errors.
*/
int BitArrIsBitOff(bitarray_t bitarray, size_t bit_index);
/*Description: return the bit_state of bitarray_t.
@params: The function gets bit_index needs to be between 0 and 63 (included)
and bitarray.
@return: The function returns the bit_state (BIT_OFF, BIT_ON)of bitarray_t.
@errors: No errors.
*/
bitstate_t BitArrGetBit(bitarray_t bitarray, size_t bit_index);
/*Description: count the number of bits that on.
@params: The function gets bitarray of type bittarray_t.
@return: The function returns the number of bits that on.
@errors: No errors.
*/
size_t BitArrCountBitsOn(bitarray_t bitarray);
/*Description: count the number of bits that off.
@params: The function gets bitarray of type bittarray_t.
@return: The function returns the number of bits that off.
@errors: No errors.
*/
size_t BitArrCountBitsOff(bitarray_t bitarray);
/*Description: set 'on' all bits.
@params: The function gets no params.
@return: The function returns a bitarray that all bits is 'on'.
@errors: No errors.
*/
bitarray_t BitArrSetAll();
/*Description: set 'off' all bits.
@params: The function gets no params.
@return: The function returns a bitarray that all bits is 'off'.
@errors: No errors.
*/
bitarray_t BitArrUnSetAll();
/*Description: The function will return a mirrored bitarray.
@params: The function gets bitarray of type bitarray_t.
@return: The function returns a mirrored bitarray of size_t.
@errors: No errors.
*/
bitarray_t BitArrMirror(bitarray_t bitarray);
/*Description: The function will rotate bitarray n times Right.
@params: The function gets bitarray of type bitarray_t and n of size_t.
@return: The function returns the rotated bitarray of size_t.
@errors: No errors.
*/
bitarray_t BitArrRotateRight(bitarray_t bitarray, size_t n);
/*Description: The function will rotate bitarray n times Left.
@params: The function gets bitarray of type bitarray_t and n of size_t.
@return: The function returns the rotated bitarray of size_t.
@errors: No errors.
*/
bitarray_t BitArrRotateLeft(bitarray_t bitarray, size_t n);
/*Description: The function will sift bitarray n times Right.
@params: The function gets bitarray of type bitarray_t and n of size_t.
@return: The function returns the shifted bitarray of size_t.
@errors: No errors.
*/
bitarray_t BitArrShiftRight(bitarray_t bitarray, size_t n);
/*Description: The function will sift bitarray n times Left.
@params: The function gets bitarray of type bitarray_t and n of size_t.
@return: The function returns the shifted bitarray of size_t.
@errors: No errors.
*/
bitarray_t BitArrShiftLeft(bitarray_t bitarray, size_t n);
/*Description: The function converts the bits content, of bit array into a
string pointed by buffer.
@params: The function gets bitarray of type bittarray_t and buffer of chars.
Size of buffer should be greater then 64.
@return: The function will return the pointer to the beginnig of the string.
@errors: If buffer is not valid, or if it is smaller then target bitarray
length, this function will produce undefined behavior.
*/
char *BitArrArrToString(bitarray_t bitarray, char *buffer);
#endif /* __BITARRAY_H__ */
|
e0c4d15e2f14334aa00b4e85e32826fee8f0cc98 | e25fbe3588fef7505ad7582d69906c8df6103c5f | /examples/ascii/snake_ascii.c | babaace78f5f19efbbbe3aae892270825aae969f | [] | no_license | PYates77/MiniSnake | 8f56b703b45e216f450b3206de26c41539f21fd0 | 4024740554a8bc8c9e3eba1f5e9dfe0f1053c46b | refs/heads/master | 2021-04-27T22:11:22.511810 | 2019-07-19T16:38:11 | 2019-07-19T16:38:11 | 122,414,127 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,928 | c | snake_ascii.c | #include "curses.h"
#include <unistd.h>
#include <time.h>
#include <stdlib.h>
#include "snake.h"
//#define USE_AI
static SnakeGame * game;
int part_at(int x, int y)
{
SnakePart * cur = game->head;
while(1){
if(cur->x == x && cur->y == y) return 1;
if(!cur->next) return 0;
cur = cur->next;
}
}
void process_ai()
{
//check to see which directions are valid
int invalid[4];
invalid[0]= part_at(game->head->x+1,game->head->y); //right
invalid[1]= part_at(game->head->x,game->head->y+1); //up
invalid[2]= part_at(game->head->x-1, game->head->y); //left
invalid[3]= part_at(game->head->x, game->head->y-1); //down
//start by setting the direction to any valid one
int i=0;
while(invalid[game->direction]) {
game->direction = (game->direction+1)%4;
if(++i >= 3) break;
}
if(!invalid[0] && game->head->x < game->mouse.x){
game->direction = 0; //right
}
else if (!invalid[2] && game->head->x > game->mouse.x){
game->direction = 2; //left
}
else if (!invalid[1] && game->head->y < game->mouse.y){
game->direction = 1; //up
}
else if (!invalid[3]) {
game->direction = 3; //down
}
}
int main()
{
int gameWidth = 32;
int gameHeight = 32;
//setup curses
initscr();
start_color();
use_default_colors();
noecho();
keypad(stdscr,TRUE);
curs_set(0);
nodelay(stdscr, TRUE);
leaveok(stdscr, TRUE);
scrollok(stdscr, FALSE);
int use_colors = has_colors();
if(use_colors)
{
init_pair(1, COLOR_RED, COLOR_RED);
init_pair(2, COLOR_WHITE, COLOR_WHITE);
init_pair(3, -1, -1);
}
getmaxyx(stdscr, gameHeight, gameWidth);
printf("Terminal Height: %d, terminal width: %d\n", gameHeight, gameWidth);
//done setting up curses
game = snake_init(gameWidth/2, gameHeight-2);
printf("Game height %d, game width %d\n", game->height, game->width);
//begin display loop
while(1)
{
//clear old pixels before updating and showing new ones
if(use_colors) attron(COLOR_PAIR(3));
mvaddch(game->mouse.y,2*game->mouse.x,' ');
mvaddch(game->mouse.y,2*game->mouse.x+1,' ');
SnakePart * cur = game->head;
while(1)
{
mvaddch(cur->y,2*cur->x,' ');
mvaddch(cur->y,2*cur->x+1,' ');
if(cur->next) cur = cur->next;
else break;
}
if(use_colors) attron(COLOR_PAIR(1));
//get player or ai input
#ifdef USE_AI
process_ai();
#else
int ch = getch();
//NOTE: Up and down are flipped since snake doesn't use 'screen' coordinates
switch(ch){
case KEY_RIGHT:
game->direction = 0;
break;
case KEY_UP:
game->direction = 3;
break;
case KEY_LEFT:
game->direction = 2;
break;
case KEY_DOWN:
game->direction = 1;
break;
}
#endif
// process game tick
snake_tick(game);
// process game events
if(game->gameover)
{
if(use_colors) attron(COLOR_PAIR(3));
char result[50];
sprintf(result, "Game over! Score: %i ", game->score);
mvaddstr(game->height+1,0, result);
}
//draw new new pixels
mvaddch(game->mouse.y,2*game->mouse.x,'<');
mvaddch(game->mouse.y,2*game->mouse.x+1,'>');
if(use_colors) attron(COLOR_PAIR(2));
cur = game->head;
while(1)
{
mvaddch(cur->y,2*cur->x,'[');
mvaddch(cur->y,2*cur->x+1,']');
if(cur->next) cur = cur->next;
else break;
}
getch();
refresh();
usleep(60000);
}
endwin();
return 0;
}
|
bcd9078b05897fa18e4645246b6942496e206360 | 3452196990e227ab40bfcbe0774dd4667b04f2bc | /src/Initialize.c | a10410ece4a488860a14007403c56d2a46b9152b | [] | no_license | 88Fuzz/Worm | 82adfd71cc2f40b968a9ef7bc00148b18a45ba17 | e74b291a40910ea580084d1ead15a1a0bfa5ebf5 | refs/heads/master | 2020-03-27T02:01:32.913345 | 2016-06-06T01:14:39 | 2016-06-06T01:14:39 | 60,398,851 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,550 | c | Initialize.c | #include "driverlib/pwm.h"
#include "driverlib/sysctl.h"
#include "inc/hw_memmap.h"
#include "driverlib/pin_map.h"
#include "driverlib/gpio.h"
#include "Initialize.h"
#include "PWMDefinitions.h"
#include "Wheels.h"
void init()
{
initClock();
initPWM();
}
void initClock()
{
//Set the clock speed to 3.2MHz
SysCtlClockSet(SYSCTL_SYSDIV_6|SYSCTL_USE_OSC|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
}
void initPWM()
{
//Enable PWM0
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//Enable ports 0-4 of PWM0
GPIOPinConfigure(WHEELS[0].pwmInfo.gpioConfig);
GPIOPinConfigure(WHEELS[1].pwmInfo.gpioConfig);
GPIOPinConfigure(WHEELS[2].pwmInfo.gpioConfig);
GPIOPinConfigure(WHEELS[3].pwmInfo.gpioConfig);
//GPIOPinTypePWM(GPIO_PORTB_BASE, WHEELS[0].pwmInfo.gpioPin |
// WHEELS[1].pwmInfo.gpioPin |
// WHEELS[2].pwmInfo.gpioPin |
// WHEELS[3].pwmInfo.gpioPin);
GPIOPinTypePWM(GPIO_PORTB_BASE, WHEELS[0].pwmInfo.gpioPin);
GPIOPinTypePWM(GPIO_PORTB_BASE, WHEELS[1].pwmInfo.gpioPin);
GPIOPinTypePWM(GPIO_PORTB_BASE, WHEELS[2].pwmInfo.gpioPin);
GPIOPinTypePWM(GPIO_PORTB_BASE, WHEELS[3].pwmInfo.gpioPin);
//Set the PWM0 run modes, since the motors will act on up ticks, these values don't matter too much
//PWMGenConfigure(PWM_BASE, WHEELS[0].pwmInfo.pwmGenPort |
// WHEELS[1].pwmInfo.pwmGenPort |
// WHEELS[2].pwmInfo.pwmGenPort |
// WHEELS[3].pwmInfo.pwmGenPort,
// PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenConfigure(PWM_BASE, WHEELS[0].pwmInfo.pwmGenPort,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenConfigure(PWM_BASE, WHEELS[1].pwmInfo.pwmGenPort,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenConfigure(PWM_BASE, WHEELS[2].pwmInfo.pwmGenPort,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenConfigure(PWM_BASE, WHEELS[3].pwmInfo.pwmGenPort,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
//Set all the PWM frequencies to 50Hz
//PWMGenPeriodSet(PWM_BASE, WHEELS[0].pwmInfo.pwmGenPort |
// WHEELS[1].pwmInfo.pwmGenPort |
// WHEELS[2].pwmInfo.pwmGenPort |
// WHEELS[3].pwmInfo.pwmGenPort, PWM_FREQUENCY);
PWMGenPeriodSet(PWM_BASE, WHEELS[0].pwmInfo.pwmGenPort, PWM_FREQUENCY);
PWMGenPeriodSet(PWM_BASE, WHEELS[1].pwmInfo.pwmGenPort, PWM_FREQUENCY);
PWMGenPeriodSet(PWM_BASE, WHEELS[2].pwmInfo.pwmGenPort, PWM_FREQUENCY);
PWMGenPeriodSet(PWM_BASE, WHEELS[3].pwmInfo.pwmGenPort, PWM_FREQUENCY);
//Turn on PWM0
//PWMOutputState(PWM_BASE, WHEELS[0].pwmInfo.pwmOutPortBit |
// WHEELS[1].pwmInfo.pwmOutPortBit |
// WHEELS[2].pwmInfo.pwmOutPortBit |
// WHEELS[3].pwmInfo.pwmOutPortBit, true);
PWMOutputState(PWM_BASE, WHEELS[0].pwmInfo.pwmOutPortBit, true);
PWMOutputState(PWM_BASE, WHEELS[1].pwmInfo.pwmOutPortBit, true);
PWMOutputState(PWM_BASE, WHEELS[2].pwmInfo.pwmOutPortBit, true);
PWMOutputState(PWM_BASE, WHEELS[3].pwmInfo.pwmOutPortBit, true);
//PWMGenEnable(PWM_BASE, WHEELS[0].pwmInfo.pwmGenPort |
// WHEELS[1].pwmInfo.pwmGenPort |
// WHEELS[2].pwmInfo.pwmGenPort |
// WHEELS[3].pwmInfo.pwmGenPort);
PWMGenEnable(PWM_BASE, WHEELS[0].pwmInfo.pwmGenPort);
PWMGenEnable(PWM_BASE, WHEELS[1].pwmInfo.pwmGenPort);
PWMGenEnable(PWM_BASE, WHEELS[2].pwmInfo.pwmGenPort);
PWMGenEnable(PWM_BASE, WHEELS[3].pwmInfo.pwmGenPort);
}
|
f999d51a7863518f2ba4a2cfa8d8670a4fd6d180 | 01b8db44ebde6217e17adedc292d6e0a3078c174 | /drivers/wlan/htc/wmi/wmi_host.h | 1b788c6366cdeacf264fc6056663b106361a174c | [] | no_license | luotao717/arsdk | 6a616153c0c56cc5b902a63c42b3ffd6ddd7603f | 9f9004157afcd26b915125576a815f6b3e0cd715 | refs/heads/master | 2021-05-01T17:45:46.249250 | 2014-08-16T10:30:39 | 2014-08-16T10:30:39 | 12,207,504 | 1 | 1 | null | null | null | null | UTF-8 | C | false | false | 3,185 | h | wmi_host.h | /*
* Copyright (c) 2010, Atheros Communications Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_HOST_H_
#define _WMI_HOST_H_
#ifdef WMI_RETRY
#include <adf_os_timer.h>
#endif
#define WMI_EVT_QUEUE_SIZE 256
#ifdef NBUF_PREALLOC_POOL
#define WMI_CMD_MAXBYTES 512 /* Verify this */
#endif
#ifdef WMI_RETRY
typedef void (*wmi_rsp_callback_t)(void *, WMI_COMMAND_ID, a_uint16_t, adf_nbuf_t, a_uint8_t *, a_uint32_t, a_uint16_t);
#else
typedef void (*wmi_rsp_callback_t)(void *, WMI_COMMAND_ID, a_uint16_t, adf_nbuf_t, a_uint8_t *, a_uint32_t);
#endif
struct wmiEventQ
{
WMI_COMMAND_ID evtid;
adf_nbuf_t buf;
a_uint8_t *netdata;
a_uint32_t netlen;
};
struct wmi_t {
void *devt;
adf_os_handle_t os_hdl;
HTC_HANDLE HtcHandle;
adf_os_spinlock_t wmi_lock;
unsigned long wmi_flags;
#ifdef MAGPIE_SINGLE_CPU_CASE
adf_os_spinlock_t wmi_op_lock;
a_uint32_t wmi_op_flags;
#else
adf_os_mutex_t wmi_op_mutex;
adf_os_mutex_t wmi_cmd_mutex;
#endif
adf_os_spinlock_t wmi_op_lock_bh;
HTC_ENDPOINT_ID wmi_endpoint_id;
wmi_event_callback_t wmi_cb;
wmi_stop_callback_t wmi_stop_cb;
a_uint16_t txSeqId;
a_uint16_t wmi_stop_flag;
a_uint8_t wmiCmdFailCnt;
a_uint8_t wmi_usb_stop_flag;
#ifdef MAGPIE_SINGLE_CPU_CASE
#else
#ifdef __linux__
htc_spin_t spin;
#else
adf_os_waitq_t wq;
#endif
#endif
a_uint8_t *cmd_rsp_buf;
a_uint32_t cmd_rsp_len;
a_uint32_t wmi_in_progress;
adf_os_bh_t wmi_evt_bh;
/* event queue related */
a_uint16_t evtHead;
a_uint16_t evtTail;
struct wmiEventQ wmi_evt_queue[WMI_EVT_QUEUE_SIZE];
#ifdef NBUF_PREALLOC_POOL
adf_nbuf_t wmi_cmd_nbuf;
#endif
#ifdef WMI_RETRY
adf_os_timer_t wmi_retry_timer_instance;
adf_nbuf_t wmi_retryBuf;
a_uint16_t wmi_retrycmdLen;
a_uint16_t wmi_retrycnt;
a_uint16_t LastSeqId;
WMI_COMMAND_ID wmi_last_sent_cmd;
#endif
};
#define LOCK_WMI(w) adf_os_spin_lock_irq(&(w)->wmi_lock, (w)->wmi_flags);
#define UNLOCK_WMI(w) adf_os_spin_unlock_irq(&(w)->wmi_lock, (w)->wmi_flags);
#endif /* !_WMI_HOST_H_ */
|
78c0550ebebeb2542dc47d8c657b0dbba336ed27 | d0ceb76774abc3d54b7f1568746cd6b0a82f2d2c | /Random/oddeven.c | adf024297a8bb219eb906a17ed4e994e59b7c5be | [] | no_license | GauthamArunachalam/C | 51e9441edaf1443da1898354c3037fe51cd4029a | 720ba132173720ea04920018fba42b8537bc5b53 | refs/heads/master | 2021-07-21T14:34:10.274860 | 2020-05-15T17:40:22 | 2020-05-15T17:40:22 | 166,998,404 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 481 | c | oddeven.c | main()
{
int a[10],b[10],c[10],i,j=1,k=1;
for(i=1;i<=10;i++)
{
printf("\n\t Enter number %d: ",i);
scanf("%d",&a[i]);
if(a[i]%2==0)
{
b[j]=a[i];
j++;
}
else
{
c[k]=a[i];
k++;
}
}
printf("\n\t Even no, are: ");
for(i=1;i<j;i++)
printf("\t%d",b[i]);
printf("\n\t Odd no. are: ");
for(i=1;i<=k/2;i++)
printf("\t%d",c[i]);
}
|
6d6582bc6fd71274e08294e40552ca7c4b4f349d | b8d39027413242ce8eeca2f47cd4e626212d175e | /SiliconImage/isi/drv/IMX258_A/source/IMX258_MIPI.c | c6b451496ad9984697c210912bd06fe58c030acb | [] | no_license | yewufengyuzhao/hardware-rockchip-camera | 5d3d3065ea5e7c5ee122b0d5f2fdef1b9ebe8bbf | 6479534032319a35cb32a46bb1549b2a281addb7 | refs/heads/master | 2020-09-16T18:02:31.172712 | 2019-04-15T06:32:01 | 2019-04-15T06:32:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 152,442 | c | IMX258_MIPI.c | /**
* @file IMX258_MIPI.c
*
* @brief
* 07/09/2018 IMX258_MIPI.c make
*
*
*****************************************************************************/
#include <ebase/types.h>
#include <ebase/trace.h>
#include <ebase/builtins.h>
#include <common/return_codes.h>
#include <common/misc.h>
#include "isi.h"
#include "isi_iss.h"
#include "isi_priv.h"
#include "IMX258_MIPI_priv.h"
#define IMX258_NEWEST_TUNING_XML "18-7-2014_oyyf-hkw_IMX258_CMK-CB0407-FV1_v0.1.2"
/******************************************************************************
* local macro definitions
*****************************************************************************/
CREATE_TRACER( IMX258_INFO , "IMX258: ", INFO, 1U );
CREATE_TRACER( IMX258_WARN , "IMX258: ", WARNING, 1U );
CREATE_TRACER( IMX258_ERROR, "IMX258: ", ERROR, 1U );
CREATE_TRACER( IMX258_DEBUG, "IMX258: ", WARNING, 1U );
CREATE_TRACER( IMX258_NOTICE0 , "IMX258: ", TRACE_NOTICE0, 1);
CREATE_TRACER( IMX258_NOTICE1, "IMX258: ", TRACE_NOTICE1, 1U );
#define IMX258_SLAVE_ADDR 0x20U /**< i2c slave address of the IMX258 camera sensor */
#define IMX258_SLAVE_ADDR2 0x34U
#define IMX258_SLAVE_AF_ADDR 0x18U //? /**< i2c slave address of the IMX258 integrated AD5820 */
#define IMX258_MAXN_GAIN (512.0f)
#define IMX258_MIN_GAIN_STEP ( 1.0f / IMX258_MAXN_GAIN); /**< min gain step size used by GUI ( 32/(32-7) - 32/(32-6); min. reg value is 6 as of datasheet; depending on actual gain ) */
#define IMX258_MAX_GAIN_AEC ( 16.0f ) /**< max. gain used by the AEC (arbitrarily chosen, recommended by Omnivision) */
/*!<
* Focus position values:
* 65 logical positions ( 0 - 64 )
* where 64 is the setting for infinity and 0 for macro
* corresponding to
* 1024 register settings (0 - 1023)
* where 0 is the setting for infinity and 1023 for macro
*/
#define MAX_LOG 64U
#define MAX_REG 1023U
#define MAX_VCMDRV_CURRENT 100U
#define MAX_VCMDRV_REG 1023U
/*!<
* Lens movement is triggered every 133ms (VGA, 7.5fps processed frames
* worst case assumed, usually even much slower, see OV5630 driver for
* details). Thus the lens has to reach the requested position after
* max. 133ms. Minimum mechanical ringing is expected with mode 1 ,
* 100us per step. A movement over the full range needs max. 102.3ms
* (see table 9 AD5820 datasheet).
*/
#define MDI_SLEW_RATE_CTRL 5U /* S3..0 for MOTOR hkw*/
/******************************************************************************
* local variable declarations
*****************************************************************************/
const char IMX258_g_acName[] = "IMX258_MIPI";
extern const IsiRegDescription_t IMX258_g_aRegDescription_fourlane[];
extern const IsiRegDescription_t IMX258_g_2096x1560_fourlane[];
extern const IsiRegDescription_t IMX258_g_2096x1560P30_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_2096x1560P25_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_2096x1560P20_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_2096x1560P15_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_2096x1560P10_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_4208x3120_fourlane[];
extern const IsiRegDescription_t IMX258_g_4208x3120P30_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_4208x3120P25_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_4208x3120P20_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_4208x3120P15_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_4208x3120P10_fourlane_fpschg[];
extern const IsiRegDescription_t IMX258_g_4208x3120P7_fourlane_fpschg[];
const IsiSensorCaps_t IMX258_g_IsiSensorDefaultConfig;
#define IMX258_I2C_NR_ADR_BYTES (2U) // 1 byte base address
#define IMX258_I2C_NR_DAT_BYTES (1U) // 8 bit registers
static uint16_t g_suppoted_mipi_lanenum_type = SUPPORT_MIPI_FOUR_LANE;
#define DEFAULT_NUM_LANES SUPPORT_MIPI_FOUR_LANE
/******************************************************************************
* local function prototypes
*****************************************************************************/
static RESULT IMX258_IsiCreateSensorIss( IsiSensorInstanceConfig_t *pConfig );
static RESULT IMX258_IsiReleaseSensorIss( IsiSensorHandle_t handle );
static RESULT IMX258_IsiGetCapsIss( IsiSensorHandle_t handle, IsiSensorCaps_t *pIsiSensorCaps );
static RESULT IMX258_IsiSetupSensorIss( IsiSensorHandle_t handle, const IsiSensorConfig_t *pConfig );
static RESULT IMX258_IsiSensorSetStreamingIss( IsiSensorHandle_t handle, bool_t on );
static RESULT IMX258_IsiSensorSetPowerIss( IsiSensorHandle_t handle, bool_t on );
static RESULT IMX258_IsiCheckSensorConnectionIss( IsiSensorHandle_t handle );
static RESULT IMX258_IsiGetSensorRevisionIss( IsiSensorHandle_t handle, uint32_t *p_value);
static RESULT IMX258_IsiGetGainLimitsIss( IsiSensorHandle_t handle, float *pMinGain, float *pMaxGain);
static RESULT IMX258_IsiGetIntegrationTimeLimitsIss( IsiSensorHandle_t handle, float *pMinIntegrationTime, float *pMaxIntegrationTime );
static RESULT IMX258_IsiExposureControlIss( IsiSensorHandle_t handle, float NewGain, float NewIntegrationTime, uint8_t *pNumberOfFramesToSkip, float *pSetGain, float *pSetIntegrationTime );
static RESULT IMX258_IsiGetCurrentExposureIss( IsiSensorHandle_t handle, float *pSetGain, float *pSetIntegrationTime );
static RESULT IMX258_IsiGetAfpsInfoIss ( IsiSensorHandle_t handle, uint32_t Resolution, IsiAfpsInfo_t* pAfpsInfo);
static RESULT IMX258_IsiGetGainIss( IsiSensorHandle_t handle, float *pSetGain );
static RESULT IMX258_IsiGetGainIncrementIss( IsiSensorHandle_t handle, float *pIncr );
static RESULT IMX258_IsiSetGainIss( IsiSensorHandle_t handle, float NewGain, float *pSetGain );
static RESULT IMX258_IsiGetIntegrationTimeIss( IsiSensorHandle_t handle, float *pSetIntegrationTime );
static RESULT IMX258_IsiGetIntegrationTimeIncrementIss( IsiSensorHandle_t handle, float *pIncr );
static RESULT IMX258_IsiSetIntegrationTimeIss( IsiSensorHandle_t handle, float NewIntegrationTime, float *pSetIntegrationTime, uint8_t *pNumberOfFramesToSkip );
static RESULT IMX258_IsiGetResolutionIss( IsiSensorHandle_t handle, uint32_t *pSetResolution );
static RESULT IMX258_IsiRegReadIss( IsiSensorHandle_t handle, const uint32_t address, uint32_t *p_value );
static RESULT IMX258_IsiRegWriteIss( IsiSensorHandle_t handle, const uint32_t address, const uint32_t value );
static RESULT IMX258_IsiGetCalibKFactor( IsiSensorHandle_t handle, Isi1x1FloatMatrix_t **pIsiKFactor );
static RESULT IMX258_IsiGetCalibPcaMatrix( IsiSensorHandle_t handle, Isi3x2FloatMatrix_t **pIsiPcaMatrix );
static RESULT IMX258_IsiGetCalibSvdMeanValue( IsiSensorHandle_t handle, Isi3x1FloatMatrix_t **pIsiSvdMeanValue );
static RESULT IMX258_IsiGetCalibCenterLine( IsiSensorHandle_t handle, IsiLine_t **ptIsiCenterLine);
static RESULT IMX258_IsiGetCalibClipParam( IsiSensorHandle_t handle, IsiAwbClipParm_t **pIsiClipParam );
static RESULT IMX258_IsiGetCalibGlobalFadeParam( IsiSensorHandle_t handle, IsiAwbGlobalFadeParm_t **ptIsiGlobalFadeParam);
static RESULT IMX258_IsiGetCalibFadeParam( IsiSensorHandle_t handle, IsiAwbFade2Parm_t **ptIsiFadeParam);
static RESULT IMX258_IsiGetIlluProfile( IsiSensorHandle_t handle, const uint32_t CieProfile, IsiIlluProfile_t **ptIsiIlluProfile );
static RESULT IMX258_IsiMdiInitMotoDriveMds( IsiSensorHandle_t handle );
static RESULT IMX258_IsiMdiSetupMotoDrive( IsiSensorHandle_t handle, uint32_t *pMaxStep );
static RESULT IMX258_IsiMdiFocusSet( IsiSensorHandle_t handle, const uint32_t Position );
static RESULT IMX258_IsiMdiFocusGet( IsiSensorHandle_t handle, uint32_t *pAbsStep );
static RESULT IMX258_IsiMdiFocusCalibrate( IsiSensorHandle_t handle );
static RESULT IMX258_IsiGetSensorMipiInfoIss( IsiSensorHandle_t handle, IsiSensorMipiInfo *ptIsiSensorMipiInfo);
static RESULT IMX258_IsiGetSensorIsiVersion( IsiSensorHandle_t handle, unsigned int* pVersion);
static RESULT IMX258_IsiGetSensorTuningXmlVersion( IsiSensorHandle_t handle, char** pTuningXmlVersion);
/* OTP START*/
struct otp_struct {
int base_info_flag;
int awb_flag;
int lsc_flag;
int spc_flag;
int module_integrator_id;
int production_year;
int production_month;
int production_day;
int current_R;
int current_Gr;
int current_Gb;
int current_B;
int golden_R;
int golden_Gr;
int golden_Gb;
int golden_B;
};
static struct otp_struct g_otp_info ={0};
int RG_Ratio_Typical=0;
int BG_Ratio_Typical=0;
#define RG_Ratio_Typical_Default 281;
#define BG_Ratio_Typical_Default 317;
#define MODULE_GZ 1
#define MODULE_CMK 2
#define MODULE_NAME MODULE_GZ
#if MODULE_NAME == MODULE_GZ
#define Sensor_OTP_SLAVE_ADDR 0xA0U
#define MODULE_INFO_FLAG_REG 0X0000
#define MODULE_ID_REG 0X0005
#define MODULE_PRODUCT_YEAR_REG 0X000A
#define MODULE_PRODUCT_MONTH_REG 0X000B
#define MODULE_PRODUCT_DAY_REG 0X000C
#define MODULE_AWB_FLAG_REG 0x001c
#define MODULE_CUR_R_REG 0x001d
#define MODULE_CUR_Gr_REG 0x001e
#define MODULE_CUR_Gb_REG 0x001f
#define MODULE_CUR_B_REG 0x0020
#define MODULE_GOLDEN_R_REG 0x0021
#define MODULE_GOLDEN_Gr_REG 0x0022
#define MODULE_GOLDEN_Gb_REG 0x0023
#define MODULE_GOLDEN_B_REG 0x0024
#define MODULE_AWB_CHECKSUM_REG 0x0025
#define MODULE_LSC_FLAG_REG 0X003A
#define MODULE_LSC_DATA_START_REG 0x003B
#define MODULE_LSC_CHECKSUM_REG 0x0233
#define MODULE_SPC_FLAG_REG 0X0CE1
#define MODULE_SPC_DATA_START_REG 0x0CE2
#define MODULE_SPC_CHECKSUM_REG 0x0d60
#elif MODULE_NAME == MODULE_CMK
#define Sensor_OTP_SLAVE_ADDR 0xB0U
#define MODULE_INFO_FLAG_REG 0X0C00
#define MODULE_ID_REG 0X0C01
#define MODULE_PRODUCT_YEAR_REG 0X0C06
#define MODULE_PRODUCT_MONTH_REG 0X0C07
#define MODULE_PRODUCT_DAY_REG 0X0C08
#define MODULE_AWB_FLAG_REG 0x0C2A
#define MODULE_CUR_R_REG 0x0C37
#define MODULE_CUR_Gr_REG 0x0C38
#define MODULE_CUR_Gb_REG 0x0C39
#define MODULE_CUR_B_REG 0x0C3A
#define MODULE_GOLDEN_R_REG 0x0C3B
#define MODULE_GOLDEN_Gr_REG 0x0C3C
#define MODULE_GOLDEN_Gb_REG 0x0C3D
#define MODULE_GOLDEN_B_REG 0x0C3E
#define MODULE_AWB_CHECKSUM_REG 0x0C4F
#define MODULE_LSC_FLAG_REG 0X1000
#define MODULE_LSC_DATA_START_REG 0x1003
#define MODULE_LSC_CHECKSUM_REG 0x174F
#define MODULE_SPC_FLAG_REG 0X0CA0
#define MODULE_SPC_DATA_START_REG 0x0CA1
#define MODULE_SPC_CHECKSUM_REG 0x0D1F
#endif
static bool bDumpRaw_OTP_switch = false;
static uint8_t IMX258MIPI_SPC_Data[126]={0};
static uint8_t IMX258MIPI_LSC_Data[504]={0};
static RESULT load_imx258_SPC_Data(IsiSensorHandle_t handle)
{
int i;
int temp = 0;
RESULT result = RET_SUCCESS;
for(i=0; i<63; i++)
{
result = IMX258_IsiRegWriteIss(handle, 0xD04C+i, IMX258MIPI_SPC_Data[i]);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "to sensor reg = 0x%04x, SPC_Data[%d] = %d\n",0xD04C+i, i, IMX258MIPI_SPC_Data[i]);
}
for(i=0; i<63; i++)
{
result = IMX258_IsiRegWriteIss(handle, 0xD08C+i, IMX258MIPI_SPC_Data[i+63]);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "to sensor reg = 0x%04x, SPC_Data[%d] = %d\n", 0xD08C+i, i+63, IMX258MIPI_SPC_Data[i+63]);
}
osSleep(10);
//result = IMX258_IsiRegWriteIss(handle, 0x0B00, 0x00);
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
//result = IMX258_IsiRegWriteIss(handle, 0x3051, 0x00);
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
//result = IMX258_IsiRegWriteIss(handle, 0x3052, 0x00);
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
//result = IMX258_IsiRegWriteIss(handle, 0x7BCA, 0x00);
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
//result = IMX258_IsiRegWriteIss(handle, 0x7BCB, 0x00);
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
result = IMX258_IsiRegWriteIss(handle, 0x7BC8, 0x01);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
#if 0
osSleep(200);
for(i=0; i<63; i++)
{
result = IMX258_IsiRegReadIss(handle, 0xD04C+i, &temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "read from sensor = 0x%04x, SPC_Data[%d] = %d\n",0xD04C+i, i, temp);
}
for(i=0; i<63; i++)
{
result = IMX258_IsiRegReadIss(handle, 0xD08C+i, &temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "read from sensor = 0x%04x, SPC_Data[%d] = %d\n", 0xD08C+i, i+63, temp);
}
result = IMX258_IsiRegReadIss(handle, 0x7BC8, &temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "read from sensor 0x7BC8 = 0x%02x\n", temp);
result = IMX258_IsiRegReadIss(handle, 0x7BC9, &temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "read from sensor 0x7BC9 = 0x%02x\n", temp);
#endif /*print info*/
return result;
}
static RESULT load_imx258_AWB_Data(IsiSensorHandle_t handle)
{
float RG_c = 0;
float BG_c = 0;
float GrGb_c = 0;
int Rgain = 0;
int Bgain = 0;
int Ggain = 0;
int Grgain = 0;
int Gbgain = 0;
int Basegain = 0;
RESULT result = RET_SUCCESS;
float current_R = (float)g_otp_info.current_R;
float current_Gr = (float)g_otp_info.current_Gr;
float current_Gb = (float)g_otp_info.current_Gb;
float current_B = (float)g_otp_info.current_B;
if((RG_Ratio_Typical==0) && (BG_Ratio_Typical==0)){
TRACE( IMX258_NOTICE0, "%s: --OTP typical value in IQ file is zero, we will try another match rule.\n", __FUNCTION__);
RG_Ratio_Typical = RG_Ratio_Typical_Default;
BG_Ratio_Typical = BG_Ratio_Typical_Default;
}
TRACE( IMX258_NOTICE0, "%s: --Finally, the (RG,BG) is (0x%x, 0x%x)\n", __FUNCTION__ , RG_Ratio_Typical, BG_Ratio_Typical);
RG_c = current_R / (current_Gr + current_Gb) * 1024;
BG_c = current_B / (current_Gr + current_Gb) * 1024;
Rgain = (int)(256 * RG_Ratio_Typical / RG_c + 0.5);
Bgain = (int)(256 * BG_Ratio_Typical / BG_c + 0.5);
Ggain = 256;
TRACE( IMX258_NOTICE0, "RG_c = %f, BG_c = %f, RG_Ratio_Typical = %d\n",RG_c,BG_c,RG_Ratio_Typical);
if (Rgain < 256 || Bgain < 256)
{
if (Rgain < Bgain)
Basegain = Rgain;
else
Basegain = Bgain;
}
else
{
Basegain = Ggain;
}
Rgain = 0x100 * Rgain / (Basegain);
Bgain = 0x100 * Bgain / (Basegain);
Grgain = 0x100 * Ggain / (Basegain);
Gbgain = 0x100 * Ggain / (Basegain);
TRACE( IMX258_DEBUG, "otp write Rgain = %d\n",Rgain);
result = IMX258_IsiRegWriteIss(handle, 0x0210, (Rgain >> 8) & 0xff);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
result = IMX258_IsiRegWriteIss(handle, 0x0211, Rgain & 0xff);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "otp write Bgain = %d\n",Bgain);
result = IMX258_IsiRegWriteIss(handle, 0x0212, (Bgain >> 8) & 0xff);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
result = IMX258_IsiRegWriteIss(handle, 0x0213, Bgain & 0xff);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "otp write Grgain = %d\n",Grgain);
result = IMX258_IsiRegWriteIss(handle, 0x020e, (Grgain >> 8) & 0xff);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
result = IMX258_IsiRegWriteIss(handle, 0x020f, Grgain & 0xff);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "otp write Gbgain = %d\n",Gbgain);
result = IMX258_IsiRegWriteIss(handle, 0x0214, (Gbgain >> 8) & 0xff);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
result = IMX258_IsiRegWriteIss(handle, 0x0215, Gbgain & 0xff);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
return result;
}
static RESULT load_imx258_LSC_Data(IsiSensorHandle_t handle)
{
int i;
uint32_t temp = 0;
RESULT result = RET_SUCCESS;
for(i=0; i<504; i++)
{
result = IMX258_IsiRegWriteIss(handle, 0xA300+i, IMX258MIPI_LSC_Data[i]);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "to sensor reg = 0x%04x, LSC_Data[%d] = %d\n",0xA300+i, i, IMX258MIPI_LSC_Data[i]);
}
osSleep(10);
//choose lsc table 1
result = IMX258_IsiRegReadIss(handle, 0x3021, &temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
temp |= 0x01;
result = IMX258_IsiRegWriteIss(handle, 0x3021, temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
//enable lsc
result = IMX258_IsiRegReadIss(handle, 0x0B00, &temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
temp |= 0x01;
result = IMX258_IsiRegWriteIss(handle, 0x0B00, temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
#if 0
osSleep(200);
for(i=0; i<504; i++)
{
result = IMX258_IsiRegReadIss(handle, 0xA300+i, &temp);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "read from sensor = 0x%04x, LSC_Data[%d] = %d\n",0xA300+i, i, temp);
}
#endif
return result;
}
static int check_read_otp(
sensor_i2c_write_t* sensor_i2c_write_p,
sensor_i2c_read_t* sensor_i2c_read_p,
sensor_version_get_t* sensor_version_get_p,
void* context,
int camsys_fd
)
{
int temp = 0;
int ret=0;
int i = 0;
int check_sum_awb = 0;
int check_sum_lsc = 0;
int check_sum_spc = 0;
int i2c_base_info[3];
i2c_base_info[0] = Sensor_OTP_SLAVE_ADDR; //otp i2c addr
i2c_base_info[1] = 2; //otp i2c reg size
i2c_base_info[2] = 1; //otp i2c value size
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_INFO_FLAG_REG,i2c_base_info);
g_otp_info.base_info_flag = temp;
if(0x01 == g_otp_info.base_info_flag){
TRACE( IMX258_DEBUG, "%s(%d):otp base info flag : %d, data is valid\n", __FUNCTION__, __LINE__,g_otp_info.base_info_flag);
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_ID_REG,i2c_base_info);
g_otp_info.module_integrator_id = temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_PRODUCT_YEAR_REG,i2c_base_info);
g_otp_info.production_year = temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_PRODUCT_MONTH_REG,i2c_base_info);
g_otp_info.production_month = temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_PRODUCT_DAY_REG,i2c_base_info);
g_otp_info.production_day = temp;
TRACE( IMX258_DEBUG, "%s(%d):otp module_integrator_id = 0x%02x", __FUNCTION__, __LINE__,g_otp_info.module_integrator_id);
TRACE( IMX258_DEBUG, "%s(%d):otp production year/month/day = %04d/%02d/%02d\n", __FUNCTION__, __LINE__,g_otp_info.production_year+2000,g_otp_info.production_month,g_otp_info.production_day);
}else{
TRACE( IMX258_ERROR, "%s(%d):otp base info flag : %d, data is invalid\n", __FUNCTION__, __LINE__,g_otp_info.base_info_flag);
}
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_AWB_FLAG_REG,i2c_base_info);
g_otp_info.awb_flag = temp;
if(0x01 == g_otp_info.awb_flag){
TRACE( IMX258_DEBUG, "%s(%d):otp awb flag : %d, data is valid\n", __FUNCTION__, __LINE__,g_otp_info.awb_flag);
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_CUR_R_REG,i2c_base_info);
g_otp_info.current_R = temp;
check_sum_awb += temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_CUR_Gr_REG,i2c_base_info);
g_otp_info.current_Gr = temp;
check_sum_awb += temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_CUR_Gb_REG,i2c_base_info);
g_otp_info.current_Gb = temp;
check_sum_awb += temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_CUR_B_REG,i2c_base_info);
g_otp_info.current_B = temp;
check_sum_awb += temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_GOLDEN_R_REG,i2c_base_info);
g_otp_info.golden_R = temp;
check_sum_awb += temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_GOLDEN_Gr_REG,i2c_base_info);
g_otp_info.golden_Gr = temp;
check_sum_awb += temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_GOLDEN_Gb_REG,i2c_base_info);
g_otp_info.golden_Gb = temp;
check_sum_awb += temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_GOLDEN_B_REG,i2c_base_info);
g_otp_info.golden_B = temp;
check_sum_awb += temp;
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_AWB_CHECKSUM_REG,i2c_base_info);
if((check_sum_awb%0xff) != temp){
TRACE( IMX258_ERROR, "%s(%d):otp awb check sum error,sum add value = %d,read from otp = %d\n", __FUNCTION__, __LINE__,check_sum_awb%0xff,temp);
}
TRACE( IMX258_DEBUG, "%s(%d):otp current_R = %d\n", __FUNCTION__, __LINE__,g_otp_info.current_R);
TRACE( IMX258_DEBUG, "%s(%d):otp current_Gr = %d\n", __FUNCTION__, __LINE__,g_otp_info.current_Gr);
TRACE( IMX258_DEBUG, "%s(%d):otp current_Gb = %d\n", __FUNCTION__, __LINE__,g_otp_info.current_Gb);
TRACE( IMX258_DEBUG, "%s(%d):otp current_B = %d\n", __FUNCTION__, __LINE__,g_otp_info.current_B);
TRACE( IMX258_DEBUG, "%s(%d):otp golden_R = %d\n", __FUNCTION__, __LINE__,g_otp_info.golden_R);
TRACE( IMX258_DEBUG, "%s(%d):otp golden_Gr = %d\n", __FUNCTION__, __LINE__,g_otp_info.golden_Gr);
TRACE( IMX258_DEBUG, "%s(%d):otp golden_Gb = %d\n", __FUNCTION__, __LINE__,g_otp_info.golden_Gb);
TRACE( IMX258_DEBUG, "%s(%d):otp golden_B = %d\n", __FUNCTION__, __LINE__,g_otp_info.golden_B);
}else{
TRACE( IMX258_ERROR, "%s(%d):otp awb flag : %d, data is invalid\n", __FUNCTION__, __LINE__,g_otp_info.awb_flag);
}
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_LSC_FLAG_REG,i2c_base_info);
g_otp_info.lsc_flag = temp;
if(0x01 == g_otp_info.lsc_flag){
TRACE( IMX258_DEBUG, "%s(%d):otp lsc flag : %d, data is valid\n", __FUNCTION__, __LINE__,g_otp_info.lsc_flag);
for (i = 0; i < 504; i++)
{
temp= sensor_i2c_read_p(context,camsys_fd,MODULE_LSC_DATA_START_REG+i,i2c_base_info);
IMX258MIPI_LSC_Data[i] = temp;
check_sum_lsc += temp;
TRACE( IMX258_DEBUG, "read from eeprom reg = 0x%04x, IMX258MIPI_LSC_Data[%d] = %d\n",0x003B+i, i, IMX258MIPI_LSC_Data[i]);
}
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_LSC_CHECKSUM_REG,i2c_base_info);
if((check_sum_lsc%0xff) != temp){
TRACE( IMX258_ERROR, "%s(%d):otp lsc check sum error,sum add value = %d,read from otp = %d\n", __FUNCTION__, __LINE__,check_sum_lsc%0xff,temp);
}
}else{
TRACE( IMX258_ERROR, "%s(%d):otp lsc flag : %d, data is invalid\n", __FUNCTION__, __LINE__,g_otp_info.lsc_flag);
}
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_SPC_FLAG_REG,i2c_base_info);
g_otp_info.spc_flag = temp;
if(0x01 == g_otp_info.spc_flag){
TRACE( IMX258_DEBUG, "%s(%d):otp spc flag : %d, data is valid\n", __FUNCTION__, __LINE__,g_otp_info.spc_flag);
for (i = 0; i < 126; i++)
{
temp= sensor_i2c_read_p(context,camsys_fd,MODULE_SPC_DATA_START_REG+i,i2c_base_info);
IMX258MIPI_SPC_Data[i] = temp;
check_sum_spc += temp;
TRACE( IMX258_DEBUG, "read from eeprom reg = 0x%04x, IMX258MIPI_SPC_Data[%d] = %d\n",0x0CE2+i, i, IMX258MIPI_SPC_Data[i]);
}
temp = sensor_i2c_read_p(context,camsys_fd,MODULE_SPC_CHECKSUM_REG,i2c_base_info);
if((check_sum_spc%0xff) != temp){
TRACE( IMX258_ERROR, "%s(%d):otp spc check sum error,sum add value = %d,read from otp = %d\n", __FUNCTION__, __LINE__,check_sum_spc%0xff,temp);
}
}else{
TRACE( IMX258_ERROR, "%s(%d):otp spc flag : %d, data is invalid\n", __FUNCTION__, __LINE__,g_otp_info.spc_flag);
}
return RET_SUCCESS;
}
static int apply_otp_data(IsiSensorHandle_t handle,struct otp_struct *otp_ptr)
{
if(0x01 == g_otp_info.spc_flag){
load_imx258_SPC_Data(handle);
}
if (0x01 == g_otp_info.awb_flag){
load_imx258_AWB_Data(handle);
}
if(0x01 == g_otp_info.lsc_flag){
load_imx258_LSC_Data(handle);
}
TRACE( IMX258_INFO, "%s: success!!!\n", __FUNCTION__ );
return RET_SUCCESS;
}
static RESULT IMX258_IsiSetOTPInfo
(
IsiSensorHandle_t handle,
uint32_t OTPInfo
)
{
RESULT result = RET_SUCCESS;
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
RG_Ratio_Typical = OTPInfo>>16;
BG_Ratio_Typical = OTPInfo&0xffff;
TRACE( IMX258_NOTICE0, "%s: --(RG,BG) in IQ file:(0x%x, 0x%x)\n", __FUNCTION__ , RG_Ratio_Typical, BG_Ratio_Typical);
return (result);
}
static RESULT IMX258_IsiEnableOTP
(
IsiSensorHandle_t handle,
const bool_t enable
)
{
RESULT result = RET_SUCCESS;
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
bDumpRaw_OTP_switch = enable;
return (result);
}
/* OTP END*/
/*****************************************************************************/
/**
* IMX258_IsiCreateSensorIss
*
* @brief This function creates a new IMX258 sensor instance handle.
*
* @param pConfig configuration structure to create the instance
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* @retval RET_OUTOFMEM
*
*****************************************************************************/
static RESULT IMX258_IsiCreateSensorIss
(
IsiSensorInstanceConfig_t *pConfig
)
{
RESULT result = RET_SUCCESS;
int32_t current_distance;
IMX258_Context_t *pIMX258Ctx;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( (pConfig == NULL) || (pConfig->pSensor ==NULL) )
{
return ( RET_NULL_POINTER );
}
pIMX258Ctx = ( IMX258_Context_t * )malloc ( sizeof (IMX258_Context_t) );
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Can't allocate IMX258 context\n", __FUNCTION__ );
return ( RET_OUTOFMEM );
}
MEMSET( pIMX258Ctx, 0, sizeof( IMX258_Context_t ) );
result = HalAddRef( pConfig->HalHandle );
if ( result != RET_SUCCESS )
{
free ( pIMX258Ctx );
return ( result );
}
pIMX258Ctx->IsiCtx.HalHandle = pConfig->HalHandle;
pIMX258Ctx->IsiCtx.HalDevID = pConfig->HalDevID;
pIMX258Ctx->IsiCtx.I2cBusNum = pConfig->I2cBusNum;
pIMX258Ctx->IsiCtx.SlaveAddress = ( pConfig->SlaveAddr == 0 ) ? IMX258_SLAVE_ADDR : pConfig->SlaveAddr;
pIMX258Ctx->IsiCtx.NrOfAddressBytes = 2U;
pIMX258Ctx->IsiCtx.I2cAfBusNum = pConfig->I2cAfBusNum;
pIMX258Ctx->IsiCtx.SlaveAfAddress = ( pConfig->SlaveAfAddr == 0 ) ? IMX258_SLAVE_AF_ADDR : pConfig->SlaveAfAddr;
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes = 0U;
pIMX258Ctx->IsiCtx.pSensor = pConfig->pSensor;
pIMX258Ctx->Configured = BOOL_FALSE;
pIMX258Ctx->Streaming = BOOL_FALSE;
pIMX258Ctx->TestPattern = BOOL_FALSE;
pIMX258Ctx->isAfpsRun = BOOL_FALSE;
/* [email protected]: v0.3.0 */
current_distance = pConfig->VcmRatedCurrent - pConfig->VcmStartCurrent;
current_distance = current_distance*MAX_VCMDRV_REG/MAX_VCMDRV_CURRENT;
pIMX258Ctx->VcmInfo.Step = (current_distance+(MAX_LOG-1))/MAX_LOG;
pIMX258Ctx->VcmInfo.StartCurrent = pConfig->VcmStartCurrent*MAX_VCMDRV_REG/MAX_VCMDRV_CURRENT;
pIMX258Ctx->VcmInfo.RatedCurrent = pIMX258Ctx->VcmInfo.StartCurrent + MAX_LOG*pIMX258Ctx->VcmInfo.Step;
pIMX258Ctx->VcmInfo.StepMode = pConfig->VcmStepMode;
pIMX258Ctx->IsiSensorMipiInfo.sensorHalDevID = pIMX258Ctx->IsiCtx.HalDevID;
if(pConfig->mipiLaneNum & g_suppoted_mipi_lanenum_type)
pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes = pConfig->mipiLaneNum;
else{
TRACE( IMX258_ERROR, "%s don't support lane numbers :%d,set to default %d\n", __FUNCTION__,pConfig->mipiLaneNum,DEFAULT_NUM_LANES);
pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes = DEFAULT_NUM_LANES;
}
pConfig->hSensor = ( IsiSensorHandle_t )pIMX258Ctx;
result = HalSetCamConfig( pIMX258Ctx->IsiCtx.HalHandle, pIMX258Ctx->IsiCtx.HalDevID, false, true, false ); //pwdn,reset active;hkw
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
result = HalSetClock( pIMX258Ctx->IsiCtx.HalHandle, pIMX258Ctx->IsiCtx.HalDevID, 24000000U);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_INFO, "%s (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiReleaseSensorIss
*
* @brief This function destroys/releases an IMX258 sensor instance.
*
* @param handle IMX258 sensor instance handle
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
*
*****************************************************************************/
static RESULT IMX258_IsiReleaseSensorIss
(
IsiSensorHandle_t handle
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
(void)IMX258_IsiSensorSetStreamingIss( pIMX258Ctx, BOOL_FALSE );
(void)IMX258_IsiSensorSetPowerIss( pIMX258Ctx, BOOL_FALSE );
(void)HalDelRef( pIMX258Ctx->IsiCtx.HalHandle );
MEMSET( pIMX258Ctx, 0, sizeof( IMX258_Context_t ) );
free ( pIMX258Ctx );
TRACE( IMX258_INFO, "%s (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCapsIss
*
* @brief fills in the correct pointers for the sensor description struct
*
* @param param1 pointer to sensor capabilities structure
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
*
*****************************************************************************/
static RESULT IMX258_IsiGetCapsIssInternal
(
IsiSensorCaps_t *pIsiSensorCaps,
uint32_t mipi_lanes
)
{
RESULT result = RET_SUCCESS;
if ( pIsiSensorCaps == NULL )
{
return ( RET_NULL_POINTER );
}
else
{
if (mipi_lanes == SUPPORT_MIPI_FOUR_LANE) {
switch (pIsiSensorCaps->Index)
{
case 0:
{
pIsiSensorCaps->Resolution = ISI_RES_4208_3120P20;
break;
}
case 1:
{
pIsiSensorCaps->Resolution = ISI_RES_4208_3120P15;
break;
}
case 2:
{
pIsiSensorCaps->Resolution = ISI_RES_2096_1560P30;
break;
}
case 3:
{
pIsiSensorCaps->Resolution = ISI_RES_2096_1560P25;
break;
}
case 4:
{
pIsiSensorCaps->Resolution = ISI_RES_2096_1560P20;
break;
}
case 5:
{
pIsiSensorCaps->Resolution = ISI_RES_2096_1560P15;
break;
}
default:
{
result = RET_OUTOFRANGE;
goto end;
}
}
}
pIsiSensorCaps->BusWidth = ISI_BUSWIDTH_10BIT; //
pIsiSensorCaps->Mode = ISI_MODE_MIPI;
pIsiSensorCaps->FieldSelection = ISI_FIELDSEL_BOTH;
pIsiSensorCaps->YCSequence = ISI_YCSEQ_YCBYCR; /**< only Bayer supported, will not be evaluated */
pIsiSensorCaps->Conv422 = ISI_CONV422_NOCOSITED;
pIsiSensorCaps->BPat = ISI_BPAT_RGRGGBGB;
pIsiSensorCaps->HPol = ISI_HPOL_REFPOS; //hsync?
pIsiSensorCaps->VPol = ISI_VPOL_POS; //VPolarity
pIsiSensorCaps->Edge = ISI_EDGE_RISING;
pIsiSensorCaps->Bls = ISI_BLS_OFF; //close;
pIsiSensorCaps->Gamma = ISI_GAMMA_OFF;//close;
pIsiSensorCaps->CConv = ISI_CCONV_OFF;//close;<
pIsiSensorCaps->BLC = ( ISI_BLC_AUTO | ISI_BLC_OFF);
pIsiSensorCaps->AGC = ( ISI_AGC_OFF );//close;
pIsiSensorCaps->AWB = ( ISI_AWB_OFF );
pIsiSensorCaps->AEC = ( ISI_AEC_OFF );
pIsiSensorCaps->DPCC = ( ISI_DPCC_AUTO | ISI_DPCC_OFF );//»µµã
pIsiSensorCaps->DwnSz = ISI_DWNSZ_SUBSMPL; //;
pIsiSensorCaps->CieProfile = ( ISI_CIEPROF_A //¹âÔ´£»
| ISI_CIEPROF_D50
| ISI_CIEPROF_D65
| ISI_CIEPROF_D75
| ISI_CIEPROF_F2
| ISI_CIEPROF_F11 );
pIsiSensorCaps->SmiaMode = ISI_SMIA_OFF;
pIsiSensorCaps->MipiMode = ISI_MIPI_MODE_RAW_10;
pIsiSensorCaps->AfpsResolutions = ( ISI_AFPS_NOTSUPP ); //ÌøÖ¡;ûÓÃ
pIsiSensorCaps->SensorOutputMode = ISI_SENSOR_OUTPUT_MODE_RAW;//
}
end:
return result;
}
static RESULT IMX258_IsiGetCapsIss
(
IsiSensorHandle_t handle,
IsiSensorCaps_t *pIsiSensorCaps
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
result = IMX258_IsiGetCapsIssInternal(pIsiSensorCaps,pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes );
TRACE( IMX258_INFO, "%s (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_g_IsiSensorDefaultConfig
*
* @brief recommended default configuration for application use via call
* to IsiGetSensorIss()
*
*****************************************************************************/
const IsiSensorCaps_t IMX258_g_IsiSensorDefaultConfig =
{
ISI_BUSWIDTH_10BIT, // BusWidth
ISI_MODE_MIPI, // MIPI
ISI_FIELDSEL_BOTH, // FieldSel
ISI_YCSEQ_YCBYCR, // YCSeq
ISI_CONV422_NOCOSITED, // Conv422
ISI_BPAT_RGRGGBGB, // BPat
ISI_HPOL_REFPOS, // HPol
ISI_VPOL_POS, // VPol
ISI_EDGE_RISING, // Edge
ISI_BLS_OFF, // Bls
ISI_GAMMA_OFF, // Gamma
ISI_CCONV_OFF, // CConv
ISI_RES_2096_1560P30,
ISI_DWNSZ_SUBSMPL, // DwnSz
ISI_BLC_AUTO, // BLC
ISI_AGC_OFF, // AGC
ISI_AWB_OFF, // AWB
ISI_AEC_OFF, // AEC
ISI_DPCC_OFF, // DPCC
ISI_CIEPROF_F11, // CieProfile, this is also used as start profile for AWB (if not altered by menu settings)
ISI_SMIA_OFF, // SmiaMode
ISI_MIPI_MODE_RAW_10, // MipiMode
ISI_AFPS_NOTSUPP, // AfpsResolutions
ISI_SENSOR_OUTPUT_MODE_RAW,
0,
};
/*****************************************************************************/
/**
* IMX258_SetupOutputFormat
*
* @brief Setup of the image sensor considering the given configuration.
*
* @param handle IMX258 sensor instance handle
* @param pConfig pointer to sensor configuration structure
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* ÑéÖ¤ÉÏÃæģʽµÈ£»
*****************************************************************************/
RESULT IMX258_SetupOutputFormat
(
IMX258_Context_t *pIMX258Ctx,
const IsiSensorConfig_t *pConfig
)
{
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s%s (enter)\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
/* bus-width */
switch ( pConfig->BusWidth ) /* only ISI_BUSWIDTH_12BIT supported, no configuration needed here */
{
case ISI_BUSWIDTH_10BIT:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: bus width not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* mode */
switch ( pConfig->Mode ) /* only ISI_MODE_BAYER supported, no configuration needed here */
{
case( ISI_MODE_MIPI ):
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: mode not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* field-selection */
switch ( pConfig->FieldSelection ) /* only ISI_FIELDSEL_BOTH supported, no configuration needed */
{
case ISI_FIELDSEL_BOTH:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: field selection not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* only Bayer mode is supported by IMX258 sensor, so the YCSequence parameter is not checked */
switch ( pConfig->YCSequence )
{
default:
{
break;
}
}
/* 422 conversion */
switch ( pConfig->Conv422 ) /* only ISI_CONV422_NOCOSITED supported, no configuration needed */
{
case ISI_CONV422_NOCOSITED:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: 422 conversion not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* bayer-pattern */
switch ( pConfig->BPat ) /* only ISI_BPAT_RGRGGBGB supported, no configuration needed */
{
case ISI_BPAT_RGRGGBGB:
case ISI_BPAT_GRGRBGBG:
case ISI_BPAT_GBGBRGRG:
case ISI_BPAT_BGBGGRGR:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: bayer pattern not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* horizontal polarity */
switch ( pConfig->HPol ) /* only ISI_HPOL_REFPOS supported, no configuration needed */
{
case ISI_HPOL_REFPOS:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: HPol not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* vertical polarity */
switch ( pConfig->VPol ) /*no configuration needed */
{
case ISI_VPOL_NEG:
{
break;
}
case ISI_VPOL_POS:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: VPol not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* edge */
switch ( pConfig->Edge ) /* only ISI_EDGE_RISING supported, no configuration needed */
{
case ISI_EDGE_RISING:
{
break;
}
case ISI_EDGE_FALLING: /*TODO for MIPI debug*/
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: edge mode not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* gamma */
switch ( pConfig->Gamma ) /* only ISI_GAMMA_OFF supported, no configuration needed */
{
case ISI_GAMMA_OFF:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: gamma not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
/* color conversion */
switch ( pConfig->CConv ) /* only ISI_CCONV_OFF supported, no configuration needed */
{
case ISI_CCONV_OFF:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: color conversion not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
switch ( pConfig->SmiaMode ) /* only ISI_SMIA_OFF supported, no configuration needed */
{
case ISI_SMIA_OFF:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: SMIA mode not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
switch ( pConfig->MipiMode ) /* only ISI_MIPI_MODE_RAW_12 supported, no configuration needed */
{
case ISI_MIPI_MODE_RAW_10:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s%s: MIPI mode not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
return ( RET_NOTSUPP );
}
}
switch ( pConfig->AfpsResolutions ) /* no configuration needed */
{
case ISI_AFPS_NOTSUPP:
{
break;
}
default:
{
// don't care about what comes in here
//TRACE( IMX258_ERROR, "%s%s: AFPS not supported\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"" );
//return ( RET_NOTSUPP );
}
}
TRACE( IMX258_INFO, "%s%s (exit)\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"");
return ( result );
}
#if 0
int IMX258_get_PCLK( IMX258_Context_t *pIMX258Ctx, int XVCLK)
{
// calculate sysclk
int prediv, mipi_preDiv, mipi_preMul, mipi_Mul, mipi_Div, sys_preDiv, sys_Mul;
uint32_t temp1, temp2;
uint64_t sysclk;
sysclk = XVCLK;
IMX258_IsiRegReadIss(pIMX258Ctx, 0xf7, &temp1 );
if(temp1 & 0x02)
{
sysclk/=2;
}
IMX258_IsiRegReadIss(pIMX258Ctx, 0xf5, &temp1 );
temp1 &= 0x18;
temp1 >>= 3;
if(temp1 >=2)
{
IMX258_IsiRegReadIss(pIMX258Ctx, 0xf2, &temp2);
sysclk /= (temp2 & 0x07) + 1;
IMX258_IsiRegReadIss(pIMX258Ctx, 0xf4, &temp2);
if(temp2 & 0x10)
{
sysclk *=2;
}
IMX258_IsiRegReadIss(pIMX258Ctx, 0xfa, &temp2);
temp2++;
temp2 *=2;
sysclk *= temp2;
}
else
{
IMX258_IsiRegReadIss(pIMX258Ctx, 0xf6, &temp2);
sysclk /= (temp2 & 0x07) + 1;
IMX258_IsiRegReadIss(pIMX258Ctx, 0xf8, &temp2);
temp2++;
temp2 *=2;
sysclk *= temp2;
}
switch(temp1)
{
case 0:
sysclk /= 4;
break;
case 1:
sysclk /= 3;
break;
case 2:
IMX258_IsiRegReadIss(pIMX258Ctx, 0xf4, &temp2);
if(temp2 & 0x10)
{
sysclk /= 4;
}
else
{
sysclk /= 2;
}
break;
case 3:
IMX258_IsiRegReadIss(pIMX258Ctx, 0xf4, &temp2);
if(temp2 & 0x10)
{
sysclk /= 5;
}
else
{
sysclk /= 2.5;
}
break;
default:
TRACE( IMX258_ERROR, "%s: failed to get_PCLK \n", __FUNCTION__ );
break;
}
IMX258_IsiRegReadIss(pIMX258Ctx, 0xfc, &temp2);
if(temp2 & 0x10)
{
sysclk /=2;
}
return (int)sysclk;
}
#endif
/*****************************************************************************/
/**
* IMX258_SetupOutputWindow
*
* @brief Setup of the image sensor considering the given configuration.
*
* @param handle IMX258 sensor instance handle
* @param pConfig pointer to sensor configuration structure
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* hkw fix
*****************************************************************************/
static RESULT IMX258_SetupOutputWindowInternal
(
IMX258_Context_t *pIMX258Ctx,
const IsiSensorConfig_t *pConfig,
bool_t set2Sensor,
bool_t res_no_chg
)
{
RESULT result = RET_SUCCESS;
uint16_t usFrameLengthLines = 0;
uint16_t usLineLengthPck = 0;
uint16_t usTimeHts;
uint16_t usTimeVts;
float rVtPixClkFreq = 0.0f;
int xclk = 24000000;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if(pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes == SUPPORT_MIPI_FOUR_LANE) {
switch ( pConfig->Resolution )
{
case ISI_RES_2096_1560P30:
case ISI_RES_2096_1560P25:
case ISI_RES_2096_1560P20:
case ISI_RES_2096_1560P15:
case ISI_RES_2096_1560P10:
{
if (set2Sensor == BOOL_TRUE) {
if (res_no_chg == BOOL_FALSE) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_2096x1560_fourlane);
TRACE( IMX258_DEBUG, "%s set IMX258_g_2096x1560_fourlane\n", __FUNCTION__);
}
if (pConfig->Resolution == ISI_RES_2096_1560P30) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_2096x1560P30_fourlane_fpschg);
} else if (pConfig->Resolution == ISI_RES_2096_1560P25) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_2096x1560P25_fourlane_fpschg);
} else if (pConfig->Resolution == ISI_RES_2096_1560P20) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_2096x1560P20_fourlane_fpschg);
} else if (pConfig->Resolution == ISI_RES_2096_1560P15) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_2096x1560P15_fourlane_fpschg);
} else if (pConfig->Resolution == ISI_RES_2096_1560P10) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_2096x1560P10_fourlane_fpschg);
}
}
pIMX258Ctx->IsiSensorMipiInfo.ulMipiFreq = 798;
usTimeHts = 5352;
rVtPixClkFreq = 319200000;
if (pConfig->Resolution == ISI_RES_2096_1560P30) {
usTimeVts = 1988; // 33.34pfs
} else if (pConfig->Resolution == ISI_RES_2096_1560P25) {
usTimeVts = 2385; // 25.00 fps
} else if (pConfig->Resolution == ISI_RES_2096_1560P20) {
usTimeVts = 2982; // 20.00 fps
} else if (pConfig->Resolution == ISI_RES_2096_1560P15) {
usTimeVts = 3976; // 16.67 fps
} else if (pConfig->Resolution == ISI_RES_2096_1560P10) {
usTimeVts = 5964; // 10.00 fps
}
break;
}
case ISI_RES_4208_3120P7:
case ISI_RES_4208_3120P10:
case ISI_RES_4208_3120P15:
case ISI_RES_4208_3120P20:
case ISI_RES_4208_3120P25:
{
if (set2Sensor == BOOL_TRUE) {
if (res_no_chg == BOOL_FALSE) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_4208x3120_fourlane);
TRACE( IMX258_ERROR, "%s set IMX258_g_4208x3120_fourlane\n", __FUNCTION__);
}
if (pConfig->Resolution == ISI_RES_4208_3120P25) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_4208x3120P25_fourlane_fpschg);
}else if (pConfig->Resolution == ISI_RES_4208_3120P20) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_4208x3120P20_fourlane_fpschg);
}else if (pConfig->Resolution == ISI_RES_4208_3120P15) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_4208x3120P15_fourlane_fpschg);
} else if (pConfig->Resolution == ISI_RES_4208_3120P10) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_4208x3120P10_fourlane_fpschg);
}
else if (pConfig->Resolution == ISI_RES_4208_3120P7) {
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_4208x3120P7_fourlane_fpschg);
}
}
pIMX258Ctx->IsiSensorMipiInfo.ulMipiFreq = 996;
rVtPixClkFreq = 398400000;
usTimeHts = 5352;
if (pConfig->Resolution == ISI_RES_4208_3120P25) {
usTimeVts = 0x0d35;//22 fps
} else if (pConfig->Resolution == ISI_RES_4208_3120P20) {
usTimeVts = 3720; //20 fps
} else if (pConfig->Resolution == ISI_RES_4208_3120P15) {
usTimeVts = 4962; // 16.67 fps
} else if (pConfig->Resolution == ISI_RES_4208_3120P10) {
usTimeVts = 7443; // 10.00 fps
}
else if (pConfig->Resolution == ISI_RES_4208_3120P7) {
usTimeVts = 10634; // 7.69 fps
}
break;
}
}
}
/* 2.) write default values derived from datasheet and evaluation kit (static setup altered by dynamic setup further below) */
usLineLengthPck = usTimeHts;
usFrameLengthLines = usTimeVts;
// store frame timing for later use in AEC module
pIMX258Ctx->VtPixClkFreq = rVtPixClkFreq;
pIMX258Ctx->LineLengthPck = usLineLengthPck;
pIMX258Ctx->FrameLengthLines = usFrameLengthLines;
pIMX258Ctx->AecMaxIntegrationTime = ( ((float)pIMX258Ctx->FrameLengthLines) * ((float)pIMX258Ctx->LineLengthPck) ) / pIMX258Ctx->VtPixClkFreq;
TRACE( IMX258_INFO, "%s (exit): Resolution %dx%d@%dfps MIPI %dlanes res_no_chg: %d rVtPixClkFreq: %f\n", __FUNCTION__,
ISI_RES_W_GET(pConfig->Resolution),ISI_RES_H_GET(pConfig->Resolution),
ISI_FPS_GET(pConfig->Resolution),
pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes,
res_no_chg,rVtPixClkFreq);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_SetupImageControl
*
* @brief Sets the image control functions (BLC, AGC, AWB, AEC, DPCC ...)
*
* @param handle IMX258 sensor instance handle
* @param pConfig pointer to sensor configuration structure
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* @don't fix hkw
*****************************************************************************/
RESULT IMX258_SetupImageControl
(
IMX258_Context_t *pIMX258Ctx,
const IsiSensorConfig_t *pConfig
)
{
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
switch ( pConfig->Bls ) /* only ISI_BLS_OFF supported, no configuration needed */
{
case ISI_BLS_OFF:
{
break;
}
default:
{
TRACE( IMX258_ERROR, "%s: Black level not supported\n", __FUNCTION__ );
return ( RET_NOTSUPP );
}
}
/* black level compensation */
switch ( pConfig->BLC )
{
case ISI_BLC_OFF:
{
/* turn off black level correction (clear bit 0) */
//result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_BLC_CTRL00, &RegValue );
//result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_BLC_CTRL00, RegValue & 0x7F);
break;
}
case ISI_BLC_AUTO:
{
/* turn on black level correction (set bit 0)
* (0x331E[7] is assumed to be already setup to 'auto' by static configration) */
//result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_BLC_CTRL00, &RegValue );
//result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_BLC_CTRL00, RegValue | 0x80 );
break;
}
default:
{
TRACE( IMX258_ERROR, "%s: BLC not supported\n", __FUNCTION__ );
return ( RET_NOTSUPP );
}
}
/* automatic gain control */
switch ( pConfig->AGC )
{
case ISI_AGC_OFF:
{
// manual gain (appropriate for AEC with Marvin)
//result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_AEC_MANUAL, &RegValue );
//result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_AEC_MANUAL, RegValue | 0x02 );
break;
}
default:
{
TRACE( IMX258_ERROR, "%s: AGC not supported\n", __FUNCTION__ );
return ( RET_NOTSUPP );
}
}
/* automatic white balance */
switch( pConfig->AWB )
{
case ISI_AWB_OFF:
{
//result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_ISP_CTRL01, &RegValue );
//result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_ISP_CTRL01, RegValue | 0x01 );
break;
}
default:
{
TRACE( IMX258_ERROR, "%s: AWB not supported\n", __FUNCTION__ );
return ( RET_NOTSUPP );
}
}
switch( pConfig->AEC )
{
case ISI_AEC_OFF:
{
//result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_AEC_MANUAL, &RegValue );
//result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_AEC_MANUAL, RegValue | 0x01 );
break;
}
default:
{
TRACE( IMX258_ERROR, "%s: AEC not supported\n", __FUNCTION__ );
return ( RET_NOTSUPP );
}
}
switch( pConfig->DPCC )
{
case ISI_DPCC_OFF:
{
// disable white and black pixel cancellation (clear bit 6 and 7)
//result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_ISP_CTRL00, &RegValue );
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
//result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_ISP_CTRL00, (RegValue &0x7c) );
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
break;
}
case ISI_DPCC_AUTO:
{
// enable white and black pixel cancellation (set bit 6 and 7)
//result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_ISP_CTRL00, &RegValue );
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
//result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_ISP_CTRL00, (RegValue | 0x83) );
//RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
break;
}
default:
{
TRACE( IMX258_ERROR, "%s: DPCC not supported\n", __FUNCTION__ );
return ( RET_NOTSUPP );
}
}// I have not update this commented part yet, as I did not find DPCC setting in the current 8810 driver of Trillian board. - SRJ
return ( result );
}
static RESULT IMX258_SetupOutputWindow
(
IMX258_Context_t *pIMX258Ctx,
const IsiSensorConfig_t *pConfig
)
{
bool_t res_no_chg;
if ((ISI_RES_W_GET(pConfig->Resolution)==ISI_RES_W_GET(pIMX258Ctx->Config.Resolution)) &&
(ISI_RES_W_GET(pConfig->Resolution)==ISI_RES_W_GET(pIMX258Ctx->Config.Resolution))) {
res_no_chg = BOOL_TRUE;
} else {
res_no_chg = BOOL_FALSE;
}
return IMX258_SetupOutputWindowInternal(pIMX258Ctx,pConfig,BOOL_TRUE, BOOL_FALSE);
}
/*****************************************************************************/
/**
* IMX258_AecSetModeParameters
*
* @brief This function fills in the correct parameters in IMX258-Instances
* according to AEC mode selection in IsiSensorConfig_t.
*
* @note It is assumed that IsiSetupOutputWindow has been called before
* to fill in correct values in instance structure.
*
* @param handle IMX258 context
* @param pConfig pointer to sensor configuration structure
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* ²»ÓøÄ
*****************************************************************************/
static RESULT IMX258_AecSetModeParameters
(
IMX258_Context_t *pIMX258Ctx,
const IsiSensorConfig_t *pConfig
)
{
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s%s (enter) Res: 0x%x 0x%x\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"",
pIMX258Ctx->Config.Resolution, pConfig->Resolution);
if ( (pIMX258Ctx->VtPixClkFreq == 0.0f) )
{
TRACE( IMX258_ERROR, "%s%s: Division by zero!\n", __FUNCTION__ );
return ( RET_OUTOFRANGE );
}
//as of mail from Omnivision FAE the limit is VTS - 6 (above that we observed a frame
//exposed way too dark from time to time)
// (formula is usually MaxIntTime = (CoarseMax * LineLength + FineMax) / Clk
// MinIntTime = (CoarseMin * LineLength + FineMin) / Clk )
pIMX258Ctx->AecMaxIntegrationTime = ( ((float)(pIMX258Ctx->FrameLengthLines - 4)) * ((float)pIMX258Ctx->LineLengthPck) ) / pIMX258Ctx->VtPixClkFreq;
pIMX258Ctx->AecMinIntegrationTime = 0.0001f;
TRACE( IMX258_DEBUG, "%s%s: AecMaxIntegrationTime = %f \n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"", pIMX258Ctx->AecMaxIntegrationTime );
pIMX258Ctx->AecMaxGain = IMX258_MAX_GAIN_AEC;
pIMX258Ctx->AecMinGain = 1.0f; //as of sensor datasheet 32/(32-6)
//_smallest_ increment the sensor/driver can handle (e.g. used for sliders in the application)
pIMX258Ctx->AecIntegrationTimeIncrement = ((float)pIMX258Ctx->LineLengthPck) / pIMX258Ctx->VtPixClkFreq;
pIMX258Ctx->AecGainIncrement = IMX258_MIN_GAIN_STEP;
//reflects the state of the sensor registers, must equal default settings
pIMX258Ctx->AecCurGain = pIMX258Ctx->AecMinGain;
pIMX258Ctx->AecCurIntegrationTime = 0.0f;
pIMX258Ctx->OldCoarseIntegrationTime = 0;
pIMX258Ctx->OldFineIntegrationTime = 0;
//pIMX258Ctx->GroupHold = true; //must be true (for unknown reason) to correctly set gain the first time
TRACE( IMX258_INFO, "%s%s (exit)\n", __FUNCTION__, pIMX258Ctx->isAfpsRun?"(AFPS)":"");
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiSetupSensorIss
*
* @brief Setup of the image sensor considering the given configuration.
*
* @param handle IMX258 sensor instance handle
* @param pConfig pointer to sensor configuration structure
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
*
*****************************************************************************/
static RESULT IMX258_IsiSetupSensorIss
(
IsiSensorHandle_t handle,
const IsiSensorConfig_t *pConfig
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint32_t RegValue = 0;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( pConfig == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid configuration (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_NULL_POINTER );
}
if ( pIMX258Ctx->Streaming != BOOL_FALSE )
{
return RET_WRONG_STATE;
}
MEMCPY( &pIMX258Ctx->Config, pConfig, sizeof( IsiSensorConfig_t ) );
/* 1.) SW reset of image IMX258 (via I2C register interface) be careful, bits 6..0 are reserved, reset bit is not sticky */
//result = IMX258_IsiRegWriteIss ( pIMX258Ctx, IMX258_SOFTWARE_RST, IMX258_SOFTWARE_RST_VALUE );//ºê¶¨Òå hkw£»
// RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "%s: IMX258 System-Reset executed\n", __FUNCTION__);
// disable streaming during sensor setup
// (this seems not to be necessary, however Omnivision is doing it in their
// reference settings, simply overwrite upper bits since setup takes care
// of 'em later on anyway)
result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_MODE_SELECT, IMX258_MODE_SELECT_OFF );//IMX258_MODE_SELECT,stream off; hkw
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: Can't write IMX258 Image System Register (disable streaming failed)\n", __FUNCTION__ );
return ( result );
}
/* 2.) write default values derived from datasheet and evaluation kit (static setup altered by dynamic setup further below) */
//result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_aRegDescription );
if(pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes == SUPPORT_MIPI_FOUR_LANE){
//result = HalSetReset( pIMX258Ctx->IsiCtx.HalHandle, pIMX258Ctx->IsiCtx.HalDevID, true );
// RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
result = IsiRegDefaultsApply( pIMX258Ctx, IMX258_g_aRegDescription_fourlane);
// result = HalSetReset( pIMX258Ctx->IsiCtx.HalHandle, pIMX258Ctx->IsiCtx.HalDevID, false );
}
/* End of SYNNEX DEBUG */
if ( result != RET_SUCCESS )
{
return ( result );
}
/* 3.) verify default values to make sure everything has been written correctly as expected */
#if 0
result = IsiRegDefaultsVerify( pIMX258Ctx, IMX258_g_aRegDescription );
if ( result != RET_SUCCESS )
{
return ( result );
}
#endif
#if 0
// output of pclk for measurement (only debugging)
result = IMX258_IsiRegWriteIss( pIMX258Ctx, 0x3009U, 0x10U );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
#endif
/* 4.) setup output format (RAW10|RAW12) */
result = IMX258_SetupOutputFormat( pIMX258Ctx, pConfig );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: SetupOutputFormat failed.\n", __FUNCTION__);
return ( result );
}
/* 5.) setup output window */
result = IMX258_SetupOutputWindow( pIMX258Ctx, pConfig );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: SetupOutputWindow failed.\n", __FUNCTION__);
return ( result );
}
result = IMX258_SetupImageControl( pIMX258Ctx, pConfig );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: SetupImageControl failed.\n", __FUNCTION__);
return ( result );
}
result = IMX258_AecSetModeParameters( pIMX258Ctx, pConfig );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: AecSetModeParameters failed.\n", __FUNCTION__);
return ( result );
}
if (result == RET_SUCCESS)
{
pIMX258Ctx->Configured = BOOL_TRUE;
}
//set OTP info
result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_MODE_SELECT, IMX258_MODE_SELECT_ON );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: Can't write IMX258 Image System Register (disable streaming failed)\n", __FUNCTION__ );
return ( result );
}
// osSleep(30);
apply_otp_data(pIMX258Ctx,NULL);
result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_MODE_SELECT, IMX258_MODE_SELECT_OFF );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: Can't write IMX258 Image System Register (disable streaming failed)\n", __FUNCTION__ );
return ( result );
}
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiChangeSensorResolutionIss
*
* @brief Change image sensor resolution while keeping all other static settings.
* Dynamic settings like current gain & integration time are kept as
* close as possible. Sensor needs 2 frames to engage (first 2 frames
* are not correctly exposed!).
*
* @note Re-read current & min/max values as they will probably have changed!
*
* @param handle Sensor instance handle
* @param Resolution new resolution ID
* @param pNumberOfFramesToSkip reference to storage for number of frames to skip
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_WRONG_STATE
* @retval RET_OUTOFRANGE
* ²»ÓøÄ
*****************************************************************************/
static RESULT IMX258_IsiChangeSensorResolutionIss
(
IsiSensorHandle_t handle,
uint32_t Resolution,
uint8_t *pNumberOfFramesToSkip
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s (enter) Resolution: %dx%d@%dfps\n", __FUNCTION__,
ISI_RES_W_GET(Resolution),ISI_RES_H_GET(Resolution), ISI_FPS_GET(Resolution));
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if (pNumberOfFramesToSkip == NULL)
{
return ( RET_NULL_POINTER );
}
if ( (pIMX258Ctx->Configured != BOOL_TRUE) )
{
return RET_WRONG_STATE;
}
IsiSensorCaps_t Caps;
Caps.Index = 0;
Caps.Resolution = 0;
while (IMX258_IsiGetCapsIss( handle, &Caps) == RET_SUCCESS) {
if (Resolution == Caps.Resolution) {
break;
}
Caps.Index++;
}
if (Resolution != Caps.Resolution) {
return RET_OUTOFRANGE;
}
if ( Resolution == pIMX258Ctx->Config.Resolution )
{
// well, no need to worry
*pNumberOfFramesToSkip = 0;
}
else
{
// change resolution
char *szResName = NULL;
bool_t res_no_chg;
if (!((ISI_RES_W_GET(Resolution)==ISI_RES_W_GET(pIMX258Ctx->Config.Resolution)) &&
(ISI_RES_H_GET(Resolution)==ISI_RES_H_GET(pIMX258Ctx->Config.Resolution))) ) {
if (pIMX258Ctx->Streaming != BOOL_FALSE) {
TRACE( IMX258_ERROR, "%s: Sensor is streaming, Change resolution is not allow\n",__FUNCTION__);
return RET_WRONG_STATE;
}
res_no_chg = BOOL_FALSE;
} else {
res_no_chg = BOOL_TRUE;
}
result = IsiGetResolutionName( Resolution, &szResName );
TRACE( IMX258_DEBUG, "%s: NewRes=0x%08x (%s)\n", __FUNCTION__, Resolution, szResName);
// update resolution in copy of config in context
pIMX258Ctx->Config.Resolution = Resolution;
// tell sensor about that
result = IMX258_SetupOutputWindowInternal( pIMX258Ctx, &pIMX258Ctx->Config, BOOL_TRUE, res_no_chg);
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: SetupOutputWindow failed.\n", __FUNCTION__);
return ( result );
}
// remember old exposure values
float OldGain = pIMX258Ctx->AecCurGain;
float OldIntegrationTime = pIMX258Ctx->AecCurIntegrationTime;
// update limits & stuff (reset current & old settings)
result = IMX258_AecSetModeParameters( pIMX258Ctx, &pIMX258Ctx->Config );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: AecSetModeParameters failed.\n", __FUNCTION__);
return ( result );
}
// restore old exposure values (at least within new exposure values' limits)
uint8_t NumberOfFramesToSkip;
float DummySetGain;
float DummySetIntegrationTime;
result = IMX258_IsiExposureControlIss( handle, OldGain, OldIntegrationTime, &NumberOfFramesToSkip, &DummySetGain, &DummySetIntegrationTime );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: IMX258_IsiExposureControlIss failed.\n", __FUNCTION__);
return ( result );
}
// return number of frames that aren't exposed correctly
if (res_no_chg == BOOL_TRUE)
*pNumberOfFramesToSkip = 0;
else
*pNumberOfFramesToSkip = NumberOfFramesToSkip + 1;
}
TRACE( IMX258_INFO, "%s (exit) result: 0x%x pNumberOfFramesToSkip: %d \n", __FUNCTION__, result,
*pNumberOfFramesToSkip);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiSensorSetStreamingIss
*
* @brief Enables/disables streaming of sensor data, if possible.
*
* @param handle Sensor instance handle
* @param on new streaming state (BOOL_TRUE=on, BOOL_FALSE=off)
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_WRONG_STATE
*
*****************************************************************************/
static RESULT IMX258_IsiSensorSetStreamingIss
(
IsiSensorHandle_t handle,
bool_t on
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_ERROR, "%s (enter) on = %d\n", __FUNCTION__,on);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( (pIMX258Ctx->Configured != BOOL_TRUE) || (pIMX258Ctx->Streaming == on) )
{
return RET_WRONG_STATE;
}
if (on == BOOL_TRUE)
{
/* enable streaming */
result = IMX258_IsiRegWriteIss ( pIMX258Ctx, IMX258_MODE_SELECT, IMX258_MODE_SELECT_ON);//IMX258_MODE_SELECT,stream on; hkw
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
}
else
{
result = IMX258_IsiRegWriteIss ( pIMX258Ctx, IMX258_MODE_SELECT, IMX258_MODE_SELECT_OFF);
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
}
if (result == RET_SUCCESS)
{
pIMX258Ctx->Streaming = on;
}
TRACE( IMX258_INFO, "%s (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiSensorSetPowerIss
*
* @brief Performs the power-up/power-down sequence of the camera, if possible.
*
* @param handle IMX258 sensor instance handle
* @param on new power state (BOOL_TRUE=on, BOOL_FALSE=off)
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* ²»ÓøÄ
*****************************************************************************/
static RESULT IMX258_IsiSensorSetPowerIss
(
IsiSensorHandle_t handle,
bool_t on
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
pIMX258Ctx->Configured = BOOL_FALSE;
pIMX258Ctx->Streaming = BOOL_FALSE;
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
if (on == BOOL_TRUE)
{
TRACE( IMX258_DEBUG, "%s power on \n", __FUNCTION__);
result = HalSetPower( pIMX258Ctx->IsiCtx.HalHandle, pIMX258Ctx->IsiCtx.HalDevID, true );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "%s reset off \n", __FUNCTION__);
result = HalSetReset( pIMX258Ctx->IsiCtx.HalHandle, pIMX258Ctx->IsiCtx.HalDevID, false );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
} else {
TRACE( IMX258_DEBUG, "%s power off \n", __FUNCTION__);
result = HalSetPower( pIMX258Ctx->IsiCtx.HalHandle, pIMX258Ctx->IsiCtx.HalDevID, false );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "%s reset on\n", __FUNCTION__);
result = HalSetReset( pIMX258Ctx->IsiCtx.HalHandle, pIMX258Ctx->IsiCtx.HalDevID, true );
}
TRACE( IMX258_INFO, "%s (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiCheckSensorConnectionIss
*
* @brief Checks the I2C-Connection to sensor by reading sensor revision id.
*
* @param handle IMX258 sensor instance handle
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* ¶Ápid;2»ò3¸ö¼Ä´æÆ÷£»
*****************************************************************************/
static RESULT IMX258_IsiCheckSensorConnectionIss
(
IsiSensorHandle_t handle
)
{
uint32_t RevId;
uint32_t value;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( handle == NULL )
{
return ( RET_WRONG_HANDLE );
}
RevId = IMX258_CHIP_ID_HIGH_BYTE_DEFAULT;
RevId = (RevId<<8U) | IMX258_CHIP_ID_LOW_BYTE_DEFAULT;
result = IMX258_IsiGetSensorRevisionIss( handle, &value );
if ( (result != RET_SUCCESS) || (RevId != value) )
{
TRACE( IMX258_ERROR, "%s RevId = 0x%08x, value = 0x%08x \n", __FUNCTION__, RevId, value );
return ( RET_FAILURE );
}
TRACE( IMX258_DEBUG, "%s RevId = 0x%08x, value = 0x%08x \n", __FUNCTION__, RevId, value );
TRACE( IMX258_INFO, "%s (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetSensorRevisionIss
*
* @brief reads the sensor revision register and returns this value
*
* @param handle pointer to sensor description struct
* @param p_value pointer to storage value
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
*
*****************************************************************************/
static RESULT IMX258_IsiGetSensorRevisionIss
(
IsiSensorHandle_t handle,
uint32_t *p_value
)
{
RESULT result = RET_SUCCESS;
uint32_t data;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( handle == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( p_value == NULL )
{
return ( RET_NULL_POINTER );
}
*p_value = 0U;
result = IMX258_IsiRegReadIss ( handle, IMX258_CHIP_ID_HIGH_BYTE, &data );
*p_value = ( (data & 0xFF) << 8U );
result = IMX258_IsiRegReadIss ( handle, IMX258_CHIP_ID_LOW_BYTE, &data );
*p_value |= ( (data & 0xFF));
*p_value = 0;
TRACE( IMX258_INFO, "%s (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiRegReadIss
*
* @brief grants user read access to the camera register
*
* @param handle pointer to sensor description struct
* @param address sensor register to write
* @param p_value pointer to value
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»ÓøÄ
*****************************************************************************/
static RESULT IMX258_IsiRegReadIss
(
IsiSensorHandle_t handle,
const uint32_t address,
uint32_t *p_value
)
{
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( handle == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( p_value == NULL )
{
return ( RET_NULL_POINTER );
}
else
{
uint8_t NrOfBytes = IsiGetNrDatBytesIss( address, IMX258_g_aRegDescription_fourlane );
if ( !NrOfBytes )
{
NrOfBytes = 1;
}
*p_value = 0;
IsiSensorContext_t *pSensorCtx = (IsiSensorContext_t *)handle;
result = IsiI2cReadSensorRegister( handle, address, (uint8_t *)p_value, NrOfBytes, BOOL_TRUE );
}
TRACE( IMX258_INFO, "%s (exit: 0x%08x 0x%08x)\n", __FUNCTION__, address, *p_value);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiRegWriteIss
*
* @brief grants user write access to the camera register
*
* @param handle pointer to sensor description struct
* @param address sensor register to write
* @param value value to write
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* ²»ÓøÄ
*****************************************************************************/
static RESULT IMX258_IsiRegWriteIss
(
IsiSensorHandle_t handle,
const uint32_t address,
const uint32_t value
)
{
RESULT result = RET_SUCCESS;
uint8_t NrOfBytes;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( handle == NULL )
{
return ( RET_WRONG_HANDLE );
}
NrOfBytes = IsiGetNrDatBytesIss( address, IMX258_g_aRegDescription_fourlane );
if ( !NrOfBytes )
{
NrOfBytes = 1;
}
result = IsiI2cWriteSensorRegister( handle, address, (uint8_t *)(&value), NrOfBytes, BOOL_TRUE );
TRACE( IMX258_INFO, "%s (exit: 0x%08x 0x%08x)\n", __FUNCTION__, address, value);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetGainLimitsIss
*
* @brief Returns the exposure minimal and maximal values of an
* IMX258 instance
*
* @param handle IMX258 sensor instance handle
* @param pMinExposure Pointer to a variable receiving minimal exposure value
* @param pMaxExposure Pointer to a variable receiving maximal exposure value
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* ²»Óøģ»»ñµÃÔöÒæÏÞÖÆ
*****************************************************************************/
static RESULT IMX258_IsiGetGainLimitsIss
(
IsiSensorHandle_t handle,
float *pMinGain,
float *pMaxGain
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint32_t RegValue = 0;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( (pMinGain == NULL) || (pMaxGain == NULL) )
{
TRACE( IMX258_ERROR, "%s: NULL pointer received!!\n" );
return ( RET_NULL_POINTER );
}
*pMinGain = pIMX258Ctx->AecMinGain;
*pMaxGain = pIMX258Ctx->AecMaxGain;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetIntegrationTimeLimitsIss
*
* @brief Returns the minimal and maximal integration time values of an
* IMX258 instance
*
* @param handle IMX258 sensor instance handle
* @param pMinExposure Pointer to a variable receiving minimal exposure value
* @param pMaxExposure Pointer to a variable receiving maximal exposure value
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* ²»Óøģ»»ñµÃÆعâÏÞÖÆ£»
*****************************************************************************/
static RESULT IMX258_IsiGetIntegrationTimeLimitsIss
(
IsiSensorHandle_t handle,
float *pMinIntegrationTime,
float *pMaxIntegrationTime
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint32_t RegValue = 0;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( (pMinIntegrationTime == NULL) || (pMaxIntegrationTime == NULL) )
{
TRACE( IMX258_ERROR, "%s: NULL pointer received!!\n" );
return ( RET_NULL_POINTER );
}
*pMinIntegrationTime = pIMX258Ctx->AecMinIntegrationTime;
*pMaxIntegrationTime = pIMX258Ctx->AecMaxIntegrationTime;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetGainIss
*
* @brief Reads gain values from the image sensor module.
*
* @param handle IMX258 sensor instance handle
* @param pSetGain set gain
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* ²»Óøģ»»ñµÃGAINÖµ
*****************************************************************************/
RESULT IMX258_IsiGetGainIss
(
IsiSensorHandle_t handle,
float *pSetGain
)
{
uint32_t data= 0;
uint32_t result_gain= 0;
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( pSetGain == NULL)
{
return ( RET_NULL_POINTER );
}
#if 0
result = IMX258_IsiRegReadIss ( pIMX258Ctx, IMX258_AEC_AGC_ADJ_H, &data);
TRACE( IMX258_INFO, " -------reg3508:%x-------\n",data );
result_gain = (data & 0x07) ;
result = IMX258_IsiRegReadIss ( pIMX258Ctx, IMX258_AEC_AGC_ADJ_L, &data);
TRACE( IMX258_INFO, " -------reg3509:%x-------\n",data );
result_gain = (result_gain<<8) + data;
*pSetGain = ( (float)result_gain ) / IMX258_MAXN_GAIN;
#else
*pSetGain = pIMX258Ctx->AecCurGain;
#endif
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetGainIncrementIss
*
* @brief Get smallest possible gain increment.
*
* @param handle IMX258 sensor instance handle
* @param pIncr increment
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* ²»Óøģ»»ñµÃGAIN×îСֵ
*****************************************************************************/
RESULT IMX258_IsiGetGainIncrementIss
(
IsiSensorHandle_t handle,
float *pIncr
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( pIncr == NULL)
{
return ( RET_NULL_POINTER );
}
//_smallest_ increment the sensor/driver can handle (e.g. used for sliders in the application)
*pIncr = pIMX258Ctx->AecGainIncrement;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiSetGainIss
*
* @brief Writes gain values to the image sensor module.
* Updates current gain and exposure in sensor struct/state.
*
* @param handle IMX258 sensor instance handle
* @param NewGain gain to be set
* @param pSetGain set gain
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* @retval RET_INVALID_PARM
* @retval RET_FAILURE
*
*****************************************************************************/
RESULT IMX258_IsiSetGainIss
(
IsiSensorHandle_t handle,
float NewGain,
float *pSetGain
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint16_t usGain = 0;
uint16_t iReg = 0;
TRACE( IMX258_INFO, "%s: (enter) pIMX258Ctx->AecMaxGain(%f) \n", __FUNCTION__,pIMX258Ctx->AecMaxGain);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( pSetGain == NULL)
{
TRACE( IMX258_ERROR, "%s: Invalid parameter (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_NULL_POINTER );
}
if( NewGain < pIMX258Ctx->AecMinGain ) NewGain = pIMX258Ctx->AecMinGain;
if( NewGain > pIMX258Ctx->AecMaxGain ) NewGain = pIMX258Ctx->AecMaxGain;
usGain = (uint16_t)(512-(512.0/NewGain)+0.5);
iReg = usGain;
IMX258_IsiRegWriteIss(pIMX258Ctx,0x0204, ((iReg & 0x100) >> 8));
IMX258_IsiRegWriteIss(pIMX258Ctx,0x0205, (iReg & 0xff));
pIMX258Ctx->AecCurGain = (float)(512.0/(512-usGain));
//return current state
*pSetGain = pIMX258Ctx->AecCurGain;
TRACE( IMX258_INFO, "%s: setgain mubiao(%f) shiji(%f)\n", __FUNCTION__, NewGain, *pSetGain);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetIntegrationTimeIss
*
* @brief Reads integration time values from the image sensor module.
*
* @param handle IMX258 sensor instance handle
* @param pSetIntegrationTime set integration time
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* »ñµÃÆعâʱ¼ä ²»ÓøÄ
*****************************************************************************/
RESULT IMX258_IsiGetIntegrationTimeIss
(
IsiSensorHandle_t handle,
float *pSetIntegrationTime
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( pSetIntegrationTime == NULL )
{
return ( RET_NULL_POINTER );
}
*pSetIntegrationTime = pIMX258Ctx->AecCurIntegrationTime;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetIntegrationTimeIncrementIss
*
* @brief Get smallest possible integration time increment.
*
* @param handle IMX258 IMX258 instance handle
* @param pIncr increment
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
* »ñµÃÆعâʱ¼äµÄstep ²»ÓøÄ
*****************************************************************************/
RESULT IMX258_IsiGetIntegrationTimeIncrementIss
(
IsiSensorHandle_t handle,
float *pIncr
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( pIncr == NULL )
{
return ( RET_NULL_POINTER );
}
//_smallest_ increment the IMX258/driver can handle (e.g. used for sliders in the application)
*pIncr = pIMX258Ctx->AecIntegrationTimeIncrement;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiSetIntegrationTimeIss
*
* @brief Writes gain and integration time values to the image sensor module.
* Updates current integration time and exposure in sensor
* struct/state.
*
* @param handle IMX258 sensor instance handle
* @param NewIntegrationTime integration time to be set
* @param pSetIntegrationTime set integration time
* @param pNumberOfFramesToSkip number of frames to skip until AE is
* executed again
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* @retval RET_INVALID_PARM
* @retval RET_FAILURE
* @retval RET_DIVISION_BY_ZERO
*ÉèÖÃÆعâʱ¼ä£»¸ù¾ÝÓ¦ÓÃÊÖ²áÐ޸ļĴæÆ÷ºê
*****************************************************************************/
RESULT IMX258_IsiSetIntegrationTimeIss
(
IsiSensorHandle_t handle,
float NewIntegrationTime,
float *pSetIntegrationTime,
uint8_t *pNumberOfFramesToSkip
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint32_t CoarseIntegrationTime = 0;
uint32_t result_intertime= 0;
float ShutterWidthPck = 0.0f; //shutter width in pixel clock periods
TRACE( IMX258_INFO, "%s: (enter) NewIntegrationTime: %f (min: %f max: %f)\n", __FUNCTION__,
NewIntegrationTime,
pIMX258Ctx->AecMinIntegrationTime,
pIMX258Ctx->AecMaxIntegrationTime);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( (pSetIntegrationTime == NULL) || (pNumberOfFramesToSkip == NULL) )
{
TRACE( IMX258_ERROR, "%s: Invalid parameter (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_NULL_POINTER );
}
if ( NewIntegrationTime > pIMX258Ctx->AecMaxIntegrationTime ) NewIntegrationTime = pIMX258Ctx->AecMaxIntegrationTime;
if ( NewIntegrationTime < pIMX258Ctx->AecMinIntegrationTime ) NewIntegrationTime = pIMX258Ctx->AecMinIntegrationTime;
ShutterWidthPck = NewIntegrationTime * ( (float)pIMX258Ctx->VtPixClkFreq );
// avoid division by zero
if ( pIMX258Ctx->LineLengthPck == 0 )
{
TRACE( IMX258_ERROR, "%s: Division by zero!\n", __FUNCTION__ );
return ( RET_DIVISION_BY_ZERO );
}
CoarseIntegrationTime = (uint32_t)( ShutterWidthPck / ((float)pIMX258Ctx->LineLengthPck) + 0.5f );
if( CoarseIntegrationTime != pIMX258Ctx->OldCoarseIntegrationTime)
{
IMX258_IsiRegWriteIss( pIMX258Ctx, 0x0202,(CoarseIntegrationTime>>8) & 0xFF );
IMX258_IsiRegWriteIss( pIMX258Ctx, 0x0203, CoarseIntegrationTime & 0xFF);
pIMX258Ctx->OldCoarseIntegrationTime = CoarseIntegrationTime; // remember current integration time
*pNumberOfFramesToSkip = 1U; //skip 1 frame
}
else
{
*pNumberOfFramesToSkip = 0U; //no frame skip
}
pIMX258Ctx->AecCurIntegrationTime = ((float)CoarseIntegrationTime) * ((float)pIMX258Ctx->LineLengthPck) / pIMX258Ctx->VtPixClkFreq;
*pSetIntegrationTime = pIMX258Ctx->AecCurIntegrationTime;
TRACE( IMX258_DEBUG, "%s: vtPixClkFreq:%f, LineLengthPck:%x, SetTi=%f, NewTi=%f, CoarseIntegrationTime=%x\n", __FUNCTION__,
pIMX258Ctx->VtPixClkFreq,pIMX258Ctx->LineLengthPck,*pSetIntegrationTime,NewIntegrationTime,CoarseIntegrationTime);
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiExposureControlIss
*
* @brief Camera hardware dependent part of the exposure control loop.
* Calculates appropriate register settings from the new exposure
* values and writes them to the image sensor module.
*
* @param handle IMX258 sensor instance handle
* @param NewGain newly calculated gain to be set
* @param NewIntegrationTime newly calculated integration time to be set
* @param pNumberOfFramesToSkip number of frames to skip until AE is
* executed again
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* @retval RET_INVALID_PARM
* @retval RET_FAILURE
* @retval RET_DIVISION_BY_ZERO
* ²»Óøģ¬ÉèÖÃÕû¸öÆع⣻
*****************************************************************************/
RESULT IMX258_IsiExposureControlIss
(
IsiSensorHandle_t handle,
float NewGain,
float NewIntegrationTime,
uint8_t *pNumberOfFramesToSkip,
float *pSetGain,
float *pSetIntegrationTime
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( (pNumberOfFramesToSkip == NULL)
|| (pSetGain == NULL)
|| (pSetIntegrationTime == NULL) )
{
TRACE( IMX258_ERROR, "%s: Invalid parameter (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_NULL_POINTER );
}
TRACE( IMX258_INFO, "%s: g=%f, Ti=%f\n", __FUNCTION__, NewGain, NewIntegrationTime );
IMX258_IsiRegWriteIss(pIMX258Ctx,0x0104,0x01);
result = IMX258_IsiSetIntegrationTimeIss( handle, NewIntegrationTime, pSetIntegrationTime, pNumberOfFramesToSkip );
result = IMX258_IsiSetGainIss( handle, NewGain, pSetGain );
IMX258_IsiRegWriteIss(pIMX258Ctx,0x0104,0x00);
TRACE( IMX258_INFO, "%s: set: g=%f, Ti=%f, skip=%d\n", __FUNCTION__, *pSetGain, *pSetIntegrationTime, *pNumberOfFramesToSkip );
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCurrentExposureIss
*
* @brief Returns the currently adjusted AE values
*
* @param handle IMX258 sensor instance handle
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
*²»Óøģ¬»ñÈ¡gainºÍexposure ʱ¼ä
*****************************************************************************/
RESULT IMX258_IsiGetCurrentExposureIss
(
IsiSensorHandle_t handle,
float *pSetGain,
float *pSetIntegrationTime
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint32_t RegValue = 0;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( (pSetGain == NULL) || (pSetIntegrationTime == NULL) )
{
return ( RET_NULL_POINTER );
}
*pSetGain = pIMX258Ctx->AecCurGain;
*pSetIntegrationTime = pIMX258Ctx->AecCurIntegrationTime;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetResolutionIss
*
* @brief Reads integration time values from the image sensor module.
*
* @param handle sensor instance handle
* @param pSettResolution set resolution
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»
*****************************************************************************/
RESULT IMX258_IsiGetResolutionIss
(
IsiSensorHandle_t handle,
uint32_t *pSetResolution
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( pSetResolution == NULL )
{
return ( RET_NULL_POINTER );
}
*pSetResolution = pIMX258Ctx->Config.Resolution;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetAfpsInfoHelperIss
*
* @brief Calc AFPS sub resolution settings for the given resolution
*
* @param pIMX258Ctx IMX258 sensor instance (dummy!) context
* @param Resolution Any supported resolution to query AFPS params for
* @param pAfpsInfo Reference of AFPS info structure to write the results to
* @param AfpsStageIdx Index of current AFPS stage to use
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* ²»Óøģ»Ã»Óã»
*****************************************************************************/
static RESULT IMX258_IsiGetAfpsInfoHelperIss(
IMX258_Context_t *pIMX258Ctx,
uint32_t Resolution,
IsiAfpsInfo_t* pAfpsInfo,
uint32_t AfpsStageIdx
)
{
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
DCT_ASSERT(pIMX258Ctx != NULL);
DCT_ASSERT(pAfpsInfo != NULL);
DCT_ASSERT(AfpsStageIdx <= ISI_NUM_AFPS_STAGES);
// update resolution in copy of config in context
pIMX258Ctx->Config.Resolution = Resolution;
// tell sensor about that
result = IMX258_SetupOutputWindowInternal( pIMX258Ctx, &pIMX258Ctx->Config,BOOL_FALSE,BOOL_FALSE );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: SetupOutputWindow failed for resolution ID %08x.\n", __FUNCTION__, Resolution);
return ( result );
}
// update limits & stuff (reset current & old settings)
result = IMX258_AecSetModeParameters( pIMX258Ctx, &pIMX258Ctx->Config );
if ( result != RET_SUCCESS )
{
TRACE( IMX258_ERROR, "%s: AecSetModeParameters failed for resolution ID %08x.\n", __FUNCTION__, Resolution);
return ( result );
}
// take over params
pAfpsInfo->Stage[AfpsStageIdx].Resolution = Resolution;
pAfpsInfo->Stage[AfpsStageIdx].MaxIntTime = pIMX258Ctx->AecMaxIntegrationTime;
pAfpsInfo->AecMinGain = pIMX258Ctx->AecMinGain;
pAfpsInfo->AecMaxGain = pIMX258Ctx->AecMaxGain;
pAfpsInfo->AecMinIntTime = pIMX258Ctx->AecMinIntegrationTime;
pAfpsInfo->AecMaxIntTime = pIMX258Ctx->AecMaxIntegrationTime;
pAfpsInfo->AecSlowestResolution = Resolution;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetAfpsInfoIss
*
* @brief Returns the possible AFPS sub resolution settings for the given resolution series
*
* @param handle IMX258 sensor instance handle
* @param Resolution Any resolution within the AFPS group to query;
* 0 (zero) to use the currently configured resolution
* @param pAfpsInfo Reference of AFPS info structure to store the results
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* @retval RET_NOTSUPP
* ²»Óøģ»Ã»Óã»
*****************************************************************************/
RESULT IMX258_IsiGetAfpsInfoIss(
IsiSensorHandle_t handle,
uint32_t Resolution,
IsiAfpsInfo_t* pAfpsInfo
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint32_t RegValue = 0;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: Invalid sensor handle (NULL pointer detected)\n", __FUNCTION__ );
return ( RET_WRONG_HANDLE );
}
if ( pAfpsInfo == NULL )
{
return ( RET_NULL_POINTER );
}
// use currently configured resolution?
if (Resolution == 0)
{
Resolution = pIMX258Ctx->Config.Resolution;
}
// prepare index
uint32_t idx = 0;
// set current resolution data in info struct
pAfpsInfo->CurrResolution = pIMX258Ctx->Config.Resolution;
pAfpsInfo->CurrMinIntTime = pIMX258Ctx->AecMinIntegrationTime;
pAfpsInfo->CurrMaxIntTime = pIMX258Ctx->AecMaxIntegrationTime;
// allocate dummy context used for Afps parameter calculation as a copy of current context
IMX258_Context_t *pDummyCtx = (IMX258_Context_t*) malloc( sizeof(IMX258_Context_t) );
if ( pDummyCtx == NULL )
{
TRACE( IMX258_ERROR, "%s: Can't allocate dummy IMX258 context\n", __FUNCTION__ );
return ( RET_OUTOFMEM );
}
*pDummyCtx = *pIMX258Ctx;
// set AFPS mode in dummy context
pDummyCtx->isAfpsRun = BOOL_TRUE;
#define AFPSCHECKANDADD(_res_) \
{ \
RESULT lres = IMX258_IsiGetAfpsInfoHelperIss( pDummyCtx, _res_, pAfpsInfo, idx); \
if ( lres == RET_SUCCESS ) \
{ \
++idx; \
} \
else \
{ \
UPDATE_RESULT( result, lres ); \
} \
}
// check which AFPS series is requested and build its params list for the enabled AFPS resolutions
switch (pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes)
{
case SUPPORT_MIPI_FOUR_LANE:
{
switch(Resolution)
{
default:
TRACE( IMX258_DEBUG, "%s: Resolution %08x not supported by AFPS\n", __FUNCTION__, Resolution );
result = RET_NOTSUPP;
break;
case ISI_RES_2096_1560P30:
case ISI_RES_2096_1560P25:
case ISI_RES_2096_1560P20:
case ISI_RES_2096_1560P15:
case ISI_RES_2096_1560P10:
if(ISI_FPS_GET(ISI_RES_2096_1560P30) >= pIMX258Ctx->preview_minimum_framerate)
AFPSCHECKANDADD( ISI_RES_2096_1560P30 );
if(ISI_FPS_GET(ISI_RES_2096_1560P25) >= pIMX258Ctx->preview_minimum_framerate)
AFPSCHECKANDADD( ISI_RES_2096_1560P25 );
if(ISI_FPS_GET(ISI_RES_2096_1560P20) >= pIMX258Ctx->preview_minimum_framerate)
AFPSCHECKANDADD( ISI_RES_2096_1560P20 );
if(ISI_FPS_GET(ISI_RES_2096_1560P15) >= pIMX258Ctx->preview_minimum_framerate)
AFPSCHECKANDADD( ISI_RES_2096_1560P15 );
if(ISI_FPS_GET(ISI_RES_2096_1560P10) >= pIMX258Ctx->preview_minimum_framerate)
AFPSCHECKANDADD( ISI_RES_2096_1560P10 );
break;
case ISI_RES_4208_3120P25:
case ISI_RES_4208_3120P20:
case ISI_RES_4208_3120P15:
case ISI_RES_4208_3120P10:
//case ISI_RES_4208_3120P7:
if(ISI_FPS_GET(ISI_RES_4208_3120P20) >= pIMX258Ctx->preview_minimum_framerate)
AFPSCHECKANDADD( ISI_RES_4208_3120P20 );
if(ISI_FPS_GET(ISI_RES_4208_3120P15) >= pIMX258Ctx->preview_minimum_framerate)
AFPSCHECKANDADD( ISI_RES_4208_3120P15 );
if(ISI_FPS_GET(ISI_RES_4208_3120P10) >= pIMX258Ctx->preview_minimum_framerate)
AFPSCHECKANDADD( ISI_RES_4208_3120P10 );
//if(ISI_FPS_GET(ISI_RES_4208_3120P7) >= pIMX258Ctx->preview_minimum_framerate)
// AFPSCHECKANDADD( ISI_RES_4208_3120P7 );
break;
}
break;
}
default:
TRACE( IMX258_DEBUG, "%s: pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes(0x%x) is invalidate!\n",
__FUNCTION__, pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes );
result = RET_FAILURE;
break;
}
// release dummy context again
free(pDummyCtx);
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCalibKFactor
*
* @brief Returns the IMX258 specific K-Factor
*
* @param handle IMX258 sensor instance handle
* @param pIsiKFactor Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»
*****************************************************************************/
static RESULT IMX258_IsiGetCalibKFactor
(
IsiSensorHandle_t handle,
Isi1x1FloatMatrix_t **pIsiKFactor
)
{
return ( RET_SUCCESS );
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( pIsiKFactor == NULL )
{
return ( RET_NULL_POINTER );
}
//*pIsiKFactor = (Isi1x1FloatMatrix_t *)&IMX258_KFactor;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCalibPcaMatrix
*
* @brief Returns the IMX258 specific PCA-Matrix
*
* @param handle IMX258 sensor instance handle
* @param pIsiPcaMatrix Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»
*****************************************************************************/
static RESULT IMX258_IsiGetCalibPcaMatrix
(
IsiSensorHandle_t handle,
Isi3x2FloatMatrix_t **pIsiPcaMatrix
)
{
return ( RET_SUCCESS );
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( pIsiPcaMatrix == NULL )
{
return ( RET_NULL_POINTER );
}
//*pIsiPcaMatrix = (Isi3x2FloatMatrix_t *)&IMX258_PCAMatrix;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCalibSvdMeanValue
*
* @brief Returns the sensor specific SvdMean-Vector
*
* @param handle IMX258 sensor instance handle
* @param pIsiSvdMeanValue Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»return success;
*****************************************************************************/
static RESULT IMX258_IsiGetCalibSvdMeanValue
(
IsiSensorHandle_t handle,
Isi3x1FloatMatrix_t **pIsiSvdMeanValue
)
{
IsiSensorContext_t *pSensorCtx = (IsiSensorContext_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pSensorCtx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( pIsiSvdMeanValue == NULL )
{
return ( RET_NULL_POINTER );
}
//*pIsiSvdMeanValue = (Isi3x1FloatMatrix_t *)&IMX258_SVDMeanValue;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCalibSvdMeanValue
*
* @brief Returns a pointer to the sensor specific centerline, a straight
* line in Hesse normal form in Rg/Bg colorspace
*
* @param handle IMX258 sensor instance handle
* @param pIsiSvdMeanValue Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»return success;
*****************************************************************************/
static RESULT IMX258_IsiGetCalibCenterLine
(
IsiSensorHandle_t handle,
IsiLine_t **ptIsiCenterLine
)
{
IsiSensorContext_t *pSensorCtx = (IsiSensorContext_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pSensorCtx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( ptIsiCenterLine == NULL )
{
return ( RET_NULL_POINTER );
}
// *ptIsiCenterLine = (IsiLine_t*)&IMX258_CenterLine;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCalibClipParam
*
* @brief Returns a pointer to the sensor specific arrays for Rg/Bg color
* space clipping
*
* @param handle IMX258 sensor instance handle
* @param pIsiSvdMeanValue Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»return success;
*****************************************************************************/
static RESULT IMX258_IsiGetCalibClipParam
(
IsiSensorHandle_t handle,
IsiAwbClipParm_t **pIsiClipParam
)
{
IsiSensorContext_t *pSensorCtx = (IsiSensorContext_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pSensorCtx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( pIsiClipParam == NULL )
{
return ( RET_NULL_POINTER );
}
//*pIsiClipParam = (IsiAwbClipParm_t *)&IMX258_AwbClipParm;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCalibGlobalFadeParam
*
* @brief Returns a pointer to the sensor specific arrays for AWB out of
* range handling
*
* @param handle IMX258 sensor instance handle
* @param pIsiSvdMeanValue Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»return success;
*****************************************************************************/
static RESULT IMX258_IsiGetCalibGlobalFadeParam
(
IsiSensorHandle_t handle,
IsiAwbGlobalFadeParm_t **ptIsiGlobalFadeParam
)
{
IsiSensorContext_t *pSensorCtx = (IsiSensorContext_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pSensorCtx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( ptIsiGlobalFadeParam == NULL )
{
return ( RET_NULL_POINTER );
}
//*ptIsiGlobalFadeParam = (IsiAwbGlobalFadeParm_t *)&IMX258_AwbGlobalFadeParm;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetCalibFadeParam
*
* @brief Returns a pointer to the sensor specific arrays for near white
* pixel parameter calculations
*
* @param handle IMX258 sensor instance handle
* @param pIsiSvdMeanValue Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»return success;
*****************************************************************************/
static RESULT IMX258_IsiGetCalibFadeParam
(
IsiSensorHandle_t handle,
IsiAwbFade2Parm_t **ptIsiFadeParam
)
{
IsiSensorContext_t *pSensorCtx = (IsiSensorContext_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pSensorCtx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( ptIsiFadeParam == NULL )
{
return ( RET_NULL_POINTER );
}
// *ptIsiFadeParam = (IsiAwbFade2Parm_t *)&IMX258_AwbFade2Parm;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiGetIlluProfile
*
* @brief Returns a pointer to illumination profile idetified by CieProfile
* bitmask
*
* @param handle sensor instance handle
* @param CieProfile
* @param ptIsiIlluProfile Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»return success;
*****************************************************************************/
static RESULT IMX258_IsiGetIlluProfile
(
IsiSensorHandle_t handle,
const uint32_t CieProfile,
IsiIlluProfile_t **ptIsiIlluProfile
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
return ( result );
#if 0
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( ptIsiIlluProfile == NULL )
{
return ( RET_NULL_POINTER );
}
else
{
uint16_t i;
*ptIsiIlluProfile = NULL;
/* check if we've a default profile */
for ( i=0U; i<IMX258_ISIILLUPROFILES_DEFAULT; i++ )
{
if ( IMX258_IlluProfileDefault[i].id == CieProfile )
{
*ptIsiIlluProfile = &IMX258_IlluProfileDefault[i];
break;
}
}
// result = ( *ptIsiIlluProfile != NULL ) ? RET_SUCCESS : RET_NOTAVAILABLE;
}
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
#endif
}
/*****************************************************************************/
/**
* IMX258_IsiGetLscMatrixTable
*
* @brief Returns a pointer to illumination profile idetified by CieProfile
* bitmask
*
* @param handle sensor instance handle
* @param CieProfile
* @param ptIsiIlluProfile Pointer to Pointer receiving the memory address
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»return success;
*****************************************************************************/
static RESULT IMX258_IsiGetLscMatrixTable
(
IsiSensorHandle_t handle,
const uint32_t CieProfile,
IsiLscMatrixTable_t **pLscMatrixTable
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
return ( result );
#if 0
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( pLscMatrixTable == NULL )
{
return ( RET_NULL_POINTER );
}
else
{
uint16_t i;
switch ( CieProfile )
{
case ISI_CIEPROF_A:
{
if ( ( pIMX258Ctx->Config.Resolution == ISI_RES_TV1080P30 ))
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_A_1920x1080;
}
#if 0
else if ( pIMX258Ctx->Config.Resolution == ISI_RES_4416_3312 )
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_A_4416x3312;
}
#endif
else
{
TRACE( IMX258_ERROR, "%s: Resolution (%08x) not supported\n", __FUNCTION__, CieProfile );
*pLscMatrixTable = NULL;
}
break;
}
case ISI_CIEPROF_F2:
{
if ( ( pIMX258Ctx->Config.Resolution == ISI_RES_TV1080P30 ) )
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_F2_1920x1080;
}
#if 0
else if ( pIMX258Ctx->Config.Resolution == ISI_RES_4416_3312 )
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_F2_4416x3312;
}
#endif
else
{
TRACE( IMX258_ERROR, "%s: Resolution (%08x) not supported\n", __FUNCTION__, CieProfile );
*pLscMatrixTable = NULL;
}
break;
}
case ISI_CIEPROF_D50:
{
if ( ( pIMX258Ctx->Config.Resolution == ISI_RES_TV1080P30 ))
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_D50_1920x1080;
}
#if 0
else if ( pIMX258Ctx->Config.Resolution == ISI_RES_4416_3312 )
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_D50_4416x3312;
}
#endif
else
{
TRACE( IMX258_ERROR, "%s: Resolution (%08x) not supported\n", __FUNCTION__, CieProfile );
*pLscMatrixTable = NULL;
}
break;
}
case ISI_CIEPROF_D65:
case ISI_CIEPROF_D75:
{
if ( ( pIMX258Ctx->Config.Resolution == ISI_RES_TV1080P30 ) )
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_D65_1920x1080;
}
#if 0
else if ( pIMX258Ctx->Config.Resolution == ISI_RES_4416_3312 )
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_D65_4416x3312;
}
#endif
else
{
TRACE( IMX258_ERROR, "%s: Resolution (%08x) not supported\n", __FUNCTION__, CieProfile );
*pLscMatrixTable = NULL;
}
break;
}
case ISI_CIEPROF_F11:
{
if ( ( pIMX258Ctx->Config.Resolution == ISI_RES_TV1080P30 ))
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_F11_1920x1080;
}
#if 0
else if ( pIMX258Ctx->Config.Resolution == ISI_RES_4416_3312 )
{
*pLscMatrixTable = &IMX258_LscMatrixTable_CIE_F11_4416x3312;
}
#endif
else
{
TRACE( IMX258_ERROR, "%s: Resolution (%08x) not supported\n", __FUNCTION__, CieProfile );
*pLscMatrixTable = NULL;
}
break;
}
default:
{
TRACE( IMX258_ERROR, "%s: Illumination not supported\n", __FUNCTION__ );
*pLscMatrixTable = NULL;
break;
}
}
result = ( *pLscMatrixTable != NULL ) ? RET_SUCCESS : RET_NOTAVAILABLE;
}
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
#endif
}
/*****************************************************************************/
/**
* IMX258_IsiMdiInitMotoDriveMds
*
* @brief General initialisation tasks like I/O initialisation.
*
* @param handle IMX258 sensor instance handle
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»
*****************************************************************************/
static RESULT IMX258_IsiMdiInitMotoDriveMds
(
IsiSensorHandle_t handle
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiMdiSetupMotoDrive
*
* @brief Setup of the MotoDrive and return possible max step.
*
* @param handle IMX258 sensor instance handle
* pMaxStep pointer to variable to receive the maximum
* possible focus step
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»
*****************************************************************************/
static RESULT IMX258_IsiMdiSetupMotoDrive
(
IsiSensorHandle_t handle,
uint32_t *pMaxStep
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
uint32_t vcm_movefull_t;
RESULT result = RET_SUCCESS;
#if MODULE_NAME == MODULE_CMK
uint8_t puSendCmd2[2] = { 0x02, 0x02 };
uint8_t puSendCmd3[2] = { 0x06, 0x61 };
uint8_t puSendCmd4[2] = { 0x07, 0x31 };
unsigned char vbusy = 0;
#elif MODULE_NAME == MODULE_GZ
uint8_t puSendCmd1[2] = { 0xec, 0xa3 };
uint8_t puSendCmd2[2] = { 0xa1, 0x0f };
uint8_t puSendCmd3[2] = { 0xf2, 0x00 };
uint8_t puSendCmd4[2] = { 0xdc, 0x51 };
#endif
TRACE( IMX258_DEBUG, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( pMaxStep == NULL )
{
return ( RET_NULL_POINTER );
}
#if MODULE_NAME == MODULE_CMK
do{
result = HalReadI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
0x05,
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&vbusy,
1U );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
osSleep(10);
}while((vbusy&0x01));
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
puSendCmd2[0],
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&puSendCmd2[1],
1U );
osSleep(5);
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
puSendCmd3[0],
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&puSendCmd3[1],
1U );
osSleep(5);
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
puSendCmd4[0],
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&puSendCmd4[1],
1U );
#elif MODULE_NAME == MODULE_GZ
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
puSendCmd1[0],
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&puSendCmd1[1],
1U );
osSleep(5);
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
puSendCmd2[0],
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&puSendCmd2[1],
1U );
osSleep(5);
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
puSendCmd3[0],
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&puSendCmd3[1],
1U );
osSleep(5);
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
puSendCmd4[0],
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&puSendCmd4[1],
1U );
#endif
if ((pIMX258Ctx->VcmInfo.StepMode & 0x0c) != 0) {
vcm_movefull_t = 64* (1<<(pIMX258Ctx->VcmInfo.StepMode & 0x03)) *1024/((1 << (((pIMX258Ctx->VcmInfo.StepMode & 0x0c)>>2)-1))*1000);
}else{
vcm_movefull_t =64*1023/1000;
TRACE( IMX258_NOTICE0, "%s: (---NO SRC---)\n", __FUNCTION__);
}
*pMaxStep = (MAX_LOG|(vcm_movefull_t<<16));
// *pMaxStep = MAX_LOG;
result = IMX258_IsiMdiFocusSet( handle, MAX_LOG );
TRACE( IMX258_DEBUG, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiMdiFocusSet
*
* @brief Drives the lens system to a certain focus point.
*
* @param handle IMX258 sensor instance handle
* AbsStep absolute focus point to apply
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²Î¿¼14825£»ÍâÖÃÂí´ï£»
*****************************************************************************/
static RESULT IMX258_IsiMdiFocusSet
(
IsiSensorHandle_t handle,
const uint32_t Position
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint32_t nPosition;
uint8_t data[2] = { 0, 0};
#if MODULE_NAME == MODULE_CMK
unsigned char vbusy = 0;
#endif
TRACE( IMX258_DEBUG, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
/* SYNNEX DEBUG*/
#if 1
/* map 64 to 0 -> infinity */
//nPosition = ( Position >= MAX_LOG ) ? 0 : ( MAX_REG - (Position * 16U) );
if( Position > MAX_LOG ){
TRACE( IMX258_ERROR, "%s: pIMX258Ctx Position (%d) max_position(%d)\n", __FUNCTION__,Position, MAX_LOG);
//Position = MAX_LOG;
}
/* [email protected]: v0.3.0 */
if ( Position >= MAX_LOG )
nPosition = pIMX258Ctx->VcmInfo.StartCurrent;
else
nPosition = pIMX258Ctx->VcmInfo.StartCurrent + (pIMX258Ctx->VcmInfo.Step*(MAX_LOG-Position));
/* [email protected]: v0.6.0 */
if (nPosition > MAX_VCMDRV_REG)
nPosition = MAX_VCMDRV_REG;
#if MODULE_NAME == MODULE_GZ
data[0] = (uint8_t)(0x00U | (( nPosition & 0x3F0U ) >> 4U)); // PD, 1, D9..D4, see AD5820 datasheet
//data[1] = (uint8_t)( ((nPosition & 0x0FU) << 4U) | MDI_SLEW_RATE_CTRL ); // D3..D0, S3..S0
data[1] = (uint8_t)( ((nPosition & 0x0FU) << 4U) | pIMX258Ctx->VcmInfo.StepMode );
TRACE( IMX258_DEBUG, "%s: value = %d, 0x%02x 0x%02x\n", __FUNCTION__, nPosition, data[0], data[1] );
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
0,
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
data,
2U );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
#elif MODULE_NAME == MODULE_CMK
data[0] = (uint8_t)(0x00U | (( nPosition & 0x300U ) >> 8U));
data[1] = (uint8_t)(nPosition & 0xFFU);
do{
result = HalReadI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
0x05,
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&vbusy,
1U );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
osSleep(10);
TRACE( IMX258_DEBUG, "%s:wait for vbusy %d\n", __FUNCTION__,vbusy);
}while((vbusy&0x01));
result = HalWriteI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
0X03,
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
data,
2U );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "%s: value = %d, 0x%02x 0x%02x\n", __FUNCTION__, nPosition, data[0], data[1] );
#endif
TRACE( IMX258_DEBUG, "%s: (exit)\n", __FUNCTION__);
#endif
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiMdiFocusGet
*
* @brief Retrieves the currently applied focus point.
*
* @param handle IMX258 sensor instance handle
* pAbsStep pointer to a variable to receive the current
* focus point
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²Î¿¼14825£»ÍâÖÃÂí´ï£»
*****************************************************************************/
static RESULT IMX258_IsiMdiFocusGet
(
IsiSensorHandle_t handle,
uint32_t *pAbsStep
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
uint8_t data[2] = { 0, 0 };
#if MODULE_NAME == MODULE_CMK
unsigned char vbusy = 0;
#endif
TRACE( IMX258_DEBUG, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( pAbsStep == NULL )
{
return ( RET_NULL_POINTER );
}
/* SYNNEX DEBUG */
#if MODULE_NAME == MODULE_GZ
result = HalReadI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
0,
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
data,
2U );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "%s:[SYNNEX_VAM_DEBUG] value = 0x%02x 0x%02x\n", __FUNCTION__, data[0], data[1] );
/* Data[0] = PD, 1, D9..D4, see VM149C datasheet */
/* Data[1] = D3..D0, S3..S0 */
*pAbsStep = ( ((uint32_t)(data[0] & 0x3FU)) << 4U ) | ( ((uint32_t)data[1]) >> 4U );
#elif MODULE_NAME == MODULE_CMK
do{
result = HalReadI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
0x05,
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
&vbusy,
1U );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
osSleep(10);
TRACE( IMX258_DEBUG, "%s:czf wait for vbusy %d\n", __FUNCTION__,vbusy);
}while((vbusy&0x01));
result = HalReadI2CMem( pIMX258Ctx->IsiCtx.HalHandle,
pIMX258Ctx->IsiCtx.I2cAfBusNum,
pIMX258Ctx->IsiCtx.SlaveAfAddress,
0x03,
pIMX258Ctx->IsiCtx.NrOfAfAddressBytes,
data,
2U );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
TRACE( IMX258_DEBUG, "%s:[SYNNEX_VAM_DEBUG] value = 0x%02x 0x%02x\n", __FUNCTION__, data[0], data[1] );
/* Data[0] = PD, 1, D9..D4, see VM149C datasheet */
/* Data[1] = D3..D0, S3..S0 */
*pAbsStep = ( ((uint32_t)(data[0] & 0x03U)) << 8U ) | ( (uint32_t)data[1]);
#endif
/* //map 0 to 64 -> infinity
if( *pAbsStep == 0 )
{
*pAbsStep = MAX_LOG;
}
else
{
*pAbsStep = ( MAX_REG - *pAbsStep ) / 16U;
}*/
if( *pAbsStep <= pIMX258Ctx->VcmInfo.StartCurrent)
{
*pAbsStep = MAX_LOG;
}
else if((*pAbsStep>pIMX258Ctx->VcmInfo.StartCurrent) && (*pAbsStep<=pIMX258Ctx->VcmInfo.RatedCurrent))
{
*pAbsStep = (pIMX258Ctx->VcmInfo.RatedCurrent - *pAbsStep ) / pIMX258Ctx->VcmInfo.Step;
}
else
{
*pAbsStep = 0;
}
TRACE( IMX258_DEBUG, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiMdiFocusCalibrate
*
* @brief Triggers a forced calibration of the focus hardware.
*
* @param handle IMX258 sensor instance handle
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»Óøģ»Ã»Óã»
*****************************************************************************/
static RESULT IMX258_IsiMdiFocusCalibrate
(
IsiSensorHandle_t handle
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
/*****************************************************************************/
/**
* IMX258_IsiActivateTestPattern
*
* @brief Triggers a forced calibration of the focus hardware.
*
* @param handle IMX258 sensor instance handle
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
*²»Óøģ¬Ã»Óã¬return£»
******************************************************************************/
static RESULT IMX258_IsiActivateTestPattern
(
IsiSensorHandle_t handle,
const bool_t enable
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
return ( result );
#if 0
uint32_t ulRegValue = 0UL;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( BOOL_TRUE == enable )
{
/* enable test-pattern */
result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_PRE_ISP_CTRL00, &ulRegValue );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
ulRegValue |= ( 0x80U );
result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_PRE_ISP_CTRL00, ulRegValue );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
}
else
{
/* disable test-pattern */
result = IMX258_IsiRegReadIss( pIMX258Ctx, IMX258_PRE_ISP_CTRL00, &ulRegValue );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
ulRegValue &= ~( 0x80 );
result = IMX258_IsiRegWriteIss( pIMX258Ctx, IMX258_PRE_ISP_CTRL00, ulRegValue );
RETURN_RESULT_IF_DIFFERENT( RET_SUCCESS, result );
}
pIMX258Ctx->TestPattern = enable;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
#endif
}
/*****************************************************************************/
/**
* IMX258_IsiGetSensorMipiInfoIss
*
* @brief Triggers a forced calibration of the focus hardware.
*
* @param handle IMX258 sensor instance handle
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_WRONG_HANDLE
* @retval RET_NULL_POINTER
* ²»ÓøÄ
******************************************************************************/
static RESULT IMX258_IsiGetSensorMipiInfoIss
(
IsiSensorHandle_t handle,
IsiSensorMipiInfo *ptIsiSensorMipiInfo
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
return ( RET_WRONG_HANDLE );
}
if ( ptIsiSensorMipiInfo == NULL )
{
return ( result );
}
ptIsiSensorMipiInfo->ucMipiLanes = pIMX258Ctx->IsiSensorMipiInfo.ucMipiLanes;
ptIsiSensorMipiInfo->ulMipiFreq= pIMX258Ctx->IsiSensorMipiInfo.ulMipiFreq;
ptIsiSensorMipiInfo->sensorHalDevID = pIMX258Ctx->IsiSensorMipiInfo.sensorHalDevID;
TRACE( IMX258_INFO, "%s: (exit)\n", __FUNCTION__);
return ( result );
}
static RESULT IMX258_IsiGetSensorIsiVersion
( IsiSensorHandle_t handle,
unsigned int* pVersion
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: pIMX258Ctx IS NULL\n", __FUNCTION__);
return ( RET_WRONG_HANDLE );
}
if(pVersion == NULL)
{
TRACE( IMX258_ERROR, "%s: pVersion IS NULL\n", __FUNCTION__);
return ( RET_WRONG_HANDLE );
}
*pVersion = CONFIG_ISI_VERSION;
return result;
}
static RESULT IMX258_IsiGetSensorTuningXmlVersion
( IsiSensorHandle_t handle,
char** pTuningXmlVersion
)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: pIMX258Ctx IS NULL\n", __FUNCTION__);
return ( RET_WRONG_HANDLE );
}
if(pTuningXmlVersion == NULL)
{
TRACE( IMX258_ERROR, "%s: pVersion IS NULL\n", __FUNCTION__);
return ( RET_WRONG_HANDLE );
}
*pTuningXmlVersion = IMX258_NEWEST_TUNING_XML;
return result;
}
static RESULT IMX258_IsiSetSensorFrameRateLimit(IsiSensorHandle_t handle, uint32_t minimum_framerate)
{
IMX258_Context_t *pIMX258Ctx = (IMX258_Context_t *)handle;
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s: (enter)\n", __FUNCTION__);
if ( pIMX258Ctx == NULL )
{
TRACE( IMX258_ERROR, "%s: pIMX258Ctx IS NULL\n", __FUNCTION__);
return ( RET_WRONG_HANDLE );
}
pIMX258Ctx->preview_minimum_framerate = minimum_framerate;
return RET_SUCCESS;
}
/*****************************************************************************/
/**
* IMX258_IsiGetSensorIss
*
* @brief fills in the correct pointers for the sensor description struct
*
* @param param1 pointer to sensor description struct
*
* @return Return the result of the function call.
* @retval RET_SUCCESS
* @retval RET_NULL_POINTER
*
*****************************************************************************/
RESULT IMX258_IsiGetSensorIss
(
IsiSensor_t *pIsiSensor
)
{
RESULT result = RET_SUCCESS;
TRACE( IMX258_INFO, "%s (enter)\n", __FUNCTION__);
if ( pIsiSensor != NULL )
{
pIsiSensor->pszName = IMX258_g_acName;
pIsiSensor->pRegisterTable = IMX258_g_aRegDescription_fourlane;
pIsiSensor->pIsiSensorCaps = &IMX258_g_IsiSensorDefaultConfig;
pIsiSensor->pIsiGetSensorIsiVer = IMX258_IsiGetSensorIsiVersion;//oyyf
pIsiSensor->pIsiGetSensorTuningXmlVersion = IMX258_IsiGetSensorTuningXmlVersion;//oyyf
#if MODULE_NAME == MODULE_CMK
pIsiSensor->pIsiCheckOTPInfo = NULL;
#else
pIsiSensor->pIsiCheckOTPInfo = check_read_otp;
#endif
pIsiSensor->pIsiSetSensorOTPInfo = IMX258_IsiSetOTPInfo;
pIsiSensor->pIsiEnableSensorOTP = IMX258_IsiEnableOTP;
pIsiSensor->pIsiCreateSensorIss = IMX258_IsiCreateSensorIss;
pIsiSensor->pIsiReleaseSensorIss = IMX258_IsiReleaseSensorIss;
pIsiSensor->pIsiGetCapsIss = IMX258_IsiGetCapsIss;
pIsiSensor->pIsiSetupSensorIss = IMX258_IsiSetupSensorIss;
pIsiSensor->pIsiChangeSensorResolutionIss = IMX258_IsiChangeSensorResolutionIss;
pIsiSensor->pIsiSensorSetStreamingIss = IMX258_IsiSensorSetStreamingIss;
pIsiSensor->pIsiSensorSetPowerIss = IMX258_IsiSensorSetPowerIss;
pIsiSensor->pIsiCheckSensorConnectionIss = IMX258_IsiCheckSensorConnectionIss;
pIsiSensor->pIsiGetSensorRevisionIss = IMX258_IsiGetSensorRevisionIss;
pIsiSensor->pIsiRegisterReadIss = IMX258_IsiRegReadIss;
pIsiSensor->pIsiRegisterWriteIss = IMX258_IsiRegWriteIss;
pIsiSensor->pIsiExposureControlIss = IMX258_IsiExposureControlIss;
pIsiSensor->pIsiGetGainLimitsIss = IMX258_IsiGetGainLimitsIss;
pIsiSensor->pIsiGetIntegrationTimeLimitsIss = IMX258_IsiGetIntegrationTimeLimitsIss;
pIsiSensor->pIsiGetCurrentExposureIss = IMX258_IsiGetCurrentExposureIss;
pIsiSensor->pIsiGetGainIss = IMX258_IsiGetGainIss;
pIsiSensor->pIsiGetGainIncrementIss = IMX258_IsiGetGainIncrementIss;
pIsiSensor->pIsiSetGainIss = IMX258_IsiSetGainIss;
pIsiSensor->pIsiGetIntegrationTimeIss = IMX258_IsiGetIntegrationTimeIss;
pIsiSensor->pIsiGetIntegrationTimeIncrementIss = IMX258_IsiGetIntegrationTimeIncrementIss;
pIsiSensor->pIsiSetIntegrationTimeIss = IMX258_IsiSetIntegrationTimeIss;
pIsiSensor->pIsiGetResolutionIss = IMX258_IsiGetResolutionIss;
pIsiSensor->pIsiGetAfpsInfoIss = IMX258_IsiGetAfpsInfoIss;
/* AWB specific functions */
/* END of SYNNEX DEBUG */
pIsiSensor->pIsiGetCalibKFactor = IMX258_IsiGetCalibKFactor;
pIsiSensor->pIsiGetCalibPcaMatrix = IMX258_IsiGetCalibPcaMatrix;
pIsiSensor->pIsiGetCalibSvdMeanValue = IMX258_IsiGetCalibSvdMeanValue;
pIsiSensor->pIsiGetCalibCenterLine = IMX258_IsiGetCalibCenterLine;
pIsiSensor->pIsiGetCalibClipParam = IMX258_IsiGetCalibClipParam;
pIsiSensor->pIsiGetCalibGlobalFadeParam = IMX258_IsiGetCalibGlobalFadeParam;
pIsiSensor->pIsiGetCalibFadeParam = IMX258_IsiGetCalibFadeParam;
pIsiSensor->pIsiGetIlluProfile = IMX258_IsiGetIlluProfile;
pIsiSensor->pIsiGetLscMatrixTable = IMX258_IsiGetLscMatrixTable;
/*SYNNEX DEBUG */
/* AF functions */
pIsiSensor->pIsiMdiInitMotoDriveMds = IMX258_IsiMdiInitMotoDriveMds;
pIsiSensor->pIsiMdiSetupMotoDrive = IMX258_IsiMdiSetupMotoDrive;
pIsiSensor->pIsiMdiFocusSet = IMX258_IsiMdiFocusSet;
pIsiSensor->pIsiMdiFocusGet = IMX258_IsiMdiFocusGet;
pIsiSensor->pIsiMdiFocusCalibrate = IMX258_IsiMdiFocusCalibrate;
/* END of SYNNEX DEBUG */
/* MIPI */
pIsiSensor->pIsiGetSensorMipiInfoIss = IMX258_IsiGetSensorMipiInfoIss;
/* Testpattern */
pIsiSensor->pIsiActivateTestPattern = IMX258_IsiActivateTestPattern;
pIsiSensor->pIsiSetSensorFrameRateLimit = IMX258_IsiSetSensorFrameRateLimit;
}
else
{
result = RET_NULL_POINTER;
}
TRACE( IMX258_INFO, "%s (exit)\n", __FUNCTION__);
return ( result );
}
//fix;hkw 14825
static RESULT IMX258_IsiGetSensorI2cInfo(sensor_i2c_info_t** pdata)
{
sensor_i2c_info_t* pSensorI2cInfo;
pSensorI2cInfo = ( sensor_i2c_info_t * )malloc ( sizeof (sensor_i2c_info_t) );
if ( pSensorI2cInfo == NULL )
{
TRACE( IMX258_ERROR, "%s: Can't allocate IMX258 context\n", __FUNCTION__ );
return ( RET_OUTOFMEM );
}
MEMSET( pSensorI2cInfo, 0, sizeof( sensor_i2c_info_t ) );
pSensorI2cInfo->i2c_addr = IMX258_SLAVE_ADDR;
pSensorI2cInfo->i2c_addr2 = IMX258_SLAVE_ADDR2;
//pSensorI2cInfo->soft_reg_addr = 0;
//pSensorI2cInfo->soft_reg_value = 0;
pSensorI2cInfo->reg_size = 2;
pSensorI2cInfo->value_size = 1;
TRACE( IMX258_DEBUG, "%s: i2c_addr: 0x%x\n", __FUNCTION__, pSensorI2cInfo->i2c_addr);
{
IsiSensorCaps_t Caps;
sensor_caps_t *pCaps;
uint32_t lanes,i;
for (i=0; i<3; i++) {
lanes = (1<<i);
ListInit(&pSensorI2cInfo->lane_res[i]);
if (g_suppoted_mipi_lanenum_type & lanes) {
Caps.Index = 0;
while(IMX258_IsiGetCapsIssInternal(&Caps,lanes)==RET_SUCCESS) {
pCaps = malloc(sizeof(sensor_caps_t));
if (pCaps != NULL) {
memcpy(&pCaps->caps,&Caps,sizeof(IsiSensorCaps_t));
ListPrepareItem(pCaps);
ListAddTail(&pSensorI2cInfo->lane_res[i], pCaps);
}
Caps.Index++;
}
}
}
}
ListInit(&pSensorI2cInfo->chipid_info);
sensor_chipid_info_t* pChipIDInfo_H = (sensor_chipid_info_t *) malloc( sizeof(sensor_chipid_info_t) );
if ( !pChipIDInfo_H )
{
return RET_OUTOFMEM;
}
MEMSET( pChipIDInfo_H, 0, sizeof(*pChipIDInfo_H) );
pChipIDInfo_H->chipid_reg_addr = IMX258_CHIP_ID_HIGH_BYTE;
pChipIDInfo_H->chipid_reg_value = IMX258_CHIP_ID_HIGH_BYTE_DEFAULT;
ListPrepareItem( pChipIDInfo_H );
ListAddTail( &pSensorI2cInfo->chipid_info, pChipIDInfo_H );
/*
sensor_chipid_info_t* pChipIDInfo_M = (sensor_chipid_info_t *) malloc( sizeof(sensor_chipid_info_t) );
if ( !pChipIDInfo_M )
{
return RET_OUTOFMEM;
}
MEMSET( pChipIDInfo_M, 0, sizeof(*pChipIDInfo_M) );
pChipIDInfo_M->chipid_reg_addr = IMX258_CHIP_ID_MIDDLE_BYTE;
pChipIDInfo_M->chipid_reg_value = IMX258_CHIP_ID_MIDDLE_BYTE_DEFAULT;
ListPrepareItem( pChipIDInfo_M );
ListAddTail( &pSensorI2cInfo->chipid_info, pChipIDInfo_M );
*/
sensor_chipid_info_t* pChipIDInfo_L = (sensor_chipid_info_t *) malloc( sizeof(sensor_chipid_info_t) );
if ( !pChipIDInfo_L )
{
return RET_OUTOFMEM;
}
MEMSET( pChipIDInfo_L, 0, sizeof(*pChipIDInfo_L) );
pChipIDInfo_L->chipid_reg_addr = IMX258_CHIP_ID_LOW_BYTE;
pChipIDInfo_L->chipid_reg_value = IMX258_CHIP_ID_LOW_BYTE_DEFAULT;
ListPrepareItem( pChipIDInfo_L );
ListAddTail( &pSensorI2cInfo->chipid_info, pChipIDInfo_L );
//oyyf sensor drv version
pSensorI2cInfo->sensor_drv_version = CONFIG_SENSOR_DRV_VERSION;
*pdata = pSensorI2cInfo;
return RET_SUCCESS;
}
/******************************************************************************
* See header file for detailed comment.
*****************************************************************************/
/*****************************************************************************/
/**
*/
/*****************************************************************************/
IsiCamDrvConfig_t IsiCamDrvConfig =
{
0,
IMX258_IsiGetSensorIss,
{
0, /**< IsiSensor_t.pszName */
0, /**< IsiSensor_t.pRegisterTable */
0, /**< IsiSensor_t.pIsiSensorCaps */
0, /**< IsiSensor_t.pIsiGetSensorIsiVer_t>*/ //oyyf add
0, /**< IsiSensor_t.pIsiGetSensorTuningXmlVersion_t>*/ //oyyf add
0, /**< IsiSensor_t.pIsiWhiteBalanceIlluminationChk>*/ //[email protected]
0, /**< IsiSensor_t.pIsiWhiteBalanceIlluminationSet>*/ //[email protected]
0, /**< IsiSensor_t.pIsiCheckOTPInfo>*/ //zyc
0, /**< IsiSensor_t.pIsiSetSensorOTPInfo>*/ //zyl
0, /**< IsiSensor_t.pIsiEnableSensorOTP>*/ //zyl
0, /**< IsiSensor_t.pIsiCreateSensorIss */
0, /**< IsiSensor_t.pIsiReleaseSensorIss */
0, /**< IsiSensor_t.pIsiGetCapsIss */
0, /**< IsiSensor_t.pIsiSetupSensorIss */
0, /**< IsiSensor_t.pIsiChangeSensorResolutionIss */
0, /**< IsiSensor_t.pIsiSensorSetStreamingIss */
0, /**< IsiSensor_t.pIsiSensorSetPowerIss */
0, /**< IsiSensor_t.pIsiCheckSensorConnectionIss */
0, /**< IsiSensor_t.pIsiGetSensorRevisionIss */
0, /**< IsiSensor_t.pIsiRegisterReadIss */
0, /**< IsiSensor_t.pIsiRegisterWriteIss */
0, /**< IsiSensor_t.pIsiIsEvenFieldIss */
0, /**< IsiSensor_t.pIsiExposureControlIss */
0, /**< IsiSensor_t.pIsiGetGainLimitsIss */
0, /**< IsiSensor_t.pIsiGetIntegrationTimeLimitsIss */
0, /**< IsiSensor_t.pIsiGetCurrentExposureIss */
0, /**< IsiSensor_t.pIsiGetGainIss */
0, /**< IsiSensor_t.pIsiGetGainIncrementIss */
0, /**< IsiSensor_t.pIsiSetGainIss */
0, /**< IsiSensor_t.pIsiGetIntegrationTimeIss */
0, /**< IsiSensor_t.pIsiGetIntegrationTimeIncrementIss */
0, /**< IsiSensor_t.pIsiSetIntegrationTimeIss */
0, /**< IsiSensor_t.pIsiGetResolutionIss */
0, /**< IsiSensor_t.pIsiGetAfpsInfoIss */
0, /**< IsiSensor_t.pIsiGetCalibKFactor */
0, /**< IsiSensor_t.pIsiGetCalibPcaMatrix */
0, /**< IsiSensor_t.pIsiGetCalibSvdMeanValue */
0, /**< IsiSensor_t.pIsiGetCalibCenterLine */
0, /**< IsiSensor_t.pIsiGetCalibClipParam */
0, /**< IsiSensor_t.pIsiGetCalibGlobalFadeParam */
0, /**< IsiSensor_t.pIsiGetCalibFadeParam */
0, /**< IsiSensor_t.pIsiGetIlluProfile */
0, /**< IsiSensor_t.pIsiGetLscMatrixTable */
0, /**< IsiSensor_t.pIsiMdiInitMotoDriveMds */
0, /**< IsiSensor_t.pIsiMdiSetupMotoDrive */
0, /**< IsiSensor_t.pIsiMdiFocusSet */
0, /**< IsiSensor_t.pIsiMdiFocusGet */
0, /**< IsiSensor_t.pIsiMdiFocusCalibrate */
0, /**< IsiSensor_t.pIsiGetSensorMipiInfoIss */
0, /**< IsiSensor_t.pIsiActivateTestPattern */
0,
0, /**< IsiSensor_t.pIsiGetColorIss */
},
IMX258_IsiGetSensorI2cInfo,
};
|
1935ff0b6fed90e5ee9bf21bbe3b36481f52a75e | b59d36b2103bcedd9abadc8a3d796bce01e20f1b | /mcu/RTC.c | 721d9afce2a4f21a2e7e2b1fc584721f3cc1bc4d | [] | no_license | lehoangnb/Fx2N | 768ad6190603abd9bba336f9bd9992887849c40b | 492c286dce868a5dae4615c4156a080a6fdb83df | refs/heads/master | 2023-04-06T16:40:17.056544 | 2017-05-02T12:03:53 | 2017-05-02T12:04:01 | null | 0 | 0 | null | null | null | null | GB18030 | C | false | false | 1,670 | c | RTC.c | /***************************************
* 文件名 ：rtc.c
* 描述 ：利用STM32的RTC实现一个简易的电子时钟。
* 显示格式为 Time: XX : XX : XX(时：分：秒)。
* 实验平台：
* 硬件连接：-------------------
* | |
* | VBAT引脚需外接电池|
* | |
* -----------------
* 库版本 ：ST3.5
*
* 作者 ：
* 博客 ：
**********************************************************************************/
#include "rtc.h"
/*
* 函数名：RTC_Configuration
* 描述 ：配置RTC
* 输入 ：无
* 输出 ：无
* 调用 ：外部调用
*/
void RTC_Configuration(void)
{
/* Enable PWR and BKP clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
/* Reset Backup Domain */
BKP_DeInit();
/* Enable LSE */
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSE is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
{}
/* Select LSE as RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
/* Enable RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC registers synchronization */
RTC_WaitForSynchro();
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Set RTC prescaler: set RTC period to 1sec */
RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1) */
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
/************************END OF FILE****/
|
99995b3a199707a9f952485f4230e27bfca46c83 | 34a39243548f6c21aec37dd4c1078ccbe71c13f1 | /SDC/lib/spi.h | cd2ba8120bd0570384316d5367a509442ddad118 | [] | no_license | rummanwaqar/STM32VL_Examples | e31c33c9e2a98ec4e33f0d22b6a6a1af2b711d72 | 478d7471b911abc9f6a5a0eb97140b11b76a1ef3 | refs/heads/master | 2020-04-26T22:47:48.624454 | 2013-07-25T04:42:26 | 2013-07-25T04:42:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 218 | h | spi.h | #ifndef _SPI_H
#define _SPI_H
void spi_init(SPI_TypeDef* SPIx);
int spi_readWrite(SPI_TypeDef* SPIx, uint8_t *rbuf, const uint8_t *tbuf, int cnt);
void spi_setPrescaler(SPI_TypeDef* SPIx, uint16_t prescaler);
#endif
|
238d6b2e408fd93a036845042a9e85dd8ebe6ae6 | 96e7347db30d3ae35f2df119a18472cf5b251fa2 | /Classes/Native/System_Configuration_System_Configuration_Protecte3876245534MethodDeclarations.h | 2de24ad7063167e6490ca822453379721fc135cb | [] | no_license | Henry0285/abcwriting | 04b111887489d9255fd2697a4ea8d9971dc17d89 | ed2e4da72fbbad85d9e0e9d912e73ddd33bc91ec | refs/heads/master | 2021-01-20T14:16:48.025648 | 2017-05-08T06:00:06 | 2017-05-08T06:00:06 | 90,583,162 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,720 | h | System_Configuration_System_Configuration_Protecte3876245534MethodDeclarations.h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include <assert.h>
#include <exception>
// System.Configuration.ProtectedConfigurationProviderCollection
struct ProtectedConfigurationProviderCollection_t3876245534;
// System.Configuration.ProtectedConfigurationProvider
struct ProtectedConfigurationProvider_t3298694412;
// System.String
struct String_t;
// System.Configuration.Provider.ProviderBase
struct ProviderBase_t1254600228;
#include "codegen/il2cpp-codegen.h"
#include "mscorlib_System_String1967731336.h"
#include "System_Configuration_System_Configuration_Provider1254600228.h"
// System.Void System.Configuration.ProtectedConfigurationProviderCollection::.ctor()
extern "C" void ProtectedConfigurationProviderCollection__ctor_m2871984156 (ProtectedConfigurationProviderCollection_t3876245534 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Configuration.ProtectedConfigurationProvider System.Configuration.ProtectedConfigurationProviderCollection::get_Item(System.String)
extern "C" ProtectedConfigurationProvider_t3298694412 * ProtectedConfigurationProviderCollection_get_Item_m2881465527 (ProtectedConfigurationProviderCollection_t3876245534 * __this, String_t* ___name, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Configuration.ProtectedConfigurationProviderCollection::Add(System.Configuration.Provider.ProviderBase)
extern "C" void ProtectedConfigurationProviderCollection_Add_m1943221191 (ProtectedConfigurationProviderCollection_t3876245534 * __this, ProviderBase_t1254600228 * ___provider, const MethodInfo* method) IL2CPP_METHOD_ATTR;
|
ba7bea35ab3b8989cb144090c50011f3aaaf4259 | e8302c75d770d1608b317d6af5c483bbad6c0493 | /arch/arc/core/cache.c | c67db4621d39442274cafc7c474a3e880f9c4436 | [
"Apache-2.0"
] | permissive | intel/zephyr | 819362089aa44ae378a5558f3b222197aaa811f7 | 06d5bc51b580777079bb0b7e769e4127598ea5ee | refs/heads/main | 2023-09-04T00:20:35.217393 | 2023-02-16T11:27:40 | 2023-02-16T14:59:16 | 65,052,293 | 32 | 32 | Apache-2.0 | 2022-04-05T17:14:07 | 2016-08-05T22:14:50 | C | UTF-8 | C | false | false | 4,908 | c | cache.c | /* cache.c - d-cache support for ARC CPUs */
/*
* Copyright (c) 2016 Synopsys, Inc. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief d-cache manipulation
*
* This module contains functions for manipulation of the d-cache.
*/
#include <zephyr/kernel.h>
#include <zephyr/arch/cpu.h>
#include <zephyr/sys/util.h>
#include <zephyr/toolchain.h>
#include <zephyr/cache.h>
#include <zephyr/linker/linker-defs.h>
#include <zephyr/arch/arc/v2/aux_regs.h>
#include <kernel_internal.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/init.h>
#include <stdbool.h>
#if defined(CONFIG_DCACHE_LINE_SIZE_DETECT)
size_t sys_cache_line_size;
#endif
#define DC_CTRL_DC_ENABLE 0x0 /* enable d-cache */
#define DC_CTRL_DC_DISABLE 0x1 /* disable d-cache */
#define DC_CTRL_INVALID_ONLY 0x0 /* invalid d-cache only */
#define DC_CTRL_INVALID_FLUSH 0x40 /* invalid and flush d-cache */
#define DC_CTRL_ENABLE_FLUSH_LOCKED 0x80 /* locked d-cache can be flushed */
#define DC_CTRL_DISABLE_FLUSH_LOCKED 0x0 /* locked d-cache cannot be flushed */
#define DC_CTRL_FLUSH_STATUS 0x100/* flush status */
#define DC_CTRL_DIRECT_ACCESS 0x0 /* direct access mode */
#define DC_CTRL_INDIRECT_ACCESS 0x20 /* indirect access mode */
#define DC_CTRL_OP_SUCCEEDED 0x4 /* d-cache operation succeeded */
static bool dcache_available(void)
{
unsigned long val = z_arc_v2_aux_reg_read(_ARC_V2_D_CACHE_BUILD);
val &= 0xff; /* extract version */
return (val == 0) ? false : true;
}
static void dcache_dc_ctrl(uint32_t dcache_en_mask)
{
if (dcache_available()) {
z_arc_v2_aux_reg_write(_ARC_V2_DC_CTRL, dcache_en_mask);
}
}
void arch_dcache_enable(void)
{
dcache_dc_ctrl(DC_CTRL_DC_ENABLE);
}
void arch_dcache_disable(void)
{
/* nothing */
}
int arch_dcache_flush_range(void *start_addr_ptr, size_t size)
{
size_t line_size = sys_cache_data_line_size_get();
uintptr_t start_addr = (uintptr_t)start_addr_ptr;
uintptr_t end_addr;
unsigned int key;
if (!dcache_available() || (size == 0U) || line_size == 0U) {
return -ENOTSUP;
}
end_addr = start_addr + size;
start_addr = ROUND_DOWN(start_addr, line_size);
key = arch_irq_lock(); /* --enter critical section-- */
do {
z_arc_v2_aux_reg_write(_ARC_V2_DC_FLDL, start_addr);
__builtin_arc_nop();
__builtin_arc_nop();
__builtin_arc_nop();
/* wait for flush completion */
do {
if ((z_arc_v2_aux_reg_read(_ARC_V2_DC_CTRL) &
DC_CTRL_FLUSH_STATUS) == 0) {
break;
}
} while (1);
start_addr += line_size;
} while (start_addr < end_addr);
arch_irq_unlock(key); /* --exit critical section-- */
return 0;
}
int arch_dcache_invd_range(void *start_addr_ptr, size_t size)
{
size_t line_size = sys_cache_data_line_size_get();
uintptr_t start_addr = (uintptr_t)start_addr_ptr;
uintptr_t end_addr;
unsigned int key;
if (!dcache_available() || (size == 0U) || line_size == 0U) {
return -ENOTSUP;
}
end_addr = start_addr + size;
start_addr = ROUND_DOWN(start_addr, line_size);
key = arch_irq_lock(); /* -enter critical section- */
do {
z_arc_v2_aux_reg_write(_ARC_V2_DC_IVDL, start_addr);
__builtin_arc_nop();
__builtin_arc_nop();
__builtin_arc_nop();
start_addr += line_size;
} while (start_addr < end_addr);
irq_unlock(key); /* -exit critical section- */
return 0;
}
int arch_dcache_flush_and_invd_range(void *start_addr_ptr, size_t size)
{
return -ENOTSUP;
}
int arch_dcache_flush_all(void)
{
return -ENOTSUP;
}
int arch_dcache_invd_all(void)
{
return -ENOTSUP;
}
int arch_dcache_flush_and_invd_all(void)
{
return -ENOTSUP;
}
#if defined(CONFIG_DCACHE_LINE_SIZE_DETECT)
static void init_dcache_line_size(void)
{
uint32_t val;
val = z_arc_v2_aux_reg_read(_ARC_V2_D_CACHE_BUILD);
__ASSERT((val&0xff) != 0U, "d-cache is not present");
val = ((val>>16) & 0xf) + 1;
val *= 16U;
sys_cache_line_size = (size_t) val;
}
size_t arch_dcache_line_size_get(void)
{
return sys_cache_line_size;
}
#endif
void arch_icache_enable(void)
{
/* nothing */
}
void arch_icache_disable(void)
{
/* nothing */
}
int arch_icache_flush_all(void)
{
return -ENOTSUP;
}
int arch_icache_invd_all(void)
{
return -ENOTSUP;
}
int arch_icache_flush_and_invd_all(void)
{
return -ENOTSUP;
}
int arch_icache_flush_range(void *addr, size_t size)
{
ARG_UNUSED(addr);
ARG_UNUSED(size);
return -ENOTSUP;
}
int arch_icache_invd_range(void *addr, size_t size)
{
ARG_UNUSED(addr);
ARG_UNUSED(size);
return -ENOTSUP;
}
int arch_icache_flush_and_invd_range(void *addr, size_t size)
{
ARG_UNUSED(addr);
ARG_UNUSED(size);
return -ENOTSUP;
}
static int init_dcache(const struct device *unused)
{
ARG_UNUSED(unused);
arch_dcache_enable();
#if defined(CONFIG_DCACHE_LINE_SIZE_DETECT)
init_dcache_line_size();
#endif
return 0;
}
SYS_INIT(init_dcache, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT);
|
6e5ec6c1a4a866fdaf5ecbab714d269a49dd506b | 06bdfb4e96c2c4a6d75e2c9a8578df30d4d947be | /3D/NC_node_scattered/utilities.h | e8b03fa06fda0ad4ecccfac69bfdd5ab537b2c2b | [] | no_license | Richetfort/Hybrid-Jacobi-Solver | fedb6bdc3430251457057b82c0cba7b0eeeffc35 | a491c0742c43630b5170c46723c64b2a5c0ee8c3 | refs/heads/master | 2022-12-04T00:02:05.733625 | 2020-08-29T10:26:23 | 2020-08-29T10:26:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 773 | h | utilities.h | #include<mpi.h>
#include"jacobi.h"
extern void BlockInit(int, int, int, int *,int *,int *);
/* Compute the number of blocks decomposing each dimension following the total number of blocks required. */
extern void AreaInit(int[3], int, int, int, int, int, int, int, int, int, int,
int *,int *,int *, int *, int *, int *);
/* Attribute to each node/socket/rank its corresponding Height/Row/Col First/Last */
extern void InitSubarraysDatatype(struct JacobiData *);
/* Initialize Datatype for transfering Non-Contiguous pieces of data */
extern void InitIndexes(struct JacobiData *);
/* Init indexes to access neighbours shmem areas properly */
extern void FirstQueryNeighbours(struct JacobiData *);
extern void QueryNeighbours(struct JacobiData *);
|
4417dbb4fcaf8a63ead18e6890d9d9b5c5ee6954 | 0a7c49cb54f676b7d8328470d6cafdeb5c02abe4 | /qca/src/qca-ovsmgr/exports/ovsmgr.h | 228e8162a5d0e62fcbac9422ffb5cf3ca6006eae | [] | no_license | ijasuja/RevIPQSW | b07a2fecc6f3c1befe2936f75d3e03d7ead4ca6b | 37c8cae5e7a5a85d79d0a6d703b4fa31611e5696 | refs/heads/master | 2023-02-22T06:27:09.232767 | 2021-01-18T02:40:59 | 2021-01-18T02:40:59 | 281,551,084 | 4 | 6 | null | null | null | null | UTF-8 | C | false | false | 6,019 | h | ovsmgr.h | /*
**************************************************************************
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all copies.
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
**************************************************************************
*/
/*
* ovsmgr.h
*/
#ifndef __OVSMGR__H
#define __OVSMGR__H
#include <linux/if_vlan.h>
/*
* Notifiers
*/
#define OVSMGR_DP_ADD 1
#define OVSMGR_DP_DEL 2
#define OVSMGR_DP_BR_ADD 3
#define OVSMGR_DP_BR_DEL 4
#define OVSMGR_DP_PORT_ADD 5
#define OVSMGR_DP_PORT_DEL 6
#define OVSMGR_DP_FLOW_ADD 7
#define OVSMGR_DP_FLOW_DEL 8
#define OVSMGR_DP_FLOW_CHANGE 9
#define OVSMGR_DP_FLOW_TBL_FLUSH 10
#define OVSMGR_DP_VLAN_ADD 11
#define OVSMGR_DP_VLAN_DEL 12
/*
* Hook numbers
*/
#define OVSMGR_DP_HOOK_PRE_FLOW_PROC 1 /* Call hook function before flow search */
#define OVSMGR_DP_HOOK_POST_FLOW_PROC 2 /* Call hook function after flow is found */
/*
* Signature to validate if skb->cb is populated by OVS manager
*/
#define OVS_SIGNATURE 0xAEAD1246
enum ovsmgr_flow_status {
OVSMGR_FLOW_STATUS_ALLOW_ACCEL, /* Allow the acceleration of the flow, no VLAN operation */
OVSMGR_FLOW_STATUS_DENY_ACCEL, /* Deny the acceleration of the flow */
OVSMGR_FLOW_STATUS_DENY_ACCEL_EGRESS, /* outdev in flow is not allowed for acceleration */
OVSMGR_FLOW_STATUS_ALLOW_VLAN_ACCEL, /* Allow the acceleration of the flow, single VLAN operation */
OVSMGR_FLOW_STATUS_ALLOW_VLAN_QINQ_ACCEL,
/* Allow the acceleration of the flow, QinQ VLAN operation */
OVSMGR_FLOW_STATUS_UNKNOWN /* Flow status is unknown */
};
/*
* ovsmgr_skb_cb
* skb->cb details updated by OVS manager before forwarding the packet post
* flow hook.
*/
struct ovsmgr_skb_cb {
uint32_t ovs_sig;
void *flow;
};
#define OVSMGR_OVS_CB(skb) ((struct ovsmgr_skb_cb *)(skb)->cb)
/*
* Hook function type
*/
typedef unsigned int (*ovsmgr_dp_hookfn_t)(struct sk_buff *skb, struct net_device *out);
/*
* ovsmgr_dp_hook_ops
* Datapath hook options
*/
struct ovsmgr_dp_hook_ops {
struct list_head list;
int protocol; /* IP protocol interested in */
int hook_num; /* Hook number */
ovsmgr_dp_hookfn_t hook; /* Hook function to be called */
};
/*
* ovsmgr_dp_tuple
* Datapath flow tuple
*/
struct ovsmgr_dp_tuple {
union {
struct {
__be32 src;
__be32 dst;
} ipv4;
struct {
struct in6_addr src;
struct in6_addr dst;
} ipv6;
};
uint16_t src_port; /* Source port */
uint16_t dst_port; /* Destination port */
uint8_t ip_version; /* IP version */
uint8_t protocol; /* IP protocol */
};
/*
* ovsmgr_dp_flow
* Datapath flow details
*/
struct ovsmgr_dp_flow {
struct net_device *indev; /* Ingress interface */
struct net_device *outdev; /* Egress interface */
uint8_t smac[ETH_ALEN]; /* Source MAC */
uint8_t dmac[ETH_ALEN]; /* Destination MAC */
struct vlan_hdr ingress_vlan; /* Ingress VLAN header */
struct ovsmgr_dp_tuple tuple; /* Flow tuple */
bool is_routed; /* Routed flag, set when flow is routed */
};
/*
* ovsmgr_dp_flow_stats
* Datapath flow statistics
*/
struct ovsmgr_dp_flow_stats {
uint32_t pkts; /* Number of received packets matching the flow */
uint32_t bytes; /* Number of received bytes matching the flow */
};
/*
* ovsmgr_vlan_info
* VLAN information for the given flow.
* ingress[0]/egress[0] represents inner VLAN header details
* ingress[1]/egress[1] represents outer VLAN header details
* 0 value represents no vlan operations required
*/
struct ovsmgr_vlan_info {
struct vlan_hdr ingress[2]; /* Ingress VLAN details */
struct vlan_hdr egress[2]; /* Egress VLAN details */
};
/*
* ovsmgr_dp_port_info
* Port notification structure
*/
struct ovsmgr_dp_port_info {
struct net_device *master; /* OVS bridge interface */
struct net_device *dev; /* OVS bridge port interface */
};
/*
* ovsmgr_dp_port_vlan_info
* Port VLAN notification structure
*/
struct ovsmgr_dp_port_vlan_info {
struct vlan_hdr vh;
struct net_device *master;
struct net_device *dev;
};
/*
* ovsmgr_notifiers_info
* Notifiers structure
*/
struct ovsmgr_notifiers_info {
union {
struct net_device *dev; /* Netdev for bridge add/del notification */
struct ovsmgr_dp_port_info *port; /* Port details for port add/del notification */
struct ovsmgr_dp_port_vlan_info *vlan; /* Port VLAN details for VLAN add/del notification */
struct ovsmgr_dp_flow *flow; /* Flow details for datapath flow add/del notification */
};
};
void ovsmgr_notifier_register(struct notifier_block *nb);
void ovsmgr_notifier_unregister(struct notifier_block *nb);
int ovsmgr_dp_hook_register(struct ovsmgr_dp_hook_ops *ops);
void ovsmgr_dp_hook_unregister(struct ovsmgr_dp_hook_ops *ops);
void ovsmgr_bridge_interface_stats_update(struct net_device *dev,
uint32_t rx_packets, uint32_t rx_bytes,
uint32_t tx_packets, uint32_t tx_bytes);
void ovsmgr_flow_stats_update(struct ovsmgr_dp_flow *flow, struct ovsmgr_dp_flow_stats *stats);
struct net_device *ovsmgr_port_find(struct sk_buff *skb, struct net_device *dev, struct ovsmgr_dp_flow *flow);
enum ovsmgr_flow_status ovsmgr_flow_info_get(struct ovsmgr_dp_flow *flow,
struct sk_buff *skb, struct ovsmgr_vlan_info *ovi);
struct net_device *ovsmgr_dev_get_master(struct net_device *dev);
bool ovsmgr_is_ovs_master(struct net_device *dev);
#endif /* __OVSMGR__H */
|
be61a18cad48ab5426ffcd32d18f33c675760ab7 | dfc20ac51a84f55d262c6d80dac83744da5db9cc | /unix/source/smg_paste_display.c | 9754dedc964a99087225c02f79dd943990dbcd15 | [] | no_license | scott-snyder/d0library | 982c75fe6d7056e3116f3cfe89731db902c866f2 | ca322a995cc03b27592642fbaa3637994b90cf0f | refs/heads/master | 2023-01-29T19:27:13.548577 | 2022-11-28T05:29:23 | 2022-11-28T05:29:23 | 66,472,973 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,519 | c | smg_paste_display.c | #include <stdlib.h>
#include "smg.h"
long smg_paste_display( DISPLAY **dpid, DISPLAY **pbid, long *prow,
long *pcol, DISPLAY **top_dpid)
/*
C----------------------------------------------------------------------
C-
C- Name: smg_paste_display
C-
C- Purpose: Paste display
C-
C- Returned value: 0 (false) - Operation failed.
C- 1 (true) - Operation succeeded.
C-
C- Arguments:
C-
C- dpid (integer*4, read only) - Display identifier.
C- pbid (integer*4, read only) - Pasteboard identifier.
C- prow (integer*4, read only) - Pasteboard row of upper left corner
C- of display.
C- pcol (integer*4, read only) - Pasteboard column of upper left
C- corner of display.
C- top_dpid (integer*4, read only) - Paste display under this display
C- (if valid and pasted).
C-
C- Created 23-Sep-1991 Herbert Greenlee
C-
C- This routine is used internally by the smg emulation package. Its
C- calling sequence is similar to smg$paste_virtual_display and
C- smg$repaste_virtual_display and it is called by both of these. This
C- routine handles the updating of the display data structures. The actual
C- updating of the virtual terminal is left to smg$paste_virtual_display
C- or smg$repaste_virtual_display.
C-
C----------------------------------------------------------------------
*/
{
DISPLAY *display, *base_display, *top_display;
int crow, ccol; /* Curses row, col of pasted display */
int xrows, xcols; /* Excess rows or columns after move */
int nrows, ncols; /* New row/column dimensions */
smg_static_data.function_name = "smg_paste_display";
/* Verify the pasteboard and display identifiers. */
if(*pbid != smg_display_root)
return smg_error("invalid pasteboard id", 0);
display = smg_verify_display(*dpid);
if(display == NULL)
return smg_error("invalid display id", 0);
/* Find the display which will come before dpid after it is repasted. This is
the last pasted display or the display before top_dpid, whichever comes
first. The root display should always be pasted. */
/* Get the top display. */
if(top_dpid != NULL)
top_display = *top_dpid;
else
top_display = NULL;
/* Search the display chain. */
base_display = smg_display_root;
if(!base_display->pasted)
return smg_error("internal error 1", 0); /* Shouldn't ever happen */
while(base_display != NULL) {
if(base_display->next == NULL || base_display->next == top_display
|| !base_display->next->pasted)
break;
base_display = base_display->next;
}
if(base_display == display)
base_display = display->prev; /* Can't be its own base */
if(base_display == NULL)
return smg_error("internal error 2", 0); /* Shouldn't ever happen */
/* Rearrange the linking order of the displays so that display comes after
base_display. */
if(display->prev != NULL)
display->prev->next = display->next;
if(display->next != NULL)
display->next->prev = display->prev;
display->next = base_display->next;
display->prev = base_display;
base_display->next = display;
if(display->next != NULL)
display->next->prev = display;
/* Set the new pasted location. Change to curses coordinates. */
display->prow = *prow - 1;
display->pcol = *pcol - 1;
display->pasted = 1;
return 1;
}
|
94f1e1971775fd9313967d801e4721bacc5ea381 | 7c8606d2a635610ffa458b5c48be0ef1ed9c8af3 | /main.c | 53ad59d9195ba4eb11a308e45800cd6c23bd49bd | [] | no_license | alexz10/03_euler_zhangAle | e7e9d27596dd0432d0efd86a5e180b45a5fb9b41 | b07e79d24e12d7385be67cec35f57d582975400f | refs/heads/master | 2023-01-01T00:21:06.087724 | 2020-10-25T20:27:04 | 2020-10-25T20:27:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,054 | c | main.c | #include <stdio.h>
//Problem #1
int sum_mult_3_and_5 (int max){
int sum = 0;
int i = 0;
for (i = 0; i < max; i++){
if ( (i%3==0) || (i%5==0) )
sum+=i;
}
return sum;
}
//Problem #5
int smallest_multiple (){
int true_false = 0;
int multiple = 1;
while (true_false == 0){
true_false = 1;
multiple++;
int i;
for (i = 2; i <= 20; i++){
if (multiple % i != 0){
true_false = 0;
break;
}
}
}
return multiple;
}
//Problem #6
int sum_square_diff (int max){
int square_sums = 0;
int squared_sum = 0;
int i;
for (i = 1; i <= max; i++){
square_sums += i * i;
squared_sum += i;
}
squared_sum = squared_sum * squared_sum;
int difference = squared_sum - square_sums;
return difference;
}
int main (){
printf ("The answer to #1 is: %d\n", sum_mult_3_and_5(1000));
printf ("The answer to #5 is: %d\n", smallest_multiple());
printf ("The answer to #6 is: %d\n", sum_square_diff(100));
return 0;
}
|
e56c764820310ca516cae65bdad8bd859fad2453 | d09afed07c62caf52f4d005ba24770646700d0fc | /src/des_wrapper.c | c0641da38bd8c0e4d2b9d024a75386819882ce0f | [] | no_license | reecer/des | 09e8d41b92df9547a74a820b5255eac5466d20dd | 64d1f7444cf19682440fdc4d29a2611e17e2dd5a | refs/heads/master | 2020-05-17T17:38:50.598271 | 2014-04-03T04:11:10 | 2014-04-03T04:11:10 | 26,367,343 | 2 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,094 | c | des_wrapper.c | #include "des_wrapper.h"
#include "constants.h"
#include "feistel.h"
#include "des_round.h"
#include "key_sched.h"
#include "ip_fp.h"
#include "hex.h"
#include "cbc.h"
#include <stdio.h>
#include <string.h>
void des_encrypt(char* input, char* key, char* output){
char subkeys[NUM_ROUNDS][SUBKEY_SIZE], temp[BLOCK_SIZE], temp2[BLOCK_SIZE];
key_sched(key, subkeys);
initial_permutation(input, temp);
feistel_encrypt(temp, des_round, subkeys, temp2);
final_permutation(temp2, output);
}
void des_decrypt(char* input, char* key, char* output){
char subkeys[NUM_ROUNDS][SUBKEY_SIZE], temp[BLOCK_SIZE], temp2[BLOCK_SIZE];
char rev_subkeys[NUM_ROUNDS][SUBKEY_SIZE];
int i, j;
key_sched(key, subkeys);
for(i = 0, j = NUM_ROUNDS - 1; i < NUM_ROUNDS; i++, j--){
memcpy(rev_subkeys[j], subkeys[i], SUBKEY_SIZE);
}
initial_permutation(input, temp);
feistel_encrypt(temp, des_round, rev_subkeys, temp2);
final_permutation(temp2, output);
}
void des_encrypt_cbc(char* input, char* key, char* iv, size_t len, char* output){
cbc_encrypt(input, key, des_encrypt, iv, len, output);
}
void des_decrypt_cbc(char* input, char* key, char* iv, size_t len, char* output){
cbc_decrypt(input, key, des_decrypt, iv, len, output);
}
void tdes2_encrypt(char* input, char* key, char* output){
char temp[BLOCK_SIZE], temp2[BLOCK_SIZE], k1[KEY_SIZE], k2[KEY_SIZE];
memcpy(k1, key, KEY_SIZE);
memcpy(k2, key+KEY_SIZE, KEY_SIZE);
des_encrypt(input, k1, temp);
des_decrypt(temp, k2, temp2);
des_encrypt(temp2, k1, output);
}
void tdes2_decrypt(char* input, char* key, char* output){
char temp[BLOCK_SIZE], temp2[BLOCK_SIZE], k1[KEY_SIZE], k2[KEY_SIZE];
memcpy(k1, key, KEY_SIZE);
memcpy(k2, key+KEY_SIZE, KEY_SIZE);
des_decrypt(input, k1, temp);
des_encrypt(temp, k2, temp2);
des_decrypt(temp2, k1, output);
}
void tdes2_encrypt_cbc(char* input, char* key, char* iv, size_t len, char* output){
cbc_encrypt(input, key, tdes2_encrypt, iv, len, output);
}
void tdes2_decrypt_cbc(char* input, char* key, char* iv, size_t len, char* output){
cbc_decrypt(input, key, tdes2_decrypt, iv, len, output);
}
void tdes3_encrypt(char* input, char* key, char* output){
char temp[BLOCK_SIZE], temp2[BLOCK_SIZE], k1[KEY_SIZE], k2[KEY_SIZE], k3[KEY_SIZE];
memcpy(k1, key, KEY_SIZE);
memcpy(k2, key+KEY_SIZE, KEY_SIZE);
memcpy(k3, key+2*KEY_SIZE, KEY_SIZE);
des_encrypt(input, k1, temp);
des_decrypt(temp, k2, temp2);
des_encrypt(temp2, k3, output);
}
void tdes3_decrypt(char* input, char* key, char* output){
char temp[BLOCK_SIZE], temp2[BLOCK_SIZE], k1[KEY_SIZE], k2[KEY_SIZE], k3[KEY_SIZE];
memcpy(k1, key, KEY_SIZE);
memcpy(k2, key+KEY_SIZE, KEY_SIZE);
memcpy(k3, key+2*KEY_SIZE, KEY_SIZE);
des_decrypt(input, k3, temp);
des_encrypt(temp, k2, temp2);
des_decrypt(temp2, k1, output);
}
void tdes3_encrypt_cbc(char* input, char* key, char* iv, size_t len, char* output){
cbc_encrypt(input, key, tdes3_encrypt, iv, len, output);
}
void tdes3_decrypt_cbc(char* input, char* key, char* iv, size_t len, char* output){
cbc_decrypt(input, key, tdes3_decrypt, iv, len, output);
}
|
2efca20783ddcc1586448b8c20c0e31fa9c5dc19 | 6b0ce7f4582bef45110d672683fb836a86314070 | /TD8/list.c | 82732365452de372c6b6b3db875057b2e0a9635d | [] | no_license | Xisabla/TDC | a648bb9714c8c2f49fb618702108b05b52296068 | e94a6fb1f8d7240ef6e0adcc919e9b0eb45dbe23 | refs/heads/master | 2021-05-11T10:42:27.107807 | 2018-04-23T10:04:51 | 2018-04-23T10:04:51 | 118,108,885 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,477 | c | list.c | #include "list.h"
list createElement(int value)
{
list element = (list)malloc(sizeof(list));
element->value = value;
element->next = NULL;
return element;
}
int isEmpty(list head)
{
return (head == NULL);
}
int addElement(list current, int value)
{
list element = createElement(value);
if (current == NULL)
{
return 0;
}
if (element == NULL)
{
printf("Erreur memoire");
return -1;
}
while (current->next != NULL)
{
current = current->next;
}
current->next = element;
return 1;
}
list unset(list head, int value, int recursive)
{
int n = 0;
list l = head;
if (l == NULL || l->next == NULL)
{
return NULL;
}
list previous = NULL;
while (l != NULL)
{
list temp = l->next;
if (l->value == value && (n == 0 || recursive == 1))
{
if (previous == NULL)
{
head = l->next;
}
else
{
previous->next = temp;
free(l);
n++;
}
}
else
{
previous = l;
}
l = temp;
}
return head;
}
int count(list l, int value)
{
int n = 0;
while (l != NULL)
{
if (l->value == value)
n++;
l = l->next;
}
return n;
}
int size(list l)
{
int n = 0;
while (l != NULL)
{
l = l->next;
n++;
}
return n;
}
int merge(list current, list l)
{
if (current == NULL || l == NULL)
{
return 0;
}
while (current->next != NULL)
{
current = current->next;
}
current->next = l;
return 1;
}
void display(list l)
{
while (l != NULL)
{
printf("|%d|", l->value);
l = l->next;
}
} |
dc607e8903480766f2b8f140cb0efa4e95058a0d | c60e879a8b1723e9e8aa5c77b194788d59ca3cb3 | /Lib/MinBlepTable.h | 799cb7e68502f2243c882fc34390dcbb3353e296 | [] | no_license | georgekrueger/PbrSynth | 2dfabf2905e976bf8e044ef732f4f62f24e8ca70 | 97984a6bfd1b586d5b24db89c576333e330e3325 | refs/heads/master | 2016-09-05T08:47:06.612231 | 2011-03-24T16:00:11 | 2011-03-24T16:00:11 | 1,519,688 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 193 | h | MinBlepTable.h |
#ifndef MINBLEPTABLE
#define MINBLEPTABLE
const int MinBlepTableCount = 2049;
const int MinBlepTableOversampleFactor = 64; // BLEP table oversampling factor
float* GetMinBlepTable();
#endif |
Subsets and Splits