Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Register map access API internal header |
| 3 | * |
| 4 | * Copyright 2011 Wolfson Microelectronics plc |
| 5 | * |
| 6 | * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License version 2 as |
| 10 | * published by the Free Software Foundation. |
| 11 | */ |
| 12 | |
| 13 | #ifndef _REGMAP_INTERNAL_H |
| 14 | #define _REGMAP_INTERNAL_H |
| 15 | |
Mark Brown | 4f7d6dd | 2016-03-29 12:28:33 -0700 | [diff] [blame] | 16 | #include <linux/device.h> |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 17 | #include <linux/regmap.h> |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 18 | #include <linux/fs.h> |
Mark Brown | 5166b7c | 2012-12-11 01:24:29 +0900 | [diff] [blame] | 19 | #include <linux/list.h> |
Mark Brown | 0d509f2 | 2013-01-27 22:07:38 +0800 | [diff] [blame] | 20 | #include <linux/wait.h> |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 21 | |
| 22 | struct regmap; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 23 | struct regcache_ops; |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 24 | |
Mark Brown | 5166b7c | 2012-12-11 01:24:29 +0900 | [diff] [blame] | 25 | struct regmap_debugfs_off_cache { |
| 26 | struct list_head list; |
| 27 | off_t min; |
| 28 | off_t max; |
| 29 | unsigned int base_reg; |
Dimitris Papastamos | c2c1ee6 | 2013-02-08 12:47:14 +0000 | [diff] [blame] | 30 | unsigned int max_reg; |
Mark Brown | 5166b7c | 2012-12-11 01:24:29 +0900 | [diff] [blame] | 31 | }; |
| 32 | |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 33 | struct regmap_format { |
| 34 | size_t buf_size; |
| 35 | size_t reg_bytes; |
Mark Brown | 82159ba | 2012-01-18 10:52:25 +0000 | [diff] [blame] | 36 | size_t pad_bytes; |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 37 | size_t val_bytes; |
| 38 | void (*format_write)(struct regmap *map, |
| 39 | unsigned int reg, unsigned int val); |
Marc Reilly | d939fb9 | 2012-03-16 12:11:43 +1100 | [diff] [blame] | 40 | void (*format_reg)(void *buf, unsigned int reg, unsigned int shift); |
| 41 | void (*format_val)(void *buf, unsigned int val, unsigned int shift); |
Mark Brown | 8a819ff | 2013-03-04 09:04:51 +0800 | [diff] [blame] | 42 | unsigned int (*parse_val)(const void *buf); |
| 43 | void (*parse_inplace)(void *buf); |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 44 | }; |
| 45 | |
Mark Brown | 0d509f2 | 2013-01-27 22:07:38 +0800 | [diff] [blame] | 46 | struct regmap_async { |
| 47 | struct list_head list; |
Mark Brown | 0d509f2 | 2013-01-27 22:07:38 +0800 | [diff] [blame] | 48 | struct regmap *map; |
| 49 | void *work_buf; |
| 50 | }; |
| 51 | |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 52 | struct regmap { |
Wang, Yalin | 336fb81 | 2014-09-11 16:19:49 +0800 | [diff] [blame] | 53 | union { |
| 54 | struct mutex mutex; |
Wang, Yalin | f93d1be | 2014-12-15 16:05:50 +0800 | [diff] [blame] | 55 | struct { |
| 56 | spinlock_t spinlock; |
| 57 | unsigned long spinlock_flags; |
| 58 | }; |
Wang, Yalin | 336fb81 | 2014-09-11 16:19:49 +0800 | [diff] [blame] | 59 | }; |
Stephen Warren | bacdbe0 | 2012-04-04 15:48:28 -0600 | [diff] [blame] | 60 | regmap_lock lock; |
| 61 | regmap_unlock unlock; |
Davide Ciminaghi | 0d4529c | 2012-10-16 15:56:59 +0200 | [diff] [blame] | 62 | void *lock_arg; /* This is passed to lock/unlock functions */ |
Stephen Boyd | b4a21fc | 2015-09-11 16:37:05 -0700 | [diff] [blame] | 63 | gfp_t alloc_flags; |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 64 | |
| 65 | struct device *dev; /* Device we do I/O on */ |
| 66 | void *work_buf; /* Scratch buffer used to format I/O */ |
| 67 | struct regmap_format format; /* Buffer format */ |
| 68 | const struct regmap_bus *bus; |
Stephen Warren | 0135bbc | 2012-04-04 15:48:30 -0600 | [diff] [blame] | 69 | void *bus_context; |
Mark Brown | 72b39f6 | 2012-05-08 17:44:40 +0100 | [diff] [blame] | 70 | const char *name; |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 71 | |
Mark Brown | 0a81980 | 2013-10-09 12:28:52 +0100 | [diff] [blame] | 72 | bool async; |
Mark Brown | 0d509f2 | 2013-01-27 22:07:38 +0800 | [diff] [blame] | 73 | spinlock_t async_lock; |
| 74 | wait_queue_head_t async_waitq; |
| 75 | struct list_head async_list; |
Mark Brown | 7e09a97 | 2013-10-07 23:00:24 +0100 | [diff] [blame] | 76 | struct list_head async_free; |
Mark Brown | 0d509f2 | 2013-01-27 22:07:38 +0800 | [diff] [blame] | 77 | int async_ret; |
| 78 | |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 79 | #ifdef CONFIG_DEBUG_FS |
| 80 | struct dentry *debugfs; |
Stephen Warren | d3c242e | 2012-04-04 15:48:29 -0600 | [diff] [blame] | 81 | const char *debugfs_name; |
Mark Brown | cbc1938 | 2012-12-06 13:29:05 +0900 | [diff] [blame] | 82 | |
| 83 | unsigned int debugfs_reg_len; |
| 84 | unsigned int debugfs_val_len; |
| 85 | unsigned int debugfs_tot_len; |
Mark Brown | 5166b7c | 2012-12-11 01:24:29 +0900 | [diff] [blame] | 86 | |
| 87 | struct list_head debugfs_off_cache; |
Dimitris Papastamos | 065b4c5 | 2013-02-20 12:15:23 +0000 | [diff] [blame] | 88 | struct mutex cache_lock; |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 89 | #endif |
| 90 | |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 91 | unsigned int max_register; |
| 92 | bool (*writeable_reg)(struct device *dev, unsigned int reg); |
| 93 | bool (*readable_reg)(struct device *dev, unsigned int reg); |
| 94 | bool (*volatile_reg)(struct device *dev, unsigned int reg); |
Mark Brown | 2efe164 | 2011-08-08 15:41:46 +0900 | [diff] [blame] | 95 | bool (*precious_reg)(struct device *dev, unsigned int reg); |
Davide Ciminaghi | 76aad39 | 2012-11-20 15:20:30 +0100 | [diff] [blame] | 96 | const struct regmap_access_table *wr_table; |
| 97 | const struct regmap_access_table *rd_table; |
| 98 | const struct regmap_access_table *volatile_table; |
| 99 | const struct regmap_access_table *precious_table; |
Lars-Peter Clausen | 6f30644 | 2011-09-05 20:46:32 +0200 | [diff] [blame] | 100 | |
Andrey Smirnov | ad27840 | 2013-01-12 12:54:12 -0800 | [diff] [blame] | 101 | int (*reg_read)(void *context, unsigned int reg, unsigned int *val); |
Andrey Smirnov | 07c320d | 2013-01-12 12:54:13 -0800 | [diff] [blame] | 102 | int (*reg_write)(void *context, unsigned int reg, unsigned int val); |
Jon Ringle | 77792b1 | 2015-10-01 12:38:07 -0400 | [diff] [blame] | 103 | int (*reg_update_bits)(void *context, unsigned int reg, |
| 104 | unsigned int mask, unsigned int val); |
Andrey Smirnov | ad27840 | 2013-01-12 12:54:12 -0800 | [diff] [blame] | 105 | |
Andrey Smirnov | d2a5884 | 2013-01-27 10:49:05 -0800 | [diff] [blame] | 106 | bool defer_caching; |
| 107 | |
Lars-Peter Clausen | 6f30644 | 2011-09-05 20:46:32 +0200 | [diff] [blame] | 108 | u8 read_flag_mask; |
| 109 | u8 write_flag_mask; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 110 | |
Marc Reilly | d939fb9 | 2012-03-16 12:11:43 +1100 | [diff] [blame] | 111 | /* number of bits to (left) shift the reg value when formatting*/ |
| 112 | int reg_shift; |
Stephen Warren | f01ee60 | 2012-04-09 13:40:24 -0600 | [diff] [blame] | 113 | int reg_stride; |
Xiubo Li | ca747be | 2016-01-04 18:00:33 +0800 | [diff] [blame] | 114 | int reg_stride_order; |
Marc Reilly | d939fb9 | 2012-03-16 12:11:43 +1100 | [diff] [blame] | 115 | |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 116 | /* regcache specific members */ |
| 117 | const struct regcache_ops *cache_ops; |
| 118 | enum regcache_type cache_type; |
| 119 | |
| 120 | /* number of bytes in reg_defaults_raw */ |
| 121 | unsigned int cache_size_raw; |
| 122 | /* number of bytes per word in reg_defaults_raw */ |
| 123 | unsigned int cache_word_size; |
| 124 | /* number of entries in reg_defaults */ |
| 125 | unsigned int num_reg_defaults; |
| 126 | /* number of entries in reg_defaults_raw */ |
| 127 | unsigned int num_reg_defaults_raw; |
| 128 | |
| 129 | /* if set, only the cache is modified not the HW */ |
Viresh Kumar | 621a5f7 | 2015-09-26 15:04:07 -0700 | [diff] [blame] | 130 | bool cache_only; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 131 | /* if set, only the HW is modified not the cache */ |
Viresh Kumar | 621a5f7 | 2015-09-26 15:04:07 -0700 | [diff] [blame] | 132 | bool cache_bypass; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 133 | /* if set, remember to free reg_defaults_raw */ |
Mark Brown | 847fb6f | 2012-02-06 18:01:35 +0000 | [diff] [blame] | 134 | bool cache_free; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 135 | |
| 136 | struct reg_default *reg_defaults; |
| 137 | const void *reg_defaults_raw; |
| 138 | void *cache; |
Kevin Cernekee | 1c79771 | 2015-05-05 15:14:14 -0700 | [diff] [blame] | 139 | /* if set, the cache contains newer data than the HW */ |
Viresh Kumar | 621a5f7 | 2015-09-26 15:04:07 -0700 | [diff] [blame] | 140 | bool cache_dirty; |
Kevin Cernekee | 1c79771 | 2015-05-05 15:14:14 -0700 | [diff] [blame] | 141 | /* if set, the HW registers are known to match map->reg_defaults */ |
| 142 | bool no_sync_defaults; |
Mark Brown | 22f0d90 | 2012-01-21 12:01:14 +0000 | [diff] [blame] | 143 | |
Nariman Poushin | 8019ff6 | 2015-07-16 16:36:21 +0100 | [diff] [blame] | 144 | struct reg_sequence *patch; |
Mark Brown | 22f0d90 | 2012-01-21 12:01:14 +0000 | [diff] [blame] | 145 | int patch_regs; |
Ashish Jangam | 2e33caf | 2012-04-30 23:23:40 +0100 | [diff] [blame] | 146 | |
Markus Pargmann | 67921a1 | 2015-08-21 10:26:42 +0200 | [diff] [blame] | 147 | /* if set, converts bulk read to single read */ |
| 148 | bool use_single_read; |
| 149 | /* if set, converts bulk read to single read */ |
| 150 | bool use_single_write; |
Opensource [Anthony Olech] | e894c3f | 2014-03-04 13:54:02 +0000 | [diff] [blame] | 151 | /* if set, the device supports multi write mode */ |
| 152 | bool can_multi_write; |
Krystian Garbaciak | 6863ca6 | 2012-06-15 11:23:56 +0100 | [diff] [blame] | 153 | |
Markus Pargmann | adaac45 | 2015-08-30 09:33:53 +0200 | [diff] [blame] | 154 | /* if set, raw reads/writes are limited to this size */ |
| 155 | size_t max_raw_read; |
| 156 | size_t max_raw_write; |
| 157 | |
Krystian Garbaciak | 6863ca6 | 2012-06-15 11:23:56 +0100 | [diff] [blame] | 158 | struct rb_root range_tree; |
| 159 | void *selector_work_buf; /* Scratch buffer used for selector */ |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 160 | }; |
| 161 | |
| 162 | struct regcache_ops { |
| 163 | const char *name; |
| 164 | enum regcache_type type; |
| 165 | int (*init)(struct regmap *map); |
| 166 | int (*exit)(struct regmap *map); |
Lars-Peter Clausen | 5e0cbe7 | 2014-08-24 15:32:27 +0200 | [diff] [blame] | 167 | #ifdef CONFIG_DEBUG_FS |
| 168 | void (*debugfs_init)(struct regmap *map); |
| 169 | #endif |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 170 | int (*read)(struct regmap *map, unsigned int reg, unsigned int *value); |
| 171 | int (*write)(struct regmap *map, unsigned int reg, unsigned int value); |
Mark Brown | ac8d91c | 2012-02-23 19:31:04 +0000 | [diff] [blame] | 172 | int (*sync)(struct regmap *map, unsigned int min, unsigned int max); |
Mark Brown | 697e85b | 2013-05-08 13:55:22 +0100 | [diff] [blame] | 173 | int (*drop)(struct regmap *map, unsigned int min, unsigned int max); |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 174 | }; |
| 175 | |
Mark Brown | 8de2f08 | 2011-08-10 17:14:41 +0900 | [diff] [blame] | 176 | bool regmap_writeable(struct regmap *map, unsigned int reg); |
| 177 | bool regmap_readable(struct regmap *map, unsigned int reg); |
| 178 | bool regmap_volatile(struct regmap *map, unsigned int reg); |
| 179 | bool regmap_precious(struct regmap *map, unsigned int reg); |
| 180 | |
Dimitris Papastamos | 4d2dc09 | 2011-09-29 10:39:07 +0100 | [diff] [blame] | 181 | int _regmap_write(struct regmap *map, unsigned int reg, |
| 182 | unsigned int val); |
| 183 | |
Krystian Garbaciak | 6863ca6 | 2012-06-15 11:23:56 +0100 | [diff] [blame] | 184 | struct regmap_range_node { |
| 185 | struct rb_node node; |
Mark Brown | d058bb4 | 2012-10-03 12:40:47 +0100 | [diff] [blame] | 186 | const char *name; |
Mark Brown | 4b020b3 | 2012-10-03 13:13:16 +0100 | [diff] [blame] | 187 | struct regmap *map; |
Krystian Garbaciak | 6863ca6 | 2012-06-15 11:23:56 +0100 | [diff] [blame] | 188 | |
| 189 | unsigned int range_min; |
| 190 | unsigned int range_max; |
| 191 | |
| 192 | unsigned int selector_reg; |
| 193 | unsigned int selector_mask; |
| 194 | int selector_shift; |
| 195 | |
| 196 | unsigned int window_start; |
| 197 | unsigned int window_len; |
| 198 | }; |
| 199 | |
Srinivas Kandagatla | 6725228 | 2013-06-11 13:18:15 +0100 | [diff] [blame] | 200 | struct regmap_field { |
| 201 | struct regmap *regmap; |
| 202 | unsigned int mask; |
| 203 | /* lsb */ |
| 204 | unsigned int shift; |
| 205 | unsigned int reg; |
Kuninori Morimoto | a010237 | 2013-09-01 20:30:50 -0700 | [diff] [blame] | 206 | |
| 207 | unsigned int id_size; |
| 208 | unsigned int id_offset; |
Srinivas Kandagatla | 6725228 | 2013-06-11 13:18:15 +0100 | [diff] [blame] | 209 | }; |
| 210 | |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 211 | #ifdef CONFIG_DEBUG_FS |
| 212 | extern void regmap_debugfs_initcall(void); |
Stephen Warren | d3c242e | 2012-04-04 15:48:29 -0600 | [diff] [blame] | 213 | extern void regmap_debugfs_init(struct regmap *map, const char *name); |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 214 | extern void regmap_debugfs_exit(struct regmap *map); |
| 215 | #else |
Lars-Peter Clausen | bbcf61c | 2011-09-05 22:06:13 +0200 | [diff] [blame] | 216 | static inline void regmap_debugfs_initcall(void) { } |
Stephen Warren | abec95a | 2012-04-05 23:09:20 -0600 | [diff] [blame] | 217 | static inline void regmap_debugfs_init(struct regmap *map, const char *name) { } |
Lars-Peter Clausen | bbcf61c | 2011-09-05 22:06:13 +0200 | [diff] [blame] | 218 | static inline void regmap_debugfs_exit(struct regmap *map) { } |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 219 | #endif |
| 220 | |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 221 | /* regcache core declarations */ |
Lars-Peter Clausen | e5e3b8a | 2011-11-16 16:28:16 +0100 | [diff] [blame] | 222 | int regcache_init(struct regmap *map, const struct regmap_config *config); |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 223 | void regcache_exit(struct regmap *map); |
| 224 | int regcache_read(struct regmap *map, |
| 225 | unsigned int reg, unsigned int *value); |
| 226 | int regcache_write(struct regmap *map, |
| 227 | unsigned int reg, unsigned int value); |
| 228 | int regcache_sync(struct regmap *map); |
Mark Brown | f8bd822 | 2013-03-29 19:32:28 +0000 | [diff] [blame] | 229 | int regcache_sync_block(struct regmap *map, void *block, |
Lars-Peter Clausen | 3f4ff56 | 2013-08-29 10:26:34 +0200 | [diff] [blame] | 230 | unsigned long *cache_present, |
Mark Brown | f8bd822 | 2013-03-29 19:32:28 +0000 | [diff] [blame] | 231 | unsigned int block_base, unsigned int start, |
| 232 | unsigned int end); |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 233 | |
Mark Brown | 8817796 | 2013-03-13 19:29:36 +0000 | [diff] [blame] | 234 | static inline const void *regcache_get_val_addr(struct regmap *map, |
| 235 | const void *base, |
| 236 | unsigned int idx) |
| 237 | { |
| 238 | return base + (map->cache_word_size * idx); |
| 239 | } |
| 240 | |
Mark Brown | 879082c | 2013-02-21 18:03:13 +0000 | [diff] [blame] | 241 | unsigned int regcache_get_val(struct regmap *map, const void *base, |
| 242 | unsigned int idx); |
| 243 | bool regcache_set_val(struct regmap *map, void *base, unsigned int idx, |
| 244 | unsigned int val); |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 245 | int regcache_lookup_reg(struct regmap *map, unsigned int reg); |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 246 | |
Mark Brown | 584de32 | 2013-03-13 19:19:34 +0000 | [diff] [blame] | 247 | int _regmap_raw_write(struct regmap *map, unsigned int reg, |
Mark Brown | 0a81980 | 2013-10-09 12:28:52 +0100 | [diff] [blame] | 248 | const void *val, size_t val_len); |
Mark Brown | 584de32 | 2013-03-13 19:19:34 +0000 | [diff] [blame] | 249 | |
Mark Brown | 0d509f2 | 2013-01-27 22:07:38 +0800 | [diff] [blame] | 250 | void regmap_async_complete_cb(struct regmap_async *async, int ret); |
| 251 | |
Guenter Roeck | 3c174d2 | 2015-02-03 10:01:18 -0800 | [diff] [blame] | 252 | enum regmap_endian regmap_get_val_endian(struct device *dev, |
| 253 | const struct regmap_bus *bus, |
| 254 | const struct regmap_config *config); |
| 255 | |
Dimitris Papastamos | 28644c80 | 2011-09-19 14:34:02 +0100 | [diff] [blame] | 256 | extern struct regcache_ops regcache_rbtree_ops; |
Dimitris Papastamos | 2cbbb57 | 2011-09-19 14:34:03 +0100 | [diff] [blame] | 257 | extern struct regcache_ops regcache_lzo_ops; |
Mark Brown | 2ac902c | 2012-12-19 14:51:55 +0000 | [diff] [blame] | 258 | extern struct regcache_ops regcache_flat_ops; |
Dimitris Papastamos | 2cbbb57 | 2011-09-19 14:34:03 +0100 | [diff] [blame] | 259 | |
Philipp Zabel | c6b570d | 2015-03-09 12:20:13 +0100 | [diff] [blame] | 260 | static inline const char *regmap_name(const struct regmap *map) |
| 261 | { |
| 262 | if (map->dev) |
| 263 | return dev_name(map->dev); |
| 264 | |
| 265 | return map->name; |
| 266 | } |
| 267 | |
Xiubo Li | ca747be | 2016-01-04 18:00:33 +0800 | [diff] [blame] | 268 | static inline unsigned int regmap_get_offset(const struct regmap *map, |
| 269 | unsigned int index) |
| 270 | { |
| 271 | if (map->reg_stride_order >= 0) |
| 272 | return index << map->reg_stride_order; |
| 273 | else |
| 274 | return index * map->reg_stride; |
| 275 | } |
| 276 | |
Xiubo Li | 8b31ec5 | 2016-01-04 18:00:34 +0800 | [diff] [blame] | 277 | static inline unsigned int regcache_get_index_by_order(const struct regmap *map, |
| 278 | unsigned int reg) |
| 279 | { |
| 280 | return reg >> map->reg_stride_order; |
| 281 | } |
| 282 | |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 283 | #endif |