开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
compatmac.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

compatmac.h：源码内容
  2. /*
  3.  * mtd/include/compatmac.h
  4.  *
  5.  * $Id: compatmac.h,v 1.36 2002/03/11 16:43:33 dwmw2 Exp $
  6.  *
  7.  * Extensions and omissions from the normal 'linux/compatmac.h'
  8.  * files. hopefully this will end up empty as the 'real' one 
  9.  * becomes fully-featured.
  10.  */
  13. /* First, include the parts which the kernel is good enough to provide 
  14.  * to us 
  15.  */
  16.    
  17. #ifndef __LINUX_MTD_COMPATMAC_H__
  18. #define __LINUX_MTD_COMPATMAC_H__
  20. #include <linux/config.h>
  21. #include <linux/module.h>
  22. #ifndef LINUX_VERSION_CODE
  23. #include <linux/version.h>
  24. #endif
  26. #ifndef VERSION_CODE
  27. #  define VERSION_CODE(vers,rel,seq) ( ((vers)<<16) | ((rel)<<8) | (seq) )
  28. #endif
  29. #ifndef KERNEL_VERSION
  30. #  define KERNEL_VERSION(a,b,c) VERSION_CODE(a,b,c)
  31. #endif
  33. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,0,0)
  34. #  error "This kernel is too old: not supported by this file"
  35. #endif
  37. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
  38. #include <linux/types.h> /* used later in this header */
  40. #define memcpy_fromio(a,b,c)    memcpy((a),(void *)(b),(c))
  41. #define memcpy_toio(a,b,c)      memcpy((void *)(a),(b),(c))
  43. typedef struct wait_queue * wait_queue_head_t;
  45. #define DECLARE_WAITQUEUE(x,y) struct wait_queue x = {y,NULL}
  46. #define DECLARE_WAIT_QUEUE_HEAD(x) struct wait_queue *x = NULL
  47. #define init_waitqueue_head init_waitqueue
  48. #define DECLARE_MUTEX(x) struct semaphore x = MUTEX
  49. #define DECLARE_MUTEX_LOCKED(x) struct semaphore x = MUTEX_LOCKED
  51. /* from sysdep-2.1.h */
  52. #  include <asm/segment.h>
  53. #  define access_ok(t,a,sz)           (verify_area((t),(a),(sz)) ? 0 : 1)
  54. #  define verify_area_20              verify_area
  55. #  define copy_to_user(t,f,n)         (memcpy_tofs(t,f,n), 0)
  56. #  define __copy_to_user(t,f,n)       copy_to_user((t),(f),(n))
  57. #  define copy_to_user_ret(t,f,n,r)   copy_to_user((t),(f),(n))
  58. #  define copy_from_user(t,f,n)       (memcpy_fromfs((t),(f),(n)), 0)
  59. #  define __copy_from_user(t,f,n)     copy_from_user((t),(f),(n))
  60. #  define copy_from_user_ret(t,f,n,r) copy_from_user((t),(f),(n))
  61. //xxx #  define PUT_USER(val,add)           (put_user((val),(add)), 0)
  62. #  define Put_user(val,add)           (put_user((val),(add)), 0)
  63. #  define __PUT_USER(val,add)         PUT_USER((val),(add))
  64. #  define PUT_USER_RET(val,add,ret)   PUT_USER((val),(add))
  65. #  define GET_USER(dest,add)          ((dest)=get_user((add)), 0)
  66. #  define __GET_USER(dest,add)        GET_USER((dest),(add))
  67. #  define GET_USER_RET(dest,add,ret)  GET_USER((dest),(add))
  69. #define ioremap(offset,size) vremap(offset,size)
  70. #define iounmap(adr) /* */
  72. #define EXPORT_SYMBOL(s) /* */
  73. #define EXPORT_SYMBOL_NOVERS(s) /* */
  75. /* 2.1.10 and 2.1.43 introduced new functions. They are worth using */
  77. #if LINUX_VERSION_CODE < VERSION_CODE(2,1,10)
  79. #  include <asm/byteorder.h>
  80. #  ifdef __LITTLE_ENDIAN
  81. #    define cpu_to_le16(x) (x)
  82. #    define cpu_to_le32(x) (x)
  83. #    define cpu_to_be16(x) htons((x))
  84. #    define cpu_to_be32(x) htonl((x))
  85. #  else
  86. #    define cpu_to_be16(x) (x)
  87. #    define cpu_to_be32(x) (x)
  88.      extern inline __u16 cpu_to_le16(__u16 x) { return (x<<8) | (x>>8);}
  89.      extern inline __u32 cpu_to_le32(__u32 x) { return((x>>24) |
  90.              ((x>>8)&0xff00) | ((x<<8)&0xff0000) | (x<<24));}
  91. #  endif
  93. #  define le16_to_cpu(x)  cpu_to_le16(x)
  94. #  define le32_to_cpu(x)  cpu_to_le32(x)
  95. #  define be16_to_cpu(x)  cpu_to_be16(x)
  96. #  define be32_to_cpu(x)  cpu_to_be32(x)
  98. #endif
  100. #if LINUX_VERSION_CODE < VERSION_CODE(2,1,43)
  101. #  define cpu_to_le16p(addr) (cpu_to_le16(*(addr)))
  102. #  define cpu_to_le32p(addr) (cpu_to_le32(*(addr)))
  103. #  define cpu_to_be16p(addr) (cpu_to_be16(*(addr)))
  104. #  define cpu_to_be32p(addr) (cpu_to_be32(*(addr)))
  106.    extern inline void cpu_to_le16s(__u16 *a) {*a = cpu_to_le16(*a);}
  107.    extern inline void cpu_to_le32s(__u16 *a) {*a = cpu_to_le32(*a);}
  108.    extern inline void cpu_to_be16s(__u16 *a) {*a = cpu_to_be16(*a);}
  109.    extern inline void cpu_to_be32s(__u16 *a) {*a = cpu_to_be32(*a);}
  111. #  define le16_to_cpup(x) cpu_to_le16p(x)
  112. #  define le32_to_cpup(x) cpu_to_le32p(x)
  113. #  define be16_to_cpup(x) cpu_to_be16p(x)
  114. #  define be32_to_cpup(x) cpu_to_be32p(x)
  116. #  define le16_to_cpus(x) cpu_to_le16s(x)
  117. #  define le32_to_cpus(x) cpu_to_le32s(x)
  118. #  define be16_to_cpus(x) cpu_to_be16s(x)
  119. #  define be32_to_cpus(x) cpu_to_be32s(x)
  120. #endif
  122. // from 2.2, linux/types.h
  123. #ifndef __BIT_TYPES_DEFINED__
  124. #define __BIT_TYPES_DEFINED__
  126. typedef         __u8            u_int8_t;
  127. typedef         __s8            int8_t;
  128. typedef         __u16           u_int16_t;
  129. typedef         __s16           int16_t;
  130. typedef         __u32           u_int32_t;
  131. typedef         __s32           int32_t;
  133. #endif /* !(__BIT_TYPES_DEFINED__) */
  135. #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)
  136.   typedef struct { } spinlock_t;
  137.   #define SPIN_LOCK_UNLOCKED (spinlock_t) { }
  138. #else
  139.   typedef struct { int gcc_is_buggy; } spinlock_t;
  140.   #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0 }
  141. #endif
  143. #define spin_lock_init(lock)    do { } while(0)
  144. #define spin_lock(lock)         (void)(lock) /* Not "unused variable". */
  145. #define spin_trylock(lock)      (1)
  146. #define spin_unlock_wait(lock)  do { } while(0)
  147. #define spin_unlock(lock)       do { } while(0)
  148. #define spin_lock_irq(lock)     cli()
  149. #define spin_unlock_irq(lock)   sti()
  151. #define spin_lock_irqsave(lock, flags) 
  152.         do { save_flags(flags); cli(); } while (0)
  153. #define spin_unlock_irqrestore(lock, flags) 
  154.         restore_flags(flags)
  156. // Doesn't work when tqueue.h is included. 
  157. // #define queue_task                   queue_task_irq_off
  158. #define tty_flip_buffer_push(tty)    queue_task_irq_off(&tty->flip.tqueue, &tq_timer)
  159. #define signal_pending(current)      (current->signal & ~current->blocked)
  160. #define schedule_timeout(to)         do {current->timeout = jiffies + (to);schedule ();} while (0)
  161. #define time_after(t1,t2)            (((long)t1-t2) > 0)
  163. #else
  164.   #include <linux/compatmac.h>
  165. #endif  // LINUX_VERSION_CODE < 0x020100
  168. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0)
  169. #include <linux/vmalloc.h>
  170. #endif
  172. /* Modularization issues */
  173. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,18)
  174. #  define __USE_OLD_SYMTAB__
  175. #  define EXPORT_NO_SYMBOLS register_symtab(NULL);
  176. #  define REGISTER_SYMTAB(tab) register_symtab(tab)
  177. #else
  178. #  define REGISTER_SYMTAB(tab) /* nothing */
  179. #endif
  181. #ifdef __USE_OLD_SYMTAB__
  182. #  define __MODULE_STRING(s)         /* nothing */
  183. #  define MODULE_PARM(v,t)           /* nothing */
  184. #  define MODULE_PARM_DESC(v,t)      /* nothing */
  185. #  define MODULE_AUTHOR(n)           /* nothing */
  186. #  define MODULE_DESCRIPTION(d)      /* nothing */
  187. #  define MODULE_SUPPORTED_DEVICE(n) /* nothing */
  188. #endif
  190. /*
  191.  * "select" changed in 2.1.23. The implementation is twin, but this
  192.  * header is new
  193.  */
  194. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,22)
  195. #  include <linux/poll.h>
  196. #else
  197. #  define __USE_OLD_SELECT__
  198. #endif
  200. /* Other change in the fops are solved using pseudo-types */
  201. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0)
  202. #  define lseek_t      long long
  203. #  define lseek_off_t  long long
  204. #else
  205. #  define lseek_t      int
  206. #  define lseek_off_t  off_t
  207. #endif
  209. /* changed the prototype of read/write */
  211. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0) || defined(__alpha__)
  212. # define count_t unsigned long
  213. # define read_write_t long
  214. #else
  215. # define count_t int
  216. # define read_write_t int
  217. #endif
  220. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,31)
  221. # define release_t void
  222. #  define release_return(x) return
  223. #else
  224. #  define release_t int
  225. #  define release_return(x) return (x)
  226. #endif
  228. #if LINUX_VERSION_CODE < 0x20300
  229. #define __exit
  230. #endif
  231. #if LINUX_VERSION_CODE < 0x20200
  232. #define __init
  233. #else
  234. #include <linux/init.h>
  235. #endif
  237. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,18)
  238. #define init_MUTEX(x) do {*(x) = MUTEX;} while (0)
  239. #define init_MUTEX_LOCKED(x) do {*(x) = MUTEX_LOCKED;} while (0)
  240. #endif
  242. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
  243. #define RQFUNC_ARG void
  244. #define blkdev_dequeue_request(req) do {CURRENT = req->next;} while (0)
  245. #else
  246. #define RQFUNC_ARG request_queue_t *q
  247. #endif
  249. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,32)
  250. #define blk_cleanup_queue(nr) do {blk_dev[nr].request_fn = 0;} while(0)
  251. #define BLK_DEFAULT_QUEUE(nr) (blk_dev[nr].request_fn)
  252. #define blk_init_queue(q, rq) do {q = rq;} while(0)
  253. #endif
  255. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,0)
  256. #ifdef CONFIG_MODULES
  257. #define __MOD_INC_USE_COUNT(mod)                                        
  258.         (atomic_inc(&(mod)->uc.usecount), (mod)->flags |= MOD_VISITED|MOD_USED_ONCE)
  259. #define __MOD_DEC_USE_COUNT(mod)                                        
  260.         (atomic_dec(&(mod)->uc.usecount), (mod)->flags |= MOD_VISITED)
  261. #else
  262. #define __MOD_INC_USE_COUNT(mod)
  263. #define __MOD_DEC_USE_COUNT(mod)
  264. #endif
  265. #endif
  268. #ifndef HAVE_INTER_MODULE
  269. static inline void *inter_module_get(char *x) {return NULL;}
  270. static inline void *inter_module_get_request(char *x, char *y) {return NULL;}
  271. static inline void inter_module_put(const char *x) {}
  272. static inline void inter_module_register(const char *x, struct module *y, const void *z) {}
  273. static inline void inter_module_unregister(const char *x) {}
  274. #endif
  276. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,18)
  278. #define DECLARE_WAIT_QUEUE_HEAD(x) struct wait_queue *x = NULL
  279. #define init_waitqueue_head init_waitqueue
  281. #endif
  283. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
  285. static inline int try_inc_mod_count(struct module *mod)
  286. {
  287. #ifdef CONFIG_MODULES
  288. if (mod)
  289. __MOD_INC_USE_COUNT(mod);
  290. #endif
  291. return 1;
  292. }
  293. #endif
  296. /* Yes, I'm aware that it's a fairly ugly hack.
  297.    Until the __constant_* macros appear in Linus' own kernels, this is
  298.    the way it has to be done.
  299.  DW 19/1/00
  300.  */
  302. #include <asm/byteorder.h>
  304. #ifndef __constant_cpu_to_le16
  306. #ifdef __BIG_ENDIAN
  307. #define __constant_cpu_to_le64(x) ___swab64((x))
  308. #define __constant_le64_to_cpu(x) ___swab64((x))
  309. #define __constant_cpu_to_le32(x) ___swab32((x))
  310. #define __constant_le32_to_cpu(x) ___swab32((x))
  311. #define __constant_cpu_to_le16(x) ___swab16((x))
  312. #define __constant_le16_to_cpu(x) ___swab16((x))
  313. #define __constant_cpu_to_be64(x) ((__u64)(x))
  314. #define __constant_be64_to_cpu(x) ((__u64)(x))
  315. #define __constant_cpu_to_be32(x) ((__u32)(x))
  316. #define __constant_be32_to_cpu(x) ((__u32)(x))
  317. #define __constant_cpu_to_be16(x) ((__u16)(x))
  318. #define __constant_be16_to_cpu(x) ((__u16)(x))
  319. #else
  320. #ifdef __LITTLE_ENDIAN
  321. #define __constant_cpu_to_le64(x) ((__u64)(x))
  322. #define __constant_le64_to_cpu(x) ((__u64)(x))
  323. #define __constant_cpu_to_le32(x) ((__u32)(x))
  324. #define __constant_le32_to_cpu(x) ((__u32)(x))
  325. #define __constant_cpu_to_le16(x) ((__u16)(x))
  326. #define __constant_le16_to_cpu(x) ((__u16)(x))
  327. #define __constant_cpu_to_be64(x) ___swab64((x))
  328. #define __constant_be64_to_cpu(x) ___swab64((x))
  329. #define __constant_cpu_to_be32(x) ___swab32((x))
  330. #define __constant_be32_to_cpu(x) ___swab32((x))
  331. #define __constant_cpu_to_be16(x) ___swab16((x))
  332. #define __constant_be16_to_cpu(x) ___swab16((x))
  333. #else
  334. #error No (recognised) endianness defined (unless it,s PDP)
  335. #endif /* __LITTLE_ENDIAN */
  336. #endif /* __BIG_ENDIAN */
  338. #endif /* ifndef __constant_cpu_to_le16 */
  340. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
  341.   #define mod_init_t int  __init
  342.   #define mod_exit_t void  
  343. #else
  344.   #define mod_init_t static int __init
  345.   #define mod_exit_t static void __exit
  346. #endif
  348. #ifndef THIS_MODULE
  349. #ifdef MODULE
  350. #define THIS_MODULE (&__this_module)
  351. #else
  352. #define THIS_MODULE (NULL)
  353. #endif
  354. #endif
  356. #if LINUX_VERSION_CODE < 0x20300
  357. #include <linux/interrupt.h>
  358. #define spin_lock_bh(lock) do {start_bh_atomic();spin_lock(lock);}while(0)
  359. #define spin_unlock_bh(lock) do {spin_unlock(lock);end_bh_atomic();}while(0)
  360. #else
  361. #include <asm/softirq.h>
  362. #include <linux/spinlock.h>
  363. #endif
  365. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,18)
  366. #define set_current_state(state_value)                        
  367.         do { current->state = (state_value); } while (0)
  368. #endif
  370. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,0) 
  371. static inline int invalidate_device(kdev_t dev, int do_sync) {
  373. if (do_sync)
  374. fsync_dev(dev);
  376. invalidate_buffers(dev);
  377. return 0;
  378. }
  379. #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,4,5)
  380. static inline int invalidate_device(kdev_t dev, int do_sync) {
  381. struct super_block *sb = get_super(dev);
  382. int res = 0;
  384. if (do_sync)
  385. fsync_dev(dev);
  387. if (sb)
  388. res = invalidate_inodes(sb);
  390. invalidate_buffers(dev);
  391. return res;
  392. }
  393. #endif
  395. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,10)
  396. #undef min
  397. #undef max
  398. #undef min_t
  399. #undef max_t
  400. /*
  401.  * min()/max() macros that also do
  402.  * strict type-checking.. See the
  403.  * "unnecessary" pointer comparison.
  404.  */
  405. #define min(x,y) ({ 
  406.         const typeof(x) _x = (x);       
  407.         const typeof(y) _y = (y);       
  408.         (void) (&_x == &_y);            
  409.         _x < _y ? _x : _y; })
  411. #define max(x,y) ({ 
  412.         const typeof(x) _x = (x);       
  413.         const typeof(y) _y = (y);       
  414.         (void) (&_x == &_y);            
  415.         _x > _y ? _x : _y; })
  417. /*
  418.  * ..and if you can't take the strict
  419.  * types, you can specify one yourself.
  420.  *
  421.  * Or not use min/max at all, of course.
  422.  */
  423. #define min_t(type,x,y) 
  424.         ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
  425. #define max_t(type,x,y) 
  426.         ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
  427. #endif
  429. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,7)
  430. struct completion {
  431. struct semaphore s;
  432. };
  434. #define complete(c) up(&(c)->s)
  435. #define wait_for_completion(c) down(&(c)->s)
  436. #define init_completion(c) init_MUTEX_LOCKED(&(c)->s);
  438. #endif
  440. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,9)
  441. /* This came later */
  442. #define complete_and_exit(c, r) do { complete(c); do_exit(r); } while(0)
  443. #endif
  445. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,9) || 
  446.     (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,10) && !defined(__rh_config_h__))
  448. #include <linux/genhd.h>
  450. static inline void add_gendisk(struct gendisk *gp)
  451. {
  452. gp->next = gendisk_head;
  453. gendisk_head = gp;
  454. }
  456. static inline void del_gendisk(struct gendisk *gp)
  457. {
  458. struct gendisk *gd, **gdp;
  460. for (gdp = &gendisk_head; *gdp; gdp = &((*gdp)->next))
  461. if (*gdp == gp) {
  462. gd = *gdp; *gdp = gd->next;
  463. break;
  464. }
  465. }
  466. #endif
  468. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,18) && defined(MODULE)
  470. #define module_init(func)
  471. mod_init_t init_module(void) {
  472. return func();
  473. }
  475. #define module_exit(func)
  476. mod_exit_t cleanup_module(void) {
  477. return func();
  478. }
  479. #endif
  481. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,9) || 
  482.     (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,10) && !defined(__rh_config_h__))
  483. #define MODULE_LICENSE(x) /* */
  484. #endif
  486. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,5)
  487. #include <linux/sched.h>
  488. static inline void __recalc_sigpending(void)
  489. {
  490. recalc_sigpending(current);
  491. }
  492. #define recalc_sigpending() __recalc_sigpending ()
  493. #endif
  495. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,5)
  496. #define parent_ino(d) ((d)->d_parent->d_inode->i_ino)
  497. #endif
  499. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,3)
  500. #define need_resched() (current->need_resched)
  501. #define cond_resched() do { if need_resched() schedule(); } while(0)
  502. #endif
  504. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
  505. #define yield() do { current->policy |= SCHED_YIELD; schedule(); } while(0)
  506. #define mk_kdev(ma,mi) MKDEV(ma,mi)
  507. #define kdev_t_to_nr(x) (x)
  508. #endif
  509. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
  510. #define major(d) (MAJOR(to_kdev_t(d)))
  511. #define minor(d) (MINOR(to_kdev_t(d)))
  512. #endif
  514. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
  515. /* Is this right? */
  516. #define set_user_nice(tsk, n) do { (tsk)->priority = 20-(n); } while(0) 
  517. #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
  518. #define set_user_nice(tsk, n) do { (tsk)->nice = n; } while(0)
  519. #endif
  521. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
  523. #define rq_data_dir(x) ((x)->cmd)
  525. #define IS_REQ_CMD(req) (1)
  527. #define QUEUE_LOCK(q) (&io_request_lock)
  529. #define BLK_INIT_QUEUE(q, req, lock) blk_init_queue((q), (req)) 
  531. #else /* > 2.5.0 */
  533. #define IS_REQ_CMD(req) ((req)->flags & REQ_CMD)
  535. #define QUEUE_LOCK(q) ((q)->queue_lock)
  537. #define BLK_INIT_QUEUE(q, req, lock) blk_init_queue((q), (req), (lock)) 
  539. #endif
  541. /* Removed cos it broke stuff. Where is this required anyway? 
  542.  * #ifndef QUEUE_EMPTY
  543.  * #define QUEUE_EMPTY  (!CURRENT)
  544.  * #endif
  545.  */
  546. #if LINUX_VERSION_CODE < 0x20300
  547. #define QUEUE_PLUGGED (blk_dev[MAJOR_NR].plug_tq.sync)
  548. #elif LINUX_VERSION_CODE < 0x20500 //FIXME (Si)
  549. #define QUEUE_PLUGGED (blk_dev[MAJOR_NR].request_queue.plugged)
  550. #else
  551. #define QUEUE_PLUGGED (blk_queue_plugged(QUEUE))
  552. #endif
  554. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,14)
  555. #define BLK_INC_USE_COUNT MOD_INC_USE_COUNT
  556. #define BLK_DEC_USE_COUNT MOD_DEC_USE_COUNT
  557. #else
  558. #define BLK_INC_USE_COUNT do {} while(0)
  559. #define BLK_DEC_USE_COUNT do {} while(0)
  560. #endif
  562. #endif /* __LINUX_MTD_COMPATMAC_H__ */