iNeil77/the-heap · Datasets at Hugging Face

14,259,703

replicas.h

thoughtpolice_bcachefs-tools/libbcachefs/replicas.h

#ifndef _BCACHEFS_REPLICAS_H #define _BCACHEFS_REPLICAS_H bool bch2_replicas_marked(struct bch_fs *, enum bch_data_type, struct bch_devs_list); bool bch2_bkey_replicas_marked(struct bch_fs *, enum bch_data_type, struct bkey_s_c); int bch2_mark_replicas(struct bch_fs *, enum bch_data_type, struct bch_devs_list); int bch2_mark_bkey_replicas(struct bch_fs *, enum bch_data_type, struct bkey_s_c); int bch2_cpu_replicas_to_text(struct bch_replicas_cpu *, char *, size_t); int bch2_sb_replicas_to_text(struct bch_sb_field_replicas *, char *, size_t); struct replicas_status { struct { unsigned nr_online; unsigned nr_offline; } replicas[BCH_DATA_NR]; }; struct replicas_status __bch2_replicas_status(struct bch_fs *, struct bch_devs_mask); struct replicas_status bch2_replicas_status(struct bch_fs *); bool bch2_have_enough_devs(struct replicas_status, unsigned); unsigned bch2_replicas_online(struct bch_fs *, bool); unsigned bch2_dev_has_data(struct bch_fs *, struct bch_dev *); int bch2_replicas_gc_end(struct bch_fs *, int); int bch2_replicas_gc_start(struct bch_fs *, unsigned); /* iterate over superblock replicas - used by userspace tools: */ static inline struct bch_replicas_entry * replicas_entry_next(struct bch_replicas_entry *i) { return (void *) i + offsetof(struct bch_replicas_entry, devs) + i->nr; } #define for_each_replicas_entry(_r, _i) \ for (_i = (_r)->entries; \ (void *) (_i) < vstruct_end(&(_r)->field) && (_i)->data_type;\ (_i) = replicas_entry_next(_i)) int bch2_sb_replicas_to_cpu_replicas(struct bch_fs *); extern const struct bch_sb_field_ops bch_sb_field_ops_replicas; #endif /* _BCACHEFS_REPLICAS_H */

1,715

C

.c

39

41.076923

77

0.710938

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,707

journal_reclaim.h

thoughtpolice_bcachefs-tools/libbcachefs/journal_reclaim.h

#ifndef _BCACHEFS_JOURNAL_RECLAIM_H #define _BCACHEFS_JOURNAL_RECLAIM_H #define JOURNAL_PIN (32 * 1024) static inline bool journal_pin_active(struct journal_entry_pin *pin) { return pin->pin_list != NULL; } static inline struct journal_entry_pin_list * journal_seq_pin(struct journal *j, u64 seq) { BUG_ON(seq < j->pin.front || seq >= j->pin.back); return &j->pin.data[seq & j->pin.mask]; } u64 bch2_journal_pin_seq(struct journal *, struct journal_entry_pin *); void bch2_journal_pin_add(struct journal *, u64, struct journal_entry_pin *, journal_pin_flush_fn); void bch2_journal_pin_drop(struct journal *, struct journal_entry_pin *); void bch2_journal_pin_add_if_older(struct journal *, struct journal_entry_pin *, struct journal_entry_pin *, journal_pin_flush_fn); void bch2_journal_reclaim_fast(struct journal *); void bch2_journal_reclaim_work(struct work_struct *); void bch2_journal_flush_pins(struct journal *, u64); static inline void bch2_journal_flush_all_pins(struct journal *j) { bch2_journal_flush_pins(j, U64_MAX); } int bch2_journal_flush_device_pins(struct journal *, int); #endif /* _BCACHEFS_JOURNAL_RECLAIM_H */

1,171

C

.c

30

36.766667

76

0.741593

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,708

fs-ioctl.h

thoughtpolice_bcachefs-tools/libbcachefs/fs-ioctl.h

#ifndef _BCACHEFS_FS_IOCTL_H #define _BCACHEFS_FS_IOCTL_H void bch2_inode_flags_to_vfs(struct bch_inode_info *); long bch2_fs_file_ioctl(struct file *, unsigned, unsigned long); long bch2_compat_fs_ioctl(struct file *, unsigned, unsigned long); #endif /* _BCACHEFS_FS_IOCTL_H */

282

C

.c

6

45.5

66

0.754579

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,710

bcachefs_ioctl.h

thoughtpolice_bcachefs-tools/libbcachefs/bcachefs_ioctl.h

#ifndef _BCACHEFS_IOCTL_H #define _BCACHEFS_IOCTL_H #include <linux/uuid.h> #include <asm/ioctl.h> #include "bcachefs_format.h" /* * Flags common to multiple ioctls: */ #define BCH_FORCE_IF_DATA_LOST (1 << 0) #define BCH_FORCE_IF_METADATA_LOST (1 << 1) #define BCH_FORCE_IF_DATA_DEGRADED (1 << 2) #define BCH_FORCE_IF_METADATA_DEGRADED (1 << 3) #define BCH_FORCE_IF_DEGRADED \ (BCH_FORCE_IF_DATA_DEGRADED| \ BCH_FORCE_IF_METADATA_DEGRADED) /* * If cleared, ioctl that refer to a device pass it as a pointer to a pathname * (e.g. /dev/sda1); if set, the dev field is the device's index within the * filesystem: */ #define BCH_BY_INDEX (1 << 4) /* * For BCH_IOCTL_READ_SUPER: get superblock of a specific device, not filesystem * wide superblock: */ #define BCH_READ_DEV (1 << 5) /* global control dev: */ /* These are currently broken, and probably unnecessary: */ #if 0 #define BCH_IOCTL_ASSEMBLE _IOW(0xbc, 1, struct bch_ioctl_assemble) #define BCH_IOCTL_INCREMENTAL _IOW(0xbc, 2, struct bch_ioctl_incremental) struct bch_ioctl_assemble { __u32 flags; __u32 nr_devs; __u64 pad; __u64 devs[]; }; struct bch_ioctl_incremental { __u32 flags; __u64 pad; __u64 dev; }; #endif /* filesystem ioctls: */ #define BCH_IOCTL_QUERY_UUID _IOR(0xbc, 1, struct bch_ioctl_query_uuid) /* These only make sense when we also have incremental assembly */ #if 0 #define BCH_IOCTL_START _IOW(0xbc, 2, struct bch_ioctl_start) #define BCH_IOCTL_STOP _IO(0xbc, 3) #endif #define BCH_IOCTL_DISK_ADD _IOW(0xbc, 4, struct bch_ioctl_disk) #define BCH_IOCTL_DISK_REMOVE _IOW(0xbc, 5, struct bch_ioctl_disk) #define BCH_IOCTL_DISK_ONLINE _IOW(0xbc, 6, struct bch_ioctl_disk) #define BCH_IOCTL_DISK_OFFLINE _IOW(0xbc, 7, struct bch_ioctl_disk) #define BCH_IOCTL_DISK_SET_STATE _IOW(0xbc, 8, struct bch_ioctl_disk_set_state) #define BCH_IOCTL_DATA _IOW(0xbc, 10, struct bch_ioctl_data) #define BCH_IOCTL_USAGE _IOWR(0xbc, 11, struct bch_ioctl_usage) #define BCH_IOCTL_READ_SUPER _IOW(0xbc, 12, struct bch_ioctl_read_super) #define BCH_IOCTL_DISK_GET_IDX _IOW(0xbc, 13, struct bch_ioctl_disk_get_idx) #define BCH_IOCTL_DISK_RESIZE _IOW(0xbc, 13, struct bch_ioctl_disk_resize) /* * BCH_IOCTL_QUERY_UUID: get filesystem UUID * * Returns user visible UUID, not internal UUID (which may not ever be changed); * the filesystem's sysfs directory may be found under /sys/fs/bcachefs with * this UUID. */ struct bch_ioctl_query_uuid { uuid_le uuid; }; #if 0 struct bch_ioctl_start { __u32 flags; __u32 pad; }; #endif /* * BCH_IOCTL_DISK_ADD: add a new device to an existing filesystem * * The specified device must not be open or in use. On success, the new device * will be an online member of the filesystem just like any other member. * * The device must first be prepared by userspace by formatting with a bcachefs * superblock, which is only used for passing in superblock options/parameters * for that device (in struct bch_member). The new device's superblock should * not claim to be a member of any existing filesystem - UUIDs on it will be * ignored. */ /* * BCH_IOCTL_DISK_REMOVE: permanently remove a member device from a filesystem * * Any data present on @dev will be permanently deleted, and @dev will be * removed from its slot in the filesystem's list of member devices. The device * may be either offline or offline. * * Will fail removing @dev would leave us with insufficient read write devices * or degraded/unavailable data, unless the approprate BCH_FORCE_IF_* flags are * set. */ /* * BCH_IOCTL_DISK_ONLINE: given a disk that is already a member of a filesystem * but is not open (e.g. because we started in degraded mode), bring it online * * all existing data on @dev will be available once the device is online, * exactly as if @dev was present when the filesystem was first mounted */ /* * BCH_IOCTL_DISK_OFFLINE: offline a disk, causing the kernel to close that * block device, without removing it from the filesystem (so it can be brought * back online later) * * Data present on @dev will be unavailable while @dev is offline (unless * replicated), but will still be intact and untouched if @dev is brought back * online * * Will fail (similarly to BCH_IOCTL_DISK_SET_STATE) if offlining @dev would * leave us with insufficient read write devices or degraded/unavailable data, * unless the approprate BCH_FORCE_IF_* flags are set. */ struct bch_ioctl_disk { __u32 flags; __u32 pad; __u64 dev; }; /* * BCH_IOCTL_DISK_SET_STATE: modify state of a member device of a filesystem * * @new_state - one of the bch_member_state states (rw, ro, failed, * spare) * * Will refuse to change member state if we would then have insufficient devices * to write to, or if it would result in degraded data (when @new_state is * failed or spare) unless the appropriate BCH_FORCE_IF_* flags are set. */ struct bch_ioctl_disk_set_state { __u32 flags; __u8 new_state; __u8 pad[3]; __u64 dev; }; enum bch_data_ops { BCH_DATA_OP_SCRUB = 0, BCH_DATA_OP_REREPLICATE = 1, BCH_DATA_OP_MIGRATE = 2, BCH_DATA_OP_NR = 3, }; /* * BCH_IOCTL_DATA: operations that walk and manipulate filesystem data (e.g. * scrub, rereplicate, migrate). * * This ioctl kicks off a job in the background, and returns a file descriptor. * Reading from the file descriptor returns a struct bch_ioctl_data_event, * indicating current progress, and closing the file descriptor will stop the * job. The file descriptor is O_CLOEXEC. */ struct bch_ioctl_data { __u32 op; __u32 flags; struct bpos start; struct bpos end; union { struct { __u32 dev; __u32 pad; } migrate; struct { __u64 pad[8]; }; }; } __attribute__((packed, aligned(8))); enum bch_data_event { BCH_DATA_EVENT_PROGRESS = 0, /* XXX: add an event for reporting errors */ BCH_DATA_EVENT_NR = 1, }; struct bch_ioctl_data_progress { __u8 data_type; __u8 btree_id; __u8 pad[2]; struct bpos pos; __u64 sectors_done; __u64 sectors_total; } __attribute__((packed, aligned(8))); struct bch_ioctl_data_event { __u8 type; __u8 pad[7]; union { struct bch_ioctl_data_progress p; __u64 pad2[15]; }; } __attribute__((packed, aligned(8))); struct bch_ioctl_dev_usage { __u8 state; __u8 alive; __u8 pad[6]; __u32 dev; __u32 bucket_size; __u64 nr_buckets; __u64 buckets[BCH_DATA_NR]; __u64 sectors[BCH_DATA_NR]; }; struct bch_ioctl_fs_usage { __u64 capacity; __u64 used; __u64 online_reserved; __u64 persistent_reserved[BCH_REPLICAS_MAX]; __u64 sectors[BCH_DATA_NR][BCH_REPLICAS_MAX]; }; /* * BCH_IOCTL_USAGE: query filesystem disk space usage * * Returns disk space usage broken out by data type, number of replicas, and * by component device * * @nr_devices - number of devices userspace allocated space for in @devs * * On success, @fs and @devs will be filled out appropriately and devs[i].alive * will indicate if a device was present in that slot * * Returns -ERANGE if @nr_devices was too small */ struct bch_ioctl_usage { __u16 nr_devices; __u16 pad[3]; struct bch_ioctl_fs_usage fs; struct bch_ioctl_dev_usage devs[0]; }; /* * BCH_IOCTL_READ_SUPER: read filesystem superblock * * Equivalent to reading the superblock directly from the block device, except * avoids racing with the kernel writing the superblock or having to figure out * which block device to read * * @sb - buffer to read into * @size - size of userspace allocated buffer * @dev - device to read superblock for, if BCH_READ_DEV flag is * specified * * Returns -ERANGE if buffer provided is too small */ struct bch_ioctl_read_super { __u32 flags; __u32 pad; __u64 dev; __u64 size; __u64 sb; }; /* * BCH_IOCTL_DISK_GET_IDX: give a path to a block device, query filesystem to * determine if disk is a (online) member - if so, returns device's index * * Returns -ENOENT if not found */ struct bch_ioctl_disk_get_idx { __u64 dev; }; /* * BCH_IOCTL_DISK_RESIZE: resize filesystem on a device * * @dev - member to resize * @nbuckets - new number of buckets */ struct bch_ioctl_disk_resize { __u32 flags; __u32 pad; __u64 dev; __u64 nbuckets; }; #endif /* _BCACHEFS_IOCTL_H */

8,297

C

.c

270

28.888889

80

0.713821

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,714

siphash.c

thoughtpolice_bcachefs-tools/libbcachefs/siphash.c

/* $OpenBSD: siphash.c,v 1.3 2015/02/20 11:51:03 tedu Exp $ */ /*- * Copyright (c) 2013 Andre Oppermann <[email protected]> * All rights reserved. * * 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. * 3. The name of the author may not be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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. */ /* * SipHash is a family of PRFs SipHash-c-d where the integer parameters c and d * are the number of compression rounds and the number of finalization rounds. * A compression round is identical to a finalization round and this round * function is called SipRound. Given a 128-bit key k and a (possibly empty) * byte string m, SipHash-c-d returns a 64-bit value SipHash-c-d(k; m). * * Implemented from the paper "SipHash: a fast short-input PRF", 2012.09.18, * by Jean-Philippe Aumasson and Daniel J. Bernstein, * Permanent Document ID b9a943a805fbfc6fde808af9fc0ecdfa * https://131002.net/siphash/siphash.pdf * https://131002.net/siphash/ */ #include <asm/byteorder.h> #include <asm/unaligned.h> #include <linux/bitops.h> #include <linux/string.h> #include "siphash.h" static void SipHash_Rounds(SIPHASH_CTX *ctx, int rounds) { while (rounds--) { ctx->v[0] += ctx->v[1]; ctx->v[2] += ctx->v[3]; ctx->v[1] = rol64(ctx->v[1], 13); ctx->v[3] = rol64(ctx->v[3], 16); ctx->v[1] ^= ctx->v[0]; ctx->v[3] ^= ctx->v[2]; ctx->v[0] = rol64(ctx->v[0], 32); ctx->v[2] += ctx->v[1]; ctx->v[0] += ctx->v[3]; ctx->v[1] = rol64(ctx->v[1], 17); ctx->v[3] = rol64(ctx->v[3], 21); ctx->v[1] ^= ctx->v[2]; ctx->v[3] ^= ctx->v[0]; ctx->v[2] = rol64(ctx->v[2], 32); } } static void SipHash_CRounds(SIPHASH_CTX *ctx, const void *ptr, int rounds) { u64 m = get_unaligned_le64(ptr); ctx->v[3] ^= m; SipHash_Rounds(ctx, rounds); ctx->v[0] ^= m; } void SipHash_Init(SIPHASH_CTX *ctx, const SIPHASH_KEY *key) { u64 k0, k1; k0 = le64_to_cpu(key->k0); k1 = le64_to_cpu(key->k1); ctx->v[0] = 0x736f6d6570736575ULL ^ k0; ctx->v[1] = 0x646f72616e646f6dULL ^ k1; ctx->v[2] = 0x6c7967656e657261ULL ^ k0; ctx->v[3] = 0x7465646279746573ULL ^ k1; memset(ctx->buf, 0, sizeof(ctx->buf)); ctx->bytes = 0; } void SipHash_Update(SIPHASH_CTX *ctx, int rc, int rf, const void *src, size_t len) { const u8 *ptr = src; size_t left, used; if (len == 0) return; used = ctx->bytes % sizeof(ctx->buf); ctx->bytes += len; if (used > 0) { left = sizeof(ctx->buf) - used; if (len >= left) { memcpy(&ctx->buf[used], ptr, left); SipHash_CRounds(ctx, ctx->buf, rc); len -= left; ptr += left; } else { memcpy(&ctx->buf[used], ptr, len); return; } } while (len >= sizeof(ctx->buf)) { SipHash_CRounds(ctx, ptr, rc); len -= sizeof(ctx->buf); ptr += sizeof(ctx->buf); } if (len > 0) memcpy(&ctx->buf[used], ptr, len); } void SipHash_Final(void *dst, SIPHASH_CTX *ctx, int rc, int rf) { u64 r; r = SipHash_End(ctx, rc, rf); *((__le64 *) dst) = cpu_to_le64(r); } u64 SipHash_End(SIPHASH_CTX *ctx, int rc, int rf) { u64 r; size_t left, used; used = ctx->bytes % sizeof(ctx->buf); left = sizeof(ctx->buf) - used; memset(&ctx->buf[used], 0, left - 1); ctx->buf[7] = ctx->bytes; SipHash_CRounds(ctx, ctx->buf, rc); ctx->v[2] ^= 0xff; SipHash_Rounds(ctx, rf); r = (ctx->v[0] ^ ctx->v[1]) ^ (ctx->v[2] ^ ctx->v[3]); memset(ctx, 0, sizeof(*ctx)); return (r); } u64 SipHash(const SIPHASH_KEY *key, int rc, int rf, const void *src, size_t len) { SIPHASH_CTX ctx; SipHash_Init(&ctx, key); SipHash_Update(&ctx, rc, rf, src, len); return SipHash_End(&ctx, rc, rf); }

4,846

C

.c

142

31.838028

80

0.683355

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,719

btree_locking.h

thoughtpolice_bcachefs-tools/libbcachefs/btree_locking.h

#ifndef _BCACHEFS_BTREE_LOCKING_H #define _BCACHEFS_BTREE_LOCKING_H /* * Only for internal btree use: * * The btree iterator tracks what locks it wants to take, and what locks it * currently has - here we have wrappers for locking/unlocking btree nodes and * updating the iterator state */ #include "btree_iter.h" #include "btree_io.h" #include "six.h" /* matches six lock types */ enum btree_node_locked_type { BTREE_NODE_UNLOCKED = -1, BTREE_NODE_READ_LOCKED = SIX_LOCK_read, BTREE_NODE_INTENT_LOCKED = SIX_LOCK_intent, }; static inline int btree_node_locked_type(struct btree_iter *iter, unsigned level) { /* * We're relying on the fact that if nodes_intent_locked is set * nodes_locked must be set as well, so that we can compute without * branches: */ return BTREE_NODE_UNLOCKED + ((iter->nodes_locked >> level) & 1) + ((iter->nodes_intent_locked >> level) & 1); } static inline bool btree_node_intent_locked(struct btree_iter *iter, unsigned level) { return btree_node_locked_type(iter, level) == BTREE_NODE_INTENT_LOCKED; } static inline bool btree_node_read_locked(struct btree_iter *iter, unsigned level) { return btree_node_locked_type(iter, level) == BTREE_NODE_READ_LOCKED; } static inline bool btree_node_locked(struct btree_iter *iter, unsigned level) { return iter->nodes_locked & (1 << level); } static inline void mark_btree_node_unlocked(struct btree_iter *iter, unsigned level) { iter->nodes_locked &= ~(1 << level); iter->nodes_intent_locked &= ~(1 << level); } static inline void mark_btree_node_locked(struct btree_iter *iter, unsigned level, enum six_lock_type type) { /* relying on this to avoid a branch */ BUILD_BUG_ON(SIX_LOCK_read != 0); BUILD_BUG_ON(SIX_LOCK_intent != 1); iter->nodes_locked |= 1 << level; iter->nodes_intent_locked |= type << level; } static inline void mark_btree_node_intent_locked(struct btree_iter *iter, unsigned level) { mark_btree_node_locked(iter, level, SIX_LOCK_intent); } static inline enum six_lock_type __btree_lock_want(struct btree_iter *iter, int level) { return level < iter->locks_want ? SIX_LOCK_intent : SIX_LOCK_read; } static inline enum btree_node_locked_type btree_lock_want(struct btree_iter *iter, int level) { if (level < iter->level) return BTREE_NODE_UNLOCKED; if (level < iter->locks_want) return BTREE_NODE_INTENT_LOCKED; if (level == iter->level) return BTREE_NODE_READ_LOCKED; return BTREE_NODE_UNLOCKED; } static inline void btree_node_unlock(struct btree_iter *iter, unsigned level) { int lock_type = btree_node_locked_type(iter, level); EBUG_ON(level >= BTREE_MAX_DEPTH); if (lock_type != BTREE_NODE_UNLOCKED) six_unlock_type(&iter->l[level].b->lock, lock_type); mark_btree_node_unlocked(iter, level); } static inline void __bch2_btree_iter_unlock(struct btree_iter *iter) { btree_iter_set_dirty(iter, BTREE_ITER_NEED_RELOCK); while (iter->nodes_locked) btree_node_unlock(iter, __ffs(iter->nodes_locked)); } static inline enum bch_time_stats lock_to_time_stat(enum six_lock_type type) { switch (type) { case SIX_LOCK_read: return BCH_TIME_btree_lock_contended_read; case SIX_LOCK_intent: return BCH_TIME_btree_lock_contended_intent; case SIX_LOCK_write: return BCH_TIME_btree_lock_contended_write; default: BUG(); } } /* * wrapper around six locks that just traces lock contended time */ static inline void __btree_node_lock_type(struct bch_fs *c, struct btree *b, enum six_lock_type type) { u64 start_time = local_clock(); six_lock_type(&b->lock, type); bch2_time_stats_update(&c->times[lock_to_time_stat(type)], start_time); } static inline void btree_node_lock_type(struct bch_fs *c, struct btree *b, enum six_lock_type type) { if (!six_trylock_type(&b->lock, type)) __btree_node_lock_type(c, b, type); } bool __bch2_btree_node_lock(struct btree *, struct bpos, unsigned, struct btree_iter *, enum six_lock_type, bool); static inline bool btree_node_lock(struct btree *b, struct bpos pos, unsigned level, struct btree_iter *iter, enum six_lock_type type, bool may_drop_locks) { EBUG_ON(level >= BTREE_MAX_DEPTH); return likely(six_trylock_type(&b->lock, type)) || __bch2_btree_node_lock(b, pos, level, iter, type, may_drop_locks); } bool __bch2_btree_node_relock(struct btree_iter *, unsigned); static inline bool bch2_btree_node_relock(struct btree_iter *iter, unsigned level) { EBUG_ON(btree_node_locked(iter, level) && btree_node_locked_type(iter, level) != __btree_lock_want(iter, level)); return likely(btree_node_locked(iter, level)) || __bch2_btree_node_relock(iter, level); } bool bch2_btree_iter_relock(struct btree_iter *); void bch2_btree_node_unlock_write(struct btree *, struct btree_iter *); void __bch2_btree_node_lock_write(struct btree *, struct btree_iter *); static inline void bch2_btree_node_lock_write(struct btree *b, struct btree_iter *iter) { EBUG_ON(iter->l[b->level].b != b); EBUG_ON(iter->lock_seq[b->level] != b->lock.state.seq); if (!six_trylock_write(&b->lock)) __bch2_btree_node_lock_write(b, iter); } #endif /* _BCACHEFS_BTREE_LOCKING_H */

5,214

C

.c

159

30.213836

87

0.719267

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,722

vstructs.h

thoughtpolice_bcachefs-tools/libbcachefs/vstructs.h

#ifndef _VSTRUCTS_H #define _VSTRUCTS_H #include "util.h" /* * NOTE: we can't differentiate between __le64 and u64 with type_is - this * assumes u64 is little endian: */ #define __vstruct_u64s(_s) \ ({ \ ( type_is((_s)->u64s, u64) ? le64_to_cpu((__force __le64) (_s)->u64s) \ : type_is((_s)->u64s, u32) ? le32_to_cpu((__force __le32) (_s)->u64s) \ : type_is((_s)->u64s, u16) ? le16_to_cpu((__force __le16) (_s)->u64s) \ : ((__force u8) ((_s)->u64s))); \ }) #define __vstruct_bytes(_type, _u64s) \ ({ \ BUILD_BUG_ON(offsetof(_type, _data) % sizeof(u64)); \ \ (offsetof(_type, _data) + (_u64s) * sizeof(u64)); \ }) #define vstruct_bytes(_s) \ __vstruct_bytes(typeof(*(_s)), __vstruct_u64s(_s)) #define __vstruct_blocks(_type, _sector_block_bits, _u64s) \ (round_up(__vstruct_bytes(_type, _u64s), \ 512 << (_sector_block_bits)) >> (9 + (_sector_block_bits))) #define vstruct_blocks(_s, _sector_block_bits) \ __vstruct_blocks(typeof(*(_s)), _sector_block_bits, __vstruct_u64s(_s)) #define vstruct_blocks_plus(_s, _sector_block_bits, _u64s) \ __vstruct_blocks(typeof(*(_s)), _sector_block_bits, \ __vstruct_u64s(_s) + (_u64s)) #define vstruct_sectors(_s, _sector_block_bits) \ (round_up(vstruct_bytes(_s), 512 << (_sector_block_bits)) >> 9) #define vstruct_next(_s) \ ((typeof(_s)) ((_s)->_data + __vstruct_u64s(_s))) #define vstruct_last(_s) \ ((typeof(&(_s)->start[0])) ((_s)->_data + __vstruct_u64s(_s))) #define vstruct_end(_s) \ ((void *) ((_s)->_data + __vstruct_u64s(_s))) #define vstruct_for_each(_s, _i) \ for (_i = (_s)->start; \ _i < vstruct_last(_s); \ _i = vstruct_next(_i)) #define vstruct_for_each_safe(_s, _i, _t) \ for (_i = (_s)->start; \ _i < vstruct_last(_s) && (_t = vstruct_next(_i), true); \ _i = _t) #define vstruct_idx(_s, _idx) \ ((typeof(&(_s)->start[0])) ((_s)->_data + (_idx))) #endif /* _VSTRUCTS_H */

1,998

C

.c

49

38.265306

74

0.550103

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,728

movinggc.h

thoughtpolice_bcachefs-tools/libbcachefs/movinggc.h

#ifndef _BCACHEFS_MOVINGGC_H #define _BCACHEFS_MOVINGGC_H void bch2_copygc_stop(struct bch_dev *); int bch2_copygc_start(struct bch_fs *, struct bch_dev *); void bch2_dev_copygc_init(struct bch_dev *); #endif /* _BCACHEFS_MOVINGGC_H */

238

C

.c

6

38.333333

57

0.747826

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,733

fsck.h

thoughtpolice_bcachefs-tools/libbcachefs/fsck.h

#ifndef _BCACHEFS_FSCK_H #define _BCACHEFS_FSCK_H s64 bch2_count_inode_sectors(struct bch_fs *, u64); int bch2_fsck(struct bch_fs *); #endif /* _BCACHEFS_FSCK_H */

166

C

.c

5

31.8

51

0.72956

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,737

rebalance.h

thoughtpolice_bcachefs-tools/libbcachefs/rebalance.h

#ifndef _BCACHEFS_REBALANCE_H #define _BCACHEFS_REBALANCE_H #include "rebalance_types.h" static inline void rebalance_wakeup(struct bch_fs *c) { struct task_struct *p; rcu_read_lock(); p = rcu_dereference(c->rebalance.thread); if (p) wake_up_process(p); rcu_read_unlock(); } void bch2_rebalance_add_key(struct bch_fs *, struct bkey_s_c, struct bch_io_opts *); void bch2_rebalance_add_work(struct bch_fs *, u64); ssize_t bch2_rebalance_work_show(struct bch_fs *, char *); void bch2_rebalance_stop(struct bch_fs *); int bch2_rebalance_start(struct bch_fs *); void bch2_fs_rebalance_init(struct bch_fs *); #endif /* _BCACHEFS_REBALANCE_H */

659

C

.c

20

30.9

61

0.734177

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,742

alloc_types.h

thoughtpolice_bcachefs-tools/libbcachefs/alloc_types.h

#ifndef _BCACHEFS_ALLOC_TYPES_H #define _BCACHEFS_ALLOC_TYPES_H #include <linux/mutex.h> #include <linux/spinlock.h> #include "clock_types.h" #include "fifo.h" /* There's two of these clocks, one for reads and one for writes: */ struct bucket_clock { /* * "now" in (read/write) IO time - incremented whenever we do X amount * of reads or writes. * * Goes with the bucket read/write prios: when we read or write to a * bucket we reset the bucket's prio to the current hand; thus hand - * prio = time since bucket was last read/written. * * The units are some amount (bytes/sectors) of data read/written, and * the units can change on the fly if we need to rescale to fit * everything in a u16 - your only guarantee is that the units are * consistent. */ u16 hand; u16 max_last_io; int rw; struct io_timer rescale; struct mutex lock; }; /* There is one reserve for each type of btree, one for prios and gens * and one for moving GC */ enum alloc_reserve { RESERVE_ALLOC = -1, RESERVE_BTREE = 0, RESERVE_MOVINGGC = 1, RESERVE_NONE = 2, RESERVE_NR = 3, }; typedef FIFO(long) alloc_fifo; /* Enough for 16 cache devices, 2 tiers and some left over for pipelining */ #define OPEN_BUCKETS_COUNT 256 #define WRITE_POINT_COUNT 32 struct open_bucket { spinlock_t lock; atomic_t pin; u8 freelist; bool valid; bool on_partial_list; unsigned sectors_free; struct bch_extent_ptr ptr; }; struct write_point { struct hlist_node node; struct mutex lock; u64 last_used; unsigned long write_point; enum bch_data_type type; u8 nr_ptrs; u8 first_ptr; /* calculated based on how many pointers we're actually going to use: */ unsigned sectors_free; struct open_bucket *ptrs[BCH_REPLICAS_MAX * 2]; u64 next_alloc[BCH_SB_MEMBERS_MAX]; }; struct write_point_specifier { unsigned long v; }; struct alloc_heap_entry { size_t bucket; size_t nr; unsigned long key; }; typedef HEAP(struct alloc_heap_entry) alloc_heap; #endif /* _BCACHEFS_ALLOC_TYPES_H */

2,037

C

.c

72

26.25

76

0.724333

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,743

buckets_types.h

thoughtpolice_bcachefs-tools/libbcachefs/buckets_types.h

#ifndef _BUCKETS_TYPES_H #define _BUCKETS_TYPES_H #include "util.h" struct bucket_mark { union { struct { atomic64_t v; }; struct { u8 gen; u8 data_type:3, gen_valid:1, owned_by_allocator:1, nouse:1, journal_seq_valid:1; u16 dirty_sectors; u16 cached_sectors; /* * low bits of journal sequence number when this bucket was most * recently modified: if journal_seq_valid is set, this bucket * can't be reused until the journal sequence number written to * disk is >= the bucket's journal sequence number: */ u16 journal_seq; }; }; }; struct bucket { union { struct bucket_mark _mark; const struct bucket_mark mark; }; u16 io_time[2]; }; struct bucket_array { struct rcu_head rcu; u16 first_bucket; size_t nbuckets; struct bucket b[]; }; struct bch_dev_usage { u64 buckets[BCH_DATA_NR]; u64 buckets_alloc; u64 buckets_unavailable; /* _compressed_ sectors: */ u64 sectors[BCH_DATA_NR]; u64 sectors_fragmented; }; /* kill, switch to bch_data_type? */ enum s_alloc { S_META, S_DIRTY, S_ALLOC_NR, }; struct bch_fs_usage { /* all fields are in units of 512 byte sectors: */ /* _uncompressed_ sectors: */ u64 online_reserved; u64 available_cache; struct { u64 data[S_ALLOC_NR]; u64 persistent_reserved; } s[BCH_REPLICAS_MAX]; }; /* * A reservation for space on disk: */ struct disk_reservation { u64 sectors; u32 gen; unsigned nr_replicas; }; struct copygc_heap_entry { u8 gen; u32 sectors; u64 offset; }; typedef HEAP(struct copygc_heap_entry) copygc_heap; #endif /* _BUCKETS_TYPES_H */

1,624

C

.c

79

18.227848

66

0.69261

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,745

movinggc.c

thoughtpolice_bcachefs-tools/libbcachefs/movinggc.c

/* * Moving/copying garbage collector * * Copyright 2012 Google, Inc. */ #include "bcachefs.h" #include "btree_iter.h" #include "btree_update.h" #include "buckets.h" #include "clock.h" #include "disk_groups.h" #include "extents.h" #include "eytzinger.h" #include "io.h" #include "keylist.h" #include "move.h" #include "movinggc.h" #include "super-io.h" #include <trace/events/bcachefs.h> #include <linux/freezer.h> #include <linux/kthread.h> #include <linux/math64.h> #include <linux/sched/task.h> #include <linux/sort.h> #include <linux/wait.h> /* * We can't use the entire copygc reserve in one iteration of copygc: we may * need the buckets we're freeing up to go back into the copygc reserve to make * forward progress, but if the copygc reserve is full they'll be available for * any allocation - and it's possible that in a given iteration, we free up most * of the buckets we're going to free before we allocate most of the buckets * we're going to allocate. * * If we only use half of the reserve per iteration, then in steady state we'll * always have room in the reserve for the buckets we're going to need in the * next iteration: */ #define COPYGC_BUCKETS_PER_ITER(ca) \ ((ca)->free[RESERVE_MOVINGGC].size / 2) /* * Max sectors to move per iteration: Have to take into account internal * fragmentation from the multiple write points for each generation: */ #define COPYGC_SECTORS_PER_ITER(ca) \ ((ca)->mi.bucket_size * COPYGC_BUCKETS_PER_ITER(ca)) static inline int sectors_used_cmp(copygc_heap *heap, struct copygc_heap_entry l, struct copygc_heap_entry r) { return (l.sectors > r.sectors) - (l.sectors < r.sectors); } static int bucket_offset_cmp(const void *_l, const void *_r, size_t size) { const struct copygc_heap_entry *l = _l; const struct copygc_heap_entry *r = _r; return (l->offset > r->offset) - (l->offset < r->offset); } static bool __copygc_pred(struct bch_dev *ca, struct bkey_s_c_extent e) { copygc_heap *h = &ca->copygc_heap; const struct bch_extent_ptr *ptr = bch2_extent_has_device(e, ca->dev_idx); if (ptr) { struct copygc_heap_entry search = { .offset = ptr->offset }; ssize_t i = eytzinger0_find_le(h->data, h->used, sizeof(h->data[0]), bucket_offset_cmp, &search); return (i >= 0 && ptr->offset < h->data[i].offset + ca->mi.bucket_size && ptr->gen == h->data[i].gen); } return false; } static enum data_cmd copygc_pred(struct bch_fs *c, void *arg, enum bkey_type type, struct bkey_s_c_extent e, struct bch_io_opts *io_opts, struct data_opts *data_opts) { struct bch_dev *ca = arg; if (!__copygc_pred(ca, e)) return DATA_SKIP; data_opts->target = dev_to_target(ca->dev_idx); data_opts->btree_insert_flags = BTREE_INSERT_USE_RESERVE; data_opts->rewrite_dev = ca->dev_idx; return DATA_REWRITE; } static bool have_copygc_reserve(struct bch_dev *ca) { bool ret; spin_lock(&ca->freelist_lock); ret = fifo_full(&ca->free[RESERVE_MOVINGGC]) || ca->allocator_blocked; spin_unlock(&ca->freelist_lock); return ret; } static void bch2_copygc(struct bch_fs *c, struct bch_dev *ca) { copygc_heap *h = &ca->copygc_heap; struct copygc_heap_entry e, *i; struct bucket_array *buckets; struct bch_move_stats move_stats; u64 sectors_to_move = 0, sectors_not_moved = 0; u64 buckets_to_move, buckets_not_moved = 0; size_t b; int ret; memset(&move_stats, 0, sizeof(move_stats)); closure_wait_event(&c->freelist_wait, have_copygc_reserve(ca)); /* * Find buckets with lowest sector counts, skipping completely * empty buckets, by building a maxheap sorted by sector count, * and repeatedly replacing the maximum element until all * buckets have been visited. */ h->used = 0; /* * We need bucket marks to be up to date - gc can't be recalculating * them: */ down_read(&c->gc_lock); down_read(&ca->bucket_lock); buckets = bucket_array(ca); for (b = buckets->first_bucket; b < buckets->nbuckets; b++) { struct bucket_mark m = READ_ONCE(buckets->b[b].mark); struct copygc_heap_entry e; if (m.owned_by_allocator || m.data_type != BCH_DATA_USER || !bucket_sectors_used(m) || bucket_sectors_used(m) >= ca->mi.bucket_size) continue; e = (struct copygc_heap_entry) { .gen = m.gen, .sectors = bucket_sectors_used(m), .offset = bucket_to_sector(ca, b), }; heap_add_or_replace(h, e, -sectors_used_cmp); } up_read(&ca->bucket_lock); up_read(&c->gc_lock); for (i = h->data; i < h->data + h->used; i++) sectors_to_move += i->sectors; while (sectors_to_move > COPYGC_SECTORS_PER_ITER(ca)) { BUG_ON(!heap_pop(h, e, -sectors_used_cmp)); sectors_to_move -= e.sectors; } buckets_to_move = h->used; if (!buckets_to_move) return; eytzinger0_sort(h->data, h->used, sizeof(h->data[0]), bucket_offset_cmp, NULL); ret = bch2_move_data(c, &ca->copygc_pd.rate, writepoint_ptr(&ca->copygc_write_point), POS_MIN, POS_MAX, copygc_pred, ca, &move_stats); down_read(&ca->bucket_lock); buckets = bucket_array(ca); for (i = h->data; i < h->data + h->used; i++) { size_t b = sector_to_bucket(ca, i->offset); struct bucket_mark m = READ_ONCE(buckets->b[b].mark); if (i->gen == m.gen && bucket_sectors_used(m)) { sectors_not_moved += bucket_sectors_used(m); buckets_not_moved++; } } up_read(&ca->bucket_lock); if (sectors_not_moved && !ret) bch_warn(c, "copygc finished but %llu/%llu sectors, %llu/%llu buckets not moved", sectors_not_moved, sectors_to_move, buckets_not_moved, buckets_to_move); trace_copygc(ca, atomic64_read(&move_stats.sectors_moved), sectors_not_moved, buckets_to_move, buckets_not_moved); } static int bch2_copygc_thread(void *arg) { struct bch_dev *ca = arg; struct bch_fs *c = ca->fs; struct io_clock *clock = &c->io_clock[WRITE]; struct bch_dev_usage usage; unsigned long last; u64 available, fragmented, reserve, next; set_freezable(); while (!kthread_should_stop()) { if (kthread_wait_freezable(c->copy_gc_enabled)) break; last = atomic_long_read(&clock->now); reserve = div64_u64((ca->mi.nbuckets - ca->mi.first_bucket) * ca->mi.bucket_size * c->opts.gc_reserve_percent, 200); usage = bch2_dev_usage_read(c, ca); /* * don't start copygc until less than half the gc reserve is * available: */ available = __dev_buckets_available(ca, usage) * ca->mi.bucket_size; if (available > reserve) { next = last + available - reserve; bch2_kthread_io_clock_wait(clock, next, MAX_SCHEDULE_TIMEOUT); continue; } /* * don't start copygc until there's more than half the copygc * reserve of fragmented space: */ fragmented = usage.sectors_fragmented; if (fragmented < reserve) { next = last + reserve - fragmented; bch2_kthread_io_clock_wait(clock, next, MAX_SCHEDULE_TIMEOUT); continue; } bch2_copygc(c, ca); } return 0; } void bch2_copygc_stop(struct bch_dev *ca) { ca->copygc_pd.rate.rate = UINT_MAX; bch2_ratelimit_reset(&ca->copygc_pd.rate); if (ca->copygc_thread) { kthread_stop(ca->copygc_thread); put_task_struct(ca->copygc_thread); } ca->copygc_thread = NULL; } int bch2_copygc_start(struct bch_fs *c, struct bch_dev *ca) { struct task_struct *t; BUG_ON(ca->copygc_thread); if (c->opts.nochanges) return 0; if (bch2_fs_init_fault("copygc_start")) return -ENOMEM; t = kthread_create(bch2_copygc_thread, ca, "bch_copygc[%s]", ca->name); if (IS_ERR(t)) return PTR_ERR(t); get_task_struct(t); ca->copygc_thread = t; wake_up_process(ca->copygc_thread); return 0; } void bch2_dev_copygc_init(struct bch_dev *ca) { bch2_pd_controller_init(&ca->copygc_pd); ca->copygc_pd.d_term = 0; }

7,768

C

.c

252

27.904762

83

0.685121

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,749

acl.h

thoughtpolice_bcachefs-tools/libbcachefs/acl.h

#ifndef _BCACHEFS_ACL_H #define _BCACHEFS_ACL_H struct bch_inode_unpacked; struct bch_hash_info; struct bch_inode_info; struct posix_acl; #ifdef CONFIG_BCACHEFS_POSIX_ACL #define BCH_ACL_VERSION 0x0001 typedef struct { __le16 e_tag; __le16 e_perm; __le32 e_id; } bch_acl_entry; typedef struct { __le16 e_tag; __le16 e_perm; } bch_acl_entry_short; typedef struct { __le32 a_version; } bch_acl_header; struct posix_acl *bch2_get_acl(struct inode *, int); int bch2_set_acl_trans(struct btree_trans *, struct bch_inode_unpacked *, const struct bch_hash_info *, struct posix_acl *, int); int bch2_set_acl(struct inode *, struct posix_acl *, int); int bch2_acl_chmod(struct btree_trans *, struct bch_inode_info *, umode_t, struct posix_acl **); #else static inline int bch2_set_acl_trans(struct btree_trans *trans, struct bch_inode_unpacked *inode_u, const struct bch_hash_info *hash_info, struct posix_acl *acl, int type) { return 0; } static inline int bch2_acl_chmod(struct btree_trans *trans, struct bch_inode_info *inode, umode_t mode, struct posix_acl **new_acl) { return 0; } #endif /* CONFIG_BCACHEFS_POSIX_ACL */ #endif /* _BCACHEFS_ACL_H */

1,246

C

.c

45

24.577778

65

0.697811

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,751

btree_cache.h

thoughtpolice_bcachefs-tools/libbcachefs/btree_cache.h

#ifndef _BCACHEFS_BTREE_CACHE_H #define _BCACHEFS_BTREE_CACHE_H #include "bcachefs.h" #include "btree_types.h" #include "extents.h" struct btree_iter; extern const char * const bch2_btree_ids[]; void bch2_recalc_btree_reserve(struct bch_fs *); void bch2_btree_node_hash_remove(struct btree_cache *, struct btree *); int __bch2_btree_node_hash_insert(struct btree_cache *, struct btree *); int bch2_btree_node_hash_insert(struct btree_cache *, struct btree *, unsigned, enum btree_id); void bch2_btree_cache_cannibalize_unlock(struct bch_fs *); int bch2_btree_cache_cannibalize_lock(struct bch_fs *, struct closure *); struct btree *bch2_btree_node_mem_alloc(struct bch_fs *); struct btree *bch2_btree_node_get(struct bch_fs *, struct btree_iter *, const struct bkey_i *, unsigned, enum six_lock_type, bool); struct btree *bch2_btree_node_get_sibling(struct bch_fs *, struct btree_iter *, struct btree *, bool, enum btree_node_sibling); void bch2_btree_node_prefetch(struct bch_fs *, struct btree_iter *, const struct bkey_i *, unsigned); void bch2_fs_btree_cache_exit(struct bch_fs *); int bch2_fs_btree_cache_init(struct bch_fs *); void bch2_fs_btree_cache_init_early(struct btree_cache *); #define PTR_HASH(_k) (bkey_i_to_extent_c(_k)->v._data[0]) /* is btree node in hash table? */ static inline bool btree_node_hashed(struct btree *b) { return bkey_extent_is_data(&b->key.k) && PTR_HASH(&b->key); } #define for_each_cached_btree(_b, _c, _tbl, _iter, _pos) \ for ((_tbl) = rht_dereference_rcu((_c)->btree_cache.table.tbl, \ &(_c)->btree_cache.table), \ _iter = 0; _iter < (_tbl)->size; _iter++) \ rht_for_each_entry_rcu((_b), (_pos), _tbl, _iter, hash) static inline size_t btree_bytes(struct bch_fs *c) { return c->opts.btree_node_size << 9; } static inline size_t btree_max_u64s(struct bch_fs *c) { return (btree_bytes(c) - sizeof(struct btree_node)) / sizeof(u64); } static inline size_t btree_page_order(struct bch_fs *c) { return get_order(btree_bytes(c)); } static inline size_t btree_pages(struct bch_fs *c) { return 1 << btree_page_order(c); } static inline unsigned btree_blocks(struct bch_fs *c) { return c->opts.btree_node_size >> c->block_bits; } #define BTREE_SPLIT_THRESHOLD(c) (btree_blocks(c) * 3 / 4) #define BTREE_FOREGROUND_MERGE_THRESHOLD(c) (btree_max_u64s(c) * 1 / 3) #define BTREE_FOREGROUND_MERGE_HYSTERESIS(c) \ (BTREE_FOREGROUND_MERGE_THRESHOLD(c) + \ (BTREE_FOREGROUND_MERGE_THRESHOLD(c) << 2)) #define btree_node_root(_c, _b) ((_c)->btree_roots[(_b)->btree_id].b) int bch2_print_btree_node(struct bch_fs *, struct btree *, char *, size_t); #endif /* _BCACHEFS_BTREE_CACHE_H */

2,708

C

.c

66

38.636364

79

0.701299

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,752

journal_seq_blacklist.h

thoughtpolice_bcachefs-tools/libbcachefs/journal_seq_blacklist.h

#ifndef _BCACHEFS_JOURNAL_SEQ_BLACKLIST_H #define _BCACHEFS_JOURNAL_SEQ_BLACKLIST_H struct journal_replay; struct journal_seq_blacklist * bch2_journal_seq_blacklist_find(struct journal *, u64); int bch2_journal_seq_should_ignore(struct bch_fs *, u64, struct btree *); int bch2_journal_seq_blacklist_read(struct journal *, struct journal_replay *); void bch2_journal_seq_blacklist_write(struct journal *); #endif /* _BCACHEFS_JOURNAL_SEQ_BLACKLIST_H */

463

C

.c

10

44.2

73

0.775556

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,756

btree_gc.h

thoughtpolice_bcachefs-tools/libbcachefs/btree_gc.h

#ifndef _BCACHEFS_BTREE_GC_H #define _BCACHEFS_BTREE_GC_H #include "btree_types.h" enum bkey_type; void bch2_coalesce(struct bch_fs *); void bch2_gc(struct bch_fs *); void bch2_gc_thread_stop(struct bch_fs *); int bch2_gc_thread_start(struct bch_fs *); int bch2_initial_gc(struct bch_fs *, struct list_head *); u8 bch2_btree_key_recalc_oldest_gen(struct bch_fs *, struct bkey_s_c); int bch2_btree_mark_key_initial(struct bch_fs *, enum bkey_type, struct bkey_s_c); void bch2_mark_dev_superblock(struct bch_fs *, struct bch_dev *, unsigned); /* * For concurrent mark and sweep (with other index updates), we define a total * ordering of _all_ references GC walks: * * Note that some references will have the same GC position as others - e.g. * everything within the same btree node; in those cases we're relying on * whatever locking exists for where those references live, i.e. the write lock * on a btree node. * * That locking is also required to ensure GC doesn't pass the updater in * between the updater adding/removing the reference and updating the GC marks; * without that, we would at best double count sometimes. * * That part is important - whenever calling bch2_mark_pointers(), a lock _must_ * be held that prevents GC from passing the position the updater is at. * * (What about the start of gc, when we're clearing all the marks? GC clears the * mark with the gc pos seqlock held, and bch_mark_bucket checks against the gc * position inside its cmpxchg loop, so crap magically works). */ /* Position of (the start of) a gc phase: */ static inline struct gc_pos gc_phase(enum gc_phase phase) { return (struct gc_pos) { .phase = phase, .pos = POS_MIN, .level = 0, }; } static inline int gc_pos_cmp(struct gc_pos l, struct gc_pos r) { if (l.phase != r.phase) return l.phase < r.phase ? -1 : 1; if (bkey_cmp(l.pos, r.pos)) return bkey_cmp(l.pos, r.pos); if (l.level != r.level) return l.level < r.level ? -1 : 1; return 0; } static inline struct gc_pos gc_pos_btree(enum btree_id id, struct bpos pos, unsigned level) { return (struct gc_pos) { .phase = GC_PHASE_BTREE_EXTENTS + id, .pos = pos, .level = level, }; } /* * GC position of the pointers within a btree node: note, _not_ for &b->key * itself, that lives in the parent node: */ static inline struct gc_pos gc_pos_btree_node(struct btree *b) { return gc_pos_btree(b->btree_id, b->key.k.p, b->level); } /* * GC position of the pointer to a btree root: we don't use * gc_pos_pointer_to_btree_node() here to avoid a potential race with * btree_split() increasing the tree depth - the new root will have level > the * old root and thus have a greater gc position than the old root, but that * would be incorrect since once gc has marked the root it's not coming back. */ static inline struct gc_pos gc_pos_btree_root(enum btree_id id) { return gc_pos_btree(id, POS_MAX, BTREE_MAX_DEPTH); } static inline struct gc_pos gc_pos_alloc(struct bch_fs *c, struct open_bucket *ob) { return (struct gc_pos) { .phase = GC_PHASE_ALLOC, .pos = POS(ob ? ob - c->open_buckets : 0, 0), }; } static inline bool gc_will_visit(struct bch_fs *c, struct gc_pos pos) { unsigned seq; bool ret; do { seq = read_seqcount_begin(&c->gc_pos_lock); ret = gc_pos_cmp(c->gc_pos, pos) < 0; } while (read_seqcount_retry(&c->gc_pos_lock, seq)); return ret; } #endif /* _BCACHEFS_BTREE_GC_H */

3,420

C

.c

98

32.928571

82

0.713724

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,769

crypto.h

thoughtpolice_bcachefs-tools/crypto.h

#ifndef _CRYPTO_H #define _CRYPTO_H #include "tools-util.h" struct bch_sb; struct bch_sb_field_crypt; struct bch_key; struct bch_encrypted_key; char *read_passphrase(const char *); char *read_passphrase_twice(const char *); struct bch_key derive_passphrase(struct bch_sb_field_crypt *, const char *); bool bch2_sb_is_encrypted(struct bch_sb *); void bch2_passphrase_check(struct bch_sb *, const char *, struct bch_key *, struct bch_encrypted_key *); void bch2_add_key(struct bch_sb *, const char *); void bch_sb_crypt_init(struct bch_sb *sb, struct bch_sb_field_crypt *, const char *); #endif /* _CRYPTO_H */

629

C

.h

17

34.823529

76

0.724876

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,772

tools-util.h

thoughtpolice_bcachefs-tools/tools-util.h

#ifndef _TOOLS_UTIL_H #define _TOOLS_UTIL_H #include <errno.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <sys/ioctl.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include <linux/bug.h> #include <linux/byteorder.h> #include <linux/kernel.h> #include <linux/log2.h> #include <linux/string.h> #include <linux/types.h> #include <linux/uuid.h> #include "ccan/darray/darray.h" void die(const char *, ...); char *mprintf(const char *, ...) __attribute__ ((format (printf, 1, 2))); void *xcalloc(size_t, size_t); void *xmalloc(size_t); void *xrealloc(void *, size_t); void xpread(int, void *, size_t, off_t); void xpwrite(int, const void *, size_t, off_t); struct stat xfstatat(int, const char *, int); struct stat xfstat(int); struct stat xstat(const char *); #define xopenat(_dirfd, _path, ...) \ ({ \ int _fd = openat((_dirfd), (_path), __VA_ARGS__); \ if (_fd < 0) \ die("Error opening %s: %m", (_path)); \ _fd; \ }) #define xopen(...) xopenat(AT_FDCWD, __VA_ARGS__) #define xioctl(_fd, _nr, ...) \ ({ \ int _ret = ioctl((_fd), (_nr), ##__VA_ARGS__); \ if (_ret < 0) \ die(#_nr " ioctl error: %m"); \ _ret; \ }) int printf_pad(unsigned pad, const char * fmt, ...); enum units { BYTES, SECTORS, HUMAN_READABLE, }; struct units_buf __pr_units(s64, enum units); struct units_buf { char b[20]; }; #define pr_units(_v, _u) &(__pr_units(_v, _u).b[0]) char *read_file_str(int, const char *); u64 read_file_u64(int, const char *); ssize_t read_string_list_or_die(const char *, const char * const[], const char *); u64 get_size(const char *, int); unsigned get_blocksize(const char *, int); int open_for_format(const char *, bool); bool ask_yn(void); struct range { u64 start; u64 end; }; typedef darray(struct range) ranges; static inline void range_add(ranges *data, u64 offset, u64 size) { darray_append(*data, (struct range) { .start = offset, .end = offset + size }); } void ranges_sort_merge(ranges *); void ranges_roundup(ranges *, unsigned); void ranges_rounddown(ranges *, unsigned); struct hole_iter { ranges r; size_t idx; u64 end; }; static inline struct range hole_iter_next(struct hole_iter *iter) { struct range r = { .start = iter->idx ? iter->r.item[iter->idx - 1].end : 0, .end = iter->idx < iter->r.size ? iter->r.item[iter->idx].start : iter->end, }; BUG_ON(r.start > r.end); iter->idx++; return r; } #define for_each_hole(_iter, _ranges, _end, _i) \ for (_iter = (struct hole_iter) { .r = _ranges, .end = _end }; \ (_iter.idx <= _iter.r.size && \ (_i = hole_iter_next(&_iter), true));) #include <linux/fiemap.h> struct fiemap_iter { struct fiemap f; struct fiemap_extent fe[1024]; unsigned idx; int fd; }; static inline void fiemap_iter_init(struct fiemap_iter *iter, int fd) { memset(iter, 0, sizeof(*iter)); iter->f.fm_extent_count = ARRAY_SIZE(iter->fe); iter->f.fm_length = FIEMAP_MAX_OFFSET; iter->fd = fd; } struct fiemap_extent fiemap_iter_next(struct fiemap_iter *); #define fiemap_for_each(fd, iter, extent) \ for (fiemap_iter_init(&iter, fd); \ (extent = fiemap_iter_next(&iter)).fe_length;) const char *strcmp_prefix(const char *, const char *); unsigned hatoi_validate(const char *, const char *); u32 crc32c(u32, const void *, size_t); char *dev_to_name(dev_t); char *dev_to_path(dev_t); char *dev_to_mount(char *); #define args_shift(_nr) \ do { \ unsigned _n = min((_nr), argc); \ argc -= _n; \ argv += _n; \ } while (0) #define arg_pop() \ ({ \ char *_ret = argc ? argv[0] : NULL; \ if (_ret) \ args_shift(1); \ _ret; \ }) #endif /* _TOOLS_UTIL_H */

3,785

C

.h

136

25.977941

69

0.629014

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,774

cmds.h

thoughtpolice_bcachefs-tools/cmds.h

/* * Author: Kent Overstreet <[email protected]> * * GPLv2 */ #ifndef _CMDS_H #define _CMDS_H #include "tools-util.h" int cmd_format(int argc, char *argv[]); int cmd_show_super(int argc, char *argv[]); #if 0 int cmd_assemble(int argc, char *argv[]); int cmd_incremental(int argc, char *argv[]); int cmd_run(int argc, char *argv[]); int cmd_stop(int argc, char *argv[]); #endif int cmd_fs_usage(int argc, char *argv[]); int cmd_device_add(int argc, char *argv[]); int cmd_device_remove(int argc, char *argv[]); int cmd_device_online(int argc, char *argv[]); int cmd_device_offline(int argc, char *argv[]); int cmd_device_evacuate(int argc, char *argv[]); int cmd_device_set_state(int argc, char *argv[]); int cmd_device_resize(int argc, char *argv[]); int cmd_data_rereplicate(int argc, char *argv[]); int cmd_unlock(int argc, char *argv[]); int cmd_set_passphrase(int argc, char *argv[]); int cmd_remove_passphrase(int argc, char *argv[]); int cmd_fsck(int argc, char *argv[]); int cmd_dump(int argc, char *argv[]); int cmd_list(int argc, char *argv[]); int cmd_migrate(int argc, char *argv[]); int cmd_migrate_superblock(int argc, char *argv[]); int cmd_version(int argc, char *argv[]); #endif /* _CMDS_H */

1,234

C

.h

35

33.771429

54

0.704047

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,793

mutex.h

thoughtpolice_bcachefs-tools/include/linux/mutex.h

#ifndef __TOOLS_LINUX_MUTEX_H #define __TOOLS_LINUX_MUTEX_H #include <pthread.h> struct mutex { pthread_mutex_t lock; }; #define DEFINE_MUTEX(mutexname) \ struct mutex mutexname = { .lock = PTHREAD_MUTEX_INITIALIZER } #define mutex_init(l) pthread_mutex_init(&(l)->lock, NULL) #define mutex_lock(l) pthread_mutex_lock(&(l)->lock) #define mutex_trylock(l) (!pthread_mutex_trylock(&(l)->lock)) #define mutex_unlock(l) pthread_mutex_unlock(&(l)->lock) #endif /* __TOOLS_LINUX_MUTEX_H */

494

C

.h

13

36.461538

63

0.720588

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,794

list.h

thoughtpolice_bcachefs-tools/include/linux/list.h

#ifndef _LINUX_LIST_H #define _LINUX_LIST_H #include <urcu/list.h> #define list_head cds_list_head #define LIST_HEAD_INIT(l) CDS_LIST_HEAD_INIT(l) #define LIST_HEAD(l) CDS_LIST_HEAD(l) #define INIT_LIST_HEAD(l) CDS_INIT_LIST_HEAD(l) #define list_add(n, h) cds_list_add(n, h) #define list_add_tail(n, h) cds_list_add_tail(n, h) #define __list_del_entry(l) cds_list_del(l) #define list_del(l) cds_list_del(l) #define list_del_init(l) cds_list_del_init(l) #define list_replace(o, n) cds_list_replace(o, n) #define list_replace_init(o, n) cds_list_replace_init(o, n) #define list_move(l, h) cds_list_move(l, h) #define list_empty(l) cds_list_empty(l) #define list_splice(l, h) cds_list_splice(l, h) #define list_entry(p, t, m) cds_list_entry(p, t, m) #define list_first_entry(p, t, m) cds_list_first_entry(p, t, m) #define list_for_each(p, h) cds_list_for_each(p, h) #define list_for_each_prev(p, h) cds_list_for_each_prev(p, h) #define list_for_each_safe(p, n, h) cds_list_for_each_safe(p, n, h) #define list_for_each_prev_safe(p, n, h) cds_list_for_each_prev_safe(p, n, h) #define list_for_each_entry(p, h, m) cds_list_for_each_entry(p, h, m) #define list_for_each_entry_reverse(p, h, m) cds_list_for_each_entry_reverse(p, h, m) #define list_for_each_entry_safe(p, n, h, m) cds_list_for_each_entry_safe(p, n, h, m) #define list_for_each_entry_safe_reverse(p, n, h, m) cds_list_for_each_entry_safe_reverse(p, n, h, m) static inline int list_empty_careful(const struct list_head *head) { struct list_head *next = head->next; return (next == head) && (next == head->prev); } static inline void list_move_tail(struct list_head *list, struct list_head *head) { list_del(list); list_add_tail(list, head); } static inline void list_splice_init(struct list_head *list, struct list_head *head) { list_splice(list, head); INIT_LIST_HEAD(list); } #define list_last_entry(ptr, type, member) \ list_entry((ptr)->prev, type, member) #define list_first_entry_or_null(ptr, type, member) \ (!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL) /* hlists: */ #include <urcu/hlist.h> #define hlist_head cds_hlist_head #define hlist_node cds_hlist_node #endif /* _LIST_LIST_H */

2,226

C

.h

53

40.377358

101

0.697502

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,795

lz4.h

thoughtpolice_bcachefs-tools/include/linux/lz4.h

#include <lz4.h> #define LZ4_compress_destSize(src, dst, srclen, dstlen, workspace) \ LZ4_compress_destSize(src, dst, srclen, dstlen) #define LZ4_MEM_COMPRESS 0

163

C

.h

4

39.25

68

0.765823

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,796

crypto.h

thoughtpolice_bcachefs-tools/include/linux/crypto.h

/* * Scatterlist Cryptographic API. * * Copyright (c) 2002 James Morris <[email protected]> * Copyright (c) 2002 David S. Miller ([email protected]) * Copyright (c) 2005 Herbert Xu <[email protected]> * * Portions derived from Cryptoapi, by Alexander Kjeldaas <[email protected]> * and Nettle, by Niels MÃ¶ller. * * 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; either version 2 of the License, or (at your option) * any later version. * */ #ifndef _LINUX_CRYPTO_H #define _LINUX_CRYPTO_H #include <linux/kernel.h> #include <linux/list.h> #include <linux/slab.h> #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN))) struct crypto_type; struct crypto_alg { struct list_head cra_list; const char *cra_name; const struct crypto_type *cra_type; void * (*alloc_tfm)(void); } CRYPTO_MINALIGN_ATTR; int crypto_register_alg(struct crypto_alg *alg); struct crypto_tfm { struct crypto_alg *alg; }; #endif /* _LINUX_CRYPTO_H */

1,159

C

.h

35

31.2

77

0.745961

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,797

page.h

thoughtpolice_bcachefs-tools/include/linux/page.h

#ifndef _LINUX_PAGE_H #define _LINUX_PAGE_H #include <sys/user.h> struct page; #ifndef PAGE_SIZE #define PAGE_SIZE 4096UL #define PAGE_MASK (~(PAGE_SIZE - 1)) #endif #define virt_to_page(p) \ ((struct page *) (((unsigned long) (p)) & PAGE_MASK)) #define offset_in_page(p) ((unsigned long) (p) & ~PAGE_MASK) #define page_address(p) ((void *) (p)) #define kmap_atomic(page) page_address(page) #define kunmap_atomic(addr) do {} while (0) static const char zero_page[PAGE_SIZE]; #define ZERO_PAGE(o) ((struct page *) &zero_page[0]) #endif /* _LINUX_PAGE_H */

584

C

.h

17

32.647059

61

0.67446

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,801

sysfs.h

thoughtpolice_bcachefs-tools/include/linux/sysfs.h

#ifndef _SYSFS_H_ #define _SYSFS_H_ #include <linux/compiler.h> #include <linux/stringify.h> struct kobject; struct attribute { const char *name; umode_t mode; }; #define __ATTR(_name, _mode, _show, _store) { \ .attr = {.name = __stringify(_name), .mode = _mode }, \ .show = _show, \ .store = _store, \ } struct sysfs_ops { ssize_t (*show)(struct kobject *, struct attribute *, char *); ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t); }; static inline int sysfs_create_files(struct kobject *kobj, const struct attribute **attr) { return 0; } static inline int sysfs_create_link(struct kobject *kobj, struct kobject *target, const char *name) { return 0; } static inline void sysfs_remove_link(struct kobject *kobj, const char *name) { } #endif /* _SYSFS_H_ */

841

C

.h

32

24.21875

78

0.6725

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,802

completion.h

thoughtpolice_bcachefs-tools/include/linux/completion.h

#ifndef __LINUX_COMPLETION_H #define __LINUX_COMPLETION_H /* * (C) Copyright 2001 Linus Torvalds * * Atomic wait-for-completion handler data structures. * See kernel/sched/completion.c for details. */ #include <linux/wait.h> struct completion { unsigned int done; wait_queue_head_t wait; }; #define DECLARE_COMPLETION(work) \ struct completion work = { \ .done = 0, \ .wait = __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) \ } #define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work) static inline void init_completion(struct completion *x) { x->done = 0; init_waitqueue_head(&x->wait); } static inline void reinit_completion(struct completion *x) { x->done = 0; } void complete(struct completion *); void wait_for_completion(struct completion *); #define wait_for_completion_interruptible(x) (wait_for_completion(x), 0) #endif

872

C

.h

32

25.4375

72

0.740964

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,807

time64.h

thoughtpolice_bcachefs-tools/include/linux/time64.h

#ifndef _LINUX_TIME64_H #define _LINUX_TIME64_H #include <linux/types.h> typedef __s64 time64_t; /* Parameters used to convert the timespec values: */ #define MSEC_PER_SEC 1000L #define USEC_PER_MSEC 1000L #define NSEC_PER_USEC 1000L #define NSEC_PER_MSEC 1000000L #define USEC_PER_SEC 1000000L #define NSEC_PER_SEC 1000000000L #define FSEC_PER_SEC 1000000000000000LL static inline struct timespec ns_to_timespec(const u64 nsec) { return (struct timespec) { .tv_sec = nsec / NSEC_PER_SEC, .tv_nsec = nsec % NSEC_PER_SEC, }; } static inline s64 timespec_to_ns(const struct timespec *ts) { return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec; } static inline struct timespec timespec_trunc(struct timespec t, unsigned gran) { /* Avoid division in the common cases 1 ns and 1 s. */ if (gran == 1) { /* nothing */ } else if (gran == NSEC_PER_SEC) { t.tv_nsec = 0; } else if (gran > 1 && gran < NSEC_PER_SEC) { t.tv_nsec -= t.tv_nsec % gran; } else { WARN(1, "illegal file time granularity: %u", gran); } return t; } #endif /* _LINUX_TIME64_H */

1,073

C

.h

38

26.473684

78

0.709144

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,810

zlib.h

thoughtpolice_bcachefs-tools/include/linux/zlib.h

#ifndef _ZLIB_H #define _ZLIB_H #include <zlib.h> #define zlib_inflate_workspacesize() 0 #define zlib_deflate_workspacesize(windowBits, memLevel) 0 #define zlib_inflateInit2 inflateInit2 #define zlib_inflate inflate #define zlib_deflateInit2 deflateInit2 #define zlib_deflate deflate #define zlib_deflateEnd deflateEnd #define DEF_MEM_LEVEL 8 #endif /* _ZLIB_H */

374

C

.h

12

29.666667

58

0.808989

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,813

zstd.h

thoughtpolice_bcachefs-tools/include/linux/zstd.h

#include <zstd.h> #define ZSTD_initDCtx(w, s) ZSTD_initStaticDCtx(w, s) #define ZSTD_initCCtx(w, s) ZSTD_initStaticCCtx(w, s) #define ZSTD_compressCCtx(w, dst, d_len, src, src_len, params) \ ZSTD_compressCCtx(w, dst, d_len, src, src_len, 0) #define ZSTD_CCtxWorkspaceBound(p) ZSTD_estimateCCtxSize(0) #define ZSTD_DCtxWorkspaceBound() ZSTD_estimateDCtxSize()

363

C

.h

7

50.285714

64

0.76204

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,816

shrinker.h

thoughtpolice_bcachefs-tools/include/linux/shrinker.h

#ifndef __TOOLS_LINUX_SHRINKER_H #define __TOOLS_LINUX_SHRINKER_H #include <linux/list.h> #include <linux/types.h> struct shrink_control { gfp_t gfp_mask; unsigned long nr_to_scan; }; #define SHRINK_STOP (~0UL) struct shrinker { unsigned long (*count_objects)(struct shrinker *, struct shrink_control *sc); unsigned long (*scan_objects)(struct shrinker *, struct shrink_control *sc); int seeks; /* seeks to recreate an obj */ long batch; /* reclaim batch size, 0 = default */ struct list_head list; }; int register_shrinker(struct shrinker *); void unregister_shrinker(struct shrinker *); void run_shrinkers(void); #endif /* __TOOLS_LINUX_SHRINKER_H */

689

C

.h

22

28.681818

50

0.723824

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,818

jiffies.h

thoughtpolice_bcachefs-tools/include/linux/jiffies.h

#ifndef _LINUX_JIFFIES_H #define _LINUX_JIFFIES_H #include <linux/kernel.h> #include <linux/time64.h> #include <linux/typecheck.h> #include <linux/types.h> #define time_after(a,b) \ (typecheck(unsigned long, a) && \ typecheck(unsigned long, b) && \ ((long)((b) - (a)) < 0)) #define time_before(a,b) time_after(b,a) #define time_after_eq(a,b) \ (typecheck(unsigned long, a) && \ typecheck(unsigned long, b) && \ ((long)((a) - (b)) >= 0)) #define time_before_eq(a,b) time_after_eq(b,a) #define time_in_range(a,b,c) \ (time_after_eq(a,b) && \ time_before_eq(a,c)) #define time_in_range_open(a,b,c) \ (time_after_eq(a,b) && \ time_before(a,c)) #define time_after64(a,b) \ (typecheck(__u64, a) && \ typecheck(__u64, b) && \ ((__s64)((b) - (a)) < 0)) #define time_before64(a,b) time_after64(b,a) #define time_after_eq64(a,b) \ (typecheck(__u64, a) && \ typecheck(__u64, b) && \ ((__s64)((a) - (b)) >= 0)) #define time_before_eq64(a,b) time_after_eq64(b,a) #define time_in_range64(a, b, c) \ (time_after_eq64(a, b) && \ time_before_eq64(a, c)) #define HZ 1000 static inline u64 jiffies_to_nsecs(const unsigned long j) { return (u64)j * NSEC_PER_MSEC; } static inline unsigned jiffies_to_msecs(const unsigned long j) { return j; } static inline unsigned long msecs_to_jiffies(const unsigned int m) { return m; } static inline unsigned long nsecs_to_jiffies(u64 n) { return n / NSEC_PER_MSEC; } static inline u64 sched_clock(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return ((s64) ts.tv_sec * NSEC_PER_SEC) + ts.tv_nsec; } static inline u64 local_clock(void) { return sched_clock(); } #define jiffies nsecs_to_jiffies(sched_clock()) #endif

1,714

C

.h

64

24.90625

66

0.670754

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,822

module.h

thoughtpolice_bcachefs-tools/include/linux/module.h

#ifndef _LINUX_MODULE_H #define _LINUX_MODULE_H #include <linux/stat.h> #include <linux/compiler.h> #include <linux/moduleparam.h> #include <linux/export.h> struct module; #define module_init(initfn) \ __attribute__((constructor(120))) \ static void __call_##initfn(void) { BUG_ON(initfn()); } #if 0 #define module_exit(exitfn) \ __attribute__((destructor(109))) \ static void __call_##exitfn(void) { exitfn(); } #endif #define module_exit(exitfn) \ __attribute__((unused)) \ static void __call_##exitfn(void) { exitfn(); } #define MODULE_INFO(tag, info) #define MODULE_ALIAS(_alias) #define MODULE_SOFTDEP(_softdep) #define MODULE_LICENSE(_license) #define MODULE_AUTHOR(_author) #define MODULE_DESCRIPTION(_description) #define MODULE_VERSION(_version) static inline void __module_get(struct module *module) { } static inline int try_module_get(struct module *module) { return 1; } static inline void module_put(struct module *module) { } #endif /* _LINUX_MODULE_H */

1,007

C

.h

36

26.5

56

0.722164

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,827

bitmap.h

thoughtpolice_bcachefs-tools/include/linux/bitmap.h

#ifndef _PERF_BITOPS_H #define _PERF_BITOPS_H #include <string.h> #include <linux/bitops.h> #include <stdlib.h> #define DECLARE_BITMAP(name,bits) \ unsigned long name[BITS_TO_LONGS(bits)] void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, int bits); #define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1))) #define BITMAP_LAST_WORD_MASK(nbits) \ ( \ ((nbits) % BITS_PER_LONG) ? \ (1UL<<((nbits) % BITS_PER_LONG))-1 : ~0UL \ ) #define small_const_nbits(nbits) \ (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG) static inline int __bitmap_weight(const unsigned long *bitmap, int bits) { int k, w = 0, lim = bits/BITS_PER_LONG; for (k = 0; k < lim; k++) w += hweight_long(bitmap[k]); if (bits % BITS_PER_LONG) w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits)); return w; } static inline int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int bits) { unsigned int k; unsigned int lim = bits/BITS_PER_LONG; unsigned long result = 0; for (k = 0; k < lim; k++) result |= (dst[k] = bitmap1[k] & bitmap2[k]); if (bits % BITS_PER_LONG) result |= (dst[k] = bitmap1[k] & bitmap2[k] & BITMAP_LAST_WORD_MASK(bits)); return result != 0; } static inline void bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits) { unsigned int k, lim = bits/BITS_PER_LONG; for (k = 0; k < lim; ++k) dst[k] = ~src[k]; if (bits % BITS_PER_LONG) dst[k] = ~src[k]; } static inline void bitmap_zero(unsigned long *dst, int nbits) { memset(dst, 0, BITS_TO_LONGS(nbits) * sizeof(unsigned long)); } static inline int bitmap_weight(const unsigned long *src, int nbits) { if (small_const_nbits(nbits)) return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits)); return __bitmap_weight(src, nbits); } static inline void bitmap_or(unsigned long *dst, const unsigned long *src1, const unsigned long *src2, int nbits) { if (small_const_nbits(nbits)) *dst = *src1 | *src2; else __bitmap_or(dst, src1, src2, nbits); } static inline unsigned long *bitmap_alloc(int nbits) { return calloc(1, BITS_TO_LONGS(nbits) * sizeof(unsigned long)); } static inline int bitmap_and(unsigned long *dst, const unsigned long *src1, const unsigned long *src2, unsigned int nbits) { if (small_const_nbits(nbits)) return (*dst = *src1 & *src2 & BITMAP_LAST_WORD_MASK(nbits)) != 0; return __bitmap_and(dst, src1, src2, nbits); } static inline unsigned long _find_next_bit(const unsigned long *addr, unsigned long nbits, unsigned long start, unsigned long invert) { unsigned long tmp; if (!nbits || start >= nbits) return nbits; tmp = addr[start / BITS_PER_LONG] ^ invert; /* Handle 1st word. */ tmp &= BITMAP_FIRST_WORD_MASK(start); start = round_down(start, BITS_PER_LONG); while (!tmp) { start += BITS_PER_LONG; if (start >= nbits) return nbits; tmp = addr[start / BITS_PER_LONG] ^ invert; } return min(start + __ffs(tmp), nbits); } static inline unsigned long find_next_bit(const unsigned long *addr, unsigned long size, unsigned long offset) { return _find_next_bit(addr, size, offset, 0UL); } static inline unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size, unsigned long offset) { return _find_next_bit(addr, size, offset, ~0UL); } #define find_first_bit(addr, size) find_next_bit((addr), (size), 0) #define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0) #endif /* _PERF_BITOPS_H */

3,608

C

.h

108

31.018519

93

0.690778

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,828

seq_file.h

thoughtpolice_bcachefs-tools/include/linux/seq_file.h

#ifndef _LINUX_SEQ_FILE_H #define _LINUX_SEQ_FILE_H #include <linux/types.h> #include <linux/fs.h> struct seq_operations; struct path; struct seq_file { char *buf; size_t size; size_t from; size_t count; size_t pad_until; loff_t index; loff_t read_pos; u64 version; const struct seq_operations *op; int poll_event; const struct file *file; void *private; }; #endif

381

C

.h

21

16.380952

33

0.747191

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,830

byteorder.h

thoughtpolice_bcachefs-tools/include/linux/byteorder.h

#ifndef __LINUX_BYTEORDER_H #define __LINUX_BYTEORDER_H #include <linux/compiler.h> #include <asm/byteorder.h> #define swab16 __swab16 #define swab32 __swab32 #define swab64 __swab64 #define swahw32 __swahw32 #define swahb32 __swahb32 #define swab16p __swab16p #define swab32p __swab32p #define swab64p __swab64p #define swahw32p __swahw32p #define swahb32p __swahb32p #define swab16s __swab16s #define swab32s __swab32s #define swab64s __swab64s #define swahw32s __swahw32s #define swahb32s __swahb32s #define cpu_to_le64 __cpu_to_le64 #define le64_to_cpu __le64_to_cpu #define cpu_to_le32 __cpu_to_le32 #define le32_to_cpu __le32_to_cpu #define cpu_to_le16 __cpu_to_le16 #define le16_to_cpu __le16_to_cpu #define cpu_to_be64 __cpu_to_be64 #define be64_to_cpu __be64_to_cpu #define cpu_to_be32 __cpu_to_be32 #define be32_to_cpu __be32_to_cpu #define cpu_to_be16 __cpu_to_be16 #define be16_to_cpu __be16_to_cpu #define cpu_to_le64p __cpu_to_le64p #define le64_to_cpup __le64_to_cpup #define cpu_to_le32p __cpu_to_le32p #define le32_to_cpup __le32_to_cpup #define cpu_to_le16p __cpu_to_le16p #define le16_to_cpup __le16_to_cpup #define cpu_to_be64p __cpu_to_be64p #define be64_to_cpup __be64_to_cpup #define cpu_to_be32p __cpu_to_be32p #define be32_to_cpup __be32_to_cpup #define cpu_to_be16p __cpu_to_be16p #define be16_to_cpup __be16_to_cpup #define cpu_to_le64s __cpu_to_le64s #define le64_to_cpus __le64_to_cpus #define cpu_to_le32s __cpu_to_le32s #define le32_to_cpus __le32_to_cpus #define cpu_to_le16s __cpu_to_le16s #define le16_to_cpus __le16_to_cpus #define cpu_to_be64s __cpu_to_be64s #define be64_to_cpus __be64_to_cpus #define cpu_to_be32s __cpu_to_be32s #define be32_to_cpus __be32_to_cpus #define cpu_to_be16s __cpu_to_be16s #define be16_to_cpus __be16_to_cpus static inline void le16_add_cpu(__le16 *var, u16 val) { *var = cpu_to_le16(le16_to_cpu(*var) + val); } static inline void le32_add_cpu(__le32 *var, u32 val) { *var = cpu_to_le32(le32_to_cpu(*var) + val); } static inline void le64_add_cpu(__le64 *var, u64 val) { *var = cpu_to_le64(le64_to_cpu(*var) + val); } #endif /* __LINUX_BYTEORDER_H */

2,127

C

.h

68

30.132353

53

0.738304

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,834

freezer.h

thoughtpolice_bcachefs-tools/include/linux/freezer.h

#ifndef __TOOLS_LINUX_FREEZER_H #define __TOOLS_LINUX_FREEZER_H #define try_to_freeze() #define set_freezable() #endif /* __TOOLS_LINUX_FREEZER_H */

151

C

.h

5

28.8

36

0.736111

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,840

printk.h

thoughtpolice_bcachefs-tools/include/linux/printk.h

#ifndef __TOOLS_LINUX_PRINTK_H #define __TOOLS_LINUX_PRINTK_H #ifndef pr_fmt #define pr_fmt(fmt) fmt #endif #include <stdarg.h> #include <stdio.h> #define KERN_EMERG "" #define KERN_ALERT "" #define KERN_CRIT "" #define KERN_ERR "" #define KERN_WARNING "" #define KERN_NOTICE "" #define KERN_INFO "" #define KERN_DEBUG "" #define KERN_DEFAULT "" #define KERN_CONT "" static inline int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) { int i = vsnprintf(buf, size, fmt, args); ssize_t ssize = size; return (i >= ssize) ? (ssize - 1) : i; } static inline int scnprintf(char * buf, size_t size, const char * fmt, ...) { ssize_t ssize = size; va_list args; int i; va_start(args, fmt); i = vsnprintf(buf, size, fmt, args); va_end(args); return (i >= ssize) ? (ssize - 1) : i; } #define printk(...) printf(__VA_ARGS__) #define no_printk(fmt, ...) \ ({ \ do { \ if (0) \ printk(fmt, ##__VA_ARGS__); \ } while (0); \ 0; \ }) #define pr_emerg(fmt, ...) \ printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__) #define pr_alert(fmt, ...) \ printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__) #define pr_crit(fmt, ...) \ printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__) #define pr_err(fmt, ...) \ printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) #define pr_warning(fmt, ...) \ printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__) #define pr_warn pr_warning #define pr_notice(fmt, ...) \ printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__) #define pr_info(fmt, ...) \ printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__) /* * Like KERN_CONT, pr_cont() should only be used when continuing * a line with no newline ('\n') enclosed. Otherwise it defaults * back to KERN_DEFAULT. */ #define pr_cont(fmt, ...) \ printk(KERN_CONT fmt, ##__VA_ARGS__) /* pr_devel() should produce zero code unless DEBUG is defined */ #ifdef DEBUG #define pr_devel(fmt, ...) \ printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #else #define pr_devel(fmt, ...) \ no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #endif /* If you are writing a driver, please use dev_dbg instead */ #if defined(CONFIG_DYNAMIC_DEBUG) #include <linux/dynamic_debug.h> /* dynamic_pr_debug() uses pr_fmt() internally so we don't need it here */ #define pr_debug(fmt, ...) \ dynamic_pr_debug(fmt, ##__VA_ARGS__) #elif defined(DEBUG) #define pr_debug(fmt, ...) \ printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #else #define pr_debug(fmt, ...) \ no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #endif /* * Print a one-time message (analogous to WARN_ONCE() et al): */ #define printk_once(fmt, ...) \ ({ \ static bool __print_once __read_mostly; \ bool __ret_print_once = !__print_once; \ \ if (!__print_once) { \ __print_once = true; \ printk(fmt, ##__VA_ARGS__); \ } \ unlikely(__ret_print_once); \ }) #define printk_deferred_once(fmt, ...) \ ({ \ static bool __print_once __read_mostly; \ bool __ret_print_once = !__print_once; \ \ if (!__print_once) { \ __print_once = true; \ printk_deferred(fmt, ##__VA_ARGS__); \ } \ unlikely(__ret_print_once); \ }) #define pr_emerg_once(fmt, ...) \ printk_once(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__) #define pr_alert_once(fmt, ...) \ printk_once(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__) #define pr_crit_once(fmt, ...) \ printk_once(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__) #define pr_err_once(fmt, ...) \ printk_once(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) #define pr_warn_once(fmt, ...) \ printk_once(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__) #define pr_notice_once(fmt, ...) \ printk_once(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__) #define pr_info_once(fmt, ...) \ printk_once(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__) #define pr_cont_once(fmt, ...) \ printk_once(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__) #if defined(DEBUG) #define pr_devel_once(fmt, ...) \ printk_once(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #else #define pr_devel_once(fmt, ...) \ no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #endif /* If you are writing a driver, please use dev_dbg instead */ #if defined(DEBUG) #define pr_debug_once(fmt, ...) \ printk_once(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #else #define pr_debug_once(fmt, ...) \ no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #endif /* * ratelimited messages with local ratelimit_state, * no local ratelimit_state used in the !PRINTK case */ #ifdef CONFIG_PRINTK #define printk_ratelimited(fmt, ...) \ ({ \ static DEFINE_RATELIMIT_STATE(_rs, \ DEFAULT_RATELIMIT_INTERVAL, \ DEFAULT_RATELIMIT_BURST); \ \ if (__ratelimit(&_rs)) \ printk(fmt, ##__VA_ARGS__); \ }) #else #define printk_ratelimited(fmt, ...) \ no_printk(fmt, ##__VA_ARGS__) #endif #define pr_emerg_ratelimited(fmt, ...) \ printk_ratelimited(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__) #define pr_alert_ratelimited(fmt, ...) \ printk_ratelimited(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__) #define pr_crit_ratelimited(fmt, ...) \ printk_ratelimited(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__) #define pr_err_ratelimited(fmt, ...) \ printk_ratelimited(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) #define pr_warn_ratelimited(fmt, ...) \ printk_ratelimited(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__) #define pr_notice_ratelimited(fmt, ...) \ printk_ratelimited(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__) #define pr_info_ratelimited(fmt, ...) \ printk_ratelimited(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__) /* no pr_cont_ratelimited, don't do that... */ #if defined(DEBUG) #define pr_devel_ratelimited(fmt, ...) \ printk_ratelimited(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #else #define pr_devel_ratelimited(fmt, ...) \ no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) #endif #endif /* __TOOLS_LINUX_PRINTK_H */

5,917

C

.h

182

30.346154

83

0.616071

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,846

uuid.h

thoughtpolice_bcachefs-tools/include/linux/uuid.h

/* * UUID/GUID definition * * Copyright (C) 2010, 2016 Intel Corp. * Huang Ying <[email protected]> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version * 2 as published by the Free Software Foundation; * * This program is distributed in the hope that it will 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. */ #ifndef _LINUX_UUID_H_ #define _LINUX_UUID_H_ #include <uapi/linux/uuid.h> #include <string.h> static inline int uuid_le_cmp(const uuid_le u1, const uuid_le u2) { return memcmp(&u1, &u2, sizeof(uuid_le)); } #endif

768

C

.h

24

30.25

70

0.751687

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,855

export.h

thoughtpolice_bcachefs-tools/include/linux/export.h

#ifndef _TOOLS_LINUX_EXPORT_H_ #define _TOOLS_LINUX_EXPORT_H_ #define EXPORT_SYMBOL(sym) #define EXPORT_SYMBOL_GPL(sym) #define EXPORT_SYMBOL_GPL_FUTURE(sym) #define EXPORT_UNUSED_SYMBOL(sym) #define EXPORT_UNUSED_SYMBOL_GPL(sym) #define THIS_MODULE ((struct module *)0) #define KBUILD_MODNAME #endif

304

C

.h

10

29.1

40

0.793814

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,856

key.h

thoughtpolice_bcachefs-tools/include/linux/key.h

#ifndef _LINUX_KEY_H #define _LINUX_KEY_H #include <linux/types.h> #include <linux/atomic.h> #include <keyutils.h> struct user_key_payload { size_t datalen; /* length of this data */ char data[0]; /* actual data */ }; struct key { atomic_t usage; /* number of references */ key_serial_t serial; /* key serial number */ struct rw_semaphore sem; /* change vs change sem */ struct user_key_payload payload; }; static inline const struct user_key_payload *user_key_payload(const struct key *key) { return &key->payload; } static inline void key_put(struct key *key) { if (atomic_dec_and_test(&key->usage)) free(key); } static inline struct key *__key_get(struct key *key) { atomic_inc(&key->usage); return key; } static inline struct key *key_get(struct key *key) { return key ? __key_get(key) : key; } #endif /* _LINUX_KEY_H */

853

C

.h

34

23.470588

84

0.707768

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,858

moduleparam.h

thoughtpolice_bcachefs-tools/include/linux/moduleparam.h

#ifndef _LINUX_MODULE_PARAMS_H #define _LINUX_MODULE_PARAMS_H #define module_param_named(name, value, type, perm) #define MODULE_PARM_DESC(_parm, desc) #endif /* _LINUX_MODULE_PARAMS_H */

190

C

.h

5

36.6

51

0.754098

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,863

slab.h

thoughtpolice_bcachefs-tools/include/linux/slab.h

#ifndef __TOOLS_LINUX_SLAB_H #define __TOOLS_LINUX_SLAB_H #include <malloc.h> #include <stdlib.h> #include <string.h> #include <linux/kernel.h> #include <linux/page.h> #include <linux/shrinker.h> #include <linux/types.h> #define ARCH_KMALLOC_MINALIGN 16 #define KMALLOC_MAX_SIZE SIZE_MAX static inline void *kmalloc(size_t size, gfp_t flags) { void *p; run_shrinkers(); p = malloc(size); if (p && (flags & __GFP_ZERO)) memset(p, 0, size); return p; } static inline void *krealloc(void *old, size_t size, gfp_t flags) { void *new; run_shrinkers(); new = malloc(size); if (!new) return NULL; if (flags & __GFP_ZERO) memset(new, 0, size); memcpy(new, old, min(malloc_usable_size(old), malloc_usable_size(new))); free(old); return new; } #define kzalloc(size, flags) kmalloc(size, flags|__GFP_ZERO) #define kmalloc_array(n, size, flags) \ ((size) != 0 && (n) > SIZE_MAX / (size) \ ? NULL : kmalloc(n * size, flags)) #define kcalloc(n, size, flags) kmalloc_array(n, size, flags|__GFP_ZERO) #define kfree(p) free(p) #define kvfree(p) free(p) #define kzfree(p) free(p) static inline struct page *alloc_pages(gfp_t flags, unsigned int order) { size_t size = PAGE_SIZE << order; void *p; run_shrinkers(); p = aligned_alloc(PAGE_SIZE, size); if (p && (flags & __GFP_ZERO)) memset(p, 0, size); return p; } #define alloc_page(gfp) alloc_pages(gfp, 0) #define __get_free_pages(gfp, order) ((unsigned long) alloc_pages(gfp, order)) #define __get_free_page(gfp) __get_free_pages(gfp, 0) #define __free_pages(page, order) \ do { \ (void) order; \ free(page); \ } while (0) #define free_pages(addr, order) \ do { \ (void) order; \ free((void *) (addr)); \ } while (0) #define __free_page(page) __free_pages((page), 0) #define free_page(addr) free_pages((addr), 0) #define VM_IOREMAP 0x00000001 /* ioremap() and friends */ #define VM_ALLOC 0x00000002 /* vmalloc() */ #define VM_MAP 0x00000004 /* vmap()ed pages */ #define VM_USERMAP 0x00000008 /* suitable for remap_vmalloc_range */ #define VM_UNINITIALIZED 0x00000020 /* vm_struct is not fully initialized */ #define VM_NO_GUARD 0x00000040 /* don't add guard page */ #define VM_KASAN 0x00000080 /* has allocated kasan shadow memory */ static inline void vunmap(const void *addr) {} static inline void *vmap(struct page **pages, unsigned int count, unsigned long flags, unsigned prot) { return NULL; } #define is_vmalloc_addr(page) 0 #define vmalloc_to_page(addr) ((struct page *) (addr)) static inline void *kmemdup(const void *src, size_t len, gfp_t gfp) { void *p; p = kmalloc(len, gfp); if (p) memcpy(p, src, len); return p; } #endif /* __TOOLS_LINUX_SLAB_H */

2,759

C

.h

92

28

78

0.675019

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,865

string.h

thoughtpolice_bcachefs-tools/include/linux/string.h

#ifndef _TOOLS_LINUX_STRING_H_ #define _TOOLS_LINUX_STRING_H_ #include <stdlib.h> #include <string.h> #include <linux/types.h> /* for size_t */ extern size_t strlcpy(char *dest, const char *src, size_t size); extern char *skip_spaces(const char *); extern char *strim(char *); extern void memzero_explicit(void *, size_t); int match_string(const char * const *, size_t, const char *); #define kstrndup(s, n, gfp) strndup(s, n) #endif /* _LINUX_STRING_H_ */

462

C

.h

12

37.166667

64

0.70852

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,867

preempt.h

thoughtpolice_bcachefs-tools/include/linux/preempt.h

#ifndef __LINUX_PREEMPT_H #define __LINUX_PREEMPT_H #define preempt_disable() barrier() #define sched_preempt_enable_no_resched() barrier() #define preempt_enable_no_resched() barrier() #define preempt_enable() barrier() #define preempt_check_resched() do { } while (0) #define preempt_disable_notrace() barrier() #define preempt_enable_no_resched_notrace() barrier() #define preempt_enable_notrace() barrier() #define preemptible() 0 #endif /* __LINUX_PREEMPT_H */

481

C

.h

12

38.833333

53

0.738197

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,870

rwsem.h

thoughtpolice_bcachefs-tools/include/linux/rwsem.h

#ifndef __TOOLS_LINUX_RWSEM_H #define __TOOLS_LINUX_RWSEM_H #include <pthread.h> struct rw_semaphore { pthread_rwlock_t lock; }; #define __RWSEM_INITIALIZER(name) \ { .lock = PTHREAD_RWLOCK_INITIALIZER } #define DECLARE_RWSEM(name) \ struct rw_semaphore name = __RWSEM_INITIALIZER(name) static inline void init_rwsem(struct rw_semaphore *lock) { pthread_rwlock_init(&lock->lock, NULL); } #define down_read(l) pthread_rwlock_rdlock(&(l)->lock) #define down_read_trylock(l) (!pthread_rwlock_tryrdlock(&(l)->lock)) #define up_read(l) pthread_rwlock_unlock(&(l)->lock) #define down_write(l) pthread_rwlock_wrlock(&(l)->lock) #define up_write(l) pthread_rwlock_unlock(&(l)->lock) #endif /* __TOOLS_LINUX_RWSEM_H */

729

C

.h

20

34.85

68

0.727532

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,871

mempool.h

thoughtpolice_bcachefs-tools/include/linux/mempool.h

/* * memory buffer pool support */ #ifndef _LINUX_MEMPOOL_H #define _LINUX_MEMPOOL_H #include <linux/compiler.h> #include <linux/bug.h> #include <linux/slab.h> struct kmem_cache; typedef void * (mempool_alloc_t)(gfp_t gfp_mask, void *pool_data); typedef void (mempool_free_t)(void *element, void *pool_data); typedef struct mempool_s { size_t elem_size; void *pool_data; mempool_alloc_t *alloc; mempool_free_t *free; } mempool_t; static inline bool mempool_initialized(mempool_t *pool) { return true; } extern int mempool_resize(mempool_t *pool, int new_min_nr); static inline void mempool_free(void *element, mempool_t *pool) { free(element); } static inline void *mempool_alloc(mempool_t *pool, gfp_t gfp_mask) __malloc { BUG_ON(!pool->elem_size); return kmalloc(pool->elem_size, gfp_mask); } static inline void mempool_exit(mempool_t *pool) {} static inline void mempool_destroy(mempool_t *pool) { free(pool); } static inline int mempool_init_slab_pool(mempool_t *pool, int min_nr, struct kmem_cache *kc) { pool->elem_size = 0; return 0; } static inline mempool_t * mempool_create_slab_pool(int min_nr, struct kmem_cache *kc) { mempool_t *pool = malloc(sizeof(*pool)); pool->elem_size = 0; return pool; } static inline int mempool_init_kmalloc_pool(mempool_t *pool, int min_nr, size_t size) { pool->elem_size = size; return 0; } static inline int mempool_init_page_pool(mempool_t *pool, int min_nr, int order) { pool->elem_size = PAGE_SIZE << order; return 0; } static inline int mempool_init(mempool_t *pool, int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *pool_data) { pool->elem_size = (size_t) pool_data; pool->pool_data = pool_data; pool->alloc = alloc_fn; pool->free = free_fn; return 0; } #endif /* _LINUX_MEMPOOL_H */

1,828

C

.h

71

23.746479

85

0.72085

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,872

cpumask.h

thoughtpolice_bcachefs-tools/include/linux/cpumask.h

#ifndef __LINUX_CPUMASK_H #define __LINUX_CPUMASK_H #define num_online_cpus() 1U #define num_possible_cpus() 1U #define num_present_cpus() 1U #define num_active_cpus() 1U #define cpu_online(cpu) ((cpu) == 0) #define cpu_possible(cpu) ((cpu) == 0) #define cpu_present(cpu) ((cpu) == 0) #define cpu_active(cpu) ((cpu) == 0) #define for_each_cpu(cpu, mask) \ for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask) #define for_each_cpu_not(cpu, mask) \ for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask) #define for_each_cpu_and(cpu, mask, and) \ for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask, (void)and) #define for_each_possible_cpu(cpu) for_each_cpu((cpu), 1) #define for_each_online_cpu(cpu) for_each_cpu((cpu), 1) #define for_each_present_cpu(cpu) for_each_cpu((cpu), 1) #endif /* __LINUX_CPUMASK_H */

809

C

.h

20

39.1

59

0.643312

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,873

random.h

thoughtpolice_bcachefs-tools/include/linux/random.h

/* * include/linux/random.h * * Include file for the random number generator. */ #ifndef _LINUX_RANDOM_H #define _LINUX_RANDOM_H #include <unistd.h> #include <sys/syscall.h> #include <linux/bug.h> #ifdef __NR_getrandom static inline int getrandom(void *buf, size_t buflen, unsigned int flags) { return syscall(SYS_getrandom, buf, buflen, flags); } #else extern int urandom_fd; static inline int getrandom(void *buf, size_t buflen, unsigned int flags) { return read(urandom_fd, buf, buflen); } #endif static inline void get_random_bytes(void *buf, int nbytes) { BUG_ON(getrandom(buf, nbytes, 0) != nbytes); } static inline void prandom_bytes(void *buf, int nbytes) { return get_random_bytes(buf, nbytes); } #define get_random_type(type) \ static inline type get_random_##type(void) \ { \ type v; \ \ get_random_bytes(&v, sizeof(v)); \ return v; \ } get_random_type(int); get_random_type(long); get_random_type(u64); #endif /* _LINUX_RANDOM_H */

991

C

.h

42

21.952381

73

0.714134

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,876

bitops.h

thoughtpolice_bcachefs-tools/include/linux/bitops.h

#ifndef _TOOLS_LINUX_BITOPS_H_ #define _TOOLS_LINUX_BITOPS_H_ #include <asm/types.h> #include <linux/kernel.h> #include <linux/compiler.h> #include <linux/page.h> #ifndef __WORDSIZE #define __WORDSIZE (__SIZEOF_LONG__ * 8) #endif #ifndef BITS_PER_LONG # define BITS_PER_LONG __WORDSIZE #endif #define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG)) #define BIT_WORD(nr) ((nr) / BITS_PER_LONG) #define BITS_PER_BYTE 8 #define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) #define BITS_TO_U64(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u64)) #define BITS_TO_U32(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u32)) #define BITS_TO_BYTES(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE) static inline void __set_bit(int nr, volatile unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); *p |= mask; } static inline void set_bit(long nr, volatile unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); __atomic_or_fetch(p, mask, __ATOMIC_RELAXED); } static inline void __clear_bit(int nr, volatile unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); *p &= ~mask; } static inline void clear_bit(long nr, volatile unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); __atomic_and_fetch(p, ~mask, __ATOMIC_RELAXED); } static inline int test_bit(long nr, const volatile unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *) addr) + BIT_WORD(nr); return (*p & mask) != 0; } static inline int __test_and_set_bit(int nr, unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); unsigned long old; old = *p; *p = old | mask; return (old & mask) != 0; } static inline bool test_and_set_bit(long nr, volatile unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *) addr) + BIT_WORD(nr); unsigned long old; old = __atomic_fetch_or(p, mask, __ATOMIC_RELAXED); return (old & mask) != 0; } static inline void clear_bit_unlock(long nr, volatile unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); __atomic_and_fetch(p, ~mask, __ATOMIC_RELEASE); } static inline bool test_and_set_bit_lock(long nr, volatile unsigned long *addr) { unsigned long mask = BIT_MASK(nr); unsigned long *p = ((unsigned long *) addr) + BIT_WORD(nr); unsigned long old; old = __atomic_fetch_or(p, mask, __ATOMIC_ACQUIRE); return (old & mask) != 0; } #define for_each_set_bit(bit, addr, size) \ for ((bit) = find_first_bit((addr), (size)); \ (bit) < (size); \ (bit) = find_next_bit((addr), (size), (bit) + 1)) /* same as for_each_set_bit() but use bit as value to start with */ #define for_each_set_bit_from(bit, addr, size) \ for ((bit) = find_next_bit((addr), (size), (bit)); \ (bit) < (size); \ (bit) = find_next_bit((addr), (size), (bit) + 1)) static inline unsigned long hweight_long(unsigned long w) { return __builtin_popcountl(w); } static inline unsigned long hweight8(unsigned long w) { return __builtin_popcountl(w); } /** * rol64 - rotate a 64-bit value left * @word: value to rotate * @shift: bits to roll */ static inline __u64 rol64(__u64 word, unsigned int shift) { return (word << shift) | (word >> (64 - shift)); } /** * ror64 - rotate a 64-bit value right * @word: value to rotate * @shift: bits to roll */ static inline __u64 ror64(__u64 word, unsigned int shift) { return (word >> shift) | (word << (64 - shift)); } /** * rol32 - rotate a 32-bit value left * @word: value to rotate * @shift: bits to roll */ static inline __u32 rol32(__u32 word, unsigned int shift) { return (word << shift) | (word >> ((-shift) & 31)); } /** * ror32 - rotate a 32-bit value right * @word: value to rotate * @shift: bits to roll */ static inline __u32 ror32(__u32 word, unsigned int shift) { return (word >> shift) | (word << (32 - shift)); } /** * rol16 - rotate a 16-bit value left * @word: value to rotate * @shift: bits to roll */ static inline __u16 rol16(__u16 word, unsigned int shift) { return (word << shift) | (word >> (16 - shift)); } /** * ror16 - rotate a 16-bit value right * @word: value to rotate * @shift: bits to roll */ static inline __u16 ror16(__u16 word, unsigned int shift) { return (word >> shift) | (word << (16 - shift)); } /** * rol8 - rotate an 8-bit value left * @word: value to rotate * @shift: bits to roll */ static inline __u8 rol8(__u8 word, unsigned int shift) { return (word << shift) | (word >> (8 - shift)); } /** * ror8 - rotate an 8-bit value right * @word: value to rotate * @shift: bits to roll */ static inline __u8 ror8(__u8 word, unsigned int shift) { return (word >> shift) | (word << (8 - shift)); } static inline unsigned long __fls(unsigned long word) { return (sizeof(word) * 8) - 1 - __builtin_clzl(word); } static inline int fls(int x) { return x ? sizeof(x) * 8 - __builtin_clz(x) : 0; } static inline int fls64(__u64 x) { #if BITS_PER_LONG == 32 __u32 h = x >> 32; if (h) return fls(h) + 32; return fls(x); #elif BITS_PER_LONG == 64 if (x == 0) return 0; return __fls(x) + 1; #endif } static inline unsigned fls_long(unsigned long l) { if (sizeof(l) == 4) return fls(l); return fls64(l); } static inline unsigned long __ffs(unsigned long word) { return __builtin_ctzl(word); } static inline unsigned long __ffs64(u64 word) { #if BITS_PER_LONG == 32 if (((u32)word) == 0UL) return __ffs((u32)(word >> 32)) + 32; #elif BITS_PER_LONG != 64 #error BITS_PER_LONG not 32 or 64 #endif return __ffs((unsigned long)word); } #define ffz(x) __ffs(~(x)) static inline __attribute__((const)) unsigned long rounddown_pow_of_two(unsigned long n) { return 1UL << (fls_long(n) - 1); } #endif

6,033

C

.h

217

26.023041

79

0.666031

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,877

wait.h

thoughtpolice_bcachefs-tools/include/linux/wait.h

#ifndef _LINUX_WAIT_H #define _LINUX_WAIT_H #include <pthread.h> #include <linux/bitmap.h> #include <linux/list.h> #include <linux/spinlock.h> typedef struct __wait_queue wait_queue_t; typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key); #define WQ_FLAG_EXCLUSIVE 0x01 struct __wait_queue { unsigned int flags; void *private; wait_queue_func_t func; struct list_head task_list; }; typedef struct { spinlock_t lock; struct list_head task_list; } wait_queue_head_t; void wake_up(wait_queue_head_t *); void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state); void finish_wait(wait_queue_head_t *q, wait_queue_t *wait); int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key); int default_wake_function(wait_queue_t *wait, unsigned mode, int flags, void *key); #define DECLARE_WAITQUEUE(name, tsk) \ wait_queue_t name = { \ .private = tsk, \ .func = default_wake_function, \ .task_list = { NULL, NULL } \ } #define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \ .lock = __SPIN_LOCK_UNLOCKED(name.lock), \ .task_list = { &(name).task_list, &(name).task_list } } #define DECLARE_WAIT_QUEUE_HEAD(name) \ wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name) static inline void init_waitqueue_head(wait_queue_head_t *q) { spin_lock_init(&q->lock); INIT_LIST_HEAD(&q->task_list); } #define DEFINE_WAIT(name) \ wait_queue_t name = { \ .private = current, \ .func = autoremove_wake_function, \ .task_list = LIST_HEAD_INIT((name).task_list), \ } #define ___wait_cond_timeout(condition) \ ({ \ bool __cond = (condition); \ if (__cond && !__ret) \ __ret = 1; \ __cond || !__ret; \ }) #define ___wait_event(wq, condition, state, exclusive, ret, cmd) \ ({ \ DEFINE_WAIT(__wait); \ long __ret = ret; \ \ for (;;) { \ prepare_to_wait(&wq, &__wait, state); \ if (condition) \ break; \ cmd; \ } \ finish_wait(&wq, &__wait); \ __ret; \ }) #define __wait_event(wq, condition) \ (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0, \ schedule()) #define wait_event(wq, condition) \ do { \ if (condition) \ break; \ __wait_event(wq, condition); \ } while (0) #define wait_event_killable(wq, condition) ({wait_event(wq, condition); 0; }) #define __wait_event_timeout(wq, condition, timeout) \ ___wait_event(wq, ___wait_cond_timeout(condition), \ TASK_UNINTERRUPTIBLE, 0, timeout, \ __ret = schedule_timeout(__ret)) #define wait_event_timeout(wq, condition, timeout) \ ({ \ long __ret = timeout; \ if (!___wait_cond_timeout(condition)) \ __ret = __wait_event_timeout(wq, condition, timeout); \ __ret; \ }) void wake_up_bit(void *, int); void __wait_on_bit(void *, int, unsigned); void __wait_on_bit_lock(void *, int, unsigned); static inline int wait_on_bit(unsigned long *word, int bit, unsigned mode) { if (!test_bit(bit, word)) return 0; __wait_on_bit(word, bit, mode); return 0; } static inline int wait_on_bit_lock(unsigned long *word, int bit, unsigned mode) { if (!test_and_set_bit(bit, word)) return 0; __wait_on_bit_lock(word, bit, mode); return 0; } #define wait_on_bit_io(w, b, m) wait_on_bit(w, b, m) #define wait_on_bit_lock_io(w, b, m) wait_on_bit_lock(w, b, m) #endif /* _LINUX_WAIT_H */

3,492

C

.h

110

29.627273

90

0.630843

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,880

closure.h

thoughtpolice_bcachefs-tools/include/linux/closure.h

#ifndef _LINUX_CLOSURE_H #define _LINUX_CLOSURE_H #include <linux/llist.h> #include <linux/sched.h> #include <linux/workqueue.h> /* * Closure is perhaps the most overused and abused term in computer science, but * since I've been unable to come up with anything better you're stuck with it * again. * * What are closures? * * They embed a refcount. The basic idea is they count "things that are in * progress" - in flight bios, some other thread that's doing something else - * anything you might want to wait on. * * The refcount may be manipulated with closure_get() and closure_put(). * closure_put() is where many of the interesting things happen, when it causes * the refcount to go to 0. * * Closures can be used to wait on things both synchronously and asynchronously, * and synchronous and asynchronous use can be mixed without restriction. To * wait synchronously, use closure_sync() - you will sleep until your closure's * refcount hits 1. * * To wait asynchronously, use * continue_at(cl, next_function, workqueue); * * passing it, as you might expect, the function to run when nothing is pending * and the workqueue to run that function out of. * * continue_at() also, critically, requires a 'return' immediately following the * location where this macro is referenced, to return to the calling function. * There's good reason for this. * * To use safely closures asynchronously, they must always have a refcount while * they are running owned by the thread that is running them. Otherwise, suppose * you submit some bios and wish to have a function run when they all complete: * * foo_endio(struct bio *bio) * { * closure_put(cl); * } * * closure_init(cl); * * do_stuff(); * closure_get(cl); * bio1->bi_endio = foo_endio; * bio_submit(bio1); * * do_more_stuff(); * closure_get(cl); * bio2->bi_endio = foo_endio; * bio_submit(bio2); * * continue_at(cl, complete_some_read, system_wq); * * If closure's refcount started at 0, complete_some_read() could run before the * second bio was submitted - which is almost always not what you want! More * importantly, it wouldn't be possible to say whether the original thread or * complete_some_read()'s thread owned the closure - and whatever state it was * associated with! * * So, closure_init() initializes a closure's refcount to 1 - and when a * closure_fn is run, the refcount will be reset to 1 first. * * Then, the rule is - if you got the refcount with closure_get(), release it * with closure_put() (i.e, in a bio->bi_endio function). If you have a refcount * on a closure because you called closure_init() or you were run out of a * closure - _always_ use continue_at(). Doing so consistently will help * eliminate an entire class of particularly pernicious races. * * Lastly, you might have a wait list dedicated to a specific event, and have no * need for specifying the condition - you just want to wait until someone runs * closure_wake_up() on the appropriate wait list. In that case, just use * closure_wait(). It will return either true or false, depending on whether the * closure was already on a wait list or not - a closure can only be on one wait * list at a time. * * Parents: * * closure_init() takes two arguments - it takes the closure to initialize, and * a (possibly null) parent. * * If parent is non null, the new closure will have a refcount for its lifetime; * a closure is considered to be "finished" when its refcount hits 0 and the * function to run is null. Hence * * continue_at(cl, NULL, NULL); * * returns up the (spaghetti) stack of closures, precisely like normal return * returns up the C stack. continue_at() with non null fn is better thought of * as doing a tail call. * * All this implies that a closure should typically be embedded in a particular * struct (which its refcount will normally control the lifetime of), and that * struct can very much be thought of as a stack frame. */ struct closure; struct closure_syncer; typedef void (closure_fn) (struct closure *); struct closure_waitlist { struct llist_head list; }; enum closure_state { /* * CLOSURE_WAITING: Set iff the closure is on a waitlist. Must be set by * the thread that owns the closure, and cleared by the thread that's * waking up the closure. * * The rest are for debugging and don't affect behaviour: * * CLOSURE_RUNNING: Set when a closure is running (i.e. by * closure_init() and when closure_put() runs then next function), and * must be cleared before remaining hits 0. Primarily to help guard * against incorrect usage and accidentally transferring references. * continue_at() and closure_return() clear it for you, if you're doing * something unusual you can use closure_set_dead() which also helps * annotate where references are being transferred. */ CLOSURE_BITS_START = (1U << 27), CLOSURE_DESTRUCTOR = (1U << 27), CLOSURE_WAITING = (1U << 29), CLOSURE_RUNNING = (1U << 31), }; #define CLOSURE_GUARD_MASK \ ((CLOSURE_DESTRUCTOR|CLOSURE_WAITING|CLOSURE_RUNNING) << 1) #define CLOSURE_REMAINING_MASK (CLOSURE_BITS_START - 1) #define CLOSURE_REMAINING_INITIALIZER (1|CLOSURE_RUNNING) struct closure { union { struct { struct workqueue_struct *wq; struct closure_syncer *s; struct llist_node list; closure_fn *fn; }; struct work_struct work; }; struct closure *parent; atomic_t remaining; #ifdef CONFIG_DEBUG_CLOSURES #define CLOSURE_MAGIC_DEAD 0xc054dead #define CLOSURE_MAGIC_ALIVE 0xc054a11e unsigned magic; struct list_head all; unsigned long ip; unsigned long waiting_on; #endif }; void closure_sub(struct closure *cl, int v); void closure_put(struct closure *cl); void __closure_wake_up(struct closure_waitlist *list); bool closure_wait(struct closure_waitlist *list, struct closure *cl); void __closure_sync(struct closure *cl); /** * closure_sync - sleep until a closure a closure has nothing left to wait on * * Sleeps until the refcount hits 1 - the thread that's running the closure owns * the last refcount. */ static inline void closure_sync(struct closure *cl) { if ((atomic_read(&cl->remaining) & CLOSURE_REMAINING_MASK) != 1) __closure_sync(cl); } #ifdef CONFIG_DEBUG_CLOSURES void closure_debug_create(struct closure *cl); void closure_debug_destroy(struct closure *cl); #else static inline void closure_debug_create(struct closure *cl) {} static inline void closure_debug_destroy(struct closure *cl) {} #endif static inline void closure_set_ip(struct closure *cl) { #ifdef CONFIG_DEBUG_CLOSURES cl->ip = _THIS_IP_; #endif } static inline void closure_set_ret_ip(struct closure *cl) { #ifdef CONFIG_DEBUG_CLOSURES cl->ip = _RET_IP_; #endif } static inline void closure_set_waiting(struct closure *cl, unsigned long f) { #ifdef CONFIG_DEBUG_CLOSURES cl->waiting_on = f; #endif } static inline void closure_set_stopped(struct closure *cl) { atomic_sub(CLOSURE_RUNNING, &cl->remaining); } static inline void set_closure_fn(struct closure *cl, closure_fn *fn, struct workqueue_struct *wq) { closure_set_ip(cl); cl->fn = fn; cl->wq = wq; /* between atomic_dec() in closure_put() */ smp_mb__before_atomic(); } static inline void closure_queue(struct closure *cl) { struct workqueue_struct *wq = cl->wq; if (wq) { INIT_WORK(&cl->work, cl->work.func); queue_work(wq, &cl->work); } else cl->fn(cl); } /** * closure_get - increment a closure's refcount */ static inline void closure_get(struct closure *cl) { #ifdef CONFIG_DEBUG_CLOSURES BUG_ON((atomic_inc_return(&cl->remaining) & CLOSURE_REMAINING_MASK) <= 1); #else atomic_inc(&cl->remaining); #endif } /** * closure_init - Initialize a closure, setting the refcount to 1 * @cl: closure to initialize * @parent: parent of the new closure. cl will take a refcount on it for its * lifetime; may be NULL. */ static inline void closure_init(struct closure *cl, struct closure *parent) { cl->fn = NULL; cl->parent = parent; if (parent) closure_get(parent); atomic_set(&cl->remaining, CLOSURE_REMAINING_INITIALIZER); closure_debug_create(cl); closure_set_ip(cl); } static inline void closure_init_stack(struct closure *cl) { memset(cl, 0, sizeof(struct closure)); atomic_set(&cl->remaining, CLOSURE_REMAINING_INITIALIZER); } /** * closure_wake_up - wake up all closures on a wait list. */ static inline void closure_wake_up(struct closure_waitlist *list) { smp_mb(); __closure_wake_up(list); } #define continue_at_noreturn(_cl, _fn, _wq) \ do { \ set_closure_fn(_cl, _fn, _wq); \ closure_sub(_cl, CLOSURE_RUNNING + 1); \ } while (0) /** * continue_at - jump to another function with barrier * * After @cl is no longer waiting on anything (i.e. all outstanding refs have * been dropped with closure_put()), it will resume execution at @fn running out * of @wq (or, if @wq is NULL, @fn will be called by closure_put() directly). * * NOTE: This macro expands to a return in the calling function! * * This is because after calling continue_at() you no longer have a ref on @cl, * and whatever @cl owns may be freed out from under you - a running closure fn * has a ref on its own closure which continue_at() drops. */ #define continue_at(_cl, _fn, _wq) \ do { \ continue_at_noreturn(_cl, _fn, _wq); \ return; \ } while (0) /** * closure_return - finish execution of a closure * * This is used to indicate that @cl is finished: when all outstanding refs on * @cl have been dropped @cl's ref on its parent closure (as passed to * closure_init()) will be dropped, if one was specified - thus this can be * thought of as returning to the parent closure. */ #define closure_return(_cl) continue_at((_cl), NULL, NULL) /** * continue_at_nobarrier - jump to another function without barrier * * Causes @fn to be executed out of @cl, in @wq context (or called directly if * @wq is NULL). * * NOTE: like continue_at(), this macro expands to a return in the caller! * * The ref the caller of continue_at_nobarrier() had on @cl is now owned by @fn, * thus it's not safe to touch anything protected by @cl after a * continue_at_nobarrier(). */ #define continue_at_nobarrier(_cl, _fn, _wq) \ do { \ closure_set_ip(_cl); \ if (_wq) { \ INIT_WORK(&(_cl)->work, (void *) _fn); \ queue_work((_wq), &(_cl)->work); \ } else { \ (_fn)(_cl); \ } \ return; \ } while (0) #define closure_return_with_destructor_noreturn(_cl, _destructor) \ do { \ set_closure_fn(_cl, _destructor, NULL); \ closure_sub(_cl, CLOSURE_RUNNING - CLOSURE_DESTRUCTOR + 1); \ } while (0) /** * closure_return - finish execution of a closure, with destructor * * Works like closure_return(), except @destructor will be called when all * outstanding refs on @cl have been dropped; @destructor may be used to safely * free the memory occupied by @cl, and it is called with the ref on the parent * closure still held - so @destructor could safely return an item to a * freelist protected by @cl's parent. */ #define closure_return_with_destructor(_cl, _destructor) \ do { \ closure_return_with_destructor_noreturn(_cl, _destructor); \ return; \ } while (0) /** * closure_call - execute @fn out of a new, uninitialized closure * * Typically used when running out of one closure, and we want to run @fn * asynchronously out of a new closure - @parent will then wait for @cl to * finish. */ static inline void closure_call(struct closure *cl, closure_fn fn, struct workqueue_struct *wq, struct closure *parent) { closure_init(cl, parent); continue_at_nobarrier(cl, fn, wq); } #define __closure_wait_event(waitlist, _cond) \ do { \ struct closure cl; \ \ closure_init_stack(&cl); \ \ while (1) { \ closure_wait(waitlist, &cl); \ if (_cond) \ break; \ closure_sync(&cl); \ } \ closure_wake_up(waitlist); \ closure_sync(&cl); \ } while (0) #define closure_wait_event(waitlist, _cond) \ do { \ if (!(_cond)) \ __closure_wait_event(waitlist, _cond); \ } while (0) #endif /* _LINUX_CLOSURE_H */

12,237

C

.h

364

31.620879

80

0.711496

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,882

timer.h

thoughtpolice_bcachefs-tools/include/linux/timer.h

#ifndef __TOOLS_LINUX_TIMER_H #define __TOOLS_LINUX_TIMER_H #include <string.h> #include <linux/types.h> struct timer_list { unsigned long expires; void (*function)(struct timer_list *timer); bool pending; }; static inline void timer_setup(struct timer_list *timer, void (*func)(struct timer_list *), unsigned int flags) { memset(timer, 0, sizeof(*timer)); timer->function = func; } #define timer_setup_on_stack(timer, callback, flags) \ timer_setup(timer, callback, flags) #define destroy_timer_on_stack(timer) do {} while (0) static inline int timer_pending(const struct timer_list *timer) { return timer->pending; } int del_timer(struct timer_list * timer); int del_timer_sync(struct timer_list *timer); #define del_singleshot_timer_sync(timer) del_timer_sync(timer) int mod_timer(struct timer_list *timer, unsigned long expires); static inline void add_timer(struct timer_list *timer) { BUG_ON(timer_pending(timer)); mod_timer(timer, timer->expires); } void flush_timers(void); #endif /* __TOOLS_LINUX_TIMER_H */

1,065

C

.h

34

29.117647

63

0.737978

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,884

blkdev.h

thoughtpolice_bcachefs-tools/include/linux/blkdev.h

#ifndef __TOOLS_LINUX_BLKDEV_H #define __TOOLS_LINUX_BLKDEV_H #include <linux/backing-dev.h> #include <linux/blk_types.h> #include <linux/kobject.h> #include <linux/types.h> typedef unsigned fmode_t; struct bio; struct user_namespace; #define MINORBITS 20 #define MINORMASK ((1U << MINORBITS) - 1) #define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS)) #define MINOR(dev) ((unsigned int) ((dev) & MINORMASK)) #define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) /* file is open for reading */ #define FMODE_READ ((__force fmode_t)0x1) /* file is open for writing */ #define FMODE_WRITE ((__force fmode_t)0x2) /* file is seekable */ #define FMODE_LSEEK ((__force fmode_t)0x4) /* file can be accessed using pread */ #define FMODE_PREAD ((__force fmode_t)0x8) /* file can be accessed using pwrite */ #define FMODE_PWRITE ((__force fmode_t)0x10) /* File is opened for execution with sys_execve / sys_uselib */ #define FMODE_EXEC ((__force fmode_t)0x20) /* File is opened with O_NDELAY (only set for block devices) */ #define FMODE_NDELAY ((__force fmode_t)0x40) /* File is opened with O_EXCL (only set for block devices) */ #define FMODE_EXCL ((__force fmode_t)0x80) /* File is opened using open(.., 3, ..) and is writeable only for ioctls (specialy hack for floppy.c) */ #define FMODE_WRITE_IOCTL ((__force fmode_t)0x100) /* 32bit hashes as llseek() offset (for directories) */ #define FMODE_32BITHASH ((__force fmode_t)0x200) /* 64bit hashes as llseek() offset (for directories) */ #define FMODE_64BITHASH ((__force fmode_t)0x400) struct inode { unsigned long i_ino; loff_t i_size; struct super_block *i_sb; }; struct file { struct inode *f_inode; }; static inline struct inode *file_inode(const struct file *f) { return f->f_inode; } #define BDEVNAME_SIZE 32 struct request_queue { struct backing_dev_info *backing_dev_info; }; struct gendisk { }; struct hd_struct { struct kobject kobj; }; #define part_to_dev(part) (part) struct block_device { char name[BDEVNAME_SIZE]; struct inode *bd_inode; struct request_queue queue; void *bd_holder; struct hd_struct *bd_part; struct gendisk *bd_disk; struct gendisk __bd_disk; int bd_fd; int bd_sync_fd; struct backing_dev_info *bd_bdi; struct backing_dev_info __bd_bdi; }; void generic_make_request(struct bio *); int submit_bio_wait(struct bio *); static inline void submit_bio(struct bio *bio) { generic_make_request(bio); } int blkdev_issue_discard(struct block_device *, sector_t, sector_t, gfp_t, unsigned long); #define bdev_get_queue(bdev) (&((bdev)->queue)) #define blk_queue_discard(q) ((void) (q), 0) #define blk_queue_nonrot(q) ((void) (q), 0) unsigned bdev_logical_block_size(struct block_device *bdev); sector_t get_capacity(struct gendisk *disk); void blkdev_put(struct block_device *bdev, fmode_t mode); void bdput(struct block_device *bdev); struct block_device *blkdev_get_by_path(const char *path, fmode_t mode, void *holder); struct block_device *lookup_bdev(const char *path); struct super_block { void *s_fs_info; }; /* * File types * * NOTE! These match bits 12..15 of stat.st_mode * (ie "(i_mode >> 12) & 15"). */ #ifndef DT_UNKNOWN #define DT_UNKNOWN 0 #define DT_FIFO 1 #define DT_CHR 2 #define DT_DIR 4 #define DT_BLK 6 #define DT_REG 8 #define DT_LNK 10 #define DT_SOCK 12 #define DT_WHT 14 #endif /* * This is the "filldir" function type, used by readdir() to let * the kernel specify what kind of dirent layout it wants to have. * This allows the kernel to read directories into kernel space or * to have different dirent layouts depending on the binary type. */ struct dir_context; typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64, unsigned); struct dir_context { const filldir_t actor; u64 pos; }; /* /sys/fs */ extern struct kobject *fs_kobj; struct file_operations { }; static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops) { return 1; } static inline void unregister_chrdev(unsigned int major, const char *name) { } static inline const char *bdevname(struct block_device *bdev, char *buf) { snprintf(buf, BDEVNAME_SIZE, "%s", bdev->name); return buf; } static inline bool op_is_write(unsigned int op) { return op == REQ_OP_READ ? false : true; } /* * return data direction, READ or WRITE */ static inline int bio_data_dir(struct bio *bio) { return op_is_write(bio_op(bio)) ? WRITE : READ; } static inline bool dir_emit(struct dir_context *ctx, const char *name, int namelen, u64 ino, unsigned type) { return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0; } static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx) { return true; } #define capable(cap) true int blk_status_to_errno(blk_status_t status); blk_status_t errno_to_blk_status(int errno); #endif /* __TOOLS_LINUX_BLKDEV_H */

4,939

C

.h

164

28.432927

86

0.719535

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,885

cputime.h

thoughtpolice_bcachefs-tools/include/linux/sched/cputime.h

static inline void task_cputime_adjusted(struct task_struct *p, u64 *utime, u64 *stime) { *utime = 0; *stime = 0; }

119

C

.h

5

22.2

87

0.707965

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,886

rt.h

thoughtpolice_bcachefs-tools/include/linux/sched/rt.h

#ifndef _SCHED_RT_H #define _SCHED_RT_H static inline int rt_task(struct task_struct *p) { return 0; } #endif /* _SCHED_RT_H */

131

C

.h

7

17.285714

48

0.704918

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,898

algapi.h

thoughtpolice_bcachefs-tools/include/crypto/algapi.h

#ifndef _CRYPTO_ALGAPI_H #define _CRYPTO_ALGAPI_H #include <linux/crypto.h> #include <crypto/skcipher.h> #endif /* _CRYPTO_ALGAPI_H */

137

C

.h

5

26

29

0.746154

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,901

poly1305.h

thoughtpolice_bcachefs-tools/include/crypto/poly1305.h

/* * Common values for the Poly1305 algorithm */ #ifndef _CRYPTO_POLY1305_H #define _CRYPTO_POLY1305_H #include <sodium/crypto_onetimeauth_poly1305.h> #define POLY1305_KEY_SIZE crypto_onetimeauth_poly1305_KEYBYTES #define POLY1305_DIGEST_SIZE crypto_onetimeauth_poly1305_BYTES #endif

290

C

.h

9

30.555556

62

0.826715

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,905

user-type.h

thoughtpolice_bcachefs-tools/include/keys/user-type.h

#ifndef _KEYS_USER_TYPE_H #define _KEYS_USER_TYPE_H #include <linux/key.h> #endif /* _KEYS_USER_TYPE_H */

108

C

.h

4

25.5

30

0.705882

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

false

true

14,259,909

lz4.h

thoughtpolice_bcachefs-tools/libbcachefs/lz4.h

#ifndef __BCH_LZ4_H__ #define __BCH_LZ4_H__ int bch2_lz4_decompress(const unsigned char *src, size_t *src_len, unsigned char *dest, size_t actual_dest_len); #endif

169

C

.h

5

31.8

66

0.716049

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,911

sysfs.h

thoughtpolice_bcachefs-tools/libbcachefs/sysfs.h

#ifndef _BCACHEFS_SYSFS_H_ #define _BCACHEFS_SYSFS_H_ #include <linux/sysfs.h> #ifndef NO_BCACHEFS_SYSFS struct attribute; struct sysfs_ops; extern struct attribute *bch2_fs_files[]; extern struct attribute *bch2_fs_internal_files[]; extern struct attribute *bch2_fs_opts_dir_files[]; extern struct attribute *bch2_fs_time_stats_files[]; extern struct attribute *bch2_dev_files[]; extern struct sysfs_ops bch2_fs_sysfs_ops; extern struct sysfs_ops bch2_fs_internal_sysfs_ops; extern struct sysfs_ops bch2_fs_opts_dir_sysfs_ops; extern struct sysfs_ops bch2_fs_time_stats_sysfs_ops; extern struct sysfs_ops bch2_dev_sysfs_ops; int bch2_opts_create_sysfs_files(struct kobject *); #else static struct attribute *bch2_fs_files[] = {}; static struct attribute *bch2_fs_internal_files[] = {}; static struct attribute *bch2_fs_opts_dir_files[] = {}; static struct attribute *bch2_fs_time_stats_files[] = {}; static struct attribute *bch2_dev_files[] = {}; static const struct sysfs_ops bch2_fs_sysfs_ops; static const struct sysfs_ops bch2_fs_internal_sysfs_ops; static const struct sysfs_ops bch2_fs_opts_dir_sysfs_ops; static const struct sysfs_ops bch2_fs_time_stats_sysfs_ops; static const struct sysfs_ops bch2_dev_sysfs_ops; static inline int bch2_opts_create_sysfs_files(struct kobject *kobj) { return 0; } #endif /* NO_BCACHEFS_SYSFS */ #endif /* _BCACHEFS_SYSFS_H_ */

1,383

C

.h

31

43.225806

82

0.775373

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,912

disk_groups.h

thoughtpolice_bcachefs-tools/libbcachefs/disk_groups.h

#ifndef _BCACHEFS_DISK_GROUPS_H #define _BCACHEFS_DISK_GROUPS_H extern const struct bch_sb_field_ops bch_sb_field_ops_disk_groups; static inline unsigned disk_groups_nr(struct bch_sb_field_disk_groups *groups) { return groups ? (vstruct_end(&groups->field) - (void *) &groups->entries[0]) / sizeof(struct bch_disk_group) : 0; } struct target { enum { TARGET_NULL, TARGET_DEV, TARGET_GROUP, } type; union { unsigned dev; unsigned group; }; }; #define TARGET_DEV_START 1 #define TARGET_GROUP_START (256 + TARGET_DEV_START) static inline u16 dev_to_target(unsigned dev) { return TARGET_DEV_START + dev; } static inline u16 group_to_target(unsigned group) { return TARGET_GROUP_START + group; } static inline struct target target_decode(unsigned target) { if (target >= TARGET_GROUP_START) return (struct target) { .type = TARGET_GROUP, .group = target - TARGET_GROUP_START }; if (target >= TARGET_DEV_START) return (struct target) { .type = TARGET_DEV, .group = target - TARGET_DEV_START }; return (struct target) { .type = TARGET_NULL }; } const struct bch_devs_mask *bch2_target_to_mask(struct bch_fs *, unsigned); bool bch2_dev_in_target(struct bch_fs *, unsigned, unsigned); int bch2_disk_path_find(struct bch_sb_handle *, const char *); int bch2_disk_path_find_or_create(struct bch_sb_handle *, const char *); int bch2_disk_path_print(struct bch_sb_handle *, char *, size_t, unsigned); int bch2_opt_target_parse(struct bch_fs *, const char *, u64 *); int bch2_opt_target_print(struct bch_fs *, char *, size_t, u64); int bch2_sb_disk_groups_to_cpu(struct bch_fs *); int bch2_dev_group_set(struct bch_fs *, struct bch_dev *, const char *); const char *bch2_sb_validate_disk_groups(struct bch_sb *, struct bch_sb_field *); #endif /* _BCACHEFS_DISK_GROUPS_H */

1,832

C

.h

57

29.894737

78

0.719727

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,914

journal.h

thoughtpolice_bcachefs-tools/libbcachefs/journal.h

#ifndef _BCACHEFS_JOURNAL_H #define _BCACHEFS_JOURNAL_H /* * THE JOURNAL: * * The primary purpose of the journal is to log updates (insertions) to the * b-tree, to avoid having to do synchronous updates to the b-tree on disk. * * Without the journal, the b-tree is always internally consistent on * disk - and in fact, in the earliest incarnations bcache didn't have a journal * but did handle unclean shutdowns by doing all index updates synchronously * (with coalescing). * * Updates to interior nodes still happen synchronously and without the journal * (for simplicity) - this may change eventually but updates to interior nodes * are rare enough it's not a huge priority. * * This means the journal is relatively separate from the b-tree; it consists of * just a list of keys and journal replay consists of just redoing those * insertions in same order that they appear in the journal. * * PERSISTENCE: * * For synchronous updates (where we're waiting on the index update to hit * disk), the journal entry will be written out immediately (or as soon as * possible, if the write for the previous journal entry was still in flight). * * Synchronous updates are specified by passing a closure (@flush_cl) to * bch2_btree_insert() or bch_btree_insert_node(), which then pass that parameter * down to the journalling code. That closure will will wait on the journal * write to complete (via closure_wait()). * * If the index update wasn't synchronous, the journal entry will be * written out after 10 ms have elapsed, by default (the delay_ms field * in struct journal). * * JOURNAL ENTRIES: * * A journal entry is variable size (struct jset), it's got a fixed length * header and then a variable number of struct jset_entry entries. * * Journal entries are identified by monotonically increasing 64 bit sequence * numbers - jset->seq; other places in the code refer to this sequence number. * * A jset_entry entry contains one or more bkeys (which is what gets inserted * into the b-tree). We need a container to indicate which b-tree the key is * for; also, the roots of the various b-trees are stored in jset_entry entries * (one for each b-tree) - this lets us add new b-tree types without changing * the on disk format. * * We also keep some things in the journal header that are logically part of the * superblock - all the things that are frequently updated. This is for future * bcache on raw flash support; the superblock (which will become another * journal) can't be moved or wear leveled, so it contains just enough * information to find the main journal, and the superblock only has to be * rewritten when we want to move/wear level the main journal. * * JOURNAL LAYOUT ON DISK: * * The journal is written to a ringbuffer of buckets (which is kept in the * superblock); the individual buckets are not necessarily contiguous on disk * which means that journal entries are not allowed to span buckets, but also * that we can resize the journal at runtime if desired (unimplemented). * * The journal buckets exist in the same pool as all the other buckets that are * managed by the allocator and garbage collection - garbage collection marks * the journal buckets as metadata buckets. * * OPEN/DIRTY JOURNAL ENTRIES: * * Open/dirty journal entries are journal entries that contain b-tree updates * that have not yet been written out to the b-tree on disk. We have to track * which journal entries are dirty, and we also have to avoid wrapping around * the journal and overwriting old but still dirty journal entries with new * journal entries. * * On disk, this is represented with the "last_seq" field of struct jset; * last_seq is the first sequence number that journal replay has to replay. * * To avoid overwriting dirty journal entries on disk, we keep a mapping (in * journal_device->seq) of for each journal bucket, the highest sequence number * any journal entry it contains. Then, by comparing that against last_seq we * can determine whether that journal bucket contains dirty journal entries or * not. * * To track which journal entries are dirty, we maintain a fifo of refcounts * (where each entry corresponds to a specific sequence number) - when a ref * goes to 0, that journal entry is no longer dirty. * * Journalling of index updates is done at the same time as the b-tree itself is * being modified (see btree_insert_key()); when we add the key to the journal * the pending b-tree write takes a ref on the journal entry the key was added * to. If a pending b-tree write would need to take refs on multiple dirty * journal entries, it only keeps the ref on the oldest one (since a newer * journal entry will still be replayed if an older entry was dirty). * * JOURNAL FILLING UP: * * There are two ways the journal could fill up; either we could run out of * space to write to, or we could have too many open journal entries and run out * of room in the fifo of refcounts. Since those refcounts are decremented * without any locking we can't safely resize that fifo, so we handle it the * same way. * * If the journal fills up, we start flushing dirty btree nodes until we can * allocate space for a journal write again - preferentially flushing btree * nodes that are pinning the oldest journal entries first. */ #include <linux/hash.h> #include "journal_types.h" struct bch_fs; static inline void journal_wake(struct journal *j) { wake_up(&j->wait); closure_wake_up(&j->async_wait); } static inline struct journal_buf *journal_cur_buf(struct journal *j) { return j->buf + j->reservations.idx; } static inline struct journal_buf *journal_prev_buf(struct journal *j) { return j->buf + !j->reservations.idx; } /* Sequence number of oldest dirty journal entry */ static inline u64 journal_last_seq(struct journal *j) { return j->pin.front; } static inline u64 journal_cur_seq(struct journal *j) { BUG_ON(j->pin.back - 1 != atomic64_read(&j->seq)); return j->pin.back - 1; } u64 bch2_inode_journal_seq(struct journal *, u64); static inline int journal_state_count(union journal_res_state s, int idx) { return idx == 0 ? s.buf0_count : s.buf1_count; } static inline void journal_state_inc(union journal_res_state *s) { s->buf0_count += s->idx == 0; s->buf1_count += s->idx == 1; } static inline void bch2_journal_set_has_inode(struct journal *j, struct journal_res *res, u64 inum) { struct journal_buf *buf = &j->buf[res->idx]; unsigned long bit = hash_64(inum, ilog2(sizeof(buf->has_inode) * 8)); /* avoid atomic op if possible */ if (unlikely(!test_bit(bit, buf->has_inode))) set_bit(bit, buf->has_inode); } /* * Amount of space that will be taken up by some keys in the journal (i.e. * including the jset header) */ static inline unsigned jset_u64s(unsigned u64s) { return u64s + sizeof(struct jset_entry) / sizeof(u64); } static inline struct jset_entry * bch2_journal_add_entry_noreservation(struct journal_buf *buf, size_t u64s) { struct jset *jset = buf->data; struct jset_entry *entry = vstruct_idx(jset, le32_to_cpu(jset->u64s)); memset(entry, 0, sizeof(*entry)); entry->u64s = cpu_to_le16(u64s); le32_add_cpu(&jset->u64s, jset_u64s(u64s)); return entry; } static inline void bch2_journal_add_entry(struct journal *j, struct journal_res *res, unsigned type, enum btree_id id, unsigned level, const void *data, unsigned u64s) { struct journal_buf *buf = &j->buf[res->idx]; struct jset_entry *entry = vstruct_idx(buf->data, res->offset); unsigned actual = jset_u64s(u64s); EBUG_ON(!res->ref); EBUG_ON(actual > res->u64s); res->offset += actual; res->u64s -= actual; memset(entry, 0, sizeof(*entry)); entry->u64s = cpu_to_le16(u64s); entry->type = type; entry->btree_id = id; entry->level = level; memcpy_u64s(entry->_data, data, u64s); } static inline void bch2_journal_add_keys(struct journal *j, struct journal_res *res, enum btree_id id, const struct bkey_i *k) { bch2_journal_add_entry(j, res, BCH_JSET_ENTRY_btree_keys, id, 0, k, k->k.u64s); } void bch2_journal_buf_put_slowpath(struct journal *, bool); static inline void bch2_journal_buf_put(struct journal *j, unsigned idx, bool need_write_just_set) { union journal_res_state s; s.v = atomic64_sub_return(((union journal_res_state) { .buf0_count = idx == 0, .buf1_count = idx == 1, }).v, &j->reservations.counter); EBUG_ON(s.idx != idx && !s.prev_buf_unwritten); /* * Do not initiate a journal write if the journal is in an error state * (previous journal entry write may have failed) */ if (s.idx != idx && !journal_state_count(s, idx) && s.cur_entry_offset != JOURNAL_ENTRY_ERROR_VAL) bch2_journal_buf_put_slowpath(j, need_write_just_set); } /* * This function releases the journal write structure so other threads can * then proceed to add their keys as well. */ static inline void bch2_journal_res_put(struct journal *j, struct journal_res *res) { if (!res->ref) return; lock_release(&j->res_map, 0, _RET_IP_); while (res->u64s) bch2_journal_add_entry(j, res, BCH_JSET_ENTRY_btree_keys, 0, 0, NULL, 0); bch2_journal_buf_put(j, res->idx, false); res->ref = 0; } int bch2_journal_res_get_slowpath(struct journal *, struct journal_res *, unsigned, unsigned); static inline int journal_res_get_fast(struct journal *j, struct journal_res *res, unsigned u64s_min, unsigned u64s_max) { union journal_res_state old, new; u64 v = atomic64_read(&j->reservations.counter); do { old.v = new.v = v; /* * Check if there is still room in the current journal * entry: */ if (old.cur_entry_offset + u64s_min > j->cur_entry_u64s) return 0; res->offset = old.cur_entry_offset; res->u64s = min(u64s_max, j->cur_entry_u64s - old.cur_entry_offset); journal_state_inc(&new); new.cur_entry_offset += res->u64s; } while ((v = atomic64_cmpxchg(&j->reservations.counter, old.v, new.v)) != old.v); res->ref = true; res->idx = new.idx; res->seq = le64_to_cpu(j->buf[res->idx].data->seq); return 1; } static inline int bch2_journal_res_get(struct journal *j, struct journal_res *res, unsigned u64s_min, unsigned u64s_max) { int ret; EBUG_ON(res->ref); EBUG_ON(u64s_max < u64s_min); EBUG_ON(!test_bit(JOURNAL_STARTED, &j->flags)); if (journal_res_get_fast(j, res, u64s_min, u64s_max)) goto out; ret = bch2_journal_res_get_slowpath(j, res, u64s_min, u64s_max); if (ret) return ret; out: lock_acquire_shared(&j->res_map, 0, 0, NULL, _THIS_IP_); EBUG_ON(!res->ref); return 0; } u64 bch2_journal_last_unwritten_seq(struct journal *); int bch2_journal_open_seq_async(struct journal *, u64, struct closure *); void bch2_journal_wait_on_seq(struct journal *, u64, struct closure *); void bch2_journal_flush_seq_async(struct journal *, u64, struct closure *); void bch2_journal_flush_async(struct journal *, struct closure *); void bch2_journal_meta_async(struct journal *, struct closure *); int bch2_journal_flush_seq(struct journal *, u64); int bch2_journal_flush(struct journal *); int bch2_journal_meta(struct journal *); void bch2_journal_halt(struct journal *); static inline int bch2_journal_error(struct journal *j) { return j->reservations.cur_entry_offset == JOURNAL_ENTRY_ERROR_VAL ? -EIO : 0; } struct bch_dev; static inline bool journal_flushes_device(struct bch_dev *ca) { return true; } int bch2_journal_mark(struct bch_fs *, struct list_head *); void bch2_journal_entries_free(struct list_head *); int bch2_journal_replay(struct bch_fs *, struct list_head *); static inline void bch2_journal_set_replay_done(struct journal *j) { BUG_ON(!test_bit(JOURNAL_STARTED, &j->flags)); set_bit(JOURNAL_REPLAY_DONE, &j->flags); } ssize_t bch2_journal_print_debug(struct journal *, char *); ssize_t bch2_journal_print_pins(struct journal *, char *); int bch2_set_nr_journal_buckets(struct bch_fs *, struct bch_dev *, unsigned nr); int bch2_dev_journal_alloc(struct bch_dev *); void bch2_dev_journal_stop(struct journal *, struct bch_dev *); void bch2_fs_journal_stop(struct journal *); void bch2_fs_journal_start(struct journal *); void bch2_dev_journal_exit(struct bch_dev *); int bch2_dev_journal_init(struct bch_dev *, struct bch_sb *); void bch2_fs_journal_exit(struct journal *); int bch2_fs_journal_init(struct journal *); #endif /* _BCACHEFS_JOURNAL_H */

12,514

C

.h

320

36.565625

85

0.728943

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,920

io_types.h

thoughtpolice_bcachefs-tools/libbcachefs/io_types.h

#ifndef _BCACHEFS_IO_TYPES_H #define _BCACHEFS_IO_TYPES_H #include "alloc_types.h" #include "btree_types.h" #include "buckets_types.h" #include "extents_types.h" #include "keylist_types.h" #include "opts.h" #include "super_types.h" #include <linux/llist.h> #include <linux/workqueue.h> struct bch_read_bio { struct bch_fs *c; u64 start_time; u64 submit_time; /* * Reads will often have to be split, and if the extent being read from * was checksummed or compressed we'll also have to allocate bounce * buffers and copy the data back into the original bio. * * If we didn't have to split, we have to save and restore the original * bi_end_io - @split below indicates which: */ union { struct bch_read_bio *parent; bio_end_io_t *end_io; }; /* * Saved copy of bio->bi_iter, from submission time - allows us to * resubmit on IO error, and also to copy data back to the original bio * when we're bouncing: */ struct bvec_iter bvec_iter; u16 flags; union { struct { u16 bounce:1, split:1, kmalloc:1, have_ioref:1, narrow_crcs:1, hole:1, retry:2, context:2; }; u16 _state; }; struct bch_devs_list devs_have; struct extent_pick_ptr pick; /* start pos of data we read (may not be pos of data we want) */ struct bpos pos; struct bversion version; struct promote_op *promote; struct bch_io_opts opts; struct work_struct work; struct bio bio; }; struct bch_write_bio { struct bch_fs *c; struct bch_write_bio *parent; u64 submit_time; struct bch_devs_list failed; u8 order; u8 dev; unsigned split:1, bounce:1, put_bio:1, have_ioref:1, used_mempool:1; struct bio bio; }; struct bch_write_op { struct closure cl; struct bch_fs *c; struct workqueue_struct *io_wq; u64 start_time; unsigned written; /* sectors */ u16 flags; s16 error; /* dio write path expects it to hold -ERESTARTSYS... */ unsigned csum_type:4; unsigned compression_type:4; unsigned nr_replicas:4; unsigned nr_replicas_required:4; unsigned alloc_reserve:4; u8 open_buckets_nr; struct bch_devs_list devs_have; u16 target; u16 nonce; struct bch_io_opts opts; struct bpos pos; struct bversion version; /* For BCH_WRITE_DATA_ENCODED: */ struct bch_extent_crc_unpacked crc; struct write_point_specifier write_point; struct disk_reservation res; u8 open_buckets[16]; /* * If caller wants to flush but hasn't passed us a journal_seq ptr, we * still need to stash the journal_seq somewhere: */ union { u64 *journal_seq_p; u64 journal_seq; }; int (*index_update_fn)(struct bch_write_op *); struct bch_devs_mask failed; struct keylist insert_keys; u64 inline_keys[BKEY_EXTENT_U64s_MAX * 2]; /* Must be last: */ struct bch_write_bio wbio; }; #endif /* _BCACHEFS_IO_TYPES_H */

2,849

C

.h

112

22.866071

72

0.707101

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,921

migrate.h

thoughtpolice_bcachefs-tools/libbcachefs/migrate.h

#ifndef _BCACHEFS_MIGRATE_H #define _BCACHEFS_MIGRATE_H int bch2_dev_data_drop(struct bch_fs *, unsigned, int); #endif /* _BCACHEFS_MIGRATE_H */

147

C

.h

4

35.25

55

0.744681

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,923

error.h

thoughtpolice_bcachefs-tools/libbcachefs/error.h

#ifndef _BCACHEFS_ERROR_H #define _BCACHEFS_ERROR_H #include <linux/list.h> #include <linux/printk.h> struct bch_dev; struct bch_fs; struct work_struct; /* * XXX: separate out errors that indicate on disk data is inconsistent, and flag * superblock as such */ /* Error messages: */ /* * Very fatal logic/inconsistency errors: these indicate that we've majorly * screwed up at runtime, i.e. it's not likely that it was just caused by the * data on disk being inconsistent. These BUG(): * * XXX: audit and convert to inconsistent() checks */ #define bch2_fs_bug(c, ...) \ do { \ bch_err(c, __VA_ARGS__); \ BUG(); \ } while (0) #define bch2_fs_bug_on(cond, c, ...) \ do { \ if (cond) \ bch2_fs_bug(c, __VA_ARGS__); \ } while (0) /* * Inconsistency errors: The on disk data is inconsistent. If these occur during * initial recovery, they don't indicate a bug in the running code - we walk all * the metadata before modifying anything. If they occur at runtime, they * indicate either a bug in the running code or (less likely) data is being * silently corrupted under us. * * XXX: audit all inconsistent errors and make sure they're all recoverable, in * BCH_ON_ERROR_CONTINUE mode */ bool bch2_inconsistent_error(struct bch_fs *); #define bch2_fs_inconsistent(c, ...) \ ({ \ bch_err(c, __VA_ARGS__); \ bch2_inconsistent_error(c); \ }) #define bch2_fs_inconsistent_on(cond, c, ...) \ ({ \ int _ret = !!(cond); \ \ if (_ret) \ bch2_fs_inconsistent(c, __VA_ARGS__); \ _ret; \ }) /* * Later we might want to mark only the particular device inconsistent, not the * entire filesystem: */ #define bch2_dev_inconsistent(ca, ...) \ do { \ bch_err(ca, __VA_ARGS__); \ bch2_inconsistent_error((ca)->fs); \ } while (0) #define bch2_dev_inconsistent_on(cond, ca, ...) \ ({ \ int _ret = !!(cond); \ \ if (_ret) \ bch2_dev_inconsistent(ca, __VA_ARGS__); \ _ret; \ }) /* * Fsck errors: inconsistency errors we detect at mount time, and should ideally * be able to repair: */ enum { BCH_FSCK_OK = 0, BCH_FSCK_ERRORS_NOT_FIXED = 1, BCH_FSCK_REPAIR_UNIMPLEMENTED = 2, BCH_FSCK_REPAIR_IMPOSSIBLE = 3, BCH_FSCK_UNKNOWN_VERSION = 4, }; enum fsck_err_opts { FSCK_OPT_EXIT, FSCK_OPT_YES, FSCK_OPT_NO, FSCK_OPT_ASK, }; enum fsck_err_ret { FSCK_ERR_IGNORE = 0, FSCK_ERR_FIX = 1, FSCK_ERR_EXIT = 2, }; struct fsck_err_state { struct list_head list; const char *fmt; u64 nr; char buf[512]; }; #define FSCK_CAN_FIX (1 << 0) #define FSCK_CAN_IGNORE (1 << 1) #define FSCK_NEED_FSCK (1 << 2) enum fsck_err_ret bch2_fsck_err(struct bch_fs *, unsigned, const char *, ...); void bch2_flush_fsck_errs(struct bch_fs *); #define __fsck_err(c, _flags, msg, ...) \ ({ \ int _fix = bch2_fsck_err(c, _flags, msg, ##__VA_ARGS__);\ \ if (_fix == FSCK_ERR_EXIT) { \ bch_err(c, "Unable to continue, halting"); \ ret = BCH_FSCK_ERRORS_NOT_FIXED; \ goto fsck_err; \ } \ \ _fix; \ }) /* These macros return true if error should be fixed: */ /* XXX: mark in superblock that filesystem contains errors, if we ignore: */ #define __fsck_err_on(cond, c, _flags, ...) \ ((cond) ? __fsck_err(c, _flags, ##__VA_ARGS__) : false) #define need_fsck_err_on(cond, c, ...) \ __fsck_err_on(cond, c, FSCK_CAN_IGNORE|FSCK_NEED_FSCK, ##__VA_ARGS__) #define need_fsck_err(c, ...) \ __fsck_err(c, FSCK_CAN_IGNORE|FSCK_NEED_FSCK, ##__VA_ARGS__) #define mustfix_fsck_err(c, ...) \ __fsck_err(c, FSCK_CAN_FIX, ##__VA_ARGS__) #define mustfix_fsck_err_on(cond, c, ...) \ __fsck_err_on(cond, c, FSCK_CAN_FIX, ##__VA_ARGS__) #define fsck_err(c, ...) \ __fsck_err(c, FSCK_CAN_FIX|FSCK_CAN_IGNORE, ##__VA_ARGS__) #define fsck_err_on(cond, c, ...) \ __fsck_err_on(cond, c, FSCK_CAN_FIX|FSCK_CAN_IGNORE, ##__VA_ARGS__) /* * Fatal errors: these don't indicate a bug, but we can't continue running in RW * mode - pretty much just due to metadata IO errors: */ void bch2_fatal_error(struct bch_fs *); #define bch2_fs_fatal_error(c, ...) \ do { \ bch_err(c, __VA_ARGS__); \ bch2_fatal_error(c); \ } while (0) #define bch2_fs_fatal_err_on(cond, c, ...) \ ({ \ int _ret = !!(cond); \ \ if (_ret) \ bch2_fs_fatal_error(c, __VA_ARGS__); \ _ret; \ }) /* * IO errors: either recoverable metadata IO (because we have replicas), or data * IO - we need to log it and print out a message, but we don't (necessarily) * want to shut down the fs: */ void bch2_io_error_work(struct work_struct *); /* Does the error handling without logging a message */ void bch2_io_error(struct bch_dev *); /* Logs message and handles the error: */ #define bch2_dev_io_error(ca, fmt, ...) \ do { \ printk_ratelimited(KERN_ERR bch2_fmt((ca)->fs, \ "IO error on %s for " fmt), \ (ca)->name, ##__VA_ARGS__); \ bch2_io_error(ca); \ } while (0) #define bch2_dev_io_err_on(cond, ca, ...) \ ({ \ bool _ret = (cond); \ \ if (_ret) \ bch2_dev_io_error(ca, __VA_ARGS__); \ _ret; \ }) /* kill? */ #define __bcache_io_error(c, fmt, ...) \ printk_ratelimited(KERN_ERR bch2_fmt(c, \ "IO error: " fmt), ##__VA_ARGS__) #define bcache_io_error(c, bio, fmt, ...) \ do { \ __bcache_io_error(c, fmt, ##__VA_ARGS__); \ (bio)->bi_status = BLK_STS_IOERR; \ } while (0) #endif /* _BCACHEFS_ERROR_H */

5,624

C

.h

184

28.429348

80

0.600445

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,924

move.h

thoughtpolice_bcachefs-tools/libbcachefs/move.h

#ifndef _BCACHEFS_MOVE_H #define _BCACHEFS_MOVE_H #include "btree_iter.h" #include "buckets.h" #include "io_types.h" #include "move_types.h" struct bch_read_bio; struct moving_context; enum data_cmd { DATA_SKIP, DATA_SCRUB, DATA_ADD_REPLICAS, DATA_REWRITE, DATA_PROMOTE, }; struct data_opts { u16 target; unsigned rewrite_dev; int btree_insert_flags; }; struct migrate_write { enum data_cmd data_cmd; struct data_opts data_opts; unsigned nr_ptrs_reserved; struct moving_context *ctxt; /* what we read: */ struct bch_extent_ptr ptr; u64 offset; struct bch_write_op op; }; void bch2_migrate_read_done(struct migrate_write *, struct bch_read_bio *); int bch2_migrate_write_init(struct bch_fs *, struct migrate_write *, struct write_point_specifier, struct bch_io_opts, enum data_cmd, struct data_opts, struct bkey_s_c); typedef enum data_cmd (*move_pred_fn)(struct bch_fs *, void *, enum bkey_type, struct bkey_s_c_extent, struct bch_io_opts *, struct data_opts *); int bch2_move_data(struct bch_fs *, struct bch_ratelimit *, struct write_point_specifier, struct bpos, struct bpos, move_pred_fn, void *, struct bch_move_stats *); int bch2_data_job(struct bch_fs *, struct bch_move_stats *, struct bch_ioctl_data); #endif /* _BCACHEFS_MOVE_H */

1,341

C

.h

48

24.979167

75

0.712275

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,926

keylist_types.h

thoughtpolice_bcachefs-tools/libbcachefs/keylist_types.h

#ifndef _BCACHEFS_KEYLIST_TYPES_H #define _BCACHEFS_KEYLIST_TYPES_H struct keylist { union { struct bkey_i *keys; u64 *keys_p; }; union { struct bkey_i *top; u64 *top_p; }; }; #endif /* _BCACHEFS_KEYLIST_TYPES_H */

235

C

.h

13

16

38

0.668182

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,927

compress.h

thoughtpolice_bcachefs-tools/libbcachefs/compress.h

#ifndef _BCACHEFS_COMPRESS_H #define _BCACHEFS_COMPRESS_H #include "extents_types.h" int bch2_bio_uncompress_inplace(struct bch_fs *, struct bio *, struct bch_extent_crc_unpacked *); int bch2_bio_uncompress(struct bch_fs *, struct bio *, struct bio *, struct bvec_iter, struct bch_extent_crc_unpacked); unsigned bch2_bio_compress(struct bch_fs *, struct bio *, size_t *, struct bio *, size_t *, unsigned); int bch2_check_set_has_compressed_data(struct bch_fs *, unsigned); void bch2_fs_compress_exit(struct bch_fs *); int bch2_fs_compress_init(struct bch_fs *); #endif /* _BCACHEFS_COMPRESS_H */

619

C

.h

13

44.846154

68

0.724252

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,930

quota.h

thoughtpolice_bcachefs-tools/libbcachefs/quota.h

#ifndef _BCACHEFS_QUOTA_H #define _BCACHEFS_QUOTA_H #include "inode.h" #include "quota_types.h" extern const struct bch_sb_field_ops bch_sb_field_ops_quota; const char *bch2_quota_invalid(const struct bch_fs *, struct bkey_s_c); void bch2_quota_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c); #define bch2_bkey_quota_ops (struct bkey_ops) { \ .key_invalid = bch2_quota_invalid, \ .val_to_text = bch2_quota_to_text, \ } enum quota_acct_mode { BCH_QUOTA_PREALLOC, BCH_QUOTA_WARN, BCH_QUOTA_NOCHECK, }; static inline struct bch_qid bch_qid(struct bch_inode_unpacked *u) { return (struct bch_qid) { .q[QTYP_USR] = u->bi_uid, .q[QTYP_GRP] = u->bi_gid, .q[QTYP_PRJ] = u->bi_project, }; } static inline unsigned enabled_qtypes(struct bch_fs *c) { return ((c->opts.usrquota << QTYP_USR)| (c->opts.grpquota << QTYP_GRP)| (c->opts.prjquota << QTYP_PRJ)); } #ifdef CONFIG_BCACHEFS_QUOTA int bch2_quota_acct(struct bch_fs *, struct bch_qid, enum quota_counters, s64, enum quota_acct_mode); int bch2_quota_transfer(struct bch_fs *, unsigned, struct bch_qid, struct bch_qid, u64); void bch2_fs_quota_exit(struct bch_fs *); void bch2_fs_quota_init(struct bch_fs *); int bch2_fs_quota_read(struct bch_fs *); extern const struct quotactl_ops bch2_quotactl_operations; #else static inline int bch2_quota_acct(struct bch_fs *c, struct bch_qid qid, enum quota_counters counter, s64 v, enum quota_acct_mode mode) { return 0; } static inline int bch2_quota_transfer(struct bch_fs *c, unsigned qtypes, struct bch_qid dst, struct bch_qid src, u64 space) { return 0; } static inline void bch2_fs_quota_exit(struct bch_fs *c) {} static inline void bch2_fs_quota_init(struct bch_fs *c) {} static inline int bch2_fs_quota_read(struct bch_fs *c) { return 0; } #endif #endif /* _BCACHEFS_QUOTA_H */

1,862

C

.h

57

30.280702

74

0.715165

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,932

dirent.h

thoughtpolice_bcachefs-tools/libbcachefs/dirent.h

#ifndef _BCACHEFS_DIRENT_H #define _BCACHEFS_DIRENT_H #include "str_hash.h" extern const struct bch_hash_desc bch2_dirent_hash_desc; const char *bch2_dirent_invalid(const struct bch_fs *, struct bkey_s_c); void bch2_dirent_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c); #define bch2_bkey_dirent_ops (struct bkey_ops) { \ .key_invalid = bch2_dirent_invalid, \ .val_to_text = bch2_dirent_to_text, \ } struct qstr; struct file; struct dir_context; struct bch_fs; struct bch_hash_info; struct bch_inode_info; unsigned bch2_dirent_name_bytes(struct bkey_s_c_dirent); int __bch2_dirent_create(struct btree_trans *, u64, const struct bch_hash_info *, u8, const struct qstr *, u64, int); int bch2_dirent_create(struct bch_fs *c, u64, const struct bch_hash_info *, u8, const struct qstr *, u64, u64 *, int); int __bch2_dirent_delete(struct btree_trans *, u64, const struct bch_hash_info *, const struct qstr *); int bch2_dirent_delete(struct bch_fs *, u64, const struct bch_hash_info *, const struct qstr *, u64 *); enum bch_rename_mode { BCH_RENAME, BCH_RENAME_OVERWRITE, BCH_RENAME_EXCHANGE, }; int bch2_dirent_rename(struct btree_trans *, struct bch_inode_info *, const struct qstr *, struct bch_inode_info *, const struct qstr *, enum bch_rename_mode); u64 bch2_dirent_lookup(struct bch_fs *, u64, const struct bch_hash_info *, const struct qstr *); int bch2_empty_dir(struct bch_fs *, u64); int bch2_readdir(struct bch_fs *, struct file *, struct dir_context *); #endif /* _BCACHEFS_DIRENT_H */

1,593

C

.h

41

35.707317

75

0.705653

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,939

tests.h

thoughtpolice_bcachefs-tools/libbcachefs/tests.h

#ifndef _BCACHEFS_TEST_H #define _BCACHEFS_TEST_H struct bch_fs; #ifdef CONFIG_BCACHEFS_TESTS void bch2_btree_perf_test(struct bch_fs *, const char *, u64, unsigned); #else #endif /* CONFIG_BCACHEFS_TESTS */ #endif /* _BCACHEFS_TEST_H */

244

C

.h

8

28.75

72

0.743478

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,945

fs-io.h

thoughtpolice_bcachefs-tools/libbcachefs/fs-io.h

#ifndef _BCACHEFS_FS_IO_H #define _BCACHEFS_FS_IO_H #ifndef NO_BCACHEFS_FS #include "buckets.h" #include "io_types.h" #include <linux/uio.h> int bch2_set_page_dirty(struct page *); int bch2_writepage(struct page *, struct writeback_control *); int bch2_readpage(struct file *, struct page *); int bch2_writepages(struct address_space *, struct writeback_control *); int bch2_readpages(struct file *, struct address_space *, struct list_head *, unsigned); int bch2_write_begin(struct file *, struct address_space *, loff_t, unsigned, unsigned, struct page **, void **); int bch2_write_end(struct file *, struct address_space *, loff_t, unsigned, unsigned, struct page *, void *); ssize_t bch2_direct_IO(struct kiocb *, struct iov_iter *); ssize_t bch2_write_iter(struct kiocb *, struct iov_iter *); int bch2_fsync(struct file *, loff_t, loff_t, int); int bch2_truncate(struct bch_inode_info *, struct iattr *); long bch2_fallocate_dispatch(struct file *, int, loff_t, loff_t); loff_t bch2_llseek(struct file *, loff_t, int); int bch2_page_mkwrite(struct vm_fault *); void bch2_invalidatepage(struct page *, unsigned int, unsigned int); int bch2_releasepage(struct page *, gfp_t); int bch2_migrate_page(struct address_space *, struct page *, struct page *, enum migrate_mode); void bch2_fs_fsio_exit(struct bch_fs *); int bch2_fs_fsio_init(struct bch_fs *); #else static inline void bch2_fs_fsio_exit(struct bch_fs *c) {} static inline int bch2_fs_fsio_init(struct bch_fs *c) { return 0; } #endif #endif /* _BCACHEFS_FS_IO_H */

1,566

C

.h

34

43.882353

72

0.726434

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,947

io.h

thoughtpolice_bcachefs-tools/libbcachefs/io.h

#ifndef _BCACHEFS_IO_H #define _BCACHEFS_IO_H #include "alloc.h" #include "checksum.h" #include "io_types.h" #define to_wbio(_bio) \ container_of((_bio), struct bch_write_bio, bio) #define to_rbio(_bio) \ container_of((_bio), struct bch_read_bio, bio) void bch2_bio_free_pages_pool(struct bch_fs *, struct bio *); void bch2_bio_alloc_pages_pool(struct bch_fs *, struct bio *, size_t); void bch2_bio_alloc_more_pages_pool(struct bch_fs *, struct bio *, size_t); void bch2_latency_acct(struct bch_dev *, u64, int); void bch2_submit_wbio_replicas(struct bch_write_bio *, struct bch_fs *, enum bch_data_type, const struct bkey_i *); #define BLK_STS_REMOVED ((__force blk_status_t)128) enum bch_write_flags { BCH_WRITE_ALLOC_NOWAIT = (1 << 0), BCH_WRITE_CACHED = (1 << 1), BCH_WRITE_FLUSH = (1 << 2), BCH_WRITE_DATA_ENCODED = (1 << 3), BCH_WRITE_PAGES_STABLE = (1 << 4), BCH_WRITE_PAGES_OWNED = (1 << 5), BCH_WRITE_ONLY_SPECIFIED_DEVS = (1 << 6), BCH_WRITE_NOPUT_RESERVATION = (1 << 7), BCH_WRITE_NOMARK_REPLICAS = (1 << 8), /* Internal: */ BCH_WRITE_JOURNAL_SEQ_PTR = (1 << 9), }; static inline u64 *op_journal_seq(struct bch_write_op *op) { return (op->flags & BCH_WRITE_JOURNAL_SEQ_PTR) ? op->journal_seq_p : &op->journal_seq; } static inline void op_journal_seq_set(struct bch_write_op *op, u64 *journal_seq) { op->journal_seq_p = journal_seq; op->flags |= BCH_WRITE_JOURNAL_SEQ_PTR; } static inline struct workqueue_struct *index_update_wq(struct bch_write_op *op) { return op->alloc_reserve == RESERVE_MOVINGGC ? op->c->copygc_wq : op->c->wq; } int bch2_write_index_default(struct bch_write_op *); static inline void bch2_write_op_init(struct bch_write_op *op, struct bch_fs *c, struct bch_io_opts opts) { op->c = c; op->io_wq = index_update_wq(op); op->flags = 0; op->written = 0; op->error = 0; op->csum_type = bch2_data_checksum_type(c, opts.data_checksum); op->compression_type = bch2_compression_opt_to_type[opts.compression]; op->nr_replicas = 0; op->nr_replicas_required = c->opts.data_replicas_required; op->alloc_reserve = RESERVE_NONE; op->open_buckets_nr = 0; op->devs_have.nr = 0; op->target = 0; op->opts = opts; op->pos = POS_MAX; op->version = ZERO_VERSION; op->write_point = (struct write_point_specifier) { 0 }; op->res = (struct disk_reservation) { 0 }; op->journal_seq = 0; op->index_update_fn = bch2_write_index_default; } void bch2_write(struct closure *); static inline struct bch_write_bio *wbio_init(struct bio *bio) { struct bch_write_bio *wbio = to_wbio(bio); memset(wbio, 0, offsetof(struct bch_write_bio, bio)); return wbio; } struct bch_devs_mask; struct cache_promote_op; struct extent_pick_ptr; int __bch2_read_extent(struct bch_fs *, struct bch_read_bio *, struct bvec_iter, struct bkey_s_c, struct bch_devs_mask *, unsigned); void bch2_read(struct bch_fs *, struct bch_read_bio *, u64); enum bch_read_flags { BCH_READ_RETRY_IF_STALE = 1 << 0, BCH_READ_MAY_PROMOTE = 1 << 1, BCH_READ_USER_MAPPED = 1 << 2, BCH_READ_NODECODE = 1 << 3, BCH_READ_LAST_FRAGMENT = 1 << 4, /* internal: */ BCH_READ_MUST_BOUNCE = 1 << 5, BCH_READ_MUST_CLONE = 1 << 6, BCH_READ_IN_RETRY = 1 << 7, }; static inline void bch2_read_extent(struct bch_fs *c, struct bch_read_bio *rbio, struct bkey_s_c k, unsigned flags) { __bch2_read_extent(c, rbio, rbio->bio.bi_iter, k, NULL, flags); } static inline struct bch_read_bio *rbio_init(struct bio *bio, struct bch_io_opts opts) { struct bch_read_bio *rbio = to_rbio(bio); rbio->_state = 0; rbio->promote = NULL; rbio->opts = opts; return rbio; } void bch2_fs_io_exit(struct bch_fs *); int bch2_fs_io_init(struct bch_fs *); #endif /* _BCACHEFS_IO_H */

3,789

C

.h

113

31.20354

80

0.675616

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,949

fifo.h

thoughtpolice_bcachefs-tools/libbcachefs/fifo.h

#ifndef _BCACHEFS_FIFO_H #define _BCACHEFS_FIFO_H #include "util.h" #define FIFO(type) \ struct { \ size_t front, back, size, mask; \ type *data; \ } #define DECLARE_FIFO(type, name) FIFO(type) name #define fifo_buf_size(fifo) \ (roundup_pow_of_two((fifo)->size) * sizeof((fifo)->data[0])) #define init_fifo(fifo, _size, _gfp) \ ({ \ (fifo)->front = (fifo)->back = 0; \ (fifo)->size = (_size); \ (fifo)->mask = (fifo)->size \ ? roundup_pow_of_two((fifo)->size) - 1 \ : 0; \ (fifo)->data = kvpmalloc(fifo_buf_size(fifo), (_gfp)); \ }) #define free_fifo(fifo) \ do { \ kvpfree((fifo)->data, fifo_buf_size(fifo)); \ (fifo)->data = NULL; \ } while (0) #define fifo_swap(l, r) \ do { \ swap((l)->front, (r)->front); \ swap((l)->back, (r)->back); \ swap((l)->size, (r)->size); \ swap((l)->mask, (r)->mask); \ swap((l)->data, (r)->data); \ } while (0) #define fifo_move(dest, src) \ do { \ typeof(*((dest)->data)) _t; \ while (!fifo_full(dest) && \ fifo_pop(src, _t)) \ fifo_push(dest, _t); \ } while (0) #define fifo_used(fifo) (((fifo)->back - (fifo)->front)) #define fifo_free(fifo) ((fifo)->size - fifo_used(fifo)) #define fifo_empty(fifo) ((fifo)->front == (fifo)->back) #define fifo_full(fifo) (fifo_used(fifo) == (fifo)->size) #define fifo_peek_front(fifo) ((fifo)->data[(fifo)->front & (fifo)->mask]) #define fifo_peek_back(fifo) ((fifo)->data[((fifo)->back - 1) & (fifo)->mask]) #define fifo_entry_idx_abs(fifo, p) \ ((((p) >= &fifo_peek_front(fifo) \ ? (fifo)->front : (fifo)->back) & ~(fifo)->mask) + \ (((p) - (fifo)->data))) #define fifo_entry_idx(fifo, p) (((p) - &fifo_peek_front(fifo)) & (fifo)->mask) #define fifo_idx_entry(fifo, i) (fifo)->data[((fifo)->front + (i)) & (fifo)->mask] #define fifo_push_back_ref(f) \ (fifo_full((f)) ? NULL : &(f)->data[(f)->back++ & (f)->mask]) #define fifo_push_front_ref(f) \ (fifo_full((f)) ? NULL : &(f)->data[--(f)->front & (f)->mask]) #define fifo_push_back(fifo, new) \ ({ \ typeof((fifo)->data) _r = fifo_push_back_ref(fifo); \ if (_r) \ *_r = (new); \ _r != NULL; \ }) #define fifo_push_front(fifo, new) \ ({ \ typeof((fifo)->data) _r = fifo_push_front_ref(fifo); \ if (_r) \ *_r = (new); \ _r != NULL; \ }) #define fifo_pop_front(fifo, i) \ ({ \ bool _r = !fifo_empty((fifo)); \ if (_r) \ (i) = (fifo)->data[(fifo)->front++ & (fifo)->mask]; \ _r; \ }) #define fifo_pop_back(fifo, i) \ ({ \ bool _r = !fifo_empty((fifo)); \ if (_r) \ (i) = (fifo)->data[--(fifo)->back & (fifo)->mask] \ _r; \ }) #define fifo_push_ref(fifo) fifo_push_back_ref(fifo) #define fifo_push(fifo, i) fifo_push_back(fifo, (i)) #define fifo_pop(fifo, i) fifo_pop_front(fifo, (i)) #define fifo_peek(fifo) fifo_peek_front(fifo) #define fifo_for_each_entry(_entry, _fifo, _iter) \ for (((void) (&(_iter) == &(_fifo)->front)), \ _iter = (_fifo)->front; \ ((_iter != (_fifo)->back) && \ (_entry = (_fifo)->data[(_iter) & (_fifo)->mask], true)); \ _iter++) #define fifo_for_each_entry_ptr(_ptr, _fifo, _iter) \ for (((void) (&(_iter) == &(_fifo)->front)), \ _iter = (_fifo)->front; \ ((_iter != (_fifo)->back) && \ (_ptr = &(_fifo)->data[(_iter) & (_fifo)->mask], true)); \ _iter++) #endif /* _BCACHEFS_FIFO_H */

3,579

C

.h

101

33.089109

82

0.512012

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,951

xattr.h

thoughtpolice_bcachefs-tools/libbcachefs/xattr.h

#ifndef _BCACHEFS_XATTR_H #define _BCACHEFS_XATTR_H #include "str_hash.h" extern const struct bch_hash_desc bch2_xattr_hash_desc; const char *bch2_xattr_invalid(const struct bch_fs *, struct bkey_s_c); void bch2_xattr_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c); #define bch2_bkey_xattr_ops (struct bkey_ops) { \ .key_invalid = bch2_xattr_invalid, \ .val_to_text = bch2_xattr_to_text, \ } static inline unsigned xattr_val_u64s(unsigned name_len, unsigned val_len) { return DIV_ROUND_UP(offsetof(struct bch_xattr, x_name) + name_len + val_len, sizeof(u64)); } #define xattr_val(_xattr) \ ((void *) (_xattr)->x_name + (_xattr)->x_name_len) struct xattr_search_key { u8 type; struct qstr name; }; #define X_SEARCH(_type, _name, _len) ((struct xattr_search_key) \ { .type = _type, .name = QSTR_INIT(_name, _len) }) struct dentry; struct xattr_handler; struct bch_hash_info; struct bch_inode_info; int bch2_xattr_get(struct bch_fs *, struct bch_inode_info *, const char *, void *, size_t, int); int bch2_xattr_set(struct btree_trans *, u64, const struct bch_hash_info *, const char *, const void *, size_t, int, int); ssize_t bch2_xattr_list(struct dentry *, char *, size_t); extern const struct xattr_handler *bch2_xattr_handlers[]; #endif /* _BCACHEFS_XATTR_H */

1,319

C

.h

34

36.705882

75

0.70181

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,954

move_types.h

thoughtpolice_bcachefs-tools/libbcachefs/move_types.h

#ifndef _BCACHEFS_MOVE_TYPES_H #define _BCACHEFS_MOVE_TYPES_H struct bch_move_stats { enum bch_data_type data_type; struct btree_iter iter; atomic64_t keys_moved; atomic64_t sectors_moved; atomic64_t sectors_seen; atomic64_t sectors_raced; }; #endif /* _BCACHEFS_MOVE_TYPES_H */

292

C

.h

11

24.727273

35

0.758993

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,955

btree_update.h

thoughtpolice_bcachefs-tools/libbcachefs/btree_update.h

#ifndef _BCACHEFS_BTREE_UPDATE_H #define _BCACHEFS_BTREE_UPDATE_H #include "btree_iter.h" #include "journal.h" struct bch_fs; struct btree; struct btree_insert; void bch2_btree_node_lock_for_insert(struct bch_fs *, struct btree *, struct btree_iter *); bool bch2_btree_bset_insert_key(struct btree_iter *, struct btree *, struct btree_node_iter *, struct bkey_i *); void bch2_btree_journal_key(struct btree_insert *trans, struct btree_iter *, struct bkey_i *); /* Normal update interface: */ struct btree_insert { struct bch_fs *c; struct disk_reservation *disk_res; struct journal_res journal_res; u64 *journal_seq; struct extent_insert_hook *hook; unsigned flags; bool did_work; unsigned short nr; struct btree_insert_entry *entries; }; int __bch2_btree_insert_at(struct btree_insert *); #define _TENTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, N, ...) N #define COUNT_ARGS(...) _TENTH_ARG(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1) #define BTREE_INSERT_ENTRY(_iter, _k) \ ((struct btree_insert_entry) { \ .iter = (_iter), \ .k = (_k), \ .done = false, \ }) #define BTREE_INSERT_ENTRY_EXTRA_RES(_iter, _k, _extra) \ ((struct btree_insert_entry) { \ .iter = (_iter), \ .k = (_k), \ .extra_res = (_extra), \ .done = false, \ }) /** * bch_btree_insert_at - insert one or more keys at iterator positions * @iter: btree iterator * @insert_key: key to insert * @disk_res: disk reservation * @hook: extent insert callback * * Return values: * -EINTR: locking changed, this function should be called again. Only returned * if passed BTREE_INSERT_ATOMIC. * -EROFS: filesystem read only * -EIO: journal or btree node IO error */ #define bch2_btree_insert_at(_c, _disk_res, _hook, \ _journal_seq, _flags, ...) \ __bch2_btree_insert_at(&(struct btree_insert) { \ .c = (_c), \ .disk_res = (_disk_res), \ .journal_seq = (_journal_seq), \ .hook = (_hook), \ .flags = (_flags), \ .nr = COUNT_ARGS(__VA_ARGS__), \ .entries = (struct btree_insert_entry[]) { \ __VA_ARGS__ \ }}) enum { __BTREE_INSERT_ATOMIC, __BTREE_INSERT_NOUNLOCK, __BTREE_INSERT_NOFAIL, __BTREE_INSERT_USE_RESERVE, __BTREE_INSERT_USE_ALLOC_RESERVE, __BTREE_INSERT_JOURNAL_REPLAY, __BTREE_INSERT_NOWAIT, __BTREE_INSERT_GC_LOCK_HELD, __BCH_HASH_SET_MUST_CREATE, __BCH_HASH_SET_MUST_REPLACE, }; /* * Don't drop/retake locks before doing btree update, instead return -EINTR if * we had to drop locks for any reason */ #define BTREE_INSERT_ATOMIC (1 << __BTREE_INSERT_ATOMIC) /* * Don't drop locks _after_ successfully updating btree: */ #define BTREE_INSERT_NOUNLOCK (1 << __BTREE_INSERT_NOUNLOCK) /* Don't check for -ENOSPC: */ #define BTREE_INSERT_NOFAIL (1 << __BTREE_INSERT_NOFAIL) /* for copygc, or when merging btree nodes */ #define BTREE_INSERT_USE_RESERVE (1 << __BTREE_INSERT_USE_RESERVE) #define BTREE_INSERT_USE_ALLOC_RESERVE (1 << __BTREE_INSERT_USE_ALLOC_RESERVE) /* * Insert is for journal replay: don't get journal reservations, or mark extents * (bch_mark_key) */ #define BTREE_INSERT_JOURNAL_REPLAY (1 << __BTREE_INSERT_JOURNAL_REPLAY) /* Don't block on allocation failure (for new btree nodes: */ #define BTREE_INSERT_NOWAIT (1 << __BTREE_INSERT_NOWAIT) #define BTREE_INSERT_GC_LOCK_HELD (1 << __BTREE_INSERT_GC_LOCK_HELD) #define BCH_HASH_SET_MUST_CREATE (1 << __BCH_HASH_SET_MUST_CREATE) #define BCH_HASH_SET_MUST_REPLACE (1 << __BCH_HASH_SET_MUST_REPLACE) int bch2_btree_delete_at(struct btree_iter *, unsigned); int bch2_btree_insert_list_at(struct btree_iter *, struct keylist *, struct disk_reservation *, struct extent_insert_hook *, u64 *, unsigned); int bch2_btree_insert(struct bch_fs *, enum btree_id, struct bkey_i *, struct disk_reservation *, struct extent_insert_hook *, u64 *, int flags); int bch2_btree_delete_range(struct bch_fs *, enum btree_id, struct bpos, struct bpos, struct bversion, struct disk_reservation *, struct extent_insert_hook *, u64 *); int bch2_btree_node_rewrite(struct bch_fs *c, struct btree_iter *, __le64, unsigned); int bch2_btree_node_update_key(struct bch_fs *, struct btree_iter *, struct btree *, struct bkey_i_extent *); /* new transactional interface: */ void bch2_trans_update(struct btree_trans *, struct btree_iter *, struct bkey_i *, unsigned); int bch2_trans_commit(struct btree_trans *, struct disk_reservation *, struct extent_insert_hook *, u64 *, unsigned); #define bch2_trans_do(_c, _journal_seq, _flags, _do) \ ({ \ struct btree_trans trans; \ int _ret; \ \ bch2_trans_init(&trans, (_c)); \ \ do { \ bch2_trans_begin(&trans); \ \ _ret = (_do) ?: bch2_trans_commit(&trans, NULL, NULL, \ (_journal_seq), (_flags)); \ } while (_ret == -EINTR); \ \ bch2_trans_exit(&trans); \ _ret; \ }) #endif /* _BCACHEFS_BTREE_UPDATE_H */

5,067

C

.h

142

32.704225

80

0.650602

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,960

super_types.h

thoughtpolice_bcachefs-tools/libbcachefs/super_types.h

#ifndef _BCACHEFS_SUPER_TYPES_H #define _BCACHEFS_SUPER_TYPES_H struct bch_sb_handle { struct bch_sb *sb; struct block_device *bdev; struct bio *bio; unsigned page_order; fmode_t mode; unsigned have_layout:1; unsigned have_bio:1; unsigned fs_sb:1; }; struct bch_devs_mask { unsigned long d[BITS_TO_LONGS(BCH_SB_MEMBERS_MAX)]; }; struct bch_devs_list { u8 nr; u8 devs[BCH_REPLICAS_MAX + 1]; }; struct bch_member_cpu { u64 nbuckets; /* device size */ u16 first_bucket; /* index of first bucket used */ u16 bucket_size; /* sectors */ u16 group; u8 state; u8 replacement; u8 discard; u8 data_allowed; u8 durability; u8 valid; }; struct bch_replicas_cpu_entry { u8 data_type; u8 devs[BCH_SB_MEMBERS_MAX / 8]; }; struct bch_replicas_cpu { struct rcu_head rcu; unsigned nr; unsigned entry_size; struct bch_replicas_cpu_entry entries[]; }; struct bch_disk_group_cpu { bool deleted; u16 parent; struct bch_devs_mask devs; }; struct bch_disk_groups_cpu { struct rcu_head rcu; unsigned nr; struct bch_disk_group_cpu entries[]; }; #endif /* _BCACHEFS_SUPER_TYPES_H */

1,150

C

.h

52

20.307692

55

0.701561

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,962

bset.h

thoughtpolice_bcachefs-tools/libbcachefs/bset.h

#ifndef _BCACHEFS_BSET_H #define _BCACHEFS_BSET_H #include <linux/kernel.h> #include <linux/types.h> #include "bcachefs_format.h" #include "bkey.h" #include "bkey_methods.h" #include "btree_types.h" #include "util.h" /* for time_stats */ #include "vstructs.h" /* * BKEYS: * * A bkey contains a key, a size field, a variable number of pointers, and some * ancillary flag bits. * * We use two different functions for validating bkeys, bkey_invalid and * bkey_deleted(). * * The one exception to the rule that ptr_invalid() filters out invalid keys is * that it also filters out keys of size 0 - these are keys that have been * completely overwritten. It'd be safe to delete these in memory while leaving * them on disk, just unnecessary work - so we filter them out when resorting * instead. * * We can't filter out stale keys when we're resorting, because garbage * collection needs to find them to ensure bucket gens don't wrap around - * unless we're rewriting the btree node those stale keys still exist on disk. * * We also implement functions here for removing some number of sectors from the * front or the back of a bkey - this is mainly used for fixing overlapping * extents, by removing the overlapping sectors from the older key. * * BSETS: * * A bset is an array of bkeys laid out contiguously in memory in sorted order, * along with a header. A btree node is made up of a number of these, written at * different times. * * There could be many of them on disk, but we never allow there to be more than * 4 in memory - we lazily resort as needed. * * We implement code here for creating and maintaining auxiliary search trees * (described below) for searching an individial bset, and on top of that we * implement a btree iterator. * * BTREE ITERATOR: * * Most of the code in bcache doesn't care about an individual bset - it needs * to search entire btree nodes and iterate over them in sorted order. * * The btree iterator code serves both functions; it iterates through the keys * in a btree node in sorted order, starting from either keys after a specific * point (if you pass it a search key) or the start of the btree node. * * AUXILIARY SEARCH TREES: * * Since keys are variable length, we can't use a binary search on a bset - we * wouldn't be able to find the start of the next key. But binary searches are * slow anyways, due to terrible cache behaviour; bcache originally used binary * searches and that code topped out at under 50k lookups/second. * * So we need to construct some sort of lookup table. Since we only insert keys * into the last (unwritten) set, most of the keys within a given btree node are * usually in sets that are mostly constant. We use two different types of * lookup tables to take advantage of this. * * Both lookup tables share in common that they don't index every key in the * set; they index one key every BSET_CACHELINE bytes, and then a linear search * is used for the rest. * * For sets that have been written to disk and are no longer being inserted * into, we construct a binary search tree in an array - traversing a binary * search tree in an array gives excellent locality of reference and is very * fast, since both children of any node are adjacent to each other in memory * (and their grandchildren, and great grandchildren...) - this means * prefetching can be used to great effect. * * It's quite useful performance wise to keep these nodes small - not just * because they're more likely to be in L2, but also because we can prefetch * more nodes on a single cacheline and thus prefetch more iterations in advance * when traversing this tree. * * Nodes in the auxiliary search tree must contain both a key to compare against * (we don't want to fetch the key from the set, that would defeat the purpose), * and a pointer to the key. We use a few tricks to compress both of these. * * To compress the pointer, we take advantage of the fact that one node in the * search tree corresponds to precisely BSET_CACHELINE bytes in the set. We have * a function (to_inorder()) that takes the index of a node in a binary tree and * returns what its index would be in an inorder traversal, so we only have to * store the low bits of the offset. * * The key is 84 bits (KEY_DEV + key->key, the offset on the device). To * compress that, we take advantage of the fact that when we're traversing the * search tree at every iteration we know that both our search key and the key * we're looking for lie within some range - bounded by our previous * comparisons. (We special case the start of a search so that this is true even * at the root of the tree). * * So we know the key we're looking for is between a and b, and a and b don't * differ higher than bit 50, we don't need to check anything higher than bit * 50. * * We don't usually need the rest of the bits, either; we only need enough bits * to partition the key range we're currently checking. Consider key n - the * key our auxiliary search tree node corresponds to, and key p, the key * immediately preceding n. The lowest bit we need to store in the auxiliary * search tree is the highest bit that differs between n and p. * * Note that this could be bit 0 - we might sometimes need all 80 bits to do the * comparison. But we'd really like our nodes in the auxiliary search tree to be * of fixed size. * * The solution is to make them fixed size, and when we're constructing a node * check if p and n differed in the bits we needed them to. If they don't we * flag that node, and when doing lookups we fallback to comparing against the * real key. As long as this doesn't happen to often (and it seems to reliably * happen a bit less than 1% of the time), we win - even on failures, that key * is then more likely to be in cache than if we were doing binary searches all * the way, since we're touching so much less memory. * * The keys in the auxiliary search tree are stored in (software) floating * point, with an exponent and a mantissa. The exponent needs to be big enough * to address all the bits in the original key, but the number of bits in the * mantissa is somewhat arbitrary; more bits just gets us fewer failures. * * We need 7 bits for the exponent and 3 bits for the key's offset (since keys * are 8 byte aligned); using 22 bits for the mantissa means a node is 4 bytes. * We need one node per 128 bytes in the btree node, which means the auxiliary * search trees take up 3% as much memory as the btree itself. * * Constructing these auxiliary search trees is moderately expensive, and we * don't want to be constantly rebuilding the search tree for the last set * whenever we insert another key into it. For the unwritten set, we use a much * simpler lookup table - it's just a flat array, so index i in the lookup table * corresponds to the i range of BSET_CACHELINE bytes in the set. Indexing * within each byte range works the same as with the auxiliary search trees. * * These are much easier to keep up to date when we insert a key - we do it * somewhat lazily; when we shift a key up we usually just increment the pointer * to it, only when it would overflow do we go to the trouble of finding the * first key in that range of bytes again. */ extern bool bch2_expensive_debug_checks; static inline bool btree_keys_expensive_checks(const struct btree *b) { #ifdef CONFIG_BCACHEFS_DEBUG return bch2_expensive_debug_checks || *b->expensive_debug_checks; #else return false; #endif } enum bset_aux_tree_type { BSET_NO_AUX_TREE, BSET_RO_AUX_TREE, BSET_RW_AUX_TREE, }; #define BSET_TREE_NR_TYPES 3 #define BSET_NO_AUX_TREE_VAL (U16_MAX) #define BSET_RW_AUX_TREE_VAL (U16_MAX - 1) static inline enum bset_aux_tree_type bset_aux_tree_type(const struct bset_tree *t) { switch (t->extra) { case BSET_NO_AUX_TREE_VAL: EBUG_ON(t->size); return BSET_NO_AUX_TREE; case BSET_RW_AUX_TREE_VAL: EBUG_ON(!t->size); return BSET_RW_AUX_TREE; default: EBUG_ON(!t->size); return BSET_RO_AUX_TREE; } } typedef void (*compiled_unpack_fn)(struct bkey *, const struct bkey_packed *); static inline void __bkey_unpack_key_format_checked(const struct btree *b, struct bkey *dst, const struct bkey_packed *src) { #ifdef HAVE_BCACHEFS_COMPILED_UNPACK { compiled_unpack_fn unpack_fn = b->aux_data; unpack_fn(dst, src); if (btree_keys_expensive_checks(b)) { struct bkey dst2 = __bch2_bkey_unpack_key(&b->format, src); /* * hack around a harmless race when compacting whiteouts * for a write: */ dst2.needs_whiteout = dst->needs_whiteout; BUG_ON(memcmp(dst, &dst2, sizeof(*dst))); } } #else *dst = __bch2_bkey_unpack_key(&b->format, src); #endif } static inline struct bkey bkey_unpack_key_format_checked(const struct btree *b, const struct bkey_packed *src) { struct bkey dst; __bkey_unpack_key_format_checked(b, &dst, src); return dst; } static inline void __bkey_unpack_key(const struct btree *b, struct bkey *dst, const struct bkey_packed *src) { if (likely(bkey_packed(src))) __bkey_unpack_key_format_checked(b, dst, src); else *dst = *packed_to_bkey_c(src); } /** * bkey_unpack_key -- unpack just the key, not the value */ static inline struct bkey bkey_unpack_key(const struct btree *b, const struct bkey_packed *src) { return likely(bkey_packed(src)) ? bkey_unpack_key_format_checked(b, src) : *packed_to_bkey_c(src); } static inline struct bpos bkey_unpack_pos_format_checked(const struct btree *b, const struct bkey_packed *src) { #ifdef HAVE_BCACHEFS_COMPILED_UNPACK return bkey_unpack_key_format_checked(b, src).p; #else return __bkey_unpack_pos(&b->format, src); #endif } static inline struct bpos bkey_unpack_pos(const struct btree *b, const struct bkey_packed *src) { return likely(bkey_packed(src)) ? bkey_unpack_pos_format_checked(b, src) : packed_to_bkey_c(src)->p; } /* Disassembled bkeys */ static inline struct bkey_s_c bkey_disassemble(struct btree *b, const struct bkey_packed *k, struct bkey *u) { __bkey_unpack_key(b, u, k); return (struct bkey_s_c) { u, bkeyp_val(&b->format, k), }; } /* non const version: */ static inline struct bkey_s __bkey_disassemble(struct btree *b, struct bkey_packed *k, struct bkey *u) { __bkey_unpack_key(b, u, k); return (struct bkey_s) { .k = u, .v = bkeyp_val(&b->format, k), }; } #define for_each_bset(_b, _t) \ for (_t = (_b)->set; _t < (_b)->set + (_b)->nsets; _t++) static inline bool bset_has_ro_aux_tree(struct bset_tree *t) { return bset_aux_tree_type(t) == BSET_RO_AUX_TREE; } static inline bool bset_has_rw_aux_tree(struct bset_tree *t) { return bset_aux_tree_type(t) == BSET_RW_AUX_TREE; } static inline void bch2_bset_set_no_aux_tree(struct btree *b, struct bset_tree *t) { BUG_ON(t < b->set); for (; t < b->set + ARRAY_SIZE(b->set); t++) { t->size = 0; t->extra = BSET_NO_AUX_TREE_VAL; t->aux_data_offset = U16_MAX; } } static inline void btree_node_set_format(struct btree *b, struct bkey_format f) { int len; b->format = f; b->nr_key_bits = bkey_format_key_bits(&f); len = bch2_compile_bkey_format(&b->format, b->aux_data); BUG_ON(len < 0 || len > U8_MAX); b->unpack_fn_len = len; bch2_bset_set_no_aux_tree(b, b->set); } static inline struct bset *bset_next_set(struct btree *b, unsigned block_bytes) { struct bset *i = btree_bset_last(b); EBUG_ON(!is_power_of_2(block_bytes)); return ((void *) i) + round_up(vstruct_bytes(i), block_bytes); } void bch2_btree_keys_free(struct btree *); int bch2_btree_keys_alloc(struct btree *, unsigned, gfp_t); void bch2_btree_keys_init(struct btree *, bool *); void bch2_bset_init_first(struct btree *, struct bset *); void bch2_bset_init_next(struct bch_fs *, struct btree *, struct btree_node_entry *); void bch2_bset_build_aux_tree(struct btree *, struct bset_tree *, bool); void bch2_bset_fix_invalidated_key(struct btree *, struct bset_tree *, struct bkey_packed *); void bch2_bset_insert(struct btree *, struct btree_node_iter *, struct bkey_packed *, struct bkey_i *, unsigned); void bch2_bset_delete(struct btree *, struct bkey_packed *, unsigned); /* Bkey utility code */ /* packed or unpacked */ static inline int bkey_cmp_p_or_unp(const struct btree *b, const struct bkey_packed *l, const struct bkey_packed *r_packed, struct bpos *r) { EBUG_ON(r_packed && !bkey_packed(r_packed)); if (unlikely(!bkey_packed(l))) return bkey_cmp(packed_to_bkey_c(l)->p, *r); if (likely(r_packed)) return __bch2_bkey_cmp_packed_format_checked(l, r_packed, b); return __bch2_bkey_cmp_left_packed_format_checked(b, l, r); } /* Returns true if @k is after iterator position @pos */ static inline bool btree_iter_pos_cmp_packed(const struct btree *b, struct bpos *pos, const struct bkey_packed *k, bool strictly_greater) { int cmp = bkey_cmp_left_packed(b, k, pos); return cmp > 0 || (cmp == 0 && !strictly_greater && !bkey_deleted(k)); } static inline bool btree_iter_pos_cmp_p_or_unp(const struct btree *b, struct bpos pos, const struct bkey_packed *pos_packed, const struct bkey_packed *k, bool strictly_greater) { int cmp = bkey_cmp_p_or_unp(b, k, pos_packed, &pos); return cmp > 0 || (cmp == 0 && !strictly_greater && !bkey_deleted(k)); } struct bset_tree *bch2_bkey_to_bset(struct btree *, struct bkey_packed *); struct bkey_packed *bch2_bkey_prev_filter(struct btree *, struct bset_tree *, struct bkey_packed *, unsigned); static inline struct bkey_packed * bch2_bkey_prev_all(struct btree *b, struct bset_tree *t, struct bkey_packed *k) { return bch2_bkey_prev_filter(b, t, k, 0); } static inline struct bkey_packed * bch2_bkey_prev(struct btree *b, struct bset_tree *t, struct bkey_packed *k) { return bch2_bkey_prev_filter(b, t, k, KEY_TYPE_DISCARD + 1); } enum bch_extent_overlap { BCH_EXTENT_OVERLAP_ALL = 0, BCH_EXTENT_OVERLAP_BACK = 1, BCH_EXTENT_OVERLAP_FRONT = 2, BCH_EXTENT_OVERLAP_MIDDLE = 3, }; /* Returns how k overlaps with m */ static inline enum bch_extent_overlap bch2_extent_overlap(const struct bkey *k, const struct bkey *m) { int cmp1 = bkey_cmp(k->p, m->p) < 0; int cmp2 = bkey_cmp(bkey_start_pos(k), bkey_start_pos(m)) > 0; return (cmp1 << 1) + cmp2; } /* Btree key iteration */ static inline void __bch2_btree_node_iter_init(struct btree_node_iter *iter, bool is_extents) { iter->is_extents = is_extents; memset(iter->data, 0, sizeof(iter->data)); } void bch2_btree_node_iter_push(struct btree_node_iter *, struct btree *, const struct bkey_packed *, const struct bkey_packed *); void bch2_btree_node_iter_init(struct btree_node_iter *, struct btree *, struct bpos, bool, bool); void bch2_btree_node_iter_init_from_start(struct btree_node_iter *, struct btree *, bool); struct bkey_packed *bch2_btree_node_iter_bset_pos(struct btree_node_iter *, struct btree *, struct bset_tree *); void bch2_btree_node_iter_sort(struct btree_node_iter *, struct btree *); void bch2_btree_node_iter_set_drop(struct btree_node_iter *, struct btree_node_iter_set *); void bch2_btree_node_iter_advance(struct btree_node_iter *, struct btree *); #define btree_node_iter_for_each(_iter, _set) \ for (_set = (_iter)->data; \ _set < (_iter)->data + ARRAY_SIZE((_iter)->data) && \ (_set)->k != (_set)->end; \ _set++) static inline bool __btree_node_iter_set_end(struct btree_node_iter *iter, unsigned i) { return iter->data[i].k == iter->data[i].end; } static inline bool bch2_btree_node_iter_end(struct btree_node_iter *iter) { return __btree_node_iter_set_end(iter, 0); } static inline int __btree_node_iter_cmp(bool is_extents, struct btree *b, struct bkey_packed *l, struct bkey_packed *r) { /* * For non extents, when keys compare equal the deleted keys have to * come first - so that bch2_btree_node_iter_next_check() can detect * duplicate nondeleted keys (and possibly other reasons?) * * For extents, bkey_deleted() is used as a proxy for k->size == 0, so * deleted keys have to sort last. */ return bkey_cmp_packed(b, l, r) ?: (is_extents ? (int) bkey_deleted(l) - (int) bkey_deleted(r) : (int) bkey_deleted(r) - (int) bkey_deleted(l)) ?: (l > r) - (l < r); } static inline int btree_node_iter_cmp(struct btree_node_iter *iter, struct btree *b, struct btree_node_iter_set l, struct btree_node_iter_set r) { return __btree_node_iter_cmp(iter->is_extents, b, __btree_node_offset_to_key(b, l.k), __btree_node_offset_to_key(b, r.k)); } static inline void __bch2_btree_node_iter_push(struct btree_node_iter *iter, struct btree *b, const struct bkey_packed *k, const struct bkey_packed *end) { if (k != end) { struct btree_node_iter_set *pos; btree_node_iter_for_each(iter, pos) ; BUG_ON(pos >= iter->data + ARRAY_SIZE(iter->data)); *pos = (struct btree_node_iter_set) { __btree_node_key_to_offset(b, k), __btree_node_key_to_offset(b, end) }; } } static inline struct bkey_packed * __bch2_btree_node_iter_peek_all(struct btree_node_iter *iter, struct btree *b) { return __btree_node_offset_to_key(b, iter->data->k); } static inline struct bkey_packed * bch2_btree_node_iter_peek_filter(struct btree_node_iter *iter, struct btree *b, unsigned min_key_type) { while (!bch2_btree_node_iter_end(iter)) { struct bkey_packed *k = __bch2_btree_node_iter_peek_all(iter, b); if (k->type >= min_key_type) return k; bch2_btree_node_iter_advance(iter, b); } return NULL; } static inline struct bkey_packed * bch2_btree_node_iter_peek_all(struct btree_node_iter *iter, struct btree *b) { return bch2_btree_node_iter_peek_filter(iter, b, 0); } static inline struct bkey_packed * bch2_btree_node_iter_peek(struct btree_node_iter *iter, struct btree *b) { return bch2_btree_node_iter_peek_filter(iter, b, KEY_TYPE_DISCARD + 1); } static inline struct bkey_packed * bch2_btree_node_iter_next_all(struct btree_node_iter *iter, struct btree *b) { struct bkey_packed *ret = bch2_btree_node_iter_peek_all(iter, b); if (ret) bch2_btree_node_iter_advance(iter, b); return ret; } struct bkey_packed *bch2_btree_node_iter_prev_filter(struct btree_node_iter *, struct btree *, unsigned); static inline struct bkey_packed * bch2_btree_node_iter_prev_all(struct btree_node_iter *iter, struct btree *b) { return bch2_btree_node_iter_prev_filter(iter, b, 0); } static inline struct bkey_packed * bch2_btree_node_iter_prev(struct btree_node_iter *iter, struct btree *b) { return bch2_btree_node_iter_prev_filter(iter, b, KEY_TYPE_DISCARD + 1); } /* * Iterates over all _live_ keys - skipping deleted (and potentially * overlapping) keys */ #define for_each_btree_node_key(b, k, iter, _is_extents) \ for (bch2_btree_node_iter_init_from_start((iter), (b), (_is_extents));\ ((k) = bch2_btree_node_iter_peek(iter, b)); \ bch2_btree_node_iter_advance(iter, b)) struct bkey_s_c bch2_btree_node_iter_peek_unpack(struct btree_node_iter *, struct btree *, struct bkey *); #define for_each_btree_node_key_unpack(b, k, iter, _is_extents, unpacked)\ for (bch2_btree_node_iter_init_from_start((iter), (b), (_is_extents));\ (k = bch2_btree_node_iter_peek_unpack((iter), (b), (unpacked))).k;\ bch2_btree_node_iter_advance(iter, b)) /* Accounting: */ static inline void btree_keys_account_key(struct btree_nr_keys *n, unsigned bset, struct bkey_packed *k, int sign) { n->live_u64s += k->u64s * sign; n->bset_u64s[bset] += k->u64s * sign; if (bkey_packed(k)) n->packed_keys += sign; else n->unpacked_keys += sign; } #define btree_keys_account_key_add(_nr, _bset_idx, _k) \ btree_keys_account_key(_nr, _bset_idx, _k, 1) #define btree_keys_account_key_drop(_nr, _bset_idx, _k) \ btree_keys_account_key(_nr, _bset_idx, _k, -1) struct bset_stats { struct { size_t nr, bytes; } sets[BSET_TREE_NR_TYPES]; size_t floats; size_t failed_unpacked; size_t failed_prev; size_t failed_overflow; }; void bch2_btree_keys_stats(struct btree *, struct bset_stats *); int bch2_bkey_print_bfloat(struct btree *, struct bkey_packed *, char *, size_t); /* Debug stuff */ void bch2_dump_bset(struct btree *, struct bset *, unsigned); void bch2_dump_btree_node(struct btree *); void bch2_dump_btree_node_iter(struct btree *, struct btree_node_iter *); #ifdef CONFIG_BCACHEFS_DEBUG void __bch2_verify_btree_nr_keys(struct btree *); void bch2_btree_node_iter_verify(struct btree_node_iter *, struct btree *); void bch2_verify_key_order(struct btree *, struct btree_node_iter *, struct bkey_packed *); #else static inline void __bch2_verify_btree_nr_keys(struct btree *b) {} static inline void bch2_btree_node_iter_verify(struct btree_node_iter *iter, struct btree *b) {} static inline void bch2_verify_key_order(struct btree *b, struct btree_node_iter *iter, struct bkey_packed *where) {} #endif static inline void bch2_verify_btree_nr_keys(struct btree *b) { if (btree_keys_expensive_checks(b)) __bch2_verify_btree_nr_keys(b); } #endif /* _BCACHEFS_BSET_H */

21,437

C

.h

567

35.012346

83

0.709918

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,963

journal_types.h

thoughtpolice_bcachefs-tools/libbcachefs/journal_types.h

#ifndef _BCACHEFS_JOURNAL_TYPES_H #define _BCACHEFS_JOURNAL_TYPES_H #include <linux/cache.h> #include <linux/workqueue.h> #include "alloc_types.h" #include "super_types.h" #include "fifo.h" struct journal_res; /* * We put two of these in struct journal; we used them for writes to the * journal that are being staged or in flight. */ struct journal_buf { struct jset *data; BKEY_PADDED(key); struct closure_waitlist wait; unsigned size; unsigned disk_sectors; /* bloom filter: */ unsigned long has_inode[1024 / sizeof(unsigned long)]; }; /* * Something that makes a journal entry dirty - i.e. a btree node that has to be * flushed: */ struct journal_entry_pin_list { struct list_head list; struct list_head flushed; atomic_t count; struct bch_devs_list devs; }; struct journal; struct journal_entry_pin; typedef void (*journal_pin_flush_fn)(struct journal *j, struct journal_entry_pin *, u64); struct journal_entry_pin { struct list_head list; journal_pin_flush_fn flush; struct journal_entry_pin_list *pin_list; }; /* corresponds to a btree node with a blacklisted bset: */ struct blacklisted_node { __le64 seq; enum btree_id btree_id; struct bpos pos; }; struct journal_seq_blacklist { struct list_head list; u64 start; u64 end; struct journal_entry_pin pin; struct blacklisted_node *entries; size_t nr_entries; }; struct journal_res { bool ref; u8 idx; u16 u64s; u32 offset; u64 seq; }; union journal_res_state { struct { atomic64_t counter; }; struct { u64 v; }; struct { u64 cur_entry_offset:20, idx:1, prev_buf_unwritten:1, buf0_count:21, buf1_count:21; }; }; /* bytes: */ #define JOURNAL_ENTRY_SIZE_MIN (64U << 10) /* 64k */ #define JOURNAL_ENTRY_SIZE_MAX (4U << 20) /* 4M */ /* * We stash some journal state as sentinal values in cur_entry_offset: * note - cur_entry_offset is in units of u64s */ #define JOURNAL_ENTRY_OFFSET_MAX ((1U << 20) - 1) #define JOURNAL_ENTRY_CLOSED_VAL (JOURNAL_ENTRY_OFFSET_MAX - 1) #define JOURNAL_ENTRY_ERROR_VAL (JOURNAL_ENTRY_OFFSET_MAX) /* * JOURNAL_NEED_WRITE - current (pending) journal entry should be written ASAP, * either because something's waiting on the write to complete or because it's * been dirty too long and the timer's expired. */ enum { JOURNAL_REPLAY_DONE, JOURNAL_STARTED, JOURNAL_NEED_WRITE, JOURNAL_NOT_EMPTY, }; /* Embedded in struct bch_fs */ struct journal { /* Fastpath stuff up front: */ unsigned long flags; union journal_res_state reservations; unsigned cur_entry_u64s; unsigned prev_buf_sectors; unsigned cur_buf_sectors; unsigned buf_size_want; /* * Two journal entries -- one is currently open for new entries, the * other is possibly being written out. */ struct journal_buf buf[2]; spinlock_t lock; /* Used when waiting because the journal was full */ wait_queue_head_t wait; struct closure_waitlist async_wait; struct closure io; struct delayed_work write_work; /* Sequence number of most recent journal entry (last entry in @pin) */ atomic64_t seq; /* last_seq from the most recent journal entry written */ u64 last_seq_ondisk; /* * FIFO of journal entries whose btree updates have not yet been * written out. * * Each entry is a reference count. The position in the FIFO is the * entry's sequence number relative to @seq. * * The journal entry itself holds a reference count, put when the * journal entry is written out. Each btree node modified by the journal * entry also holds a reference count, put when the btree node is * written. * * When a reference count reaches zero, the journal entry is no longer * needed. When all journal entries in the oldest journal bucket are no * longer needed, the bucket can be discarded and reused. */ struct { u64 front, back, size, mask; struct journal_entry_pin_list *data; } pin; u64 replay_journal_seq; struct mutex blacklist_lock; struct list_head seq_blacklist; struct journal_seq_blacklist *new_blacklist; BKEY_PADDED(key); struct write_point wp; spinlock_t err_lock; struct delayed_work reclaim_work; unsigned long last_flushed; /* protects advancing ja->last_idx: */ struct mutex reclaim_lock; unsigned write_delay_ms; unsigned reclaim_delay_ms; u64 res_get_blocked_start; u64 need_write_time; u64 write_start_time; struct time_stats *write_time; struct time_stats *delay_time; struct time_stats *blocked_time; struct time_stats *flush_seq_time; #ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map res_map; #endif }; /* * Embedded in struct bch_dev. First three fields refer to the array of journal * buckets, in bch_sb. */ struct journal_device { /* * For each journal bucket, contains the max sequence number of the * journal writes it contains - so we know when a bucket can be reused. */ u64 *bucket_seq; unsigned sectors_free; /* Journal bucket we're currently writing to */ unsigned cur_idx; /* Last journal bucket that still contains an open journal entry */ /* * j->lock and j->reclaim_lock must both be held to modify, j->lock * sufficient to read: */ unsigned last_idx; unsigned nr; u64 *buckets; /* Bio for journal reads/writes to this device */ struct bio *bio; /* for bch_journal_read_device */ struct closure read; }; #endif /* _BCACHEFS_JOURNAL_TYPES_H */

5,405

C

.h

192

25.911458

80

0.731603

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

true

14,259,965

eytzinger.h

thoughtpolice_bcachefs-tools/libbcachefs/eytzinger.h

#ifndef _EYTZINGER_H #define _EYTZINGER_H #include <linux/bitops.h> #include <linux/log2.h> #include "util.h" /* * Traversal for trees in eytzinger layout - a full binary tree layed out in an * array */ /* * One based indexing version: * * With one based indexing each level of the tree starts at a power of two - * good for cacheline alignment: * * Size parameter is treated as if we were using 0 based indexing, however: * valid nodes, and inorder indices, are in the range [1..size) - that is, there * are actually size - 1 elements */ static inline unsigned eytzinger1_child(unsigned i, unsigned child) { EBUG_ON(child > 1); return (i << 1) + child; } static inline unsigned eytzinger1_left_child(unsigned i) { return eytzinger1_child(i, 0); } static inline unsigned eytzinger1_right_child(unsigned i) { return eytzinger1_child(i, 1); } static inline unsigned eytzinger1_first(unsigned size) { return rounddown_pow_of_two(size - 1); } static inline unsigned eytzinger1_last(unsigned size) { return rounddown_pow_of_two(size) - 1; } /* * eytzinger1_next() and eytzinger1_prev() have the nice properties that * * eytzinger1_next(0) == eytzinger1_first()) * eytzinger1_prev(0) == eytzinger1_last()) * * eytzinger1_prev(eytzinger1_first()) == 0 * eytzinger1_next(eytzinger1_last()) == 0 */ static inline unsigned eytzinger1_next(unsigned i, unsigned size) { EBUG_ON(i >= size); if (eytzinger1_right_child(i) < size) { i = eytzinger1_right_child(i); i <<= __fls(size) - __fls(i); i >>= i >= size; } else { i >>= ffz(i) + 1; } return i; } static inline unsigned eytzinger1_prev(unsigned i, unsigned size) { EBUG_ON(i >= size); if (eytzinger1_left_child(i) < size) { i = eytzinger1_left_child(i) + 1; i <<= __fls(size) - __fls(i); i -= 1; i >>= i >= size; } else { i >>= __ffs(i) + 1; } return i; } static inline unsigned eytzinger1_extra(unsigned size) { return (size - rounddown_pow_of_two(size - 1)) << 1; } static inline unsigned __eytzinger1_to_inorder(unsigned i, unsigned size, unsigned extra) { unsigned b = __fls(i); unsigned shift = __fls(size - 1) - b; int s; EBUG_ON(!i || i >= size); i ^= 1U << b; i <<= 1; i |= 1; i <<= shift; /* * sign bit trick: * * if (i > extra) * i -= (i - extra) >> 1; */ s = extra - i; i += (s >> 1) & (s >> 31); return i; } static inline unsigned __inorder_to_eytzinger1(unsigned i, unsigned size, unsigned extra) { unsigned shift; int s; EBUG_ON(!i || i >= size); /* * sign bit trick: * * if (i > extra) * i += i - extra; */ s = extra - i; i -= s & (s >> 31); shift = __ffs(i); i >>= shift + 1; i |= 1U << (__fls(size - 1) - shift); return i; } static inline unsigned eytzinger1_to_inorder(unsigned i, unsigned size) { return __eytzinger1_to_inorder(i, size, eytzinger1_extra(size)); } static inline unsigned inorder_to_eytzinger1(unsigned i, unsigned size) { return __inorder_to_eytzinger1(i, size, eytzinger1_extra(size)); } #define eytzinger1_for_each(_i, _size) \ for ((_i) = eytzinger1_first((_size)); \ (_i) != 0; \ (_i) = eytzinger1_next((_i), (_size))) /* Zero based indexing version: */ static inline unsigned eytzinger0_child(unsigned i, unsigned child) { EBUG_ON(child > 1); return (i << 1) + 1 + child; } static inline unsigned eytzinger0_left_child(unsigned i) { return eytzinger0_child(i, 0); } static inline unsigned eytzinger0_right_child(unsigned i) { return eytzinger0_child(i, 1); } static inline unsigned eytzinger0_first(unsigned size) { return eytzinger1_first(size + 1) - 1; } static inline unsigned eytzinger0_last(unsigned size) { return eytzinger1_last(size + 1) - 1; } static inline unsigned eytzinger0_next(unsigned i, unsigned size) { return eytzinger1_next(i + 1, size + 1) - 1; } static inline unsigned eytzinger0_prev(unsigned i, unsigned size) { return eytzinger1_prev(i + 1, size + 1) - 1; } static inline unsigned eytzinger0_extra(unsigned size) { return eytzinger1_extra(size + 1); } static inline unsigned __eytzinger0_to_inorder(unsigned i, unsigned size, unsigned extra) { return __eytzinger1_to_inorder(i + 1, size + 1, extra) - 1; } static inline unsigned __inorder_to_eytzinger0(unsigned i, unsigned size, unsigned extra) { return __inorder_to_eytzinger1(i + 1, size + 1, extra) - 1; } static inline unsigned eytzinger0_to_inorder(unsigned i, unsigned size) { return __eytzinger0_to_inorder(i, size, eytzinger0_extra(size)); } static inline unsigned inorder_to_eytzinger0(unsigned i, unsigned size) { return __inorder_to_eytzinger0(i, size, eytzinger0_extra(size)); } #define eytzinger0_for_each(_i, _size) \ for ((_i) = eytzinger0_first((_size)); \ (_i) != -1; \ (_i) = eytzinger0_next((_i), (_size))) typedef int (*eytzinger_cmp_fn)(const void *l, const void *r, size_t size); /* return greatest node <= @search, or -1 if not found */ static inline ssize_t eytzinger0_find_le(void *base, size_t nr, size_t size, eytzinger_cmp_fn cmp, const void *search) { unsigned i, n = 0; if (!nr) return -1; do { i = n; n = eytzinger0_child(i, cmp(search, base + i * size, size) >= 0); } while (n < nr); if (n & 1) { /* @i was greater than @search, return previous node: */ if (i == eytzinger0_first(nr)) return -1; return eytzinger0_prev(i, nr); } else { return i; } } static inline size_t eytzinger0_find(void *base, size_t nr, size_t size, eytzinger_cmp_fn cmp, const void *search) { size_t i = 0; int res; while (i < nr && (res = cmp(search, base + i * size, size))) i = eytzinger0_child(i, res > 0); return i; } void eytzinger0_sort(void *, size_t, size_t, int (*cmp_func)(const void *, const void *, size_t), void (*swap_func)(void *, void *, size_t)); #endif /* _EYTZINGER_H */

5,880

C

.h

221

24.199095

80

0.669346

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,970

extents_types.h

thoughtpolice_bcachefs-tools/libbcachefs/extents_types.h

#ifndef _BCACHEFS_EXTENTS_TYPES_H #define _BCACHEFS_EXTENTS_TYPES_H #include "bcachefs_format.h" struct bch_extent_crc_unpacked { u8 csum_type; u8 compression_type; u16 compressed_size; u16 uncompressed_size; u16 offset; u16 live_size; u16 nonce; struct bch_csum csum; }; struct extent_pick_ptr { struct bch_extent_ptr ptr; struct bch_extent_crc_unpacked crc; }; #endif /* _BCACHEFS_EXTENTS_TYPES_H */

436

C

.h

18

22.222222

38

0.743902

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,976

quota_types.h

thoughtpolice_bcachefs-tools/libbcachefs/quota_types.h

#ifndef _BCACHEFS_QUOTA_TYPES_H #define _BCACHEFS_QUOTA_TYPES_H #include <linux/generic-radix-tree.h> struct bch_qid { u32 q[QTYP_NR]; }; struct memquota_counter { u64 v; u64 hardlimit; u64 softlimit; s64 timer; int warns; int warning_issued; }; struct bch_memquota { struct memquota_counter c[Q_COUNTERS]; }; typedef GENRADIX(struct bch_memquota) bch_memquota_table; struct quota_limit { u32 timelimit; u32 warnlimit; }; struct bch_memquota_type { struct quota_limit limits[Q_COUNTERS]; bch_memquota_table table; struct mutex lock; }; #endif /* _BCACHEFS_QUOTA_TYPES_H */

624

C

.h

28

20.535714

57

0.731293

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,259,977

journal_io.h

thoughtpolice_bcachefs-tools/libbcachefs/journal_io.h

#ifndef _BCACHEFS_JOURNAL_IO_H #define _BCACHEFS_JOURNAL_IO_H /* * Only used for holding the journal entries we read in btree_journal_read() * during cache_registration */ struct journal_replay { struct list_head list; struct bch_devs_list devs; /* must be last: */ struct jset j; }; static inline struct jset_entry *__jset_entry_type_next(struct jset *jset, struct jset_entry *entry, unsigned type) { while (entry < vstruct_last(jset)) { if (entry->type == type) return entry; entry = vstruct_next(entry); } return NULL; } #define for_each_jset_entry_type(entry, jset, type) \ for (entry = (jset)->start; \ (entry = __jset_entry_type_next(jset, entry, type)); \ entry = vstruct_next(entry)) #define for_each_jset_key(k, _n, entry, jset) \ for_each_jset_entry_type(entry, jset, BCH_JSET_ENTRY_btree_keys) \ vstruct_for_each_safe(entry, k, _n) int bch2_journal_set_seq(struct bch_fs *c, u64, u64); int bch2_journal_read(struct bch_fs *, struct list_head *); int bch2_journal_entry_sectors(struct journal *); void bch2_journal_write(struct closure *); #endif /* _BCACHEFS_JOURNAL_IO_H */

1,143

C

.h

34

31.235294

76

0.704545

thoughtpolice/bcachefs-tools

3

92

0

GPL-2.0

9/7/2024, 2:13:28 PM (Europe/Amsterdam)

false

14,374,638

sc2035_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v200_mpp_1.0.2.0/component/isp/sensor/sc2035/sc2035_sensor_ctl.c

#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "hi_comm_video.h" #ifdef HI_GPIO_I2C #include "gpioi2c_ex.h" #else #include "hi_i2c.h" #endif const unsigned char sensor_i2c_addr = 0x60; /* I2C Address of SC2035 */ const unsigned int sensor_addr_byte = 2; const unsigned int sensor_data_byte = 1; static int g_fd = -1; static int flag_init = 0; extern WDR_MODE_E genSensorMode; extern HI_U8 gu8SensorImageMode; extern HI_BOOL bSensorInit; int sensor_i2c_init(void) { if(g_fd >= 0) { return 0; } #ifdef HI_GPIO_I2C int ret; g_fd = open("/dev/gpioi2c_ex", 0); if(g_fd < 0) { printf("Open gpioi2c_ex error!\n"); return -1; } #else int ret; g_fd = open("/dev/i2c-0", O_RDWR); if(g_fd < 0) { printf("Open /dev/i2c-0 error!\n"); return -1; } ret = ioctl(g_fd, I2C_SLAVE_FORCE, sensor_i2c_addr); if (ret < 0) { printf("CMD_SET_DEV error!\n"); return ret; } #endif return 0; } int sensor_i2c_exit(void) { if (g_fd >= 0) { close(g_fd); g_fd = -1; return 0; } return -1; } int sensor_read_register(int addr) { // TODO: return 0; } int sensor_write_register(int addr, int data) { #ifdef HI_GPIO_I2C i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(g_fd, GPIO_I2C_WRITE, &i2c_data); if (ret) { printf("GPIO-I2C write faild!\n"); return ret; } #else if(flag_init == 0) { sensor_i2c_init(); flag_init = 1; } int idx = 0; int ret; char buf[8]; buf[idx++] = addr & 0xFF; if (sensor_addr_byte == 2) { ret = ioctl(g_fd, I2C_16BIT_REG, 1); buf[idx++] = addr >> 8; } else { ret = ioctl(g_fd, I2C_16BIT_REG, 0); } if (ret < 0) { printf("CMD_SET_REG_WIDTH error!\n"); return -1; } buf[idx++] = data; if (sensor_data_byte == 2) { ret = ioctl(g_fd, I2C_16BIT_DATA, 1); buf[idx++] = data >> 8; } else { ret = ioctl(g_fd, I2C_16BIT_DATA, 0); } if (ret) { printf("hi_i2c write faild!\n"); return -1; } ret = write(g_fd, buf, idx); if(ret < 0) { printf("I2C_WRITE error!\n"); return -1; } #endif return 0; } static void delay_ms(int ms) { usleep(ms*1000); } void sensor_prog(int* rom) { int i = 0; while (1) { int lookup = rom[i++]; int addr = (lookup >> 16) & 0xFFFF; int data = lookup & 0xFFFF; if (addr == 0xFFFE) { delay_ms(data); } else if (addr == 0xFFFF) { return; } else { sensor_write_register(addr, data); } } } void sensor_linear_1080p30_init(); #define SENSOR_1080P_30FPS_MODE (1) void sensor_init() { sensor_i2c_init(); #if 0 /* When sensor first init, config all registers */ if (HI_FALSE == bSensorInit) { if(SENSOR_720P_25FPS_MODE == gu8SensorImageMode) { sensor_linear_720p25_init(); } } /* When sensor switch mode(linear<->WDR or resolution), config different registers(if possible) */ else { if(SENSOR_720P_25FPS_MODE == gu8SensorImageMode) { sensor_linear_720p25_init(); } } #endif sensor_linear_1080p30_init(); return ; } void sensor_exit() { sensor_i2c_exit(); flag_init = 0; return; } void sensor_linear_1080p30_init() { //2.8AVDD_1.8DOVDD_SC2035_27Minput_67.5MPCLK_1080p_30fps_20160317 #if 1 //20160317 sensor_write_register(0x3105,0x02); //start up timing begin sensor_write_register(0x0103,0x01); // reset all registers sensor_write_register(0x3105,0x02); sensor_write_register(0x0100,0x00); //start up timing end sensor_write_register(0x301E,0xB0); // mode select sensor_write_register(0x320c,0x03); // hts=2000 sensor_write_register(0x320d,0xe8); sensor_write_register(0x3231,0x24); // half hts to 2000 sensor_write_register(0x320E,0x04); sensor_write_register(0x320F,0x65); sensor_write_register(0x3211,0x08); //x start 20160113 20160120 sensor_write_register(0x3213,0x10); //y start sensor_write_register(0x3e03,0x03); //AEC AGC 03 : close aec/agc 00: open aec/agc sensor_write_register(0x3e01,0x46); //exp time sensor_write_register(0x3e08,0x00); //gain 1x sensor_write_register(0x3e09,0x10); //10-1f,16step->1/16 sensor_write_register(0x3518,0x03); sensor_write_register(0x5025,0x09); sensor_write_register(0x3908,0xc0); //BLC RNCincrease blc target for rnc sensor_write_register(0x3907,0x01); //12.14 sensor_write_register(0x3928,0x01); //20160315 sensor_write_register(0x3416,0x12); //20160113 sensor_write_register(0x3401,0x1e); //12.11 sensor_write_register(0x3402,0x0c); //12.11 sensor_write_register(0x3403,0x70); //12.11 sensor_write_register(0x3e0f,0x90); sensor_write_register(0x3638,0x84); //RAMP config 20160113B sensor_write_register(0x3637,0xbc); //1018 20160113 20160120 sensor_write_register(0x3639,0x98); sensor_write_register(0x3035,0x01); //count clk sensor_write_register(0x3034,0xc2); //1111 20160120 sensor_write_register(0x3300,0x12); //eq 20160315 sensor_write_register(0x3301,0x08); //cmprst 20160120 20160307 sensor_write_register(0x3308,0x30); // tx 1111 20160307 sensor_write_register(0x3306,0x3a); // count down 1111 20160120 sensor_write_register(0x330a,0x00); sensor_write_register(0x330b,0x90); // count up sensor_write_register(0x3303,0x30); //ramp gap 20160307 sensor_write_register(0x3309,0x30); //cnt up gap 20160307 sensor_write_register(0x331E,0x2c); //integ 1st pos point 20160307 sensor_write_register(0x331F,0x2c); //integ 2nd pos point 20160307 sensor_write_register(0x3320,0x2e); //ofs fine 1st pos point 20160307 sensor_write_register(0x3321,0x2e); //ofs fine 2nd pos point 20160307 sensor_write_register(0x3322,0x2e); //20160307 sensor_write_register(0x3323,0x2e); //20160307 sensor_write_register(0x3626,0x03); //memory readout delay 0613 0926 sensor_write_register(0x3621,0x28); //counter clock div [3] column fpn 0926 sensor_write_register(0x3F08,0x04); //WRITE TIME sensor_write_register(0x3F09,0x44); //WRITE/READ TIME GAP sensor_write_register(0x4500,0x25); //data delay 0926 sensor_write_register(0x3c09,0x08); // Sram start position sensor_write_register(0x335D,0x20); //prechg tx auto ctrl [5] sensor_write_register(0x3368,0x02); //EXP1 sensor_write_register(0x3369,0x00); sensor_write_register(0x336A,0x04); //EXP2 sensor_write_register(0x336b,0x65); sensor_write_register(0x330E,0x50); // start value sensor_write_register(0x3367,0x08); // end value 12.14 sensor_write_register(0x3f00,0x06); sensor_write_register(0x3f04,0x01); // sram write sensor_write_register(0x3f05,0xdf); // 1111 20160113 20160120 20160307 sensor_write_register(0x3905,0x1c); sensor_write_register(0x5780,0x7f); //DPC sensor_write_register(0x5781,0x0a); //12.17 20160307 sensor_write_register(0x5782,0x0a); //12.17 20160307 sensor_write_register(0x5783,0x08); //12.17 20160307 20160317 sensor_write_register(0x5784,0x08); //12.17 20160307 20160317 sensor_write_register(0x5785,0x18); //12.11 ; 20160112 20160307 sensor_write_register(0x5786,0x18); //12.11 ; 20160112 20160307 sensor_write_register(0x5787,0x18); //12.11 20160307 20160317 sensor_write_register(0x5788,0x18); // 20160307 20160317 sensor_write_register(0x5789,0x01); //12.11 sensor_write_register(0x578a,0x0f); //12.11 sensor_write_register(0x5000,0x06); sensor_write_register(0x3632,0x44); //bypass NVDD analog config 20160113 sensor_write_register(0x3622,0x0e); //enable sa1/ecl blksun sensor_write_register(0x3627,0x08); //0921 20160307 sensor_write_register(0x3630,0xb4); //94 1111 20160113 20160120 sensor_write_register(0x3633,0x97); //vrhlp voltage 14~24 could be choosed 20160113 sensor_write_register(0x3620,0x62); //comp and bitline current 20160307 sensor_write_register(0x363a,0x0c); //sa1 common voltage sensor_write_register(0x3333,0x10); // 20160307 sensor_write_register(0x3334,0x20); //column fpn 20160307 sensor_write_register(0x3312,0x06); //20160307 sensor_write_register(0x3340,0x03); //20160307 sensor_write_register(0x3341,0xb0); //20160307 sensor_write_register(0x3342,0x02); //20160307 sensor_write_register(0x3343,0x20); //20160307 sensor_write_register(0x303f,0x81); //format sensor_write_register(0x501f,0x00); sensor_write_register(0x3b00,0xf8); sensor_write_register(0x3b01,0x40); sensor_write_register(0x3c01,0x14); sensor_write_register(0x4000,0x00); sensor_write_register(0x3d08,0x00); //data output DVP CLK INV sensor_write_register(0x3640,0x00); // pad driver sensor_write_register(0x0100,0x01); sensor_write_register(0x303a,0x07); // PLL 67.5M pclk sensor_write_register(0x3039,0x8e); sensor_write_register(0x303f,0x82); sensor_write_register(0x3636,0x88); //lpDVDD sensor_write_register(0x3631,0x80); //0820 20160113 20160120 sensor_write_register(0x3635,0x66); //1018 20160113 20160120 sensor_write_register(0x3105,0x04); //1018 sensor_write_register(0x3105,0x04); //1018 #else //20160128 sensor_write_register(0x3105,0x02); //start up timing begin sensor_write_register(0x0103,0x01); // reset all registers sensor_write_register(0x3105,0x02); sensor_write_register(0x0100,0x00); //start up timing end sensor_write_register(0x301E,0xB0); // mode select sensor_write_register(0x320c,0x03); // hts=2000 sensor_write_register(0x320d,0xe8); sensor_write_register(0x3231,0x24); // half hts to 2000 sensor_write_register(0x320E,0x04); sensor_write_register(0x320F,0x65); sensor_write_register(0x3211,0x08); //x start 20160113 20160120 sensor_write_register(0x3213,0x10); //y start sensor_write_register(0x3e03,0x03); //AEC AGC 03 : close aec/agc 00: open aec/agc sensor_write_register(0x3e01,0x46); //exp time sensor_write_register(0x3e08,0x00); //gain 1x sensor_write_register(0x3e09,0x10); //10-1f,16step->1/16 sensor_write_register(0x3518,0x03); sensor_write_register(0x5025,0x09); sensor_write_register(0x3908,0xc0); //BLC RNCincrease blc target for rnc sensor_write_register(0x3907,0x01); //12.14 sensor_write_register(0x3416,0x12); //20160113 sensor_write_register(0x3401,0x1e); //12.11 sensor_write_register(0x3402,0x0c); //12.11 sensor_write_register(0x3403,0x70); //12.11 sensor_write_register(0x3e0f,0x90); sensor_write_register(0x3638,0x84); //RAMP config 20160113B sensor_write_register(0x3637,0xbc); //1018 20160113 20160120 sensor_write_register(0x3639,0x98); sensor_write_register(0x3035,0x01); //count clk sensor_write_register(0x3034,0xc2); //1111 20160120 sensor_write_register(0x3300,0x10); //eq sensor_write_register(0x3301,0x14); //cmprst 20160120 sensor_write_register(0x3308,0x38); // tx 1111 sensor_write_register(0x3306,0x3a); // count down 1111 20160120 sensor_write_register(0x330a,0x00); sensor_write_register(0x330b,0x90); // count up sensor_write_register(0x3303,0x18); //ramp gap sensor_write_register(0x3309,0x18); //cnt up gap sensor_write_register(0x331E,0x0e); //integ 1st pos point sensor_write_register(0x331F,0x0e); //integ 2nd pos point sensor_write_register(0x3320,0x14); //ofs fine 1st pos point sensor_write_register(0x3321,0x14); //ofs fine 2nd pos point sensor_write_register(0x3322,0x14); sensor_write_register(0x3323,0x14); sensor_write_register(0x3626,0x03); //memory readout delay 0613 0926 sensor_write_register(0x3621,0x28); //counter clock div [3] column fpn 0926 sensor_write_register(0x3F08,0x04); //WRITE TIME sensor_write_register(0x3F09,0x44); //WRITE/READ TIME GAP sensor_write_register(0x4500,0x25); //data delay 0926 sensor_write_register(0x3c09,0x08); // Sram start position sensor_write_register(0x335D,0x20); //prechg tx auto ctrl [5] sensor_write_register(0x3368,0x02); //EXP1 sensor_write_register(0x3369,0x00); sensor_write_register(0x336A,0x04); //EXP2 sensor_write_register(0x336b,0x65); sensor_write_register(0x330E,0x50); // start value sensor_write_register(0x3367,0x08); // end value 12.14 sensor_write_register(0x3f00,0x06); sensor_write_register(0x3f04,0x01); // sram write sensor_write_register(0x3f05,0xd8); // 1111 20160113 20160120 sensor_write_register(0x3905,0x1c); sensor_write_register(0x5780,0x7f); //DPC sensor_write_register(0x5781,0x0a); //12.17 sensor_write_register(0x5782,0x0a); //12.17 sensor_write_register(0x5783,0x08); //12.17 sensor_write_register(0x5784,0x08); //12.17 sensor_write_register(0x5785,0x10); //12.11 ; 20160112 sensor_write_register(0x5786,0x10); //12.11 ; 20160112 sensor_write_register(0x5787,0x0c); //12.11 sensor_write_register(0x5788,0x0c); sensor_write_register(0x5789,0x01); //12.11 sensor_write_register(0x578a,0x0f); //12.11 sensor_write_register(0x5000,0x06); sensor_write_register(0x3632,0x44); //bypass NVDD analog config 20160113 sensor_write_register(0x3622,0x0e); //enable sa1/ecl blksun sensor_write_register(0x3627,0x02); //0921 sensor_write_register(0x3630,0xb4); //94 1111 20160113 20160120 sensor_write_register(0x3633,0x97); //vrhlp voltage 14~24 could be choosed 20160113 sensor_write_register(0x3620,0x42); //comp and bitline current sensor_write_register(0x363a,0x0c); //sa1 common voltage sensor_write_register(0x3334,0x60); //column fpn sensor_write_register(0x303f,0x81); //format sensor_write_register(0x501f,0x00); sensor_write_register(0x3b00,0xf8); sensor_write_register(0x3b01,0x40); sensor_write_register(0x3c01,0x14); sensor_write_register(0x4000,0x00); sensor_write_register(0x3d08,0x00); //data output DVP CLK INV sensor_write_register(0x3640,0x00); // pad driver sensor_write_register(0x0100,0x01); sensor_write_register(0x303a,0x07); // PLL 67.5M pclk sensor_write_register(0x3039,0x8e); sensor_write_register(0x303f,0x82); sensor_write_register(0x3636,0x88); //lpDVDD sensor_write_register(0x3631,0x80); //0820 20160113 20160120 sensor_write_register(0x3635,0x66); //1018 20160113 20160120 sensor_write_register(0x3105,0x04); //1018 sensor_write_register(0x3105,0x04); //1018 #endif #if 0 sensor_write_register(0x3e01,0x46); //exp time sensor_write_register(0x3e02,0x10); //exp time sensor_write_register(0x3e08,0x7b); //exp time sensor_write_register(0x3e09,0x1f); //exp time #endif bSensorInit = HI_TRUE; printf("=========================================================\n"); printf("===sc2035 sensor 1080P30fps(Parallel port) init success222!=====\n"); printf("=========================================================\n"); return; }

15,157

C

.c

401

34.002494

102

0.708474

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,374,924

vpss_debug.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/tools/vpss_debug.c

#include <stdio.h> #include <stdlib.h> #include <string.h> #include "hi_common.h" #include "hi_comm_video.h" #include "hi_comm_sys.h" #include "hi_comm_vo.h" #include "hi_comm_vi.h" #include "hi_comm_vpss.h" #include "mpi_vb.h" #include "mpi_sys.h" #include "mpi_vi.h" #include "mpi_vo.h" #include "mpi_vpss.h" #define MAX_PARAMS 20 #define USAGE_HELP()\ {\ printf("\n\tusage : %s -g group -c chn -s param1=value1,param2=value2...\n", argv[0]); \ printf("\t : %s -g group -c chn -f config_file\n", argv[0]); \ printf("\n\t param: \n"); \ printf("\t\t tf [time_strength, value:0~63, default:8 ]\n"); \ printf("\t\t tf_y_pro [tf_y_profile, value:0~4, default:4 ]\n"); \ printf("\t\t sf_post_flag [sf_post_flag, value:0~1, default:0 ]\n"); \ printf("\t\t c_range [c_range, value:0~255, default:8 ]\n"); \ printf("\t\t c_mad_thresh [c_mad_thresh, value:0~63, default:8 ]\n"); \ printf("\t\t c_mad_slope [c_mad_slope, value:0~15, default:0 ]\n"); \ printf("\t\t s0 [space_strength,value:0~255, default:32]\n"); \ printf("\t\t s1 [space_strength,value:0~16, default:2 ]\n"); \ printf("\t\t s2 [space_strength,value:0~63, default:8 ]\n"); \ printf("\n\t examples: %s -g 0 -c 0 -s tf=7,c_range=16\n", argv[0]); \ printf("\t %s -g 0 -c 0 -f vpss_night.cfg \n", argv[0]); \ printf("\n\t append keyword \'off\' to disable image quality debug\n"); \ printf("\t example: %s -g 0 -c 0 off\n", argv[0]); \ } #define CHECK_RET(express,name)\ do{\ if (HI_SUCCESS != express)\ {\ printf("%s failed at %s: LINE: %d ! errno:%d \n", \ name, __FUNCTION__, __LINE__, express);\ return HI_FAILURE;\ }\ }while(0) extern HI_S32 HI_MPI_VPSS_GetImageQualityCfg(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, VPSS_IMG_QUALITY_CFG_S *pstImageQualityCfg); extern HI_S32 HI_MPI_VPSS_SetImageQualityCfg(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, VPSS_IMG_QUALITY_CFG_S *pstImageQualityCfg); static int parse_line(char *line, VPSS_IMG_QUALITY_PARAM_S *pImgQualityParam) { char para[255]; unsigned int value; char *comma; if (line[0] == '#' || line[0] == '\0') return 0; comma = strchr(line, '='); if (!comma) { printf("invalid set %s\n", line); return -1; } *comma = '\0'; snprintf(para, 255, "%s", line); value = atoi(++comma); #if 0 printf("para=%s,value=%d\n", para, value); #endif if (0 == strcmp(para, "tf")) { pImgQualityParam->u32TfStrength = value; } else if (0 == strcmp(para, "tf_y_pro")) { pImgQualityParam->u32TfyProfile = value; } else if (0 == strcmp(para, "c_range")) { pImgQualityParam->u32CStrength = value; } else if (0 == strcmp(para, "c_mad_thresh")) { pImgQualityParam->u32CMADThresh = value; } else if (0 == strcmp(para, "c_mad_slope")) { pImgQualityParam->u32CMADSlope = value; } else if (0 == strcmp(para, "sf_post_flag")) { pImgQualityParam->u32SfPostFlag = value; } else if (0 == strcmp(para, "s0")) { pImgQualityParam->u32SfStrength0 = value; } else if (0 == strcmp(para, "s1")) { pImgQualityParam->u32SfStrength1 = value; } else if (0 == strcmp(para, "s2")) { pImgQualityParam->u32SfStrength2 = value; } else { printf("unknown param %s\n", para); return -1; } return 0; } static int parse_config_string(char *str, VPSS_IMG_QUALITY_PARAM_S *pImgQualityParam) { char lines[MAX_PARAMS][100]; int i = 0; int j = 0; char *string = str; if (!string) { printf("string invalid\n"); return -1; } for (;;) { char *comma = strchr(string, ','); if (comma) { *comma = '\0'; if (i > MAX_PARAMS) break; snprintf(lines[i], 100, "%s", string); i++; *comma = ','; string = ++comma; } else { if (string != '\0') { if (i > MAX_PARAMS) break; snprintf(lines[i], 100, "%s", string); i++; break; } else { printf("invalid param \n"); return -1; } } } //printf("i=%d\n", i); for (j=0;j<i;j++) { //printf("%s\n", lines[j]); if (parse_line(lines[j], pImgQualityParam) < 0) { printf("%s parse line error\n", __func__); return -1; } } return 0; } static int parse_config_file(const char *file_name, VPSS_IMG_QUALITY_PARAM_S *pImgQualityParam) { FILE *fp; int n = 0; char line[255]; if (!(fp = fopen(file_name, "r"))) { printf("open %s failed\n", file_name); return -1; } while(fgets(line, sizeof(line), fp)) { n++; line[strlen(line)-1] = '\0'; //printf("%s\n", line); if (parse_line(line, pImgQualityParam) < 0) { fclose(fp); return -1; } } //printf("line number = %d\n", n); fclose(fp); return 0; } int main(int argc, char **argv) { int i = 0; int result = -1; int enable = 1; VPSS_IMG_QUALITY_CFG_S stImgQualityCfg; VPSS_IMG_QUALITY_PARAM_S *pstImgQualityParam; VPSS_GRP VpssGrp = 0; VPSS_CHN VpssChn = 0; if (argc < 3) { printf("no input param\n"); USAGE_HELP(); return -1; } pstImgQualityParam = &stImgQualityCfg.stImageQualityParam; printf("%s %d\n", __func__, __LINE__); #if 1 //get group 0,channel 0 as default. result = HI_MPI_VPSS_GetImageQualityCfg(VpssGrp, VpssChn, &stImgQualityCfg); CHECK_RET(result, "HI_MPI_VPSS_GetImgQualityParam"); for (i = 1; i < argc; i++) { if (!strcmp("-f", argv[i])) { i++; char *file_name = argv[i]; result = parse_config_file(file_name, pstImgQualityParam); } else if (!strcmp("-s", argv[i])) { i++; char *string = argv[i]; result = parse_config_string(string, pstImgQualityParam); } else if (!strcmp("-g", argv[i])) { i++; VpssGrp = atoi(argv[i]); if (VpssGrp > VPSS_MAX_GRP_NUM || VpssGrp < 0) { printf("invalid group num %d", VpssGrp); return -1; } } else if (!strcmp("-c", argv[i])) { i++; VpssChn = atoi(argv[i]); if (VpssChn > VPSS_MAX_GRP_NUM || VpssChn < 0) { printf("invalid chn num %d", VpssChn); return -1; } /*if grp, chnl exist, get new debug param*/ result = HI_MPI_VPSS_GetImageQualityCfg(VpssGrp, VpssChn, &stImgQualityCfg); CHECK_RET(result, "HI_MPI_VPSS_GetImgQualityParam"); } else if (!strcmp("off", argv[i])) { i++; printf("\tdisable Image quality Cfg!!\n"); enable = 0; } else { printf("invalid options %s\n", argv[i]); result = -1; } if (result < 0) { return result; } } if (enable) { stImgQualityCfg.bEnable = HI_TRUE; printf("\t\t tf %d\n", pstImgQualityParam->u32TfStrength); printf("\t\t tf_y_pro %d\n", pstImgQualityParam->u32TfyProfile); printf("\t\t sf_post_flag %d\n", pstImgQualityParam->u32SfPostFlag); printf("\t\t c_range %d\n", pstImgQualityParam->u32CStrength); printf("\t\t c_mad_thresh %d\n", pstImgQualityParam->u32CMADThresh); printf("\t\t c_mad_slope %d\n", pstImgQualityParam->u32CMADSlope); printf("\t\t s0 %d\n", pstImgQualityParam->u32SfStrength0); printf("\t\t s1 %d\n", pstImgQualityParam->u32SfStrength1); printf("\t\t s2 %d\n", pstImgQualityParam->u32SfStrength2); } else { stImgQualityCfg.bEnable = HI_FALSE; } result = HI_MPI_VPSS_SetImageQualityCfg(VpssGrp, VpssChn, &stImgQualityCfg); CHECK_RET(result, "HI_MPI_VPSS_SetImgQualityCfg"); #endif return 0; }

7,523

C

.c

273

24.043956

95

0.603776

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,064

m034_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/aptina_9m034/m034_sensor_ctl.c

#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "m034_sensor_config.h" #ifdef HI_GPIO_I2C #include "gpioi2c_32.h" #include "gpio_i2c.h" #else #include "hi_i2c.h" #endif const unsigned char sensor_i2c_addr = 0x20; /* I2C Address of 9m034 */ const unsigned int sensor_addr_byte = 2; const unsigned int sensor_data_byte = 2; int sensor_read_register(int addr) { // TODO: return 0; } int sensor_write_register(int addr, int data) { #ifdef HI_GPIO_I2C int fd = -1; int ret; Aptina_9M034_DATA i2c_data; fd = open("/dev/gpioi2c_32", 0); if(fd<0) { printf("Open gpioi2c_32 error!\n"); return -1; } i2c_data.I2cDevAddr = sensor_i2c_addr; i2c_data.I2cRegAddr = addr ; i2c_data.RWData = data ; ret = ioctl(fd, GPIO_I2C_WRITE, &i2c_data); if (ret) { printf("GPIO-I2C write faild!\n"); close(fd); return -1; } close(fd); #else int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_WRITE, &i2c_data); if (ret) { printf("hi_i2c write faild!\n"); close(fd); return -1; } close(fd); #endif return 0; } static void delay_ms(int ms) { usleep(ms*1000); } void sensor_prog(int* rom) { int i = 0; while (1) { int lookup = rom[i++]; int addr = (lookup >> 16) & 0xFFFF; int data = lookup & 0xFFFF; if (addr == 0xFFFE) { delay_ms(data); } else if (addr == 0xFFFF) { return; } else { sensor_write_register(addr, data); } } } void sensor_init() { printf("linear mode\n"); /* program sensor to linear mode */ sensor_prog(sensor_rom_30_lin); /* Enable DCG */ sensor_write_register(0x3100, 0x001E); /* Enable 1.25x analog gain */ sensor_write_register(0x3EE4, 0xD308); }

2,290

C

.c

99

18.292929

71

0.591458

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,068

pana34031_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/pana34031/pana34031_sensor_ctl.c

#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "hi_ssp.h" int pana_sensor_write_packet(unsigned int data) { int fd = -1; int ret; unsigned int value; fd = open("/dev/ssp", 0); if(fd<0) { printf("Open /dev/ssp error!\n"); return -1; } value = data; ret = ioctl(fd, SSP_WRITE_ALT, &value); //printf("ssp_write %#x, %#x\n", addr, value); close(fd); return 0; } int sensor_write_register(int addr, int data) { return pana_sensor_write_packet((unsigned int)((addr<<16) | (data & 0xFFFF))); } static void delay_ms(int ms) { } void sensor_prog(int* rom) { int i = 0; while (1) { int lookup = rom[i++]; int addr = (lookup >> 16) & 0xFFFF; int data = lookup & 0xFFFF; if (addr == 0xFFFE) { delay_ms(data); } else if (addr == 0xFFFF) { return; } else { sensor_write_register(addr, data); } } } void sensor_init() { sensor_write_register(0x0001,0x0030); sensor_write_register(0x0002,0x0002); sensor_write_register(0x0004,0x0546); sensor_write_register(0x0000,0x0003); sensor_write_register(0x0003,0x8220); sensor_write_register(0x0000,0x0013); sensor_write_register(0x0005,0x0000); sensor_write_register(0x0006,0x2AAA); sensor_write_register(0x0007,0x0000); sensor_write_register(0x0008,0x0000); sensor_write_register(0x0100,0x0697); sensor_write_register(0x0101,0x0697); sensor_write_register(0x0102,0x0697); sensor_write_register(0x0103,0x01A5); sensor_write_register(0x0104,0x0000); sensor_write_register(0x0105,0x0000); sensor_write_register(0x0106,0x0000); sensor_write_register(0x0107,0x0000); sensor_write_register(0x0108,0x0008); sensor_write_register(0x0109,0x0009); sensor_write_register(0x010A,0x0696); sensor_write_register(0x010B,0x0008); sensor_write_register(0x010C,0x0000); sensor_write_register(0x010D,0x0008); sensor_write_register(0x010E,0x0009); sensor_write_register(0x010F,0x0696); sensor_write_register(0x0110,0x0000); sensor_write_register(0x0111,0x0003); sensor_write_register(0x0112,0x0009); sensor_write_register(0x0113,0x0696); sensor_write_register(0x0114,0x033E); sensor_write_register(0x0115,0x0341); sensor_write_register(0x0116,0x034F); sensor_write_register(0x0117,0x05EF); sensor_write_register(0x0118,0x0000); sensor_write_register(0x0119,0x0005); sensor_write_register(0x011A,0x001F); sensor_write_register(0x011B,0x0000); sensor_write_register(0x011C,0x0005); sensor_write_register(0x011D,0x0013); sensor_write_register(0x011E,0x001D); sensor_write_register(0x011F,0x001F); sensor_write_register(0x0120,0x0000); sensor_write_register(0x0121,0x0007); sensor_write_register(0x0122,0x0006); sensor_write_register(0x0123,0x0000); sensor_write_register(0x0124,0x034F); sensor_write_register(0x0125,0x05F9); sensor_write_register(0x0126,0x0002); sensor_write_register(0x0127,0x068F); sensor_write_register(0x0130,0x0000); sensor_write_register(0x0131,0x0000); sensor_write_register(0x0132,0x0000); sensor_write_register(0x0133,0x0000); sensor_write_register(0x0134,0x0000); sensor_write_register(0x0135,0x0605); sensor_write_register(0x0136,0x0351); sensor_write_register(0x0137,0x0000); sensor_write_register(0x0138,0x0000); sensor_write_register(0x0139,0x0000); sensor_write_register(0x013A,0x0000); sensor_write_register(0x0140,0x0009); sensor_write_register(0x0141,0x00D0); sensor_write_register(0x0142,0x0007); sensor_write_register(0x0143,0x031D); sensor_write_register(0x0144,0x0008); sensor_write_register(0x0145,0x00CF); sensor_write_register(0x0146,0x0006); sensor_write_register(0x0147,0x031C); sensor_write_register(0x0148,0x0000); sensor_write_register(0x0149,0x0000); sensor_write_register(0x014A,0x0008); sensor_write_register(0x014B,0x0006); sensor_write_register(0x014C,0x0000); sensor_write_register(0x014D,0x0002); sensor_write_register(0x014E,0x0002); sensor_write_register(0x014F,0x0007); sensor_write_register(0x0150,0x0008); sensor_write_register(0x0151,0x0006); sensor_write_register(0x0152,0x0009); sensor_write_register(0x0160,0x0001); sensor_write_register(0x0161,0x0004); sensor_write_register(0x0162,0x01A5); sensor_write_register(0x0163,0x0001); sensor_write_register(0x0164,0x0007); sensor_write_register(0x0165,0x0017); sensor_write_register(0x0166,0x001F); sensor_write_register(0x0167,0x0163); sensor_write_register(0x0168,0x0003); sensor_write_register(0x0169,0x0004); sensor_write_register(0x016A,0x0000); sensor_write_register(0x016B,0x0000); sensor_write_register(0x0170,0x0335); sensor_write_register(0x0171,0x0343); sensor_write_register(0x0172,0x0000); sensor_write_register(0x0173,0x0000); sensor_write_register(0x0174,0x0000); sensor_write_register(0x0175,0x0000); sensor_write_register(0x0176,0x0000); sensor_write_register(0x0177,0x0000); sensor_write_register(0x0178,0x0000); sensor_write_register(0x0179,0x0000); sensor_write_register(0x017C,0x0000); sensor_write_register(0x017D,0x0000); sensor_write_register(0x017E,0x0000); sensor_write_register(0x017F,0x0000); sensor_write_register(0x0190,0x0007); sensor_write_register(0x0191,0x0181); sensor_write_register(0x0192,0x0013); sensor_write_register(0x0193,0x0015); sensor_write_register(0x0194,0x0016); sensor_write_register(0x0195,0x0017); sensor_write_register(0x0196,0x001B); sensor_write_register(0x0197,0x0174); sensor_write_register(0x0198,0x0000); sensor_write_register(0x0199,0x0174); sensor_write_register(0x019A,0x001B); sensor_write_register(0x019B,0x0174); sensor_write_register(0x01A0,0x0429); sensor_write_register(0x01A1,0x0000); sensor_write_register(0x01A2,0x0429); sensor_write_register(0x01A3,0x041B); sensor_write_register(0x01A4,0x0429); sensor_write_register(0x01A5,0x041B); sensor_write_register(0x01A6,0x0000); sensor_write_register(0x01A7,0x041C); sensor_write_register(0x01A8,0x0001); sensor_write_register(0x01A9,0x0009); sensor_write_register(0x01AA,0x0008); sensor_write_register(0x01AB,0x0009); sensor_write_register(0x01AC,0x0000); sensor_write_register(0x01AD,0x041B); sensor_write_register(0x01AE,0x0000); sensor_write_register(0x01AF,0x0000); sensor_write_register(0x01B0,0x0000); sensor_write_register(0x01B1,0x041C); sensor_write_register(0x01B2,0x0000); sensor_write_register(0x01B3,0x0000); sensor_write_register(0x01C0,0x0010); sensor_write_register(0x01C1,0x0417); sensor_write_register(0x01C2,0x0010); sensor_write_register(0x01C3,0x0417); sensor_write_register(0x01C4,0x0000); sensor_write_register(0x01C5,0x0000); sensor_write_register(0x01C6,0x0000); sensor_write_register(0x01C7,0x0000); sensor_write_register(0x01C8,0x000F); sensor_write_register(0x01D0,0x0000); sensor_write_register(0x01D1,0x0000); sensor_write_register(0x01D2,0x0000); sensor_write_register(0x01D3,0x0000); sensor_write_register(0x01E0,0x000A); sensor_write_register(0x01E1,0x0023); sensor_write_register(0x01E2,0x0023); sensor_write_register(0x01E3,0x0023); sensor_write_register(0x01E4,0x0026); sensor_write_register(0x01E5,0x0026); sensor_write_register(0x01E6,0x0026); sensor_write_register(0x01E7,0x004A); sensor_write_register(0x01E8,0x008C); sensor_write_register(0x01E9,0x008C); sensor_write_register(0x01EA,0x008C); sensor_write_register(0x01EB,0x0087); sensor_write_register(0x01EC,0x00CF); sensor_write_register(0x01ED,0x00D8); sensor_write_register(0x01EE,0x0116); sensor_write_register(0x01EF,0x0324); sensor_write_register(0x01F0,0x0003); sensor_write_register(0x01F1,0x001F); sensor_write_register(0x01F2,0x00B3); sensor_write_register(0x01F3,0x01BC); sensor_write_register(0x0200,0x0697); sensor_write_register(0x0201,0x0697); sensor_write_register(0x0202,0x0697); sensor_write_register(0x0203,0x01A5); sensor_write_register(0x0204,0x0000); sensor_write_register(0x0205,0x0000); sensor_write_register(0x0206,0x0000); sensor_write_register(0x0207,0x0000); sensor_write_register(0x0208,0x0008); sensor_write_register(0x0209,0x0009); sensor_write_register(0x020A,0x0696); sensor_write_register(0x020B,0x0008); sensor_write_register(0x020C,0x0000); sensor_write_register(0x020D,0x0008); sensor_write_register(0x020E,0x0009); sensor_write_register(0x020F,0x0696); sensor_write_register(0x0210,0x0000); sensor_write_register(0x0211,0x0003); sensor_write_register(0x0212,0x0009); sensor_write_register(0x0213,0x0696); sensor_write_register(0x0214,0x033E); sensor_write_register(0x0215,0x0341); sensor_write_register(0x0216,0x034F); sensor_write_register(0x0217,0x05EF); sensor_write_register(0x0218,0x0000); sensor_write_register(0x0219,0x0005); sensor_write_register(0x021A,0x001F); sensor_write_register(0x021B,0x0000); sensor_write_register(0x021C,0x0005); sensor_write_register(0x021D,0x0013); sensor_write_register(0x021E,0x001D); sensor_write_register(0x021F,0x001F); sensor_write_register(0x0220,0x0000); sensor_write_register(0x0221,0x0007); sensor_write_register(0x0222,0x0006); sensor_write_register(0x0223,0x0000); sensor_write_register(0x0224,0x034F); sensor_write_register(0x0225,0x05F9); sensor_write_register(0x0226,0x0002); sensor_write_register(0x0227,0x068F); sensor_write_register(0x0230,0x0000); sensor_write_register(0x0231,0x0000); sensor_write_register(0x0232,0x0000); sensor_write_register(0x0233,0x0000); sensor_write_register(0x0234,0x0000); sensor_write_register(0x0235,0x0605); sensor_write_register(0x0236,0x0351); sensor_write_register(0x0237,0x0000); sensor_write_register(0x0238,0x0000); sensor_write_register(0x0239,0x0000); sensor_write_register(0x023A,0x0000); sensor_write_register(0x0240,0x0009); sensor_write_register(0x0241,0x00D0); sensor_write_register(0x0242,0x0007); sensor_write_register(0x0243,0x031D); sensor_write_register(0x0244,0x0008); sensor_write_register(0x0245,0x00CF); sensor_write_register(0x0246,0x0006); sensor_write_register(0x0247,0x031C); sensor_write_register(0x0248,0x0000); sensor_write_register(0x0249,0x0000); sensor_write_register(0x024A,0x0008); sensor_write_register(0x024B,0x0006); sensor_write_register(0x024C,0x0000); sensor_write_register(0x024D,0x0002); sensor_write_register(0x024E,0x0002); sensor_write_register(0x024F,0x0007); sensor_write_register(0x0250,0x0008); sensor_write_register(0x0251,0x0006); sensor_write_register(0x0252,0x0009); sensor_write_register(0x0260,0x0001); sensor_write_register(0x0261,0x0004); sensor_write_register(0x0262,0x01A5); sensor_write_register(0x0263,0x0001); sensor_write_register(0x0264,0x0007); sensor_write_register(0x0265,0x0017); sensor_write_register(0x0266,0x001F); sensor_write_register(0x0267,0x0163); sensor_write_register(0x0268,0x0003); sensor_write_register(0x0269,0x0004); sensor_write_register(0x026A,0x0000); sensor_write_register(0x026B,0x0000); sensor_write_register(0x0270,0x0335); sensor_write_register(0x0271,0x0343); sensor_write_register(0x0272,0x0000); sensor_write_register(0x0273,0x0000); sensor_write_register(0x0274,0x0000); sensor_write_register(0x0275,0x0000); sensor_write_register(0x0276,0x0000); sensor_write_register(0x0277,0x0000); sensor_write_register(0x0278,0x0000); sensor_write_register(0x0279,0x0000); sensor_write_register(0x027C,0x0000); sensor_write_register(0x027D,0x0000); sensor_write_register(0x027E,0x0000); sensor_write_register(0x027F,0x0000); sensor_write_register(0x0290,0x0007); sensor_write_register(0x0291,0x0181); sensor_write_register(0x0292,0x0013); sensor_write_register(0x0293,0x0015); sensor_write_register(0x0294,0x0016); sensor_write_register(0x0295,0x0017); sensor_write_register(0x0296,0x001B); sensor_write_register(0x0297,0x0174); sensor_write_register(0x0298,0x0000); sensor_write_register(0x0299,0x0174); sensor_write_register(0x029A,0x001B); sensor_write_register(0x029B,0x0174); sensor_write_register(0x02A0,0x0429); sensor_write_register(0x02A1,0x0000); sensor_write_register(0x02A2,0x0429); sensor_write_register(0x02A3,0x041B); sensor_write_register(0x02A4,0x0429); sensor_write_register(0x02A5,0x041B); sensor_write_register(0x02A6,0x0000); sensor_write_register(0x02A7,0x041C); sensor_write_register(0x02A8,0x0001); sensor_write_register(0x02A9,0x0009); sensor_write_register(0x02AA,0x0008); sensor_write_register(0x02AB,0x0009); sensor_write_register(0x02AC,0x0000); sensor_write_register(0x02AD,0x041B); sensor_write_register(0x02AE,0x0000); sensor_write_register(0x02AF,0x0000); sensor_write_register(0x02B0,0x0000); sensor_write_register(0x02B1,0x041C); sensor_write_register(0x02B2,0x0000); sensor_write_register(0x02B3,0x0000); sensor_write_register(0x02C0,0x0010); sensor_write_register(0x02C1,0x0417); sensor_write_register(0x02C2,0x0010); sensor_write_register(0x02C3,0x0417); sensor_write_register(0x02C4,0x0000); sensor_write_register(0x02C5,0x0000); sensor_write_register(0x02C6,0x0000); sensor_write_register(0x02C7,0x0000); sensor_write_register(0x02C8,0x000F); sensor_write_register(0x02D0,0x0000); sensor_write_register(0x02D1,0x0000); sensor_write_register(0x02D2,0x0000); sensor_write_register(0x02D3,0x0000); sensor_write_register(0x02E0,0x000A); sensor_write_register(0x02E1,0x0023); sensor_write_register(0x02E2,0x0023); sensor_write_register(0x02E3,0x0023); sensor_write_register(0x02E4,0x0026); sensor_write_register(0x02E5,0x0026); sensor_write_register(0x02E6,0x0026); sensor_write_register(0x02E7,0x004A); sensor_write_register(0x02E8,0x008C); sensor_write_register(0x02E9,0x008C); sensor_write_register(0x02EA,0x008C); sensor_write_register(0x02EB,0x0087); sensor_write_register(0x02EC,0x00CF); sensor_write_register(0x02ED,0x00D8); sensor_write_register(0x02EE,0x0116); sensor_write_register(0x02EF,0x0324); sensor_write_register(0x02F0,0x0003); sensor_write_register(0x02F1,0x001F); sensor_write_register(0x02F2,0x00B3); sensor_write_register(0x02F3,0x01BC); sensor_write_register(0x0020,0x0080); sensor_write_register(0x0021,0x0000); sensor_write_register(0x0022,0x0000); sensor_write_register(0x0023,0x000F); sensor_write_register(0x0024,0x0000); sensor_write_register(0x0025,0x0000); sensor_write_register(0x0026,0x0000); sensor_write_register(0x0027,0x0000); sensor_write_register(0x0028,0x0008); sensor_write_register(0x0029,0x0000); sensor_write_register(0x0030,0x5420); sensor_write_register(0x0031,0x111A); sensor_write_register(0x0032,0x0460); sensor_write_register(0x0033,0x0000); sensor_write_register(0x0034,0x0000); sensor_write_register(0x0035,0x20E0); sensor_write_register(0x0036,0x0400); sensor_write_register(0x0037,0x0000); sensor_write_register(0x003E,0x014E); sensor_write_register(0x003F,0x0000); sensor_write_register(0x0040,0x0000); sensor_write_register(0x0041,0x0200); sensor_write_register(0x0042,0x0100); sensor_write_register(0x0043,0x7057); sensor_write_register(0x0046,0x0000); sensor_write_register(0x004C,0x0000); sensor_write_register(0x004E,0x0FFF); sensor_write_register(0x004F,0x0000); sensor_write_register(0x0050,0x0FFE); sensor_write_register(0x0057,0x0010); sensor_write_register(0x005C,0x0038); sensor_write_register(0x0060,0x0000); sensor_write_register(0x0061,0x0200); sensor_write_register(0x0062,0x0100); sensor_write_register(0x0063,0x7057); sensor_write_register(0x0066,0x0000); sensor_write_register(0x006C,0x0000); sensor_write_register(0x006D,0x0000); sensor_write_register(0x006E,0x0FFF); sensor_write_register(0x006F,0x0000); sensor_write_register(0x0070,0x0FFE); sensor_write_register(0x0077,0x0010); sensor_write_register(0x007C,0x0038); sensor_write_register(0x0080,0x000C); sensor_write_register(0x0081,0xFFFF); sensor_write_register(0x0082,0x0000); sensor_write_register(0x0083,0x0000); sensor_write_register(0x0084,0x0000); sensor_write_register(0x0085,0x0004); sensor_write_register(0x0086,0x1032); sensor_write_register(0x0087,0x0000); sensor_write_register(0x0088,0x0001); sensor_write_register(0x0089,0x0000); sensor_write_register(0x0090,0x0012); sensor_write_register(0x0091,0x0013); sensor_write_register(0x0092,0x0010); sensor_write_register(0x0093,0x0011); sensor_write_register(0x0094,0x0016); sensor_write_register(0x0095,0x0017); sensor_write_register(0x0096,0x0014); sensor_write_register(0x0097,0x0015); sensor_write_register(0x0098,0x0002); sensor_write_register(0x0099,0x0003); sensor_write_register(0x009A,0x0000); sensor_write_register(0x009B,0x0001); sensor_write_register(0x009C,0x0006); sensor_write_register(0x009D,0x0007); sensor_write_register(0x009E,0x0004); sensor_write_register(0x009F,0x0005); sensor_write_register(0x00A0,0x0000); sensor_write_register(0x00A1,0x0000); sensor_write_register(0x00A2,0x0000); sensor_write_register(0x00A3,0x0000); sensor_write_register(0x00A4,0x0000); sensor_write_register(0x00A9,0x0000); sensor_write_register(0x00C0,0x1155); sensor_write_register(0x00C1,0xC5D5); sensor_write_register(0x00C2,0x93D5); sensor_write_register(0x00C3,0x01FC); sensor_write_register(0x00C4,0xF041); sensor_write_register(0x00C5,0x7FC4); sensor_write_register(0x00C6,0x0F54); sensor_write_register(0x00C7,0x0051); sensor_write_register(0x00C8,0x1541); sensor_write_register(0x00C9,0x0200); sensor_write_register(0x00CA,0x0100); sensor_write_register(0x00CB,0x0000); sensor_write_register(0x00CC,0x0000); sensor_write_register(0x00CE,0x0000); sensor_write_register(0x00D0,0x0000); sensor_write_register(0x00D1,0x041B); sensor_write_register(0x00D2,0x0000); sensor_write_register(0x00D3,0x041B); sensor_write_register(0x0000,0x0113); sensor_write_register(0x0003,0x8260); printf("-------sensor MN34031 initial ok!----\n"); }

19,446

C

.c

476

35.07563

82

0.730357

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,070

pana34041_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/pana34041/pana34041_sensor_ctl.c

#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "hi_ssp.h" int pana_sensor_write_packet(unsigned int data) { int fd = -1; int ret; unsigned int value; fd = open("/dev/ssp", 0); if(fd<0) { printf("Open /dev/ssp error!\n"); return -1; } value = data; ret = ioctl(fd, SSP_WRITE_ALT, &value); //printf("ssp_write %#x, %#x\n", addr, value); close(fd); return 0; } int sensor_write_register(int addr, int data) { return pana_sensor_write_packet((unsigned int)((addr<<16) | (data & 0xFFFF))); } static void delay_ms(int ms) { } void sensor_prog(int* rom) { int i = 0; while (1) { int lookup = rom[i++]; int addr = (lookup >> 16) & 0xFFFF; int data = lookup & 0xFFFF; if (addr == 0xFFFE) { delay_ms(data); } else if (addr == 0xFFFF) { return; } else { sensor_write_register(addr, data); } } } void sensor_init() { //for PLL system register,only writing sensor_write_register(0x0001,0x001B); sensor_write_register(0x0002,0x0002); sensor_write_register(0x0004,0x01c2); sensor_write_register(0x0000,0x0003); sensor_write_register(0x0003,0x0209); sensor_write_register(0x0006,0x442a); sensor_write_register(0x0005,0xC000); //wait for PLL stable usleep(10); sensor_write_register(0x0000,0x0013); sensor_write_register(0x0036,0x0021); sensor_write_register(0x0037,0x0300); //usleep(10); //printf("-------delay 30ms for TG--------\n"); sensor_write_register(0x0020,0x0080); sensor_write_register(0x0021,0x0080); sensor_write_register(0x0022,0x0000); sensor_write_register(0x0023,0x0000); sensor_write_register(0x0024,0x0010); sensor_write_register(0x0025,0x0011); sensor_write_register(0x0026,0x0012); sensor_write_register(0x0027,0x0013); sensor_write_register(0x0028,0x0000); sensor_write_register(0x0030,0x0424); sensor_write_register(0x0031,0x110A); sensor_write_register(0x0032,0x7450); sensor_write_register(0x0033,0x0000); //usleep(15); sensor_write_register(0x0034,0x0000); sensor_write_register(0x0035,0x0281); //usleep(15); sensor_write_register(0x0038,0x0001); sensor_write_register(0x0039,0x0210); sensor_write_register(0x003a,0x0333); sensor_write_register(0x003b,0x0111); sensor_write_register(0x003f,0x0000); sensor_write_register(0x0040,0x0004); sensor_write_register(0x0041,0x0200); sensor_write_register(0x0042,0x0100); sensor_write_register(0x0043,0x0070); sensor_write_register(0x0044,0x0000); sensor_write_register(0x0045,0x0000); sensor_write_register(0x0046,0x0000); sensor_write_register(0x0047,0x0010); sensor_write_register(0x0048,0x0000); sensor_write_register(0x0049,0x0002); sensor_write_register(0x004a,0x0ffe); sensor_write_register(0x004b,0x0004); sensor_write_register(0x0056,0x0000); sensor_write_register(0x0057,0x1fff); sensor_write_register(0x0058,0x2000); sensor_write_register(0x0059,0x0000); sensor_write_register(0x005a,0x0011); sensor_write_register(0x0070,0x2084); sensor_write_register(0x0071,0xffff); sensor_write_register(0x0072,0x0000); sensor_write_register(0x0073,0x0000); sensor_write_register(0x0074,0x0000); sensor_write_register(0x0075,0x0004); sensor_write_register(0x0076,0x0230); sensor_write_register(0x0077,0x0541); sensor_write_register(0x0078,0x0001); sensor_write_register(0x0079,0x0011); sensor_write_register(0x0080,0x0002); sensor_write_register(0x0081,0x0003); sensor_write_register(0x0082,0x0000); sensor_write_register(0x0083,0x0001); sensor_write_register(0x0084,0x0012); sensor_write_register(0x0085,0x0013); sensor_write_register(0x0086,0x0010); sensor_write_register(0x0087,0x0011); sensor_write_register(0x0088,0x000a); sensor_write_register(0x0089,0x000b); sensor_write_register(0x008a,0x0008); sensor_write_register(0x008b,0x0009); sensor_write_register(0x008c,0x0006); sensor_write_register(0x008d,0x0007); sensor_write_register(0x008e,0x0004); sensor_write_register(0x008f,0x0005); sensor_write_register(0x0090,0x0016); sensor_write_register(0x0091,0x0017); sensor_write_register(0x0092,0x0014); sensor_write_register(0x0093,0x0015); sensor_write_register(0x0094,0x001a); sensor_write_register(0x0095,0x001b); sensor_write_register(0x0096,0x0018); sensor_write_register(0x0097,0x0019); sensor_write_register(0x00a0,0x3000); sensor_write_register(0x00a1,0x0000); sensor_write_register(0x00a2,0x0002); sensor_write_register(0x00a3,0x0000); sensor_write_register(0x00a4,0x0000); sensor_write_register(0x00a5,0x0000); sensor_write_register(0x00a6,0x0000); sensor_write_register(0x00a7,0x0000); sensor_write_register(0x00a8,0x000f); sensor_write_register(0x00a9,0x0022); sensor_write_register(0x00c0,0x5540); sensor_write_register(0x00c1,0x5fd5); sensor_write_register(0x00c2,0xf757); sensor_write_register(0x00c3,0xdf5f); sensor_write_register(0x00c4,0x208a); sensor_write_register(0x00c5,0x0071); sensor_write_register(0x00c6,0x0557); sensor_write_register(0x00c7,0x0000); sensor_write_register(0x00ca,0x0080); sensor_write_register(0x00cb,0x0000); sensor_write_register(0x00cc,0x0000); sensor_write_register(0x00cd,0x0000); sensor_write_register(0x00ce,0x0000); sensor_write_register(0x0100,0x03a8); sensor_write_register(0x0101,0x03a8); sensor_write_register(0x0102,0x02c0); sensor_write_register(0x0103,0x037a); sensor_write_register(0x0104,0x002b); sensor_write_register(0x0105,0x00de); sensor_write_register(0x0106,0x00fa); sensor_write_register(0x0170,0x0002); sensor_write_register(0x0171,0x000d); sensor_write_register(0x0172,0x0007); sensor_write_register(0x0173,0x0004); sensor_write_register(0x0174,0x002a); sensor_write_register(0x0175,0x0062); sensor_write_register(0x0176,0x0079); sensor_write_register(0x0177,0x0326); sensor_write_register(0x0178,0x0003); sensor_write_register(0x0179,0x0033); sensor_write_register(0x017a,0x0360); sensor_write_register(0x017b,0x0002); sensor_write_register(0x017c,0x000d); sensor_write_register(0x0190,0x0000); sensor_write_register(0x0191,0x0000); sensor_write_register(0x0192,0x0000); sensor_write_register(0x0193,0x0000); sensor_write_register(0x0194,0x0000); sensor_write_register(0x0195,0x0000); sensor_write_register(0x0196,0x0000); sensor_write_register(0x0197,0x01ba); sensor_write_register(0x0198,0xb060); sensor_write_register(0x0199,0x7c0a); sensor_write_register(0x019a,0x0000); sensor_write_register(0x019b,0x0313); sensor_write_register(0x019c,0x0b08); sensor_write_register(0x019d,0x3906); sensor_write_register(0x019e,0x0000); sensor_write_register(0x01a0,0x0464); sensor_write_register(0x01a1,0x0000); sensor_write_register(0x01a2,0x0000); sensor_write_register(0x01a3,0x0464); sensor_write_register(0x01a4,0x0000); sensor_write_register(0x01a5,0x0453); sensor_write_register(0x01a6,0x0000); sensor_write_register(0x01a7,0x0464); sensor_write_register(0x01a8,0x0000); sensor_write_register(0x01a9,0x0454); sensor_write_register(0x01aa,0x0000); sensor_write_register(0x01ab,0x0000); sensor_write_register(0x01ac,0x0000); sensor_write_register(0x01ad,0x0454); sensor_write_register(0x01ae,0x0000); sensor_write_register(0x01af,0x0000); sensor_write_register(0x01b0,0x0000); sensor_write_register(0x01b1,0x0454); sensor_write_register(0x01b2,0x0000); sensor_write_register(0x01b3,0x0000); sensor_write_register(0x01b4,0x0000); sensor_write_register(0x01b5,0x0454); sensor_write_register(0x01b6,0x0000); sensor_write_register(0x01b7,0x0000); sensor_write_register(0x01b8,0x0000); sensor_write_register(0x01b9,0x0453); sensor_write_register(0x01ba,0x0000); sensor_write_register(0x01bb,0x0000); sensor_write_register(0x01bc,0x0000); sensor_write_register(0x01bd,0x0453); sensor_write_register(0x01be,0x0000); sensor_write_register(0x01c4,0x0000); sensor_write_register(0x01c5,0x0000); sensor_write_register(0x01c6,0x0011); sensor_write_register(0x0200,0x03a8); sensor_write_register(0x0201,0x03a8); sensor_write_register(0x0202,0x02c0); sensor_write_register(0x0203,0x037a); sensor_write_register(0x0204,0x002b); sensor_write_register(0x0205,0x00de); sensor_write_register(0x0206,0x00fa); sensor_write_register(0x0270,0x0002); sensor_write_register(0x0271,0x000d); sensor_write_register(0x0272,0x0007); sensor_write_register(0x0273,0x0004); sensor_write_register(0x0274,0x002a); sensor_write_register(0x0275,0x0062); sensor_write_register(0x0276,0x0079); sensor_write_register(0x0277,0x0326); sensor_write_register(0x0278,0x0003); sensor_write_register(0x0279,0x0033); sensor_write_register(0x027a,0x0360); sensor_write_register(0x027b,0x0002); sensor_write_register(0x027c,0x000d); sensor_write_register(0x0290,0x0000); sensor_write_register(0x0291,0x0000); sensor_write_register(0x0292,0x0000); sensor_write_register(0x0293,0x0000); sensor_write_register(0x0294,0x0000); sensor_write_register(0x0295,0x0000); sensor_write_register(0x0296,0x0000); sensor_write_register(0x0297,0x01ba); sensor_write_register(0x0298,0xb060); sensor_write_register(0x0299,0x7c0a); sensor_write_register(0x029a,0x0000); sensor_write_register(0x029b,0x0313); sensor_write_register(0x029c,0x0b08); sensor_write_register(0x029d,0x3906); sensor_write_register(0x029e,0x0000); sensor_write_register(0x02a0,0x0464); sensor_write_register(0x02a1,0x0000); sensor_write_register(0x02a2,0x0000); sensor_write_register(0x02a3,0x0464); sensor_write_register(0x02a4,0x0000); sensor_write_register(0x02a5,0x0453); sensor_write_register(0x02a6,0x0000); sensor_write_register(0x02a7,0x0464); sensor_write_register(0x02a8,0x0000); sensor_write_register(0x02a9,0x0454); sensor_write_register(0x02aa,0x0000); sensor_write_register(0x02ab,0x0000); sensor_write_register(0x02ac,0x0000); sensor_write_register(0x02ad,0x0454); sensor_write_register(0x02ae,0x0000); sensor_write_register(0x02af,0x0000); sensor_write_register(0x02b0,0x0000); sensor_write_register(0x02b1,0x0454); sensor_write_register(0x02b2,0x0000); sensor_write_register(0x02b3,0x0000); sensor_write_register(0x02b4,0x0000); sensor_write_register(0x02b5,0x0454); sensor_write_register(0x02b6,0x0000); sensor_write_register(0x02b7,0x0000); sensor_write_register(0x02b8,0x0000); sensor_write_register(0x02b9,0x0453); sensor_write_register(0x02ba,0x0000); sensor_write_register(0x02bb,0x0000); sensor_write_register(0x02bc,0x0000); sensor_write_register(0x02bd,0x0453); sensor_write_register(0x02be,0x0000); sensor_write_register(0x02c4,0x0000); sensor_write_register(0x02c5,0x0000); sensor_write_register(0x02c6,0x0011); sensor_write_register(0x0108,0x0000); sensor_write_register(0x0109,0x000f); sensor_write_register(0x010a,0x0009); sensor_write_register(0x010b,0x0000); sensor_write_register(0x010c,0x0016); sensor_write_register(0x010d,0x0000); sensor_write_register(0x010e,0x000f); sensor_write_register(0x010f,0x0000); sensor_write_register(0x0110,0x0009); sensor_write_register(0x0111,0x0000); sensor_write_register(0x0112,0x0016); sensor_write_register(0x0113,0x0003); sensor_write_register(0x0114,0x000a); sensor_write_register(0x0115,0x0000); sensor_write_register(0x0116,0x0009); sensor_write_register(0x0117,0x0000); sensor_write_register(0x0118,0x0016); sensor_write_register(0x0119,0x0018); sensor_write_register(0x011a,0x0017); sensor_write_register(0x011b,0x0000); sensor_write_register(0x011c,0x0002); sensor_write_register(0x011d,0x0009); sensor_write_register(0x011e,0x0012); sensor_write_register(0x011f,0x0001); sensor_write_register(0x0120,0x003a); sensor_write_register(0x0121,0x0000); sensor_write_register(0x0122,0x0000); sensor_write_register(0x0123,0x0000); sensor_write_register(0x0124,0x0011); sensor_write_register(0x0125,0x0000); sensor_write_register(0x0126,0x0003); sensor_write_register(0x0127,0x0003); sensor_write_register(0x0128,0x0000); sensor_write_register(0x0129,0x0010); sensor_write_register(0x012a,0x0000); sensor_write_register(0x012b,0x0003); sensor_write_register(0x012c,0x0000); sensor_write_register(0x012d,0x0011); sensor_write_register(0x012e,0x0000); sensor_write_register(0x012f,0x0009); sensor_write_register(0x0130,0x0009); sensor_write_register(0x0131,0x0012); sensor_write_register(0x0132,0x0000); sensor_write_register(0x0133,0x0000); sensor_write_register(0x0134,0x0009); sensor_write_register(0x0135,0x0009); sensor_write_register(0x0136,0x0012); sensor_write_register(0x0137,0x0006); sensor_write_register(0x0138,0x0000); sensor_write_register(0x0139,0x0010); sensor_write_register(0x013a,0x0000); sensor_write_register(0x0140,0x0020); sensor_write_register(0x0141,0x0036); sensor_write_register(0x0142,0x0000); sensor_write_register(0x0143,0x0001); sensor_write_register(0x0144,0x0003); sensor_write_register(0x0145,0x0000); sensor_write_register(0x0146,0x0000); sensor_write_register(0x0150,0x0011); sensor_write_register(0x0151,0x0001); sensor_write_register(0x0152,0x0001); sensor_write_register(0x0153,0x0001); sensor_write_register(0x0154,0x0010); sensor_write_register(0x0155,0x0000); sensor_write_register(0x0156,0x0003); sensor_write_register(0x0157,0x0000); sensor_write_register(0x0158,0x0013); sensor_write_register(0x0159,0x0000); sensor_write_register(0x015a,0x0000); sensor_write_register(0x015b,0x0008); sensor_write_register(0x015c,0x0000); sensor_write_register(0x015d,0x0004); sensor_write_register(0x015e,0x0005); sensor_write_register(0x015f,0x000a); sensor_write_register(0x0160,0x0006); sensor_write_register(0x0161,0x000f); sensor_write_register(0x0162,0x000d); sensor_write_register(0x0163,0x0004); sensor_write_register(0x0164,0x0002); sensor_write_register(0x0165,0x0002); sensor_write_register(0x0166,0x0000); sensor_write_register(0x0167,0x0010); sensor_write_register(0x0168,0x0009); sensor_write_register(0x0169,0x0003); sensor_write_register(0x016a,0x0000); sensor_write_register(0x016b,0x0000); sensor_write_register(0x0180,0x0017); sensor_write_register(0x0181,0x00c5); sensor_write_register(0x0182,0x0000); sensor_write_register(0x0183,0x0000); sensor_write_register(0x0184,0x00fa); sensor_write_register(0x0185,0x00a5); sensor_write_register(0x0186,0x01ef); sensor_write_register(0x0187,0x03d9); sensor_write_register(0x0188,0x01fb); sensor_write_register(0x0189,0x035f); sensor_write_register(0x018a,0x0000); sensor_write_register(0x018b,0x0000); sensor_write_register(0x018c,0x0000); sensor_write_register(0x018d,0x0000); sensor_write_register(0x01d0,0x0000); sensor_write_register(0x01d1,0x0000); sensor_write_register(0x01d2,0x0000); sensor_write_register(0x01d3,0x0000); sensor_write_register(0x01d4,0x0000); sensor_write_register(0x01d5,0x0000); sensor_write_register(0x01d6,0x0000); sensor_write_register(0x01d7,0x0000); sensor_write_register(0x01d8,0x0006); sensor_write_register(0x01d9,0x0005); sensor_write_register(0x01da,0x0001); sensor_write_register(0x01db,0x0006); sensor_write_register(0x01dc,0x0001); sensor_write_register(0x01dd,0x0007); sensor_write_register(0x01de,0x0001); sensor_write_register(0x01df,0x0002); sensor_write_register(0x01e0,0x0001); sensor_write_register(0x01e1,0x0001); sensor_write_register(0x01e2,0x00c9); sensor_write_register(0x01e3,0x8000); sensor_write_register(0x01e4,0x003e); sensor_write_register(0x01e5,0x0015); sensor_write_register(0x01e6,0x003e); sensor_write_register(0x01e7,0x00c8); sensor_write_register(0x01e8,0x0043); sensor_write_register(0x01e9,0x00a9); sensor_write_register(0x01ea,0x00a9); sensor_write_register(0x01eb,0x00a9); sensor_write_register(0x01ec,0x00fb); sensor_write_register(0x01ed,0x00b0); sensor_write_register(0x01ee,0x00b9); sensor_write_register(0x01ef,0x01bb); sensor_write_register(0x01f0,0x02ec); sensor_write_register(0x01f1,0x02ec); sensor_write_register(0x01f2,0x02ec); sensor_write_register(0x01f3,0x01bd); sensor_write_register(0x01f4,0x034a); sensor_write_register(0x01f5,0x03d8); sensor_write_register(0x01f6,0x03fc); //usleep(15000); //printf("-------delay 30ms for TG--------\n"); sensor_write_register(0x0000,0x0113); //printf("-------sensor MN34041 initial ok!----\n"); } void sensor_init_exit(int fps) { //for PLL system register,only writing sensor_write_register(0x0001,0x001B); sensor_write_register(0x0002,0x0002); sensor_write_register(0x0004,0x01c2); sensor_write_register(0x0000,0x0003); sensor_write_register(0x0003,0x0209); sensor_write_register(0x0006,0x442a); sensor_write_register(0x0005,0xC000); //wait for PLL stable usleep(10); sensor_write_register(0x0000,0x0013); sensor_write_register(0x0036,0x0021); sensor_write_register(0x0037,0x0300); //usleep(10); //printf("-------delay 30ms for TG--------\n"); sensor_write_register(0x0020,0x0080); sensor_write_register(0x0021,0x0080); sensor_write_register(0x0022,0x0000); sensor_write_register(0x0023,0x0000); sensor_write_register(0x0024,0x0010); sensor_write_register(0x0025,0x0011); sensor_write_register(0x0026,0x0012); sensor_write_register(0x0027,0x0013); sensor_write_register(0x0028,0x0000); sensor_write_register(0x0030,0x0424); sensor_write_register(0x0031,0x110A); sensor_write_register(0x0032,0x7450); sensor_write_register(0x0033,0x0000); //usleep(15); sensor_write_register(0x0034,0x0000); sensor_write_register(0x0035,0x0281); //usleep(15); sensor_write_register(0x0038,0x0001); sensor_write_register(0x0039,0x0210); sensor_write_register(0x003a,0x0333); sensor_write_register(0x003b,0x0111); sensor_write_register(0x003f,0x0000); sensor_write_register(0x0040,0x0004); sensor_write_register(0x0041,0x0200); sensor_write_register(0x0042,0x0100); sensor_write_register(0x0043,0x0070); sensor_write_register(0x0044,0x0000); sensor_write_register(0x0045,0x0000); sensor_write_register(0x0046,0x0000); sensor_write_register(0x0047,0x0010); sensor_write_register(0x0048,0x0000); sensor_write_register(0x0049,0x0002); sensor_write_register(0x004a,0x0ffe); sensor_write_register(0x004b,0x0004); sensor_write_register(0x0056,0x0000); sensor_write_register(0x0057,0x1fff); sensor_write_register(0x0058,0x2000); sensor_write_register(0x0059,0x0000); sensor_write_register(0x005a,0x0011); sensor_write_register(0x0070,0x2084); sensor_write_register(0x0071,0xffff); sensor_write_register(0x0072,0x0000); sensor_write_register(0x0073,0x0000); sensor_write_register(0x0074,0x0000); sensor_write_register(0x0075,0x0004); sensor_write_register(0x0076,0x0230); sensor_write_register(0x0077,0x0541); sensor_write_register(0x0078,0x0001); sensor_write_register(0x0079,0x0011); sensor_write_register(0x0080,0x0002); sensor_write_register(0x0081,0x0003); sensor_write_register(0x0082,0x0000); sensor_write_register(0x0083,0x0001); sensor_write_register(0x0084,0x0012); sensor_write_register(0x0085,0x0013); sensor_write_register(0x0086,0x0010); sensor_write_register(0x0087,0x0011); sensor_write_register(0x0088,0x000a); sensor_write_register(0x0089,0x000b); sensor_write_register(0x008a,0x0008); sensor_write_register(0x008b,0x0009); sensor_write_register(0x008c,0x0006); sensor_write_register(0x008d,0x0007); sensor_write_register(0x008e,0x0004); sensor_write_register(0x008f,0x0005); sensor_write_register(0x0090,0x0016); sensor_write_register(0x0091,0x0017); sensor_write_register(0x0092,0x0014); sensor_write_register(0x0093,0x0015); sensor_write_register(0x0094,0x001a); sensor_write_register(0x0095,0x001b); sensor_write_register(0x0096,0x0018); sensor_write_register(0x0097,0x0019); sensor_write_register(0x00a0,0x3000); sensor_write_register(0x00a1,0x0000); sensor_write_register(0x00a2,0x0002); sensor_write_register(0x00a3,0x0000); sensor_write_register(0x00a4,0x0000); sensor_write_register(0x00a5,0x0000); sensor_write_register(0x00a6,0x0000); sensor_write_register(0x00a7,0x0000); sensor_write_register(0x00a8,0x000f); sensor_write_register(0x00a9,0x0022); sensor_write_register(0x00c0,0x5540); sensor_write_register(0x00c1,0x5fd5); sensor_write_register(0x00c2,0xf757); sensor_write_register(0x00c3,0xdf5f); sensor_write_register(0x00c4,0x208a); sensor_write_register(0x00c5,0x0071); sensor_write_register(0x00c6,0x0557); sensor_write_register(0x00c7,0x0000); sensor_write_register(0x00ca,0x0080); sensor_write_register(0x00cb,0x0000); sensor_write_register(0x00cc,0x0000); sensor_write_register(0x00cd,0x0000); sensor_write_register(0x00ce,0x0000); sensor_write_register(0x0100,0x03a8); sensor_write_register(0x0101,0x03a8); sensor_write_register(0x0102,0x02c0); sensor_write_register(0x0103,0x037a); sensor_write_register(0x0104,0x002b); sensor_write_register(0x0105,0x00de); sensor_write_register(0x0106,0x00fa); sensor_write_register(0x0170,0x0002); sensor_write_register(0x0171,0x000d); sensor_write_register(0x0172,0x0007); sensor_write_register(0x0173,0x0004); sensor_write_register(0x0174,0x002a); sensor_write_register(0x0175,0x0062); sensor_write_register(0x0176,0x0079); sensor_write_register(0x0177,0x0326); sensor_write_register(0x0178,0x0003); sensor_write_register(0x0179,0x0033); sensor_write_register(0x017a,0x0360); sensor_write_register(0x017b,0x0002); sensor_write_register(0x017c,0x000d); sensor_write_register(0x0190,0x0000); sensor_write_register(0x0191,0x0000); sensor_write_register(0x0192,0x0000); sensor_write_register(0x0193,0x0000); sensor_write_register(0x0194,0x0000); sensor_write_register(0x0195,0x0000); sensor_write_register(0x0196,0x0000); sensor_write_register(0x0197,0x01ba); sensor_write_register(0x0198,0xb060); sensor_write_register(0x0199,0x7c0a); sensor_write_register(0x019a,0x0000); sensor_write_register(0x019b,0x0313); sensor_write_register(0x019c,0x0b08); sensor_write_register(0x019d,0x3906); sensor_write_register(0x019e,0x0000); if (30 == fps) { sensor_write_register(0x01a0,0x0464); sensor_write_register(0x01a1,0x0000); sensor_write_register(0x01a2,0x0000); sensor_write_register(0x01a3,0x0464); sensor_write_register(0x01a4,0x0000); sensor_write_register(0x01a5,0x0453); sensor_write_register(0x01a6,0x0000); sensor_write_register(0x01a7,0x0464); sensor_write_register(0x01a8,0x0000); } else if (25 == fps) { sensor_write_register(0x01a0,0x0545); sensor_write_register(0x01a1,0x0000); sensor_write_register(0x01a2,0x0000); sensor_write_register(0x01a3,0x0545); sensor_write_register(0x01a4,0x0000); sensor_write_register(0x01a5,0x0453); sensor_write_register(0x01a6,0x0000); sensor_write_register(0x01a7,0x0545); sensor_write_register(0x01a8,0x0000); } sensor_write_register(0x01a9,0x0454); sensor_write_register(0x01aa,0x0000); sensor_write_register(0x01ab,0x0000); sensor_write_register(0x01ac,0x0000); sensor_write_register(0x01ad,0x0454); sensor_write_register(0x01ae,0x0000); sensor_write_register(0x01af,0x0000); sensor_write_register(0x01b0,0x0000); sensor_write_register(0x01b1,0x0454); sensor_write_register(0x01b2,0x0000); sensor_write_register(0x01b3,0x0000); sensor_write_register(0x01b4,0x0000); sensor_write_register(0x01b5,0x0454); sensor_write_register(0x01b6,0x0000); sensor_write_register(0x01b7,0x0000); sensor_write_register(0x01b8,0x0000); sensor_write_register(0x01b9,0x0453); sensor_write_register(0x01ba,0x0000); sensor_write_register(0x01bb,0x0000); sensor_write_register(0x01bc,0x0000); sensor_write_register(0x01bd,0x0453); sensor_write_register(0x01be,0x0000); sensor_write_register(0x01c4,0x0000); sensor_write_register(0x01c5,0x0000); sensor_write_register(0x01c6,0x0011); sensor_write_register(0x0200,0x03a8); sensor_write_register(0x0201,0x03a8); sensor_write_register(0x0202,0x02c0); sensor_write_register(0x0203,0x037a); sensor_write_register(0x0204,0x002b); sensor_write_register(0x0205,0x00de); sensor_write_register(0x0206,0x00fa); sensor_write_register(0x0270,0x0002); sensor_write_register(0x0271,0x000d); sensor_write_register(0x0272,0x0007); sensor_write_register(0x0273,0x0004); sensor_write_register(0x0274,0x002a); sensor_write_register(0x0275,0x0062); sensor_write_register(0x0276,0x0079); sensor_write_register(0x0277,0x0326); sensor_write_register(0x0278,0x0003); sensor_write_register(0x0279,0x0033); sensor_write_register(0x027a,0x0360); sensor_write_register(0x027b,0x0002); sensor_write_register(0x027c,0x000d); sensor_write_register(0x0290,0x0000); sensor_write_register(0x0291,0x0000); sensor_write_register(0x0292,0x0000); sensor_write_register(0x0293,0x0000); sensor_write_register(0x0294,0x0000); sensor_write_register(0x0295,0x0000); sensor_write_register(0x0296,0x0000); sensor_write_register(0x0297,0x01ba); sensor_write_register(0x0298,0xb060); sensor_write_register(0x0299,0x7c0a); sensor_write_register(0x029a,0x0000); sensor_write_register(0x029b,0x0313); sensor_write_register(0x029c,0x0b08); sensor_write_register(0x029d,0x3906); sensor_write_register(0x029e,0x0000); if (30 == fps) { sensor_write_register(0x02a0,0x0464); sensor_write_register(0x02a1,0x0000); sensor_write_register(0x02a2,0x0000); sensor_write_register(0x02a3,0x0464); sensor_write_register(0x02a4,0x0000); sensor_write_register(0x02a5,0x0453); sensor_write_register(0x02a6,0x0000); sensor_write_register(0x02a7,0x0464); } else if (25 == fps) { sensor_write_register(0x02a0,0x0545); sensor_write_register(0x02a1,0x0000); sensor_write_register(0x02a2,0x0000); sensor_write_register(0x02a3,0x0545); sensor_write_register(0x02a4,0x0000); sensor_write_register(0x02a5,0x0453); sensor_write_register(0x02a6,0x0000); sensor_write_register(0x02a7,0x0545); sensor_write_register(0x02a8,0x0000); } sensor_write_register(0x02a9,0x0454); sensor_write_register(0x02aa,0x0000); sensor_write_register(0x02ab,0x0000); sensor_write_register(0x02ac,0x0000); sensor_write_register(0x02ad,0x0454); sensor_write_register(0x02ae,0x0000); sensor_write_register(0x02af,0x0000); sensor_write_register(0x02b0,0x0000); sensor_write_register(0x02b1,0x0454); sensor_write_register(0x02b2,0x0000); sensor_write_register(0x02b3,0x0000); sensor_write_register(0x02b4,0x0000); sensor_write_register(0x02b5,0x0454); sensor_write_register(0x02b6,0x0000); sensor_write_register(0x02b7,0x0000); sensor_write_register(0x02b8,0x0000); sensor_write_register(0x02b9,0x0453); sensor_write_register(0x02ba,0x0000); sensor_write_register(0x02bb,0x0000); sensor_write_register(0x02bc,0x0000); sensor_write_register(0x02bd,0x0453); sensor_write_register(0x02be,0x0000); sensor_write_register(0x02c4,0x0000); sensor_write_register(0x02c5,0x0000); sensor_write_register(0x02c6,0x0011); sensor_write_register(0x0108,0x0000); sensor_write_register(0x0109,0x000f); sensor_write_register(0x010a,0x0009); sensor_write_register(0x010b,0x0000); sensor_write_register(0x010c,0x0016); sensor_write_register(0x010d,0x0000); sensor_write_register(0x010e,0x000f); sensor_write_register(0x010f,0x0000); sensor_write_register(0x0110,0x0009); sensor_write_register(0x0111,0x0000); sensor_write_register(0x0112,0x0016); sensor_write_register(0x0113,0x0003); sensor_write_register(0x0114,0x000a); sensor_write_register(0x0115,0x0000); sensor_write_register(0x0116,0x0009); sensor_write_register(0x0117,0x0000); sensor_write_register(0x0118,0x0016); sensor_write_register(0x0119,0x0018); sensor_write_register(0x011a,0x0017); sensor_write_register(0x011b,0x0000); sensor_write_register(0x011c,0x0002); sensor_write_register(0x011d,0x0009); sensor_write_register(0x011e,0x0012); sensor_write_register(0x011f,0x0001); sensor_write_register(0x0120,0x003a); sensor_write_register(0x0121,0x0000); sensor_write_register(0x0122,0x0000); sensor_write_register(0x0123,0x0000); sensor_write_register(0x0124,0x0011); sensor_write_register(0x0125,0x0000); sensor_write_register(0x0126,0x0003); sensor_write_register(0x0127,0x0003); sensor_write_register(0x0128,0x0000); sensor_write_register(0x0129,0x0010); sensor_write_register(0x012a,0x0000); sensor_write_register(0x012b,0x0003); sensor_write_register(0x012c,0x0000); sensor_write_register(0x012d,0x0011); sensor_write_register(0x012e,0x0000); sensor_write_register(0x012f,0x0009); sensor_write_register(0x0130,0x0009); sensor_write_register(0x0131,0x0012); sensor_write_register(0x0132,0x0000); sensor_write_register(0x0133,0x0000); sensor_write_register(0x0134,0x0009); sensor_write_register(0x0135,0x0009); sensor_write_register(0x0136,0x0012); sensor_write_register(0x0137,0x0006); sensor_write_register(0x0138,0x0000); sensor_write_register(0x0139,0x0010); sensor_write_register(0x013a,0x0000); sensor_write_register(0x0140,0x0020); sensor_write_register(0x0141,0x0036); sensor_write_register(0x0142,0x0000); sensor_write_register(0x0143,0x0001); sensor_write_register(0x0144,0x0003); sensor_write_register(0x0145,0x0000); sensor_write_register(0x0146,0x0000); sensor_write_register(0x0150,0x0011); sensor_write_register(0x0151,0x0001); sensor_write_register(0x0152,0x0001); sensor_write_register(0x0153,0x0001); sensor_write_register(0x0154,0x0010); sensor_write_register(0x0155,0x0000); sensor_write_register(0x0156,0x0003); sensor_write_register(0x0157,0x0000); sensor_write_register(0x0158,0x0013); sensor_write_register(0x0159,0x0000); sensor_write_register(0x015a,0x0000); sensor_write_register(0x015b,0x0008); sensor_write_register(0x015c,0x0000); sensor_write_register(0x015d,0x0004); sensor_write_register(0x015e,0x0005); sensor_write_register(0x015f,0x000a); sensor_write_register(0x0160,0x0006); sensor_write_register(0x0161,0x000f); sensor_write_register(0x0162,0x000d); sensor_write_register(0x0163,0x0004); sensor_write_register(0x0164,0x0002); sensor_write_register(0x0165,0x0002); sensor_write_register(0x0166,0x0000); sensor_write_register(0x0167,0x0010); sensor_write_register(0x0168,0x0009); sensor_write_register(0x0169,0x0003); sensor_write_register(0x016a,0x0000); sensor_write_register(0x016b,0x0000); sensor_write_register(0x0180,0x0017); sensor_write_register(0x0181,0x00c5); sensor_write_register(0x0182,0x0000); sensor_write_register(0x0183,0x0000); sensor_write_register(0x0184,0x00fa); sensor_write_register(0x0185,0x00a5); sensor_write_register(0x0186,0x01ef); sensor_write_register(0x0187,0x03d9); sensor_write_register(0x0188,0x01fb); sensor_write_register(0x0189,0x035f); sensor_write_register(0x018a,0x0000); sensor_write_register(0x018b,0x0000); sensor_write_register(0x018c,0x0000); sensor_write_register(0x018d,0x0000); sensor_write_register(0x01d0,0x0000); sensor_write_register(0x01d1,0x0000); sensor_write_register(0x01d2,0x0000); sensor_write_register(0x01d3,0x0000); sensor_write_register(0x01d4,0x0000); sensor_write_register(0x01d5,0x0000); sensor_write_register(0x01d6,0x0000); sensor_write_register(0x01d7,0x0000); sensor_write_register(0x01d8,0x0006); sensor_write_register(0x01d9,0x0005); sensor_write_register(0x01da,0x0001); sensor_write_register(0x01db,0x0006); sensor_write_register(0x01dc,0x0001); sensor_write_register(0x01dd,0x0007); sensor_write_register(0x01de,0x0001); sensor_write_register(0x01df,0x0002); sensor_write_register(0x01e0,0x0001); sensor_write_register(0x01e1,0x0001); sensor_write_register(0x01e2,0x00c9); sensor_write_register(0x01e3,0x8000); sensor_write_register(0x01e4,0x003e); sensor_write_register(0x01e5,0x0015); sensor_write_register(0x01e6,0x003e); sensor_write_register(0x01e7,0x00c8); sensor_write_register(0x01e8,0x0043); sensor_write_register(0x01e9,0x00a9); sensor_write_register(0x01ea,0x00a9); sensor_write_register(0x01eb,0x00a9); sensor_write_register(0x01ec,0x00fb); sensor_write_register(0x01ed,0x00b0); sensor_write_register(0x01ee,0x00b9); sensor_write_register(0x01ef,0x01bb); sensor_write_register(0x01f0,0x02ec); sensor_write_register(0x01f1,0x02ec); sensor_write_register(0x01f2,0x02ec); sensor_write_register(0x01f3,0x01bd); sensor_write_register(0x01f4,0x034a); sensor_write_register(0x01f5,0x03d8); sensor_write_register(0x01f6,0x03fc); //usleep(15000); //printf("-------delay 30ms for TG--------\n"); sensor_write_register(0x0000,0x0113); //printf("-------sensor MN34041 initial ok!----\n"); }

32,269

C

.c

864

35.175926

82

0.8025

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,072

ar0330_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/aptina_ar0330/ar0330_sensor_ctl.c

#include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #ifdef HI_GPIO_I2C #include "gpioi2c_ex.h" #include "gpio_i2c.h" #else #include "hi_i2c.h" #endif const unsigned char sensor_i2c_addr = 0x20; /* I2C Address of AR0330 */ const unsigned int sensor_addr_byte = 2; /* ADDR byte of AR0330 */ const unsigned int sensor_data_byte = 2; /* DATA byte of AR0330 */ int sensor_read_register(int addr) { // TODO: return 0; } int sensor_write_register(int addr, int data) { #ifdef HI_GPIO_I2C int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/gpioi2c_ex", 0); if(fd<0) { printf("Open gpioi2c_ex error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, GPIO_I2C_WRITE, &i2c_data); if (ret) { printf("GPIO-I2C write faild!\n"); return -1; } close(fd); #else int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd < 0) { printf("Open i2c device error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_WRITE, &i2c_data); if(ret) { printf("i2c write failed!\n"); return -1 ; } close(fd); #endif return 0; } static void delay_ms(int ms) { usleep(ms*1000); } void sensor_init() { sensor_write_register(0x301A, 0x10D9); delay_ms(100); sensor_write_register(0x301A, 0x10D8); sensor_write_register(0x30FE, 0x0080); sensor_write_register(0x31E0, 0x0303); sensor_write_register(0x3ECE, 0x08FF); sensor_write_register(0x3ED0, 0xE4F6); sensor_write_register(0x3ED2, 0x0146); sensor_write_register(0x3ED4, 0x8F6C); sensor_write_register(0x3ED6, 0x66CC); sensor_write_register(0x3ED8, 0x8C42); sensor_write_register(0x3EDA, 0x889B); sensor_write_register(0x3EDC, 0x8863); sensor_write_register(0x3EDE, 0xAA04); sensor_write_register(0x3EE0, 0x15F0); sensor_write_register(0x3EE6, 0x008C); sensor_write_register(0x3EE8, 0x2024); sensor_write_register(0x3EEA, 0xFF1F); sensor_write_register(0x3F06, 0x046A); sensor_write_register(0x3064, 0x1802); sensor_write_register(0x3EDA, 0x88BC); sensor_write_register(0x3EDC, 0xAA63); sensor_write_register(0x305E, 0x00A0); sensor_write_register(0x302A, 0x0006); sensor_write_register(0x302C, 0x0001); sensor_write_register(0x302E, 0x0002); sensor_write_register(0x3030, 0x0025); sensor_write_register(0x3036, 0x000C); sensor_write_register(0x3038, 0x0001); sensor_write_register(0x31AC, 0x0C0C); sensor_write_register(0x31AE, 0x0301); sensor_write_register(0x3002, 0x00EA); sensor_write_register(0x3004, 0x00C6); sensor_write_register(0x3006, 0x0521); sensor_write_register(0x3008, 0x0845); sensor_write_register(0x300A, 0x0444); sensor_write_register(0x300C, 0x0469); sensor_write_register(0x3012, 0x0147); sensor_write_register(0x3014, 0x0000); sensor_write_register(0x30A2, 0x0001); sensor_write_register(0x30A6, 0x0001); sensor_write_register(0x308C, 0x0006); sensor_write_register(0x308A, 0x0006); sensor_write_register(0x3090, 0x0605); sensor_write_register(0x308E, 0x0905); sensor_write_register(0x30AA, 0x0B94); sensor_write_register(0x303E, 0x04E0); sensor_write_register(0x3016, 0x0B92); sensor_write_register(0x3018, 0x0000); sensor_write_register(0x30AE, 0x0001); sensor_write_register(0x30A8, 0x0001); sensor_write_register(0x3040, 0x0000); sensor_write_register(0x3042, 0x0000); sensor_write_register(0x30BA, 0x002C); sensor_write_register(0x3088, 0x80BA); sensor_write_register(0x3086, 0x0253); sensor_write_register(0x301A, 0x10DC); printf("Aptina AR0330 sensor 1080p 30fps init success!\n"); }

4,319

C

.c

134

27.522388

86

0.680552

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,074

imx225_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/sony_imx225/imx225_sensor_ctl.c

/****************************************************************************** Copyright (C), 2001-2011, Hisilicon Tech. Co., Ltd. ****************************************************************************** File Name : sony225_sensor_ctl.c Version : Initial Draft Author : Hisilicon multimedia software group Created : 2014/11/07 Description : Sony IMX225 sensor driver History : 1.Date : 2014/11/07 Author : MPP Modification: Created file ******************************************************************************/ #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "hi_ssp.h" int sony_sensor_write_packet(unsigned int data) { int fd = -1; int ret; unsigned int value; fd = open("/dev/ssp", 0); if(fd < 0) { printf("Open /dev/ssp error!\n"); return -1; } value = data; ret = ioctl(fd, SSP_WRITE_ALT, &value); close(fd); return 0; } int sony_sensor_read_packet(unsigned int data) { unsigned int value; int fd = -1; int ret; fd = open("/dev/ssp", 0); if(fd < 0) { printf("Open /dev/ssp error!\n"); return -1; } value = data; ret = ioctl(fd, SSP_READ_ALT, &value); close(fd); return (value&0xff); } int sensor_write_register(int addr, int data) { unsigned int value = (unsigned int)(((addr&0xffff)<<8) | (data & 0xff)); return sony_sensor_write_packet(value); } int sensor_read_register(int addr) { unsigned int data = (unsigned int)(((addr&0xffff)<<8)); return sony_sensor_read_packet(data); } void sensor_prog(int* rom) { } void sensor_init() { sensor_write_register(0x200, 0x01); //Standby usleep(200000); // chip_id = 0x2 sensor_write_register(0x207, 0x10); sensor_write_register(0x209, 0x01); sensor_write_register(0x20f, 0x00); sensor_write_register(0x212, 0x2c); sensor_write_register(0x213, 0x01); sensor_write_register(0x216, 0x09); sensor_write_register(0x218, 0xee); sensor_write_register(0x219, 0x02); sensor_write_register(0x21b, 0xc8); sensor_write_register(0x21c, 0x19); sensor_write_register(0x21d, 0xc2); sensor_write_register(0x246, 0x03); sensor_write_register(0x247, 0x06); sensor_write_register(0x248, 0xc2); sensor_write_register(0x25c, 0x20); sensor_write_register(0x25D, 0x00); sensor_write_register(0x25E, 0x20); sensor_write_register(0x25F, 0x00); sensor_write_register(0x270, 0x02); sensor_write_register(0x271, 0x01); sensor_write_register(0x29E, 0x22); sensor_write_register(0x2A5, 0xFB); sensor_write_register(0x2A6, 0x02); sensor_write_register(0x2B3, 0xFF); sensor_write_register(0x2B4, 0x01); sensor_write_register(0x2B5, 0x42); sensor_write_register(0x2B8, 0x10); sensor_write_register(0x2C2, 0x01); // chip_id = 0x3 sensor_write_register(0x30F, 0x0F); sensor_write_register(0x310, 0x0E); sensor_write_register(0x311, 0xE7); sensor_write_register(0x312, 0x9C); sensor_write_register(0x313, 0x83); sensor_write_register(0x314, 0x10); sensor_write_register(0x315, 0x42); sensor_write_register(0x328, 0x1E); sensor_write_register(0x3ED, 0x38); // chip_id = 0x4 sensor_write_register(0x40C, 0xCF); sensor_write_register(0x44C, 0x40); sensor_write_register(0x44D, 0x03); sensor_write_register(0x461, 0xE0); sensor_write_register(0x462, 0x02); sensor_write_register(0x46E, 0x2F); sensor_write_register(0x46F, 0x30); sensor_write_register(0x470, 0x03); sensor_write_register(0x498, 0x00); sensor_write_register(0x49A, 0x12); sensor_write_register(0x49B, 0xF1); sensor_write_register(0x49C, 0x0C); usleep(200000); sensor_write_register(0x200, 0x00); //release standy usleep(200000); sensor_write_register(0x202, 0x00); //Master mose start usleep(200000); sensor_write_register(0x249, 0x80); //XVS & XHS output usleep(200000); printf("-------Sony IMX225 Sensor Initial OK!-------\n"); return ; }

4,102

C

.c

131

27.656489

80

0.654765

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,076

soih22_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/soi_h22/soih22_sensor_ctl.c

/****************************************************************************** A driver program of soi h22 on HI3518A ****************************************************************************** Modification: 2013-03 Created ******************************************************************************/ #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #ifdef HI_GPIO_I2C #include "gpioi2c_ov.h" #include "gpio_i2c.h" #else #include "hi_i2c.h" #endif const unsigned int sensor_i2c_addr = 0x60; /* I2C Address of SOI H22 */ //const unsigned int sensor_i2c_addr = 0x6C; /* I2C Address of SOI H22 */ const unsigned int sensor_addr_byte = 1; const unsigned int sensor_data_byte = 1; int sensor_read_register(int addr) { #ifdef HI_GPIO_I2C int fd = -1; int ret; int value; fd = open("/dev/gpioi2c_ov", 0); if(fd<0) { printf("Open gpioi2c_ov error!\n"); return -1; } value = ((sensor_i2c_addr&0xff)<<24) | ((addr&0xff)<<16); ret = ioctl(fd, GPIO_I2C_READ, &value); if (ret) { printf("GPIO-I2C read faild!\n"); close(fd); return -1; } value &= 0xff; close(fd); return value; #else int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_WRITE, &i2c_data); if (ret) { printf("hi_i2c write faild!\n"); close(fd); return -1; } close(fd); #endif return i2c_data.data; } int sensor_write_register(int addr, int data) { #ifdef HI_GPIO_I2C int fd = -1; int ret; int value; fd = open("/dev/gpioi2c_ov", 0); if(fd<0) { printf("Open gpioi2c_ov error!\n"); return -1; } value = ((sensor_i2c_addr&0xff)<<24) | ((addr&0xff)<<16) | (data&0xff); ret = ioctl(fd, GPIO_I2C_WRITE, &value); // printf("sensor_write_register gpioi2c_ov addr: %#x, data: %#x \n",addr,data); if (ret) { printf("GPIO-I2C write faild!\n"); close(fd); return -1; } close(fd); #else int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; // printf("sensor_write_register hi_i2c addr: %#x, data: %#x \n",addr,data); ret = ioctl(fd, CMD_I2C_WRITE, &i2c_data); if (ret) { printf("hi_i2c write faild!\n"); close(fd); return -1; } close(fd); #endif return 0; } int sensor_write_register_bit(int addr, int data, int mask) { #ifdef HI_GPIO_I2C int fd = -1; int ret; int value; fd = open("/dev/gpioi2c_ov", 0); if(fd<0) { printf("Open gpioi2c_ov error!\n"); return -1; } value = ((sensor_i2c_addr&0xff)<<24) | ((addr&0xff)<<16); ret = ioctl(fd, GPIO_I2C_READ, &value); if (ret) { printf("GPIO-I2C read faild!\n"); close(fd); return -1; } value &= 0xff; value &= ~mask; value |= data & mask; value = ((sensor_i2c_addr&0xff)<<24) | ((addr&0xff)<<16) | (value&0xff); ret = ioctl(fd, GPIO_I2C_WRITE, &value); if (ret) { printf("GPIO-I2C write faild!\n"); close(fd); return -1; } close(fd); #else int fd = -1; int ret; int value; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_READ, &i2c_data); if (ret) { printf("hi_i2c read faild!\n"); close(fd); return -1; } value = i2c_data.data; value &= ~mask; value |= data & mask; i2c_data.data = value; ret = ioctl(fd, CMD_I2C_WRITE, &i2c_data); if (ret) { printf("hi_i2c write faild!\n"); close(fd); return -1; } close(fd); #endif return 0; } static void delay_ms(int ms) { usleep(ms*1000); } void sensor_prog(int* rom) { int i = 0; while (1) { int u32Lookup = rom[i++]; int addr = (u32Lookup >> 16) & 0xFFFF; int data = u32Lookup & 0xFFFF; if (addr == 0xFFFE) { delay_ms(data); } else if (addr == 0xFFFF) { return; } else { sensor_write_register(addr, data); } } } void sensor_init() { sensor_write_register(0x0e, 0x1D); sensor_write_register(0x0f, 0x0B); sensor_write_register(0x10, 0x26); sensor_write_register(0x11, 0x80); sensor_write_register(0x1B, 0x4F); sensor_write_register(0x1D, 0xFF); sensor_write_register(0x1E, 0x9F); sensor_write_register(0x20, 0x72); sensor_write_register(0x21, 0x06); sensor_write_register(0x22, 0xFF); sensor_write_register(0x23, 0x02); sensor_write_register(0x24, 0x00); sensor_write_register(0x25, 0xE0); sensor_write_register(0x26, 0x25); sensor_write_register(0x27, 0xE9); sensor_write_register(0x28, 0x0D); sensor_write_register(0x29, 0x00); sensor_write_register(0x2C, 0x00); sensor_write_register(0x2D, 0x08); sensor_write_register(0x2E, 0xC4); sensor_write_register(0x2F, 0x20); sensor_write_register(0x6C, 0x90); sensor_write_register(0x2A, 0xD4); sensor_write_register(0x30, 0x90); sensor_write_register(0x31, 0x10); sensor_write_register(0x32, 0x10); sensor_write_register(0x33, 0x10); sensor_write_register(0x34, 0x32); sensor_write_register(0x14, 0x80); sensor_write_register(0x18, 0xD5); sensor_write_register(0x19, 0x10); sensor_write_register(0x0d, 0x00); sensor_write_register(0x1f, 0x00); sensor_write_register(0x13, 0x87); sensor_write_register(0x4A, 0x03); sensor_write_register(0x49, 0x06); return ; }

6,640

C

.c

253

20.695652

86

0.56254

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,078

imx104_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/sony_imx104/imx104_sensor_ctl.c

/****************************************************************************** Copyright (C), 2001-2011, Hisilicon Tech. Co., Ltd. ****************************************************************************** File Name : sony104_sensor_ctl.c Version : Initial Draft Author : Hisilicon multimedia software group Created : 2011/03/23 Description : Sony IMX036 sensor driver History : 1.Date : 2011/03/23 Author : MPP Modification: Created file ******************************************************************************/ #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "hi_ssp.h" int sony_sensor_write_packet(unsigned int data) { int fd = -1; int ret; unsigned int value; fd = open("/dev/ssp", 0); if(fd < 0) { printf("Open /dev/ssp error!\n"); return -1; } value = data; ret = ioctl(fd, SSP_WRITE_ALT, &value); close(fd); return 0; } int sony_sensor_read_packet(unsigned int data) { unsigned int value; int fd = -1; int ret; fd = open("/dev/ssp", 0); if(fd < 0) { printf("Open /dev/ssp error!\n"); return -1; } value = data; ret = ioctl(fd, SSP_READ_ALT, &value); close(fd); return (value&0xff); } int sensor_write_register(int addr, int data) { unsigned int value = (unsigned int)(((addr&0xffff)<<8) | (data & 0xff)); //printf("write data = %#x\n", value); return sony_sensor_write_packet(value); } int sensor_read_register(int addr) { unsigned int data = (unsigned int)(((addr&0xffff)<<8)); //printf("read data = %#x\n", data); return sony_sensor_read_packet(data); } void sensor_prog(int* rom) { } void setup_sensor(int isp_mode) { } void sensor_init() { sensor_write_register(0x200, 0x01); //Standby usleep(200000); // chip_id = 0x2 sensor_write_register(0x205, 0x01); //12bit sensor_write_register(0x206, 0x00); //Drive mode:All-pix scan mode(720p mode) sensor_write_register(0x207, 0x10); //Window mode:720p mode sensor_write_register(0x209, 0x02); //30fps mode sensor_write_register(0x20A, 0xF0); //black level /*linear & WDR mode is different*/ sensor_write_register(0x20C, 0x00); sensor_write_register(0x20F, 0x01); sensor_write_register(0x210, 0x39); sensor_write_register(0x212, 0x50); sensor_write_register(0x217, 0x01); sensor_write_register(0x218, 0xEE); sensor_write_register(0x219, 0x02); sensor_write_register(0x21A, 0x00); sensor_write_register(0x21B, 0xC0); sensor_write_register(0x21C, 0x19); sensor_write_register(0x21D, 0xFF); sensor_write_register(0x21E, 0x01); sensor_write_register(0x236, 0x14); //VB size sensor_write_register(0x238, 0x00); //cropping postion(Vertical position) sensor_write_register(0x239, 0x00); sensor_write_register(0x23A, 0x19); //cropping size(Vertical direction) sensor_write_register(0x23B, 0x04); sensor_write_register(0x23C, 0x00); //cropping postion(horizontal position) sensor_write_register(0x23D, 0x00); sensor_write_register(0x23E, 0x1C); //cropping size(horizontal direction) sensor_write_register(0x23F, 0x05); sensor_write_register(0x244, 0x01); //Parallel CMOS SDR output sensor_write_register(0x254, 0x63); sensor_write_register(0x25B, 0x00); //CLK 37.125MHz sensor_write_register(0x25D, 0x00); //CLK 37.125MHz sensor_write_register(0x25F, 0x10); //invalid sensor_write_register(0x2BF, 0x1F); /*linear & WDR mode is different*/ sensor_write_register(0x265, 0x20); sensor_write_register(0x286, 0x01); sensor_write_register(0x2CF, 0xD1); sensor_write_register(0x2D0, 0x1B); sensor_write_register(0x2D2, 0x5F); sensor_write_register(0x2D3, 0x00); // chip_id = 0x3 sensor_write_register(0x312, 0x00); sensor_write_register(0x31D, 0x07); sensor_write_register(0x323, 0x07); sensor_write_register(0x326, 0xDF); sensor_write_register(0x347, 0x87); // chip_id = 0x4 sensor_write_register(0x403, 0xCD); sensor_write_register(0x407, 0x4B); sensor_write_register(0x409, 0xE9); sensor_write_register(0x413, 0x1B); sensor_write_register(0x415, 0xED); sensor_write_register(0x416, 0x01); sensor_write_register(0x418, 0x09); sensor_write_register(0x41A, 0x19); sensor_write_register(0x41B, 0xA1); sensor_write_register(0x41C, 0x11); sensor_write_register(0x427, 0x00); sensor_write_register(0x428, 0x05); sensor_write_register(0x429, 0xEC); sensor_write_register(0x42A, 0x40); sensor_write_register(0x42B, 0x11); sensor_write_register(0x42D, 0x22); sensor_write_register(0x42E, 0x00); sensor_write_register(0x42F, 0x05); sensor_write_register(0x431, 0xEC); sensor_write_register(0x432, 0x40); sensor_write_register(0x433, 0x11); sensor_write_register(0x435, 0x23); sensor_write_register(0x436, 0xB0); sensor_write_register(0x437, 0x04); sensor_write_register(0x439, 0x24); sensor_write_register(0x43A, 0x30); sensor_write_register(0x43B, 0x04); sensor_write_register(0x43C, 0xED); sensor_write_register(0x43D, 0xC0); sensor_write_register(0x43E, 0x10); sensor_write_register(0x440, 0x44); sensor_write_register(0x441, 0xA0); sensor_write_register(0x442, 0x04); sensor_write_register(0x443, 0x0D); sensor_write_register(0x444, 0x31); sensor_write_register(0x445, 0x11); sensor_write_register(0x447, 0xEC); sensor_write_register(0x448, 0xD0); sensor_write_register(0x449, 0x1D); sensor_write_register(0x455, 0x03); sensor_write_register(0x456, 0x54); sensor_write_register(0x457, 0x60); sensor_write_register(0x458, 0x1F); sensor_write_register(0x45A, 0xA9); sensor_write_register(0x45B, 0x50); sensor_write_register(0x45C, 0x0A); sensor_write_register(0x45D, 0x25); sensor_write_register(0x45E, 0x11); sensor_write_register(0x45F, 0x12); sensor_write_register(0x461, 0x9B); sensor_write_register(0x466, 0xD0); sensor_write_register(0x467, 0x08); sensor_write_register(0x46A, 0x20); sensor_write_register(0x46B, 0x0A); sensor_write_register(0x46E, 0x20); sensor_write_register(0x46F, 0x0A); sensor_write_register(0x472, 0x20); sensor_write_register(0x473, 0x0A); sensor_write_register(0x475, 0xEC); sensor_write_register(0x47D, 0xA5); sensor_write_register(0x47E, 0x20); sensor_write_register(0x47F, 0x0A); sensor_write_register(0x481, 0xEF); sensor_write_register(0x482, 0xC0); sensor_write_register(0x483, 0x0E); sensor_write_register(0x485, 0xF6); sensor_write_register(0x48A, 0x60); sensor_write_register(0x48B, 0x1F); sensor_write_register(0x48D, 0xBB); sensor_write_register(0x48E, 0x90); sensor_write_register(0x48F, 0x0D); sensor_write_register(0x490, 0x39); sensor_write_register(0x491, 0xC1); sensor_write_register(0x492, 0x1D); sensor_write_register(0x494, 0xC9); sensor_write_register(0x495, 0x70); sensor_write_register(0x496, 0x0E); sensor_write_register(0x497, 0x47); sensor_write_register(0x498, 0xA1); sensor_write_register(0x499, 0x1E); sensor_write_register(0x49B, 0xC5); sensor_write_register(0x49C, 0xB0); sensor_write_register(0x49D, 0x0E); sensor_write_register(0x49E, 0x43); sensor_write_register(0x49F, 0xE1); sensor_write_register(0x4A0, 0x1E); sensor_write_register(0x4A2, 0xBB); sensor_write_register(0x4A3, 0x10); sensor_write_register(0x4A4, 0x0C); sensor_write_register(0x4A6, 0xB3); sensor_write_register(0x4A7, 0x30); sensor_write_register(0x4A8, 0x0A); sensor_write_register(0x4A9, 0x29); sensor_write_register(0x4AA, 0x91); sensor_write_register(0x4AB, 0x11); sensor_write_register(0x4AD, 0xB4); sensor_write_register(0x4AE, 0x40); sensor_write_register(0x4AF, 0x0A); sensor_write_register(0x4B0, 0x2A); sensor_write_register(0x4B1, 0xA1); sensor_write_register(0x4B2, 0x11); sensor_write_register(0x4B4, 0xAB); sensor_write_register(0x4B5, 0xB0); sensor_write_register(0x4B6, 0x0B); sensor_write_register(0x4B7, 0x21); sensor_write_register(0x4B8, 0x11); sensor_write_register(0x4B9, 0x13); sensor_write_register(0x4BB, 0xAC); sensor_write_register(0x4BC, 0xC0); sensor_write_register(0x4BD, 0x0B); sensor_write_register(0x4BE, 0x22); sensor_write_register(0x4BF, 0x21); sensor_write_register(0x4C0, 0x13); sensor_write_register(0x4C2, 0xAD); sensor_write_register(0x4C3, 0x10); sensor_write_register(0x4C4, 0x0B); sensor_write_register(0x4C5, 0x23); sensor_write_register(0x4C6, 0x71); sensor_write_register(0x4C7, 0x12); sensor_write_register(0x4C9, 0xB5); sensor_write_register(0x4CA, 0x90); sensor_write_register(0x4CB, 0x0B); sensor_write_register(0x4CC, 0x2B); sensor_write_register(0x4CD, 0xF1); sensor_write_register(0x4CE, 0x12); sensor_write_register(0x4D0, 0xBB); sensor_write_register(0x4D1, 0x10); sensor_write_register(0x4D2, 0x0C); sensor_write_register(0x4D4, 0xE7); sensor_write_register(0x4D5, 0x90); sensor_write_register(0x4D6, 0x0E); sensor_write_register(0x4D8, 0x45); sensor_write_register(0x4D9, 0x11); sensor_write_register(0x4DA, 0x1F); sensor_write_register(0x4EB, 0xA4); sensor_write_register(0x4EC, 0x60); sensor_write_register(0x4ED, 0x1F); /*linear & WDR mode is different*/ sensor_write_register(0x461, 0x9B); sensor_write_register(0x466, 0xD0); sensor_write_register(0x467, 0x08); usleep(200000); sensor_write_register(0x200, 0x00); //release standy usleep(200000); sensor_write_register(0x202, 0x00); //Master mose start usleep(200000); sensor_write_register(0x249, 0x0A); //XVS & XHS output usleep(200000); printf("-------Sony IMX104 Sensor Initial OK!-------\n"); } void sensor_init_wdr() { sensor_write_register(0x200, 0x01); //Standby usleep(200000); // chip_id = 0x2 sensor_write_register(0x205, 0x01); //12bit sensor_write_register(0x206, 0x00); //Drive mode:All-pix scan mode sensor_write_register(0x207, 0x10); //Window mode:720p mode sensor_write_register(0x209, 0x00); //30fps mode sensor_write_register(0x20A, 0xF0); //black level sensor_write_register(0x20B, 0x00); sensor_write_register(0x20C, 0x02); sensor_write_register(0x20F, 0x04); sensor_write_register(0x210, 0x38); sensor_write_register(0x211, 0x00); sensor_write_register(0x212, 0x0F); sensor_write_register(0x213, 0x00); sensor_write_register(0x215, 0x00); sensor_write_register(0x217, 0x04); sensor_write_register(0x218, 0xEE); sensor_write_register(0x219, 0x02); sensor_write_register(0x21A, 0x00); sensor_write_register(0x21B, 0xC0); sensor_write_register(0x21C, 0x19); sensor_write_register(0x21D, 0xFF); sensor_write_register(0x21E, 0x01); sensor_write_register(0x220, 0x00); sensor_write_register(0x221, 0x00); sensor_write_register(0x222, 0x00); sensor_write_register(0x223, 0x00); sensor_write_register(0x224, 0x00); sensor_write_register(0x225, 0x00); sensor_write_register(0x236, 0x14); //VB size sensor_write_register(0x238, 0x00); //cropping postion(Vertical position) sensor_write_register(0x239, 0x00); sensor_write_register(0x23A, 0x19); //cropping size(Vertical direction) sensor_write_register(0x23B, 0x04); sensor_write_register(0x23C, 0x00); //cropping postion(horizontal position) sensor_write_register(0x23D, 0x00); sensor_write_register(0x23E, 0x1C); //cropping size(horizontal direction) sensor_write_register(0x23F, 0x05); sensor_write_register(0x244, 0x01); //Parallel CMOS SDR output sensor_write_register(0x254, 0x63); sensor_write_register(0x256, 0xC9); //wdc_ccmp1[3:0] wdc_ccmp2[3:0],the first and second point changing slope of compressed output. sensor_write_register(0x257, 0x01); //wdc_ACMP1[3:0] wdc_acmp2[3:0], gain setting of the first and second region of compressed output sensor_write_register(0x265, 0xC9); sensor_write_register(0x284, 0x0F); //Midpoint potential setting sensor_write_register(0x286, 0x10); sensor_write_register(0x25B, 0x00); //CLK 37.125MHz sensor_write_register(0x25D, 0x00); //CLK 37.125MHz sensor_write_register(0x25F, 0x10); //invalid sensor_write_register(0x2BF, 0x1F); sensor_write_register(0x2CF, 0xE1); sensor_write_register(0x2D0, 0x29); sensor_write_register(0x2D2, 0x9B); sensor_write_register(0x2D3, 0x01); // chip_id = 0x3 sensor_write_register(0x312, 0x00); sensor_write_register(0x31D, 0x07); sensor_write_register(0x323, 0x07); sensor_write_register(0x326, 0xDF); sensor_write_register(0x347, 0x87); // chip_id = 0x4 sensor_write_register(0x403, 0xCD); sensor_write_register(0x407, 0x4B); sensor_write_register(0x409, 0xE9); sensor_write_register(0x413, 0x1B); sensor_write_register(0x415, 0xED); sensor_write_register(0x416, 0x01); sensor_write_register(0x418, 0x09); sensor_write_register(0x41A, 0x19); sensor_write_register(0x41B, 0xA1); sensor_write_register(0x41C, 0x11); sensor_write_register(0x427, 0x00); sensor_write_register(0x428, 0x05); sensor_write_register(0x429, 0xEC); sensor_write_register(0x42A, 0x40); sensor_write_register(0x42B, 0x11); sensor_write_register(0x42D, 0x22); sensor_write_register(0x42E, 0x00); sensor_write_register(0x42F, 0x05); sensor_write_register(0x431, 0xEC); sensor_write_register(0x432, 0x40); sensor_write_register(0x433, 0x11); sensor_write_register(0x435, 0x23); sensor_write_register(0x436, 0xB0); sensor_write_register(0x437, 0x04); sensor_write_register(0x439, 0x24); sensor_write_register(0x43A, 0x30); sensor_write_register(0x43B, 0x04); sensor_write_register(0x43C, 0xED); sensor_write_register(0x43D, 0xC0); sensor_write_register(0x43E, 0x10); sensor_write_register(0x440, 0x44); sensor_write_register(0x441, 0xA0); sensor_write_register(0x442, 0x04); sensor_write_register(0x443, 0x0D); sensor_write_register(0x444, 0x31); sensor_write_register(0x445, 0x11); sensor_write_register(0x447, 0xEC); sensor_write_register(0x448, 0xD0); sensor_write_register(0x449, 0x1D); sensor_write_register(0x455, 0x03); sensor_write_register(0x456, 0x54); sensor_write_register(0x457, 0x60); sensor_write_register(0x458, 0x1F); sensor_write_register(0x45A, 0xA9); sensor_write_register(0x45B, 0x50); sensor_write_register(0x45C, 0x0A); sensor_write_register(0x45D, 0x25); sensor_write_register(0x45E, 0x11); sensor_write_register(0x45F, 0x12); sensor_write_register(0x461, 0x9B); sensor_write_register(0x462, 0x40); sensor_write_register(0x463, 0x00); sensor_write_register(0x464, 0x00); sensor_write_register(0x465, 0x04); sensor_write_register(0x466, 0xD0); sensor_write_register(0x467, 0x08); sensor_write_register(0x46A, 0x20); sensor_write_register(0x46B, 0x0A); sensor_write_register(0x46E, 0x20); sensor_write_register(0x46F, 0x0A); sensor_write_register(0x472, 0x20); sensor_write_register(0x473, 0x0A); sensor_write_register(0x475, 0xEC); sensor_write_register(0x47D, 0xA5); sensor_write_register(0x47E, 0x20); sensor_write_register(0x47F, 0x0A); sensor_write_register(0x481, 0xEF); sensor_write_register(0x482, 0xC0); sensor_write_register(0x483, 0x0E); sensor_write_register(0x485, 0xF6); sensor_write_register(0x48A, 0x60); sensor_write_register(0x48B, 0x1F); sensor_write_register(0x48D, 0xBB); sensor_write_register(0x48E, 0x90); sensor_write_register(0x48F, 0x0D); sensor_write_register(0x490, 0x39); sensor_write_register(0x491, 0xC1); sensor_write_register(0x492, 0x1D); sensor_write_register(0x494, 0xC9); sensor_write_register(0x495, 0x70); sensor_write_register(0x496, 0x0E); sensor_write_register(0x497, 0x47); sensor_write_register(0x498, 0xA1); sensor_write_register(0x499, 0x1E); sensor_write_register(0x49B, 0xC5); sensor_write_register(0x49C, 0xB0); sensor_write_register(0x49D, 0x0E); sensor_write_register(0x49E, 0x43); sensor_write_register(0x49F, 0xE1); sensor_write_register(0x4A0, 0x1E); sensor_write_register(0x4A2, 0xBB); sensor_write_register(0x4A3, 0x10); sensor_write_register(0x4A4, 0x0C); sensor_write_register(0x4A6, 0xB3); sensor_write_register(0x4A7, 0x30); sensor_write_register(0x4A8, 0x0A); sensor_write_register(0x4A9, 0x29); sensor_write_register(0x4AA, 0x91); sensor_write_register(0x4AB, 0x11); sensor_write_register(0x4AD, 0xB4); sensor_write_register(0x4AE, 0x40); sensor_write_register(0x4AF, 0x0A); sensor_write_register(0x4B0, 0x2A); sensor_write_register(0x4B1, 0xA1); sensor_write_register(0x4B2, 0x11); sensor_write_register(0x4B4, 0xAB); sensor_write_register(0x4B5, 0xB0); sensor_write_register(0x4B6, 0x0B); sensor_write_register(0x4B7, 0x21); sensor_write_register(0x4B8, 0x11); sensor_write_register(0x4B9, 0x13); sensor_write_register(0x4BB, 0xAC); sensor_write_register(0x4BC, 0xC0); sensor_write_register(0x4BD, 0x0B); sensor_write_register(0x4BE, 0x22); sensor_write_register(0x4BF, 0x21); sensor_write_register(0x4C0, 0x13); sensor_write_register(0x4C2, 0xAD); sensor_write_register(0x4C3, 0x10); sensor_write_register(0x4C4, 0x0B); sensor_write_register(0x4C5, 0x23); sensor_write_register(0x4C6, 0x71); sensor_write_register(0x4C7, 0x12); sensor_write_register(0x4C9, 0xB5); sensor_write_register(0x4CA, 0x90); sensor_write_register(0x4CB, 0x0B); sensor_write_register(0x4CC, 0x2B); sensor_write_register(0x4CD, 0xF1); sensor_write_register(0x4CE, 0x12); sensor_write_register(0x4D0, 0xBB); sensor_write_register(0x4D1, 0x10); sensor_write_register(0x4D2, 0x0C); sensor_write_register(0x4D4, 0xE7); sensor_write_register(0x4D5, 0x90); sensor_write_register(0x4D6, 0x0E); sensor_write_register(0x4D8, 0x45); sensor_write_register(0x4D9, 0x11); sensor_write_register(0x4DA, 0x1F); sensor_write_register(0x4EB, 0xA4); sensor_write_register(0x4EC, 0x60); sensor_write_register(0x4ED, 0x1F); usleep(200000); sensor_write_register(0x200, 0x00); //release standy usleep(200000); sensor_write_register(0x202, 0x00); //Master mose start usleep(200000); sensor_write_register(0x249, 0x0A); //XVS & XHS output usleep(200000); }

18,997

C

.c

484

34.378099

137

0.698439

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,083

ar0140_sensor_config.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/aptina_ar0140/ar0140_sensor_config.c

#ifndef _AR0140_SENSOR_CONFIG_C_ #define _AR0140_SENSOR_CONFIG_C_ // [addr:data] // when addr = 0xFFFF, configuration process end; when addr = 0xFFFE, deay data ms; int sensor_rom_30_lin[] = { //[Linear (Parallel) 720p30 74.25MHz PCLK 24MHz MCLK] //Reset 0x301A0001, // RESET_REGISTER 0x301A10D8, // RESET_REGISTER //Delay=200 0xFFFE00C8, //delay 200ms //LOAD=sequencer_ers_0828_AR0140.i //LOAD= AR0140 Rev3 Optimized settings //Delay=100 //[sequencer_ers_0828_AR0140.i] 0x30888000, 0x30864558, 0x30866E9B, 0x30864A31, 0x30864342, 0x30868E03, 0x30862714, 0x30864578, 0x30867B3D, 0x3086FF3D, 0x3086FF3D, 0x3086EA27, 0x3086043D, 0x30861027, 0x30860527, 0x30861535, 0x30862705, 0x30863D10, 0x30864558, 0x30862704, 0x30862714, 0x30863DFF, 0x30863DFF, 0x30863DEA, 0x30862704, 0x30866227, 0x3086288E, 0x30860036, 0x30862708, 0x30863D64, 0x30867A3D, 0x30860444, 0x30862C4B, 0x30868F01, 0x30864372, 0x3086719F, 0x30864643, 0x3086166F, 0x30869F92, 0x30861244, 0x30861646, 0x30864316, 0x30869326, 0x30860426, 0x3086848E, 0x30860327, 0x3086FC5C, 0x30860D57, 0x30865417, 0x30860955, 0x30865649, 0x30865F53, 0x30860553, 0x30860728, 0x30866C4C, 0x30860928, 0x30862C72, 0x3086A37C, 0x30869728, 0x3086A879, 0x30866026, 0x30869C5C, 0x30861B45, 0x30864845, 0x30860845, 0x30868826, 0x3086BE8E, 0x30860127, 0x3086F817, 0x30860227, 0x3086FA17, 0x3086095C, 0x30860B17, 0x30861026, 0x3086BA5C, 0x30860317, 0x30861026, 0x3086B217, 0x3086065F, 0x30862888, 0x30869060, 0x308627F2, 0x30861710, 0x308626A2, 0x308626A3, 0x30865F4D, 0x30862808, 0x30861A27, 0x3086FA84, 0x308669A0, 0x3086785D, 0x30862888, 0x30868710, 0x30868C82, 0x30868926, 0x3086B217, 0x3086036B, 0x30869C60, 0x30869417, 0x30862926, 0x30868345, 0x3086A817, 0x30860727, 0x3086FB17, 0x30862945, 0x30868820, 0x30861708, 0x308627FA, 0x30865D87, 0x3086108C, 0x30868289, 0x3086170E, 0x30864826, 0x30869A28, 0x3086884C, 0x30860B79, 0x30861730, 0x30862692, 0x30861709, 0x30869160, 0x308627F2, 0x30861710, 0x30862682, 0x30862683, 0x30865F4D, 0x30862808, 0x30861A27, 0x3086FA84, 0x308669A1, 0x3086785D, 0x30862888, 0x30868710, 0x30868C80, 0x30868A26, 0x30869217, 0x3086036B, 0x30869D95, 0x30862603, 0x30865C01, 0x30864558, 0x30868E00, 0x30862798, 0x3086170A, 0x30864A0A, 0x30864316, 0x30860B43, 0x30865B43, 0x30861659, 0x30864316, 0x30868E03, 0x3086279C, 0x30864578, 0x30861707, 0x3086279D, 0x30861722, 0x30865D87, 0x30861028, 0x30860853, 0x30860D8C, 0x3086808A, 0x30864558, 0x30861708, 0x30868E01, 0x30862798, 0x30868E00, 0x308676A2, 0x308677A2, 0x30864644, 0x30861616, 0x3086967A, 0x30862644, 0x30865C05, 0x30861244, 0x30864B71, 0x3086759E, 0x30868B86, 0x3086184A, 0x30860343, 0x30861606, 0x30864316, 0x30860743, 0x30861604, 0x30864316, 0x30865843, 0x3086165A, 0x30864316, 0x30864558, 0x30868E03, 0x3086279C, 0x30864578, 0x30867B17, 0x30860727, 0x30869D17, 0x30862245, 0x30865822, 0x30861710, 0x30868E01, 0x30862798, 0x30868E00, 0x30861710, 0x30861244, 0x30864B8D, 0x3086602C, 0x30862C2C, 0x30862C00, //[==== Optimized and Sequencer settings (DO NOT CHANGE) ====] //[AR0140 Rev3 Optimized Settings] 0x30440400, //Manufacturer-specific 0x3052A134, //Manufacturer-specific 0x3092010F, //Manufacturer-specific 0x30FE0080, //Manufacturer-specific 0x3ECE40FF, //Manufacturer-specific 0x3ED0FF40, //Manufacturer-specific 0x3ED2A906, //Manufacturer-specific 0x3ED4001F, //Manufacturer-specific 0x3ED6638F, //Manufacturer-specific 0x3ED8CC99, //Manufacturer-specific 0x3EDA0888, //Manufacturer-specific 0x3EDE8878, //Manufacturer-specific 0x3EE07744, //Manufacturer-specific 0x3EE24463, //Manufacturer-specific 0x3EE4AAE0, //Manufacturer-specific 0x3EE61400, //Manufacturer-specific 0x3EEAA4FF, //Manufacturer-specific 0x3EEC80F0, //Manufacturer-specific 0x3EEE0000, //Manufacturer-specific 0x31E01701, //Manufacturer-specific 0xFFFE0064, //delay 100ms //PLL_configuration_Parallel 0x302A0006, // VT_PIX_CLK_DIV 0x302C0001, // VT_SYS_CLK_DIV 0x302E0004, // PRE_PLL_CLK_DIV 0x30300042, // PLL_MULTIPLIER 0x3036000C, // OP_PIX_CLK_DIV 0x30380001, // OP_SYS_CLK_DIV //720P30fps_configuration 0x30040012, // X_ADDR_START 0x30020040, // Y_ADDR_START 0x30080519, // X_ADDR_END 0x30060317, // Y_ADDR_END 0x300A02EE, // FRAME_LENGTH_LINES 0x300C0CE4, // LINE_LENGTH_PCK 0x3012002D, // COARSE_INTEGRATION_TIME 0x30A20001, // X_ODD_INC 0x30A60001, // Y_ODD_INC 0x30400000, // READ_MODE //Linear Mode Setup 0x30820009, //Linear mode 0x318C0000, // Motion Compensation Off 0x32000000, // ADACD Disabled 0x31D00000, // COMPANDING disabled 0x30B00000, //DIGITAL_TEST 0x30BA012C, //DIGITAL_CTRL 0x31AC0C0C, //DATA_FORMAT_BITS: 12bit 0x31AE0301, //SERAIL_FORAMT: parallel infterface 0x30641882, // no statistic data output //0x306Ef010, // current-drive set 0x306Ee810, // current-drive set 0x301A10DC, //Start streaming 0xFFFF0000 //end of configuration }; int sensor_rom_30_wdr[] = { //[HDR (Parallel) 720p30 74.25MHz PCLK 24MHz MCLK] //Reset 0x301A0001, // RESET_REGISTER 0x301A10D8, // RESET_REGISTER //Delay=200 0xFFFE00C8, //delay 200ms //LOAD=sequencer_hidy_0828_AR0140.i //LOAD= AR0140 Rev3 Optimized settings //Delay=100 //[sequencer_hidy_0828_AR0140.i] 0x30888000, 0x30864558, 0x30866E9B, 0x30864A31, 0x30864342, 0x30868E03, 0x30862714, 0x30864578, 0x30867B3D, 0x3086FF3D, 0x3086FF3D, 0x3086EA27, 0x3086043D, 0x30861027, 0x30860527, 0x30861535, 0x30862705, 0x30863D10, 0x30864558, 0x30862704, 0x30862714, 0x30863DFF, 0x30863DFF, 0x30863DEA, 0x30862704, 0x30866227, 0x3086288E, 0x30860036, 0x30862708, 0x30863D64, 0x30867A3D, 0x30860444, 0x30862C4B, 0x30868F00, 0x30864372, 0x3086719F, 0x30866343, 0x3086166F, 0x30869F92, 0x30861244, 0x30861663, 0x30864316, 0x30869326, 0x30860426, 0x3086848E, 0x30860327, 0x3086FC5C, 0x30860D57, 0x30865417, 0x30860955, 0x30865649, 0x30865F53, 0x30860553, 0x30860728, 0x30866C4C, 0x30860928, 0x30862C72, 0x3086AD7C, 0x3086A928, 0x3086A879, 0x30866026, 0x30869C5C, 0x30861B45, 0x30864845, 0x30860845, 0x30868826, 0x3086BE8E, 0x30860127, 0x3086F817, 0x30860227, 0x3086FA17, 0x3086095C, 0x30860B17, 0x30861026, 0x3086BA5C, 0x30860317, 0x30861026, 0x3086B217, 0x3086065F, 0x30862888, 0x30869060, 0x308627F2, 0x30861710, 0x308626A2, 0x308626A3, 0x30865F4D, 0x30862808, 0x30861927, 0x3086FA84, 0x308669A0, 0x3086785D, 0x30862888, 0x30868710, 0x30868C82, 0x30868926, 0x3086B217, 0x3086036B, 0x30869C60, 0x30869417, 0x30862926, 0x30868345, 0x3086A817, 0x30860727, 0x3086FB17, 0x30862945, 0x3086881F, 0x30861708, 0x308627FA, 0x30865D87, 0x3086108C, 0x30868289, 0x3086170E, 0x30864826, 0x30869A28, 0x3086884C, 0x30860B79, 0x30861730, 0x30862692, 0x30861709, 0x30869160, 0x308627F2, 0x30861710, 0x30862682, 0x30862683, 0x30865F4D, 0x30862808, 0x30861927, 0x3086FA84, 0x308669A1, 0x3086785D, 0x30862888, 0x30868710, 0x30868C80, 0x30868A26, 0x30869217, 0x3086036B, 0x30869D95, 0x30862603, 0x30865C01, 0x30864558, 0x30868E00, 0x30862798, 0x3086170A, 0x30864A65, 0x30864316, 0x30866643, 0x3086165B, 0x30864316, 0x30865943, 0x3086168E, 0x30860327, 0x30869C45, 0x30867817, 0x30860727, 0x30869D17, 0x3086225D, 0x30868710, 0x30862808, 0x3086530D, 0x30868C80, 0x30868A45, 0x30865823, 0x30861708, 0x30868E01, 0x30862798, 0x30868E00, 0x30862644, 0x30865C05, 0x30861244, 0x30864B71, 0x3086759E, 0x30868B85, 0x30860143, 0x30867271, 0x3086A346, 0x30864316, 0x30866FA3, 0x30869612, 0x30864416, 0x30864643, 0x30861697, 0x30862604, 0x30862684, 0x30868E03, 0x308627FC, 0x30865C0D, 0x30865754, 0x30861709, 0x30865556, 0x3086495F, 0x30865305, 0x30865307, 0x3086286C, 0x30864C09, 0x3086282C, 0x308672AE, 0x30867CAA, 0x308628A8, 0x30867960, 0x3086269C, 0x30865C1B, 0x30864548, 0x30864508, 0x30864588, 0x308626BE, 0x30868E01, 0x308627F8, 0x30861702, 0x308627FA, 0x30861709, 0x30865C0B, 0x30861710, 0x308626BA, 0x30865C03, 0x30861710, 0x308626B2, 0x30861706, 0x30865F28, 0x30868898, 0x30866027, 0x3086F217, 0x30861026, 0x3086A226, 0x3086A35F, 0x30864D28, 0x3086081A, 0x308627FA, 0x30868469, 0x3086A578, 0x30865D28, 0x30868887, 0x3086108C, 0x30868289, 0x308626B2, 0x30861703, 0x30866BA4, 0x30866099, 0x30861729, 0x30862683, 0x308645A8, 0x30861707, 0x308627FB, 0x30861729, 0x30864588, 0x30862017, 0x30860827, 0x3086FA5D, 0x30868710, 0x30868C82, 0x30868917, 0x30860E48, 0x3086269A, 0x30862888, 0x30864C0B, 0x30867917, 0x30863026, 0x30869217, 0x3086099A, 0x30866027, 0x3086F217, 0x30861026, 0x30868226, 0x3086835F, 0x30864D28, 0x3086081A, 0x308627FA, 0x30868469, 0x3086AB78, 0x30865D28, 0x30868887, 0x3086108C, 0x3086808A, 0x30862692, 0x30861703, 0x30866BA6, 0x3086A726, 0x3086035C, 0x30860145, 0x3086588E, 0x30860027, 0x30869817, 0x30860A4A, 0x30860A43, 0x3086160B, 0x3086438E, 0x30860327, 0x30869C45, 0x30867817, 0x30860727, 0x30869D17, 0x3086225D, 0x30868710, 0x30862808, 0x3086530D, 0x30868C80, 0x30868A45, 0x30865817, 0x3086088E, 0x30860127, 0x3086988E, 0x30860076, 0x3086AC77, 0x3086AC46, 0x30864416, 0x308616A8, 0x30867A26, 0x3086445C, 0x30860512, 0x3086444B, 0x30867175, 0x3086A24A, 0x30860343, 0x30861604, 0x30864316, 0x30865843, 0x3086165A, 0x30864316, 0x30860643, 0x30861607, 0x30864316, 0x30868E03, 0x3086279C, 0x30864578, 0x30867B17, 0x3086078B, 0x30868627, 0x30869D17, 0x30862345, 0x30865822, 0x30861708, 0x30868E01, 0x30862798, 0x30868E00, 0x30862644, 0x30865C05, 0x30861244, 0x30864B8D, 0x3086602C, 0x30862C2C, 0x30862C00, //[==== Optimized and Sequencer settings (DO NOT CHANGE) ====] //[AR0140 Rev3 Optimized Settings] 0x30440400, //Manufacturer-specific 0x3052A134, //Manufacturer-specific 0x3092010F, //Manufacturer-specific 0x30FE0080, //Manufacturer-specific 0x3ECE40FF, //Manufacturer-specific 0x3ED0FF40, //Manufacturer-specific 0x3ED2A906, //Manufacturer-specific 0x3ED4001F, //Manufacturer-specific 0x3ED6638F, //Manufacturer-specific 0x3ED8CC99, //Manufacturer-specific 0x3EDA0888, //Manufacturer-specific 0x3EDE8878, //Manufacturer-specific 0x3EE07744, //Manufacturer-specific 0x3EE24463, //Manufacturer-specific 0x3EE4AAE0, //Manufacturer-specific 0x3EE61400, //Manufacturer-specific 0x3EEAA4FF, //Manufacturer-specific 0x3EEC80F0, //Manufacturer-specific 0x3EEE0000, //Manufacturer-specific 0x31E01701, //Manufacturer-specific 0xFFFE0064, //delay 100ms //PLL_configuration_Parallel 0x302A0006, // VT_PIX_CLK_DIV 0x302C0001, // VT_SYS_CLK_DIV 0x302E0004, // PRE_PLL_CLK_DIV 0x30300042, // PLL_MULTIPLIER 0x3036000C, // OP_PIX_CLK_DIV 0x30380001, // OP_SYS_CLK_DIV //720P30fps_configuration 0x30040012, // X_ADDR_START 0x30020040, // Y_ADDR_START 0x30080519, // X_ADDR_END 0x30060317, // Y_ADDR_END 0x300A05D4, // FRAME_LENGTH_LINES 0x300C0672, // LINE_LENGTH_PCK 0x3012002D, // COARSE_INTEGRATION_TIME 0x30A20001, // X_ODD_INC 0x30A60001, // Y_ODD_INC 0x30400000, // READ_MODE //Companding_enabled_16to12 0x31AC100C, // DATA_FORMAT_BITS 0x31D00001, // COMPANDING //HDR Mode 16x Setup 0x305E0080, // global_gain 0x30820008, //HDR mode 0x318CC000, // Motion Compensation On 0x320A0080, // ADACD_PEDESTAL 0x32060A06, // ADACD_NOISE_FLOOR1 0x32060A06, // ADACD_NOISE_FLOOR1 0x32081A12, // ADACD_NOISE_FLOOR2 0x32081A12, // ADACD_NOISE_FLOOR2 0x320200A0, // ADACD_NOISE_MODEL1 0x32000002, // ADACD_CONTROL 0x31AC100C, // DATA_FORMAT_BITS 0x31D00001, // COMPANDING 0x318A0E74, // HDR_MC_CTRL1 0x31920400, // HDR_MC_CTRL5 0x3198183C, //Motion detect Q1 set to 60, Q2 set to 24 0x318E0800, //Gain before DLO set to 1 0x31940BB8, //T1 barrier set to 3000 0x31960E74, //T2 barrier set to 3700 0x30B00000, //DIGITAL_TEST 0x30BA012C, //DIGITAL_CTRL 0x31AE0301, //SERAIL_FORAMT: parallel infterface 0x30641882, // no statistic data output //0x306EF010, // current-drive set 0x306EE810, // current-drive set 0x301A10DC, //Start streaming 0xFFFF0000 //end of configuration }; #endif

12,388

C

.c

701

15.536377

84

0.799104

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,084

ar0140_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/aptina_ar0140/ar0140_sensor_ctl.c

#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "hi_i2c.h" #include "ar0140_sensor_config.h" const unsigned char sensor_i2c_addr = 0x20; /* I2C Address of AR0140 */ //or 0x30 const unsigned int sensor_addr_byte = 2; const unsigned int sensor_data_byte = 2; int sensor_read_register(int addr) { // TODO: return 0; } int sensor_write_register(int addr, int data) { int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_WRITE, &i2c_data); if (ret) { printf("hi_i2c write faild!\n"); return -1; } close(fd); return 0; } static void delay_ms(int ms) { usleep(ms*1000); } void sensor_prog(int* rom) { int i = 0; while (1) { int lookup = rom[i++]; int addr = (lookup >> 16) & 0xFFFF; int data = lookup & 0xFFFF; if (addr == 0xFFFE) { delay_ms(data); } else if (addr == 0xFFFF) { return; } else { sensor_write_register(addr, data); } } } void sensor_init() { printf("linear mode\n"); /* program sensor to linear mode */ sensor_prog(sensor_rom_30_lin); }

1,549

C

.c

66

18.787879

83

0.597938

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,086

ar0140_sensor_config.h

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/aptina_ar0140/ar0140_sensor_config.h

#ifndef _AR0140_SENSOR_CONFIG_H_ #define _AR0140_SENSOR_CONFIG_H_ // [addr:data] // when addr = 0xFFFF, configuration process end; when addr = 0xFFFE, deay data ms; extern int sensor_rom_30_lin[]; extern int sensor_rom_30_wdr[]; #endif

257

C

.c

7

32.714286

84

0.720339

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,088

imx138_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/sony_imx138/imx138_sensor_ctl.c

/****************************************************************************** Copyright (C), 2001-2011, Hisilicon Tech. Co., Ltd. ****************************************************************************** File Name : sony138_sensor_ctl.c Version : Initial Draft Author : Hisilicon multimedia software group Created : 2011/09/09 Description : Sony IMX138 sensor driver History : 1.Date : 2011/09/09 Author : MPP Modification: Created file ******************************************************************************/ #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "hi_ssp.h" int sony_sensor_write_packet(unsigned int data) { int fd = -1; int ret; unsigned int value; fd = open("/dev/ssp", 0); if(fd < 0) { printf("Open /dev/ssp error!\n"); return -1; } value = data; ret = ioctl(fd, SSP_WRITE_ALT, &value); close(fd); return 0; } int sony_sensor_read_packet(unsigned int data) { unsigned int value; int fd = -1; int ret; fd = open("/dev/ssp", 0); if(fd < 0) { printf("Open /dev/ssp error!\n"); return -1; } value = data; ret = ioctl(fd, SSP_READ_ALT, &value); close(fd); return (value&0xff); } int sensor_write_register(int addr, int data) { unsigned int value = (unsigned int)(((addr&0xffff)<<8) | (data & 0xff)); return sony_sensor_write_packet(value); } int sensor_read_register(int addr) { unsigned int data = (unsigned int)(((addr&0xffff)<<8)); return sony_sensor_read_packet(data); } void sensor_prog(int* rom) { } void setup_sensor(int isp_mode) { } void sensor_init() { sensor_write_register(0x200, 0x01); //Standby usleep(200000); // chip_id = 0x2 sensor_write_register(0x205, 0x01); //12bit sensor_write_register(0x206, 0x00); //Drive mode:All-pix scan mode(720p mode) sensor_write_register(0x207, 0x10); //Window mode:720p mode sensor_write_register(0x209, 0x02); //30fps mode sensor_write_register(0x20A, 0xF0); //black level /*linear & WDR mode is different*/ sensor_write_register(0x20C, 0x00); sensor_write_register(0x20F, 0x01); sensor_write_register(0x210, 0x39); sensor_write_register(0x212, 0x50); sensor_write_register(0x217, 0x01); sensor_write_register(0x218, 0xF0); sensor_write_register(0x219, 0x02); sensor_write_register(0x21A, 0x00); sensor_write_register(0x21B, 0xC0);//different from imx104 sensor_write_register(0x21C, 0x19); sensor_write_register(0x21D, 0xFF); sensor_write_register(0x21E, 0x01); sensor_write_register(0x236, 0x14); //VB size sensor_write_register(0x238, 0x00); //cropping postion(Vertical position) sensor_write_register(0x239, 0x00); sensor_write_register(0x23A, 0x19); //cropping size(Vertical direction) sensor_write_register(0x23B, 0x04); sensor_write_register(0x23C, 0x00); //cropping postion(horizontal position) sensor_write_register(0x23D, 0x00); sensor_write_register(0x23E, 0x1C); //cropping size(horizontal direction) sensor_write_register(0x23F, 0x05); sensor_write_register(0x244, 0x01); //Parallel CMOS SDR output sensor_write_register(0x254, 0x63); sensor_write_register(0x25B, 0x00); //CLK 37.125MHz sensor_write_register(0x25D, 0x00); //CLK 37.125MHz sensor_write_register(0x25F, 0x10); //invalid sensor_write_register(0x2BF, 0x1F); /*linear & WDR mode is different*/ sensor_write_register(0x265, 0x20); sensor_write_register(0x286, 0x01); sensor_write_register(0x2CF, 0xD1); sensor_write_register(0x2D0, 0x1B); sensor_write_register(0x2D2, 0x5F); sensor_write_register(0x2D3, 0x00); // chip_id = 0x3 sensor_write_register(0x312, 0x00); sensor_write_register(0x31D, 0x07); sensor_write_register(0x323, 0x07); sensor_write_register(0x326, 0xDF); sensor_write_register(0x347, 0x87); // chip_id = 0x4 sensor_write_register(0x403, 0xCD); sensor_write_register(0x407, 0x4B); sensor_write_register(0x409, 0xE9); sensor_write_register(0x413, 0x1B); sensor_write_register(0x415, 0xED); sensor_write_register(0x416, 0x01); sensor_write_register(0x418, 0x09); sensor_write_register(0x41A, 0x19); sensor_write_register(0x41B, 0xA1); sensor_write_register(0x41C, 0x11); sensor_write_register(0x427, 0x00); sensor_write_register(0x428, 0x05); sensor_write_register(0x429, 0xEC); sensor_write_register(0x42A, 0x40); sensor_write_register(0x42B, 0x11); sensor_write_register(0x42D, 0x22); sensor_write_register(0x42E, 0x00); sensor_write_register(0x42F, 0x05); sensor_write_register(0x431, 0xEC); sensor_write_register(0x432, 0x40); sensor_write_register(0x433, 0x11); sensor_write_register(0x435, 0x23); sensor_write_register(0x436, 0xB0); sensor_write_register(0x437, 0x04); sensor_write_register(0x439, 0x24); sensor_write_register(0x43A, 0x30); sensor_write_register(0x43B, 0x04); sensor_write_register(0x43C, 0xED); sensor_write_register(0x43D, 0xC0); sensor_write_register(0x43E, 0x10); sensor_write_register(0x440, 0x44); sensor_write_register(0x441, 0xA0); sensor_write_register(0x442, 0x04); sensor_write_register(0x443, 0x0D); sensor_write_register(0x444, 0x31); sensor_write_register(0x445, 0x11); sensor_write_register(0x447, 0xEC); sensor_write_register(0x448, 0xD0); sensor_write_register(0x449, 0x1D); sensor_write_register(0x455, 0x03); sensor_write_register(0x456, 0x54); sensor_write_register(0x457, 0x60); sensor_write_register(0x458, 0x1F); sensor_write_register(0x45A, 0xA9); sensor_write_register(0x45B, 0x50); sensor_write_register(0x45C, 0x0A); sensor_write_register(0x45D, 0x25); sensor_write_register(0x45E, 0x11); sensor_write_register(0x45F, 0x12); sensor_write_register(0x461, 0x9B); sensor_write_register(0x466, 0xD0); sensor_write_register(0x467, 0x08); sensor_write_register(0x46A, 0x20); sensor_write_register(0x46B, 0x0A); sensor_write_register(0x46E, 0x20); sensor_write_register(0x46F, 0x0A); sensor_write_register(0x472, 0x20); sensor_write_register(0x473, 0x0A); sensor_write_register(0x475, 0xEC); sensor_write_register(0x47D, 0xA5); sensor_write_register(0x47E, 0x20); sensor_write_register(0x47F, 0x0A); sensor_write_register(0x481, 0xEF); sensor_write_register(0x482, 0xC0); sensor_write_register(0x483, 0x0E); sensor_write_register(0x485, 0xF6); sensor_write_register(0x48A, 0x60); sensor_write_register(0x48B, 0x1F); sensor_write_register(0x48D, 0xBB); sensor_write_register(0x48E, 0x90); sensor_write_register(0x48F, 0x0D); sensor_write_register(0x490, 0x39); sensor_write_register(0x491, 0xC1); sensor_write_register(0x492, 0x1D); sensor_write_register(0x494, 0xC9); sensor_write_register(0x495, 0x70); sensor_write_register(0x496, 0x0E); sensor_write_register(0x497, 0x47); sensor_write_register(0x498, 0xA1); sensor_write_register(0x499, 0x1E); sensor_write_register(0x49B, 0xC5); sensor_write_register(0x49C, 0xB0); sensor_write_register(0x49D, 0x0E); sensor_write_register(0x49E, 0x43); sensor_write_register(0x49F, 0xE1); sensor_write_register(0x4A0, 0x1E); sensor_write_register(0x4A2, 0xBB); sensor_write_register(0x4A3, 0x10); sensor_write_register(0x4A4, 0x0C); sensor_write_register(0x4A6, 0xB3); sensor_write_register(0x4A7, 0x30); sensor_write_register(0x4A8, 0x0A); sensor_write_register(0x4A9, 0x29); sensor_write_register(0x4AA, 0x91); sensor_write_register(0x4AB, 0x11); sensor_write_register(0x4AD, 0xB4); sensor_write_register(0x4AE, 0x40); sensor_write_register(0x4AF, 0x0A); sensor_write_register(0x4B0, 0x2A); sensor_write_register(0x4B1, 0xA1); sensor_write_register(0x4B2, 0x11); sensor_write_register(0x4B4, 0xAB); sensor_write_register(0x4B5, 0xB0); sensor_write_register(0x4B6, 0x0B); sensor_write_register(0x4B7, 0x21); sensor_write_register(0x4B8, 0x11); sensor_write_register(0x4B9, 0x13); sensor_write_register(0x4BB, 0xAC); sensor_write_register(0x4BC, 0xC0); sensor_write_register(0x4BD, 0x0B); sensor_write_register(0x4BE, 0x22); sensor_write_register(0x4BF, 0x21); sensor_write_register(0x4C0, 0x13); sensor_write_register(0x4C2, 0xAD); sensor_write_register(0x4C3, 0x10); sensor_write_register(0x4C4, 0x0B); sensor_write_register(0x4C5, 0x23); sensor_write_register(0x4C6, 0x71); sensor_write_register(0x4C7, 0x12); sensor_write_register(0x4C9, 0xB5); sensor_write_register(0x4CA, 0x90); sensor_write_register(0x4CB, 0x0B); sensor_write_register(0x4CC, 0x2B); sensor_write_register(0x4CD, 0xF1); sensor_write_register(0x4CE, 0x12); sensor_write_register(0x4D0, 0xBB); sensor_write_register(0x4D1, 0x10); sensor_write_register(0x4D2, 0x0C); sensor_write_register(0x4D4, 0xE7); sensor_write_register(0x4D5, 0x90); sensor_write_register(0x4D6, 0x0E); sensor_write_register(0x4D8, 0x45); sensor_write_register(0x4D9, 0x11); sensor_write_register(0x4DA, 0x1F); sensor_write_register(0x4EB, 0xA4); sensor_write_register(0x4EC, 0x60); sensor_write_register(0x4ED, 0x1F); /*linear & WDR mode is different*/ sensor_write_register(0x461, 0x9B); sensor_write_register(0x466, 0xD0); sensor_write_register(0x467, 0x08); usleep(200000); sensor_write_register(0x200, 0x00); //release standy usleep(200000); sensor_write_register(0x202, 0x00); //Master mose start usleep(200000); sensor_write_register(0x249, 0x0A); //XVS & XHS output usleep(200000); printf("-------Sony IMX138 Sensor Initial OK!-------\n"); }

9,420

C

.c

270

32.574074

79

0.731424

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,094

po3100k_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/pixelplus_3100k/po3100k_sensor_ctl.c

#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #ifdef HI_GPIO_I2C #include "gpioi2c_ex.h" #include "gpio_i2c.h" #else #include "hi_i2c.h" #endif const unsigned char sensor_i2c_addr = 0x64; const unsigned int sensor_addr_byte = 1; const unsigned int sensor_data_byte = 1; int sensor_read_register(int addr) { #ifdef HI_GPIO_I2C int fd = -1; int ret; int value; fd = open("/dev/gpioi2c_ov", 0); if(fd<0) { printf("Open gpioi2c_ov error!\n"); return -1; } value = ((sensor_i2c_addr&0xff)<<24) | ((addr&0xff)<<16); ret = ioctl(fd, GPIO_I2C_READ, &value); if (ret) { printf("GPIO-I2C read faild!\n"); return -1; } value &= 0xff; close(fd); return value; #else int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_READ, &i2c_data); if (ret) { printf("hi_i2c read faild!\n"); return -1; } close(fd); #endif return i2c_data.data; return 0; } int sensor_write_register(int addr, int data) { #ifdef HI_GPIO_I2C int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/gpioi2c_ex", 0); if(fd<0) { printf("Open gpioi2c_ex error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, GPIO_I2C_WRITE, &i2c_data); if (ret) { printf("GPIO-I2C write faild!\n"); return -1; } close(fd); #else int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_WRITE, &i2c_data); if (ret) { printf("hi_i2c write faild!\n"); return -1; } close(fd); #endif return 0; } static void delay_ms(int ms) { usleep(ms*1000); } void sensor_prog(int* rom) { int i = 0; while (1) { int lookup = rom[i++]; int addr = (lookup >> 16) & 0xFFFF; int data = lookup & 0xFFFF; if (addr == 0xFFFE) { delay_ms(data); } else if (addr == 0xFFFF) { return; } else { sensor_write_register(addr, data); } } } void sensor_init() { printf("-----------start init pixel plus 3100K------------"); sensor_write_register(0x03,0x00); // -------- A sensor_write_register(0x2D,0x01); sensor_write_register(0x29,0x9D); sensor_write_register(0x04,0x02); sensor_write_register(0x05,0x03); sensor_write_register(0x06,0x06); sensor_write_register(0x07,0x71); sensor_write_register(0x08,0x02); sensor_write_register(0x09,0xEE); sensor_write_register(0x0A,0x02); sensor_write_register(0x0B,0xEE); sensor_write_register(0x0C,0x00); sensor_write_register(0x0D,0x05); sensor_write_register(0x0E,0x00); sensor_write_register(0x0F,0x05); sensor_write_register(0x10,0x05); sensor_write_register(0x11,0x04); sensor_write_register(0x12,0x02); sensor_write_register(0x13,0xD4); sensor_write_register(0x14,0x00); sensor_write_register(0x15,0x17); sensor_write_register(0x16,0x02); sensor_write_register(0x17,0xE8); sensor_write_register(0x03,0x05); sensor_write_register(0x04,0x00); sensor_write_register(0x03,0x00); sensor_write_register(0x18,0x00); sensor_write_register(0x19,0x00); sensor_write_register(0x1A,0x00); sensor_write_register(0x1B,0x02); sensor_write_register(0x1C,0x00); sensor_write_register(0x1D,0x00); sensor_write_register(0x1E,0x00); sensor_write_register(0x1F,0x00); sensor_write_register(0x20,0x08); sensor_write_register(0x21,0x00); sensor_write_register(0x22,0x00); sensor_write_register(0x23,0x50); sensor_write_register(0x24,0x00); sensor_write_register(0x25,0x08); sensor_write_register(0x26,0x41); sensor_write_register(0x27,0x66); sensor_write_register(0x28,0x30); sensor_write_register(0x2A,0x00); sensor_write_register(0x2B,0xC0); sensor_write_register(0x2C,0x00); sensor_write_register(0x2E,0x00); sensor_write_register(0x2F,0x00); sensor_write_register(0x30,0x00); sensor_write_register(0x31,0x00); sensor_write_register(0x32,0x00); sensor_write_register(0x33,0x02); sensor_write_register(0x34,0x01); sensor_write_register(0x35,0x2F); sensor_write_register(0x36,0x80); sensor_write_register(0x37,0x44); sensor_write_register(0x38,0x58); sensor_write_register(0x39,0x40); sensor_write_register(0x3A,0x18); sensor_write_register(0x3B,0x20); sensor_write_register(0x3C,0x00); sensor_write_register(0x3D,0x00); sensor_write_register(0x3E,0x00); sensor_write_register(0x3F,0x00); sensor_write_register(0x41,0x02); sensor_write_register(0x42,0x0B); sensor_write_register(0x40,0x3C); // pll sensor_write_register(0x4F,0x40); sensor_write_register(0x50,0x00); sensor_write_register(0x51,0x05); sensor_write_register(0x52,0x79); sensor_write_register(0x53,0x04); sensor_write_register(0x54,0x8D); sensor_write_register(0x55,0x40); sensor_write_register(0x56,0x00); sensor_write_register(0x57,0x00); sensor_write_register(0x58,0x40); sensor_write_register(0x59,0x00); sensor_write_register(0x5A,0xBB); sensor_write_register(0x5B,0x80); sensor_write_register(0x5C,0x00); sensor_write_register(0x5D,0xE1); sensor_write_register(0x5E,0x00); sensor_write_register(0x5F,0x04); sensor_write_register(0x60,0x65); sensor_write_register(0xD0,0x02); sensor_write_register(0xD1,0x05); sensor_write_register(0xD2,0x00); sensor_write_register(0xD3,0x80); sensor_write_register(0xD4,0x05); sensor_write_register(0xD5,0x00); // -- sensor_write_register(0xD6,0x02); sensor_write_register(0xD7,0xD0); sensor_write_register(0xD8,0x00); sensor_write_register(0xD9,0x00); sensor_write_register(0xDA,0x00); sensor_write_register(0xDB,0x00); sensor_write_register(0xDC,0x02); sensor_write_register(0xDD,0xEE); sensor_write_register(0xDE,0x00); sensor_write_register(0xDF,0x00); sensor_write_register(0xE0,0x1A); sensor_write_register(0xE1,0x00); sensor_write_register(0xE2,0x00); sensor_write_register(0xE3,0x01); sensor_write_register(0xE4,0x00); sensor_write_register(0xE5,0x00); sensor_write_register(0xE6,0x00); sensor_write_register(0xE7,0xFF); sensor_write_register(0xE8,0x00); sensor_write_register(0xE9,0x00); sensor_write_register(0xEA,0x00); sensor_write_register(0xEB,0x00); sensor_write_register(0xEC,0x00); sensor_write_register(0xED,0x00); sensor_write_register(0xEE,0x00); sensor_write_register(0xEF,0x00); sensor_write_register(0xF0,0xB6); sensor_write_register(0xF1,0xAB); sensor_write_register(0xF2,0x9D); sensor_write_register(0xF3,0x80); sensor_write_register(0xF4,0xF1); sensor_write_register(0xF5,0xEC); sensor_write_register(0xF6,0xDA); sensor_write_register(0xF7,0xC7); sensor_write_register(0xF8,0xFF); sensor_write_register(0xF9,0x00); sensor_write_register(0xFA,0x80); sensor_write_register(0xFB,0x10); sensor_write_register(0xFC,0x00); sensor_write_register(0xFD,0x02); sensor_write_register(0xFE,0x80); sensor_write_register(0xFF,0x00); sensor_write_register(0x03,0x01); // -------- B sensor_write_register(0x04,0xF0); sensor_write_register(0x05,0x02); sensor_write_register(0x06,0x02); sensor_write_register(0x07,0x67); sensor_write_register(0x08,0x20); sensor_write_register(0x09,0x04); sensor_write_register(0x0A,0xF0); sensor_write_register(0x0B,0x10); sensor_write_register(0x0C,0x00); sensor_write_register(0x0D,0x00); sensor_write_register(0x0E,0x1B); sensor_write_register(0x0F,0x00); sensor_write_register(0x10,0x00); sensor_write_register(0x11,0x04); sensor_write_register(0x12,0x0A); sensor_write_register(0x13,0x40); sensor_write_register(0x14,0x01); sensor_write_register(0x15,0x81); sensor_write_register(0x16,0x05); sensor_write_register(0x17,0xFA); sensor_write_register(0x18,0xC3); sensor_write_register(0x19,0xC0); sensor_write_register(0x1A,0xF0); sensor_write_register(0x1B,0x00); sensor_write_register(0x1C,0x11); sensor_write_register(0x1D,0x47); sensor_write_register(0x1E,0x0E); sensor_write_register(0x1F,0x00); sensor_write_register(0x20,0x00); sensor_write_register(0x21,0xFF); sensor_write_register(0x22,0x00); sensor_write_register(0x23,0x00); sensor_write_register(0x24,0x00); sensor_write_register(0x25,0x00); sensor_write_register(0x26,0x03); sensor_write_register(0x27,0xFF); sensor_write_register(0x28,0x07); sensor_write_register(0x29,0xFF); sensor_write_register(0x2A,0x00); sensor_write_register(0x2B,0x00); sensor_write_register(0x2C,0x00); sensor_write_register(0x2D,0x00); sensor_write_register(0x2E,0x00); sensor_write_register(0x2F,0x80); sensor_write_register(0x30,0x00); sensor_write_register(0x31,0x00); sensor_write_register(0x32,0x00); sensor_write_register(0x33,0x0A); sensor_write_register(0x34,0x02); sensor_write_register(0x35,0xEA); sensor_write_register(0x36,0x01); sensor_write_register(0x37,0x12); sensor_write_register(0x38,0x06); sensor_write_register(0x39,0x22); sensor_write_register(0x3A,0x00); sensor_write_register(0x3B,0x02); sensor_write_register(0x3C,0x00); sensor_write_register(0x3D,0x08); sensor_write_register(0x3E,0x01); sensor_write_register(0x3F,0x12); sensor_write_register(0x40,0x06); sensor_write_register(0x41,0x22); sensor_write_register(0x42,0x00); sensor_write_register(0x43,0x00); sensor_write_register(0x44,0x00); sensor_write_register(0x45,0x00); sensor_write_register(0x46,0x00); sensor_write_register(0x47,0x00); sensor_write_register(0x48,0x01); sensor_write_register(0x49,0x00); sensor_write_register(0x4A,0x01); sensor_write_register(0x4B,0x00); sensor_write_register(0x4C,0x01); sensor_write_register(0x4D,0x00); sensor_write_register(0x4E,0x01); sensor_write_register(0x4F,0x02); sensor_write_register(0x50,0x7F); sensor_write_register(0x51,0x04); sensor_write_register(0x52,0xFF); sensor_write_register(0x53,0x00); sensor_write_register(0x54,0x0A); sensor_write_register(0x55,0x06); sensor_write_register(0x56,0x24); sensor_write_register(0x57,0x06); sensor_write_register(0x58,0x24); sensor_write_register(0x59,0x06); sensor_write_register(0x5A,0x53); sensor_write_register(0x5B,0x00); sensor_write_register(0x5C,0x02); sensor_write_register(0x5D,0x06); sensor_write_register(0x5E,0x1C); sensor_write_register(0x5F,0x00); sensor_write_register(0x60,0x02); sensor_write_register(0x61,0x00); sensor_write_register(0x62,0xA0); sensor_write_register(0x63,0x00); sensor_write_register(0x64,0x00); sensor_write_register(0x65,0x00); sensor_write_register(0x66,0x00); sensor_write_register(0x67,0x00); sensor_write_register(0x68,0xB3); sensor_write_register(0x69,0x00); sensor_write_register(0x6A,0xC6); sensor_write_register(0x6B,0x00); sensor_write_register(0x6C,0x00); sensor_write_register(0x6D,0x00); sensor_write_register(0x6E,0x00); sensor_write_register(0x6F,0x00); sensor_write_register(0x70,0xD0); sensor_write_register(0x71,0x06); sensor_write_register(0x72,0x1A); sensor_write_register(0x73,0x00); sensor_write_register(0x74,0xD6); sensor_write_register(0x75,0x06); sensor_write_register(0x76,0x18); sensor_write_register(0x77,0x06); sensor_write_register(0x78,0x46); sensor_write_register(0x79,0x06); sensor_write_register(0x7A,0x50); sensor_write_register(0x7B,0x00); sensor_write_register(0x7C,0xD6); sensor_write_register(0x7D,0x06); sensor_write_register(0x7E,0x18); sensor_write_register(0x7F,0x06); sensor_write_register(0x80,0x30); sensor_write_register(0x81,0x06); sensor_write_register(0x82,0x67); sensor_write_register(0x83,0x06); sensor_write_register(0x84,0x30); sensor_write_register(0x85,0x06); sensor_write_register(0x86,0x67); sensor_write_register(0x87,0x06); sensor_write_register(0x88,0x28); sensor_write_register(0x89,0x06); sensor_write_register(0x8A,0x2D); sensor_write_register(0x8B,0x00); sensor_write_register(0x8C,0xD8); sensor_write_register(0x8D,0x06); sensor_write_register(0x8E,0x30); sensor_write_register(0x8F,0x00); sensor_write_register(0x90,0xAD); sensor_write_register(0x91,0x06); sensor_write_register(0x92,0x30); sensor_write_register(0x93,0x06); sensor_write_register(0x94,0x71); sensor_write_register(0x95,0x06); sensor_write_register(0x96,0x30); sensor_write_register(0x97,0x06); sensor_write_register(0x98,0x41); sensor_write_register(0x99,0x00); sensor_write_register(0x9A,0xB3); sensor_write_register(0x9B,0x06); sensor_write_register(0x9C,0x24); sensor_write_register(0x9D,0x00); sensor_write_register(0x9E,0x00); sensor_write_register(0x9F,0x06); sensor_write_register(0xA0,0x56); sensor_write_register(0xA1,0x04); sensor_write_register(0xA2,0x6E); sensor_write_register(0xA3,0x00); sensor_write_register(0xA4,0x00); sensor_write_register(0xA5,0x00); sensor_write_register(0xA6,0x00); sensor_write_register(0xA7,0x00); sensor_write_register(0xA8,0x00); sensor_write_register(0xA9,0x00); sensor_write_register(0xAA,0xFF); sensor_write_register(0xAB,0x7F); sensor_write_register(0xAC,0x00); sensor_write_register(0xAD,0x00); sensor_write_register(0xAE,0x20); sensor_write_register(0xAF,0x20); sensor_write_register(0xB0,0x20); sensor_write_register(0xB1,0x30); sensor_write_register(0xB2,0x00); sensor_write_register(0xB3,0x40); sensor_write_register(0xB4,0x40); sensor_write_register(0xB5,0x40); sensor_write_register(0xB6,0x00); sensor_write_register(0xB7,0x00); sensor_write_register(0xB8,0x00); sensor_write_register(0xB9,0x06); sensor_write_register(0xBA,0x30); sensor_write_register(0xBB,0x06); sensor_write_register(0xBC,0x67); sensor_write_register(0xBD,0x00); sensor_write_register(0xBE,0x08); sensor_write_register(0xBF,0x00); sensor_write_register(0xC0,0x00); sensor_write_register(0xC1,0x27); sensor_write_register(0xC2,0x76); sensor_write_register(0xC3,0x00); sensor_write_register(0xC4,0x40); sensor_write_register(0xC5,0x00); sensor_write_register(0xC6,0x11); sensor_write_register(0xC7,0x70); sensor_write_register(0xC8,0x01); sensor_write_register(0xC9,0x01); sensor_write_register(0xCA,0x00); sensor_write_register(0xCB,0x00); sensor_write_register(0xCC,0x00); sensor_write_register(0xCD,0x00); sensor_write_register(0xCE,0x00); sensor_write_register(0xCF,0x00); sensor_write_register(0xD0,0x00); sensor_write_register(0xD1,0x00); sensor_write_register(0xD2,0x00); sensor_write_register(0xD3,0x00); sensor_write_register(0xD4,0x00); sensor_write_register(0xD5,0x00); sensor_write_register(0xD6,0x00); sensor_write_register(0xD7,0x00); sensor_write_register(0xD8,0x00); sensor_write_register(0x03,0x02); // -------- C sensor_write_register(0x04,0x00); sensor_write_register(0x05,0x02); sensor_write_register(0x06,0x00); sensor_write_register(0x07,0xE0); sensor_write_register(0x08,0x00); sensor_write_register(0x09,0x00); sensor_write_register(0x0A,0x15); sensor_write_register(0x0B,0x80); sensor_write_register(0x0C,0x00); sensor_write_register(0x29,0x41); sensor_write_register(0x2A,0x00); sensor_write_register(0x2B,0x14); sensor_write_register(0x2C,0x00); sensor_write_register(0x2D,0x40); sensor_write_register(0x2E,0x30); sensor_write_register(0x2F,0x14); sensor_write_register(0x30,0x80); sensor_write_register(0x31,0x80); sensor_write_register(0x32,0x00); sensor_write_register(0x7A,0x8C); sensor_write_register(0x7B,0x20); sensor_write_register(0x7C,0x20); sensor_write_register(0x7D,0x00); sensor_write_register(0x7E,0x0A); sensor_write_register(0x7F,0x80); sensor_write_register(0x8E,0xFE); sensor_write_register(0x8F,0x00); sensor_write_register(0x90,0x00); sensor_write_register(0x9A,0x81); sensor_write_register(0x9B,0x00); sensor_write_register(0x9C,0x00); sensor_write_register(0x9D,0x00); sensor_write_register(0xAC,0x00); sensor_write_register(0xAD,0x00); sensor_write_register(0xAE,0x00); sensor_write_register(0xAF,0x0C); sensor_write_register(0xB0,0x04); sensor_write_register(0xB1,0x4B); sensor_write_register(0xB2,0x00); sensor_write_register(0xB3,0x00); sensor_write_register(0xB4,0x05); sensor_write_register(0xB5,0x05); sensor_write_register(0xB6,0x04); sensor_write_register(0xB7,0x00); sensor_write_register(0xB8,0x05); sensor_write_register(0xB9,0x02); sensor_write_register(0xBA,0xD4); sensor_write_register(0xBB,0x01); sensor_write_register(0xBC,0xAF); sensor_write_register(0xBD,0x03); sensor_write_register(0xBE,0x5A); sensor_write_register(0xBF,0x00); sensor_write_register(0xC0,0xF5); sensor_write_register(0xC1,0x01); sensor_write_register(0xC2,0xE4); sensor_write_register(0xC3,0x02); sensor_write_register(0xC4,0x85); sensor_write_register(0xC5,0x01); sensor_write_register(0xC6,0x6D); sensor_write_register(0xC7,0x00); sensor_write_register(0xC8,0x05); sensor_write_register(0xC9,0x05); sensor_write_register(0xCA,0x04); sensor_write_register(0xCB,0x00); sensor_write_register(0xCC,0x05); sensor_write_register(0xCD,0x02); sensor_write_register(0xCE,0xD4); sensor_write_register(0x03,0x03); // -------- D sensor_write_register(0x16,0x3A); sensor_write_register(0x17,0x50); sensor_write_register(0x18,0x5A); sensor_write_register(0x19,0x20); sensor_write_register(0x1A,0x00); sensor_write_register(0x22,0x00); sensor_write_register(0x23,0x00); sensor_write_register(0x24,0x00); sensor_write_register(0x25,0x00); sensor_write_register(0x26,0x00); sensor_write_register(0x27,0x10); sensor_write_register(0x28,0x20); sensor_write_register(0x29,0x00); sensor_write_register(0x2A,0x00); sensor_write_register(0x2B,0x0C); sensor_write_register(0x2C,0x1C); sensor_write_register(0x2D,0x00); sensor_write_register(0x2E,0x5F); sensor_write_register(0x2F,0x3F); sensor_write_register(0x30,0x3F); sensor_write_register(0x31,0x5F); sensor_write_register(0x32,0x40); sensor_write_register(0x33,0x40); sensor_write_register(0x34,0x40); sensor_write_register(0x35,0x40); sensor_write_register(0x36,0x00); sensor_write_register(0x37,0x08); sensor_write_register(0x38,0x18); sensor_write_register(0x39,0x00); sensor_write_register(0x3A,0x10); sensor_write_register(0x3B,0x10); sensor_write_register(0x3C,0x10); sensor_write_register(0x3D,0x10); sensor_write_register(0x3E,0x04); sensor_write_register(0x3F,0x08); sensor_write_register(0x40,0x18); sensor_write_register(0x41,0x04); sensor_write_register(0x42,0x00); sensor_write_register(0x03,0x04); // -------- E sensor_write_register(0x04,0x9F); sensor_write_register(0x05,0x64); sensor_write_register(0x06,0x80); sensor_write_register(0x07,0x80); sensor_write_register(0x08,0x00); sensor_write_register(0x09,0x01); sensor_write_register(0x0A,0x00); sensor_write_register(0x0B,0x80); sensor_write_register(0x0E,0x00); sensor_write_register(0x0F,0x20); sensor_write_register(0x10,0x40); sensor_write_register(0x11,0xEE); sensor_write_register(0x12,0x02); sensor_write_register(0x13,0xE8); sensor_write_register(0x14,0x02); sensor_write_register(0x15,0xE8); sensor_write_register(0x16,0x02); sensor_write_register(0x17,0xE8); sensor_write_register(0x18,0x00); sensor_write_register(0x19,0x00); sensor_write_register(0x1A,0x20); sensor_write_register(0x1B,0x00); sensor_write_register(0x1C,0xBA); sensor_write_register(0x1D,0x00); sensor_write_register(0x1E,0x00); sensor_write_register(0x1F,0xBA); sensor_write_register(0x20,0x00); sensor_write_register(0x21,0x00); sensor_write_register(0x22,0x00); sensor_write_register(0x23,0x80); sensor_write_register(0x24,0x00); sensor_write_register(0x25,0x01); sensor_write_register(0x26,0x00); sensor_write_register(0x27,0x00); sensor_write_register(0x28,0x00); sensor_write_register(0x29,0x27); sensor_write_register(0x2A,0x76); sensor_write_register(0x2B,0x00); sensor_write_register(0x2C,0xBB); sensor_write_register(0x2D,0x00); sensor_write_register(0x2E,0x02); sensor_write_register(0x2F,0x00); sensor_write_register(0x03,0x00); // pll sensor_write_register(0x40,0x2C); sensor_write_register(0x03,0x01); printf("PixelPlus po3100k sensor 720P30fps init success!\n"); }

22,211

C

.c

635

29.948031

65

0.705524

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false

14,375,095

imx236_sensor_ctl.c

thatking_hisilicon_mpp/hi3518v100_mpp_1.0.B.0/component/isp2/sensor/sony_imx236/imx236_sensor_ctl.c

#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <fcntl.h> #include <unistd.h> #include "hi_comm_isp.h" #ifdef HI_GPIO_I2C #include "gpioi2c_32.h" #include "gpio_i2c.h" #else #include "hi_i2c.h" #endif #define SPI2IIC_ADDR_MAP_OFFSET 0x2e00 const unsigned char sensor_i2c_addr = 0x34; /* I2C Address of IMX236 */ const unsigned int sensor_addr_byte = 2; /* I2C addr byte of IMX236 */ const unsigned int sensor_data_byte = 1; /* I2C data byte of IMX236 */ void sensor_linner_init(); void sensor_wdr_init(); int sensor_read_register(int addr) { int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr + SPI2IIC_ADDR_MAP_OFFSET; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_READ, &i2c_data); if (ret) { printf("hi_i2c read faild!\n"); close(fd); return -1; } close(fd); return i2c_data.data; } int sensor_write_register(int addr, int data) { #ifdef HI_GPIO_I2C int fd = -1; int ret; Aptina_9M034_DATA i2c_data; fd = open("/dev/gpioi2c_32", 0); if(fd<0) { printf("Open gpioi2c_32 error!\n"); return -1; } i2c_data.I2cDevAddr = sensor_i2c_addr; i2c_data.I2cRegAddr = addr + SPI2IIC_ADDR_MAP_OFFSET; i2c_data.RWData = data ; ret = ioctl(fd, GPIO_I2C_WRITE, &i2c_data); if (ret) { printf("GPIO-I2C write faild!\n"); return -1; } close(fd); #else int fd = -1; int ret; I2C_DATA_S i2c_data; fd = open("/dev/hi_i2c", 0); if(fd<0) { printf("Open hi_i2c error!\n"); return -1; } i2c_data.dev_addr = sensor_i2c_addr; i2c_data.reg_addr = addr + SPI2IIC_ADDR_MAP_OFFSET; i2c_data.addr_byte_num = sensor_addr_byte; i2c_data.data = data; i2c_data.data_byte_num = sensor_data_byte; ret = ioctl(fd, CMD_I2C_WRITE, &i2c_data); if (ret) { printf("hi_i2c write faild!\n"); return -1; } close(fd); #endif return 0; } void sensor_prog(int* rom) { return; } void sensor_linner_init() { sensor_write_register(0x200, 0x01); /* Standby */ usleep(200000); sensor_write_register(0x205, 0x01); /* 12 bit */ sensor_write_register(0x209, 0x02); /* Frame rate (data rate) setting: 30fps */ sensor_write_register(0x20C, 0x00); /* 00 normal mode, 02 Built-in WDR mode */ sensor_write_register(0x20F, 0x01); /* WDR */ sensor_write_register(0x210, 0x01); /* WDR */ //sensor_write_register(0x212, 0x00); /* WDR */ sensor_write_register(0x212, 0xF0); // sensor_write_register(0x213, 0x00); /* WDR */ sensor_write_register(0x215, 0x00); /* WDR */ sensor_write_register(0x244, 0x01); /* cmos parallel output, 12bit */ printf("\r\n-------Sony IMX236 Sensor Initial OK!-------\r\n"); /* waiting for image stabilization */ usleep(200000); sensor_write_register(0x200, 0x00); /* release standy */ usleep(200000); sensor_write_register(0x202, 0x00); /* Master mode operation start */ usleep(200000); sensor_write_register(0x249, 0x0A); /* HSYNC and VSYNC output */ usleep(200000); return; } void sensor_wdr_init() { sensor_write_register(0x200, 0x01); /* Standby */ usleep(200000); sensor_write_register(0x205, 0x01); /* 12 bit */ sensor_write_register(0x209, 0x02); /* Frame rate (data rate) setting: 30fps */ sensor_write_register(0x20C, 0x02); /* 00 normal mode, 02 Built-in WDR mode */ sensor_write_register(0x20F, 0x05); /* WDR */ sensor_write_register(0x210, 0x00); /* WDR */ sensor_write_register(0x212, 0x2D); /* WDR */ sensor_write_register(0x213, 0x00); /* WDR */ sensor_write_register(0x215, 0x00); /* WDR */ sensor_write_register(0x244, 0x01); /* cmos parallel output, 12bit */ sensor_write_register(0x265, 0x00); /* WDR */ sensor_write_register(0x284, 0x10); /* WDR */ sensor_write_register(0x286, 0x10); /* WDR */ sensor_write_register(0x2CF, 0xE1); /* WDR */ sensor_write_register(0x2D0, 0x30); /* WDR */ sensor_write_register(0x2D2, 0xC4); /* WDR */ sensor_write_register(0x2D3, 0x01); /* WDR */ sensor_write_register(0x2CC, 0x21); /* 21h 16times, 31h 32times */ printf("\r\n-------Sony IMX236 Sensor Built-In WDR Initial OK!-------\r\n"); /* waiting for image stabilization */ usleep(200000); sensor_write_register(0x200, 0x00); /* release standy */ usleep(200000); sensor_write_register(0x202, 0x00); /* Master mode operation start */ usleep(200000); sensor_write_register(0x249, 0x0A); /* HSYNC and VSYNC output */ usleep(200000); return; } void sensor_init() { sensor_write_register(0x200, 0x01); /* Standby */ usleep(200000); sensor_write_register(0x202, 0x01); /* master mode stop */ sensor_write_register(0x205, 0x01); /* 12 bit */ sensor_write_register(0x206, 0x00); /* All-pix scan mode */ sensor_write_register(0x207, 0x10); /* 1080p mode */ sensor_write_register(0x209, 0x02); /* Frame rate (data rate) setting: 30fps */ sensor_write_register(0x20A, 0xF0); /* Black level offset */ sensor_write_register(0x20B, 0x00); /* Black level offset */ sensor_write_register(0x20B, 0x00); /* Black level offset */ sensor_write_register(0x214, 0x0C); /* AGC min gain 1.2dB; */ sensor_write_register(0x218, 0x65); /* Vertical span[7:0] */ sensor_write_register(0x219, 0x04); /* Vertical span[15:8] */ sensor_write_register(0x21A, 0x00); /* Vertical span[15:8] */ sensor_write_register(0x21B, 0x30); /* Horizontal span[7:0] */ sensor_write_register(0x21C, 0x11); /* Horizontal span[15:8] */ sensor_write_register(0x220, 0xC0); /* Shutter[7:0] */ sensor_write_register(0x221, 0x03); /* Shutter[15:8] */ sensor_write_register(0x244, 0x01); /* cmos parallel output, 12bit */ sensor_write_register(0x246, 0x01); sensor_write_register(0x247, 0x01); sensor_write_register(0x248, 0x01); sensor_write_register(0x249, 0x0A); /* HSYNC,VSYNC output */ sensor_write_register(0x254, 0x63); sensor_write_register(0x25B, 0x00); /* INCK setting0 */ sensor_write_register(0x25C, 0x20); /* INCK setting1 */ sensor_write_register(0x25D, 0x06); /* INCK setting2 */ sensor_write_register(0x25E, 0x30); /* INCK setting3 */ sensor_write_register(0x25F, 0x04); /* INCK setting4 */ sensor_write_register(0x30F, 0x0E); /* */ sensor_write_register(0x316, 0x02); /* */ sensor_write_register(0x436, 0x71); /* */ sensor_write_register(0x439, 0xF1); /* */ sensor_write_register(0x441, 0xF2); /* */ sensor_write_register(0x442, 0x21); /* */ sensor_write_register(0x443, 0x21); /* */ sensor_write_register(0x448, 0xF2); /* */ sensor_write_register(0x449, 0x21); /* */ sensor_write_register(0x44A, 0x21); /* */ sensor_write_register(0x452, 0x01); /* */ sensor_write_register(0x454, 0xB1); /* */ /* waiting for image stabilization */ usleep(200000); sensor_write_register(0x200, 0x00); /* release standy */ usleep(200000); sensor_write_register(0x202, 0x00); /* Master mode operation start */ usleep(200000); sensor_write_register(0x249, 0x0A); /* HSYNC and VSYNC output */ usleep(200000); sensor_linner_init(); }

7,942

C

.c

205

33.780488

88

0.615737

thatking/hisilicon_mpp

3

26

0

GPL-2.0

9/7/2024, 2:14:14 PM (Europe/Amsterdam)

false