projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drivers: power: report battery voltage in AOSP compatible format
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / genhd.h
CommitLineData
1da177e4
LT		 1#ifndef _LINUX_GENHD_H
2#define _LINUX_GENHD_H
3
4/*
5 * genhd.h Copyright (C) 1992 Drew Eckhardt
6 * Generic hard disk header file by
7 * Drew Eckhardt
8 *
9 * <drew@colorado.edu>
10 */
11
1da177e4 12#include <linux/types.h>
edfaa7c3 13#include <linux/kdev_t.h>
e71bf0d0 14#include <linux/rcupdate.h>
6d1d8050 15#include <linux/slab.h>
1da177e4 16
9361401e
DH		 17#ifdef CONFIG_BLOCK
18
548b10eb 19#define dev_to_disk(device) container_of((device), struct gendisk, part0.__dev)
ed9e1982 20#define dev_to_part(device) container_of((device), struct hd_struct, __dev)
548b10eb 21#define disk_to_dev(disk) (&(disk)->part0.__dev)
ed9e1982 22#define part_to_dev(part) (&((part)->__dev))
edfaa7c3 23
edfaa7c3
KS		 24extern struct device_type part_type;
25extern struct kobject *block_depr;
26extern struct class block_class;
27
1da177e4
LT		 28enum {
29/* These three have identical behaviour; use the second one if DOS FDISK gets
30 confused about extended/logical partitions starting past cylinder 1023. */
31 DOS_EXTENDED_PARTITION = 5,
32 LINUX_EXTENDED_PARTITION = 0x85,
33 WIN98_EXTENDED_PARTITION = 0x0f,
34
d18d7682
FMDN		 35 SUN_WHOLE_DISK = DOS_EXTENDED_PARTITION,
36
1da177e4 37 LINUX_SWAP_PARTITION = 0x82,
4419d1ac
OH		 38 LINUX_DATA_PARTITION = 0x83,
39 LINUX_LVM_PARTITION = 0x8e,
1da177e4
LT		 40 LINUX_RAID_PARTITION = 0xfd, /* autodetect RAID partition */
41
42 SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
43 NEW_SOLARIS_X86_PARTITION = 0xbf,
44
45 DM6_AUX1PARTITION = 0x51, /* no DDO: use xlated geom */
46 DM6_AUX3PARTITION = 0x53, /* no DDO: use xlated geom */
47 DM6_PARTITION = 0x54, /* has DDO: use xlated geom & offset */
48 EZD_PARTITION = 0x55, /* EZ-DRIVE */
49
50 FREEBSD_PARTITION = 0xa5, /* FreeBSD Partition ID */
51 OPENBSD_PARTITION = 0xa6, /* OpenBSD Partition ID */
52 NETBSD_PARTITION = 0xa9, /* NetBSD Partition ID */
53 BSDI_PARTITION = 0xb7, /* BSDI Partition ID */
54 MINIX_PARTITION = 0x81, /* Minix Partition ID */
55 UNIXWARE_PARTITION = 0x63, /* Same as GNU_HURD and SCO Unix */
56};
57
689d6fac 58#define DISK_MAX_PARTS 256
3e1a7ff8 59#define DISK_NAME_LEN 32
689d6fac 60
34186efc
DW		 61#include <linux/major.h>
62#include <linux/device.h>
63#include <linux/smp.h>
64#include <linux/string.h>
65#include <linux/fs.h>
8ce7ad7b 66#include <linux/workqueue.h>
34186efc 67
1da177e4
LT		 68struct partition {
69 unsigned char boot_ind; /* 0x80 - active */
70 unsigned char head; /* starting head */
71 unsigned char sector; /* starting sector */
72 unsigned char cyl; /* starting cylinder */
73 unsigned char sys_ind; /* What partition type */
74 unsigned char end_head; /* end head */
75 unsigned char end_sector; /* end sector */
76 unsigned char end_cyl; /* end cylinder */
77 __le32 start_sect; /* starting sector counting from 0 */
78 __le32 nr_sects; /* nr of sectors in partition */
79} __attribute__((packed));
80
ea5c48ab
JM		 81struct disk_stats {
82 unsigned long sectors[2]; /* READs and WRITEs */
83 unsigned long ios[2];
84 unsigned long merges[2];
85 unsigned long ticks[2];
86 unsigned long io_ticks;
87 unsigned long time_in_queue;
88};
6d1d8050
WD		 89
90#define PARTITION_META_INFO_VOLNAMELTH 64
1ad7e899
SW		 91/*
92 * Enough for the string representation of any kind of UUID plus NULL.
93 * EFI UUID is 36 characters. MSDOS UUID is 11 characters.
94 */
95#define PARTITION_META_INFO_UUIDLTH 37
6d1d8050
WD		 96
97struct partition_meta_info {
1ad7e899 98 char uuid[PARTITION_META_INFO_UUIDLTH];
6d1d8050
WD		 99 u8 volname[PARTITION_META_INFO_VOLNAMELTH];
100};
101
1da177e4
LT		 102struct hd_struct {
103 sector_t start_sect;
c83f6bf9
VG		 104 /*
105 * nr_sects is protected by sequence counter. One might extend a
106 * partition while IO is happening to it and update of nr_sects
107 * can be non-atomic on 32bit machines with 64bit sector_t.
108 */
1da177e4 109 sector_t nr_sects;
c83f6bf9 110 seqcount_t nr_sects_seq;
c72758f3 111 sector_t alignment_offset;
a1706ac4 112 unsigned int discard_alignment;
ed9e1982 113 struct device __dev;
6a4d44c1 114 struct kobject *holder_dir;
1da177e4 115 int policy, partno;
6d1d8050 116 struct partition_meta_info *info;
c17bb495
AM		 117#ifdef CONFIG_FAIL_MAKE_REQUEST
118 int make_it_fail;
ea5c48ab
JM		 119#endif
120 unsigned long stamp;
1e9bb880 121 atomic_t in_flight[2];
ea5c48ab 122#ifdef CONFIG_SMP
43cf38eb 123 struct disk_stats __percpu *dkstats;
ea5c48ab
JM		 124#else
125 struct disk_stats dkstats;
c17bb495 126#endif
6c23a968 127 atomic_t ref;
e71bf0d0 128 struct rcu_head rcu_head;
1da177e4
LT		 129};
130
131#define GENHD_FL_REMOVABLE 1
97fedbbe 132/* 2 is unused */
86ce18d7 133#define GENHD_FL_MEDIA_CHANGE_NOTIFY 4
1da177e4
LT		 134#define GENHD_FL_CD 8
135#define GENHD_FL_UP 16
136#define GENHD_FL_SUPPRESS_PARTITION_INFO 32
689d6fac 137#define GENHD_FL_EXT_DEVT 64 /* allow extended devt */
db429e9e 138#define GENHD_FL_NATIVE_CAPACITY 128
d4dc210f 139#define GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE 256
d27769ec 140#define GENHD_FL_NO_PART_SCAN 512
1da177e4 141
77ea887e
TH		 142enum {
143 DISK_EVENT_MEDIA_CHANGE = 1 << 0, /* media changed */
144 DISK_EVENT_EJECT_REQUEST = 1 << 1, /* eject requested */
6fa3eb70
S		 145#ifdef CONFIG_MTK_MULTI_PARTITION_MOUNT_ONLY_SUPPORT
146 DISK_EVENT_MEDIA_DISAPPEAR = 1 << 2, /* add for sdcard hotplug*/
147#endif
77ea887e
TH		 148};
149
540eed56
TH		 150#define BLK_SCSI_MAX_CMDS (256)
151#define BLK_SCSI_CMD_PER_LONG (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
152
153struct blk_scsi_cmd_filter {
154 unsigned long read_ok[BLK_SCSI_CMD_PER_LONG];
155 unsigned long write_ok[BLK_SCSI_CMD_PER_LONG];
156 struct kobject kobj;
157};
158
159struct disk_part_tbl {
160 struct rcu_head rcu_head;
161 int len;
4d2deb40
AB		 162 struct hd_struct __rcu *last_lookup;
163 struct hd_struct __rcu *part[];
540eed56
TH		 164};
165
77ea887e
TH		 166struct disk_events;
167
1da177e4 168struct gendisk {
689d6fac
TH		 169 /* major, first_minor and minors are input parameters only,
170 * don't use directly. Use disk_devt() and disk_max_parts().
f331c029 171 */
1da177e4
LT		 172 int major; /* major number of driver */
173 int first_minor;
174 int minors; /* maximum number of minors, =1 for
175 * disks that can't be partitioned. */
f331c029 176
3e1a7ff8 177 char disk_name[DISK_NAME_LEN]; /* name of major driver */
2c9ede55 178 char *(*devnode)(struct gendisk *gd, umode_t *mode);
77ea887e
TH		 179
180 unsigned int events; /* supported events */
181 unsigned int async_events; /* async events, subset of all */
182
b5d0b9df 183 /* Array of pointers to partitions indexed by partno.
e71bf0d0
TH		 184 * Protected with matching bdev lock but stat and other
185 * non-critical accesses use RCU. Always access through
186 * helpers.
187 */
4d2deb40 188 struct disk_part_tbl __rcu *part_tbl;
b5d0b9df 189 struct hd_struct part0;
e71bf0d0 190
83d5cde4 191 const struct block_device_operations *fops;
1da177e4
LT		 192 struct request_queue *queue;
193 void *private_data;
1da177e4
LT		 194
195 int flags;
edfaa7c3 196 struct device *driverfs_dev; // FIXME: remove
6a4d44c1 197 struct kobject *slave_dir;
1da177e4
LT		 198
199 struct timer_rand_state *random;
1da177e4 200 atomic_t sync_io; /* RAID */
77ea887e 201 struct disk_events *ev;
7ba1ba12
MP		 202#ifdef CONFIG_BLK_DEV_INTEGRITY
203 struct blk_integrity *integrity;
204#endif
540eed56 205 int node_id;
1da177e4
LT		 206};
207
310a2c10
TH		 208static inline struct gendisk *part_to_disk(struct hd_struct *part)
209{
548b10eb
TH		 210 if (likely(part)) {
211 if (part->partno)
212 return dev_to_disk(part_to_dev(part)->parent);
213 else
214 return dev_to_disk(part_to_dev(part));
215 }
310a2c10
TH		 216 return NULL;
217}
218
6d1d8050
WD		 219static inline void part_pack_uuid(const u8 *uuid_str, u8 *to)
220{
221 int i;
222 for (i = 0; i < 16; ++i) {
223 *to++ = (hex_to_bin(*uuid_str) << 4) |
224 (hex_to_bin(*(uuid_str + 1)));
225 uuid_str += 2;
226 switch (i) {
227 case 3:
228 case 5:
229 case 7:
230 case 9:
231 uuid_str++;
232 continue;
233 }
234 }
235}
236
446d64e3
MZ		 237static inline int blk_part_pack_uuid(const u8 *uuid_str, u8 *to)
238{
239 part_pack_uuid(uuid_str, to);
240 return 0;
241}
242
f331c029
TH		 243static inline int disk_max_parts(struct gendisk *disk)
244{
689d6fac
TH		 245 if (disk->flags & GENHD_FL_EXT_DEVT)
246 return DISK_MAX_PARTS;
247 return disk->minors;
b5d0b9df
TH		 248}
249
d27769ec 250static inline bool disk_part_scan_enabled(struct gendisk *disk)
b5d0b9df 251{
d27769ec
TH		 252 return disk_max_parts(disk) > 1 &&
253 !(disk->flags & GENHD_FL_NO_PART_SCAN);
f331c029
TH		 254}
255
256static inline dev_t disk_devt(struct gendisk *disk)
257{
ed9e1982 258 return disk_to_dev(disk)->devt;
f331c029
TH		 259}
260
261static inline dev_t part_devt(struct hd_struct *part)
262{
ed9e1982 263 return part_to_dev(part)->devt;
f331c029
TH		 264}
265
e71bf0d0
TH		 266extern struct hd_struct *disk_get_part(struct gendisk *disk, int partno);
267
268static inline void disk_put_part(struct hd_struct *part)
269{
270 if (likely(part))
ed9e1982 271 put_device(part_to_dev(part));
e71bf0d0
TH		 272}
273
274/*
275 * Smarter partition iterator without context limits.
276 */
277#define DISK_PITER_REVERSE (1 << 0) /* iterate in the reverse direction */
278#define DISK_PITER_INCL_EMPTY (1 << 1) /* include 0-sized parts */
b5d0b9df 279#define DISK_PITER_INCL_PART0 (1 << 2) /* include partition 0 */
71982a40 280#define DISK_PITER_INCL_EMPTY_PART0 (1 << 3) /* include empty partition 0 */
e71bf0d0
TH		 281
282struct disk_part_iter {
283 struct gendisk *disk;
284 struct hd_struct *part;
285 int idx;
286 unsigned int flags;
287};
288
289extern void disk_part_iter_init(struct disk_part_iter *piter,
290 struct gendisk *disk, unsigned int flags);
291extern struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter);
292extern void disk_part_iter_exit(struct disk_part_iter *piter);
293
294extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
295 sector_t sector);
296
c9959059 297/*
1da177e4
LT		 298 * Macros to operate on percpu disk statistics:
299 *
c9959059
TH		 300 * {disk|part|all}_stat_{add|sub|inc|dec}() modify the stat counters
301 * and should be called between disk_stat_lock() and
302 * disk_stat_unlock().
303 *
304 * part_stat_read() can be called at any time.
305 *
306 * part_stat_{add|set_all}() and {init|free}_part_stats are for
307 * internal use only.
1da177e4
LT		 308 */
309#ifdef CONFIG_SMP
074a7aca
TH		 310#define part_stat_lock() ({ rcu_read_lock(); get_cpu(); })
311#define part_stat_unlock() do { put_cpu(); rcu_read_unlock(); } while (0)
ea5c48ab 312
074a7aca
TH		 313#define __part_stat_add(cpu, part, field, addnd) \
314 (per_cpu_ptr((part)->dkstats, (cpu))->field += (addnd))
ea5c48ab
JM		 315
316#define part_stat_read(part, field) \
317({ \
074a7aca 318 typeof((part)->dkstats->field) res = 0; \
7af92f87
SH		 319 unsigned int _cpu; \
320 for_each_possible_cpu(_cpu) \
321 res += per_cpu_ptr((part)->dkstats, _cpu)->field; \
ea5c48ab
JM		 322 res; \
323})
324
28f13702
JA		 325static inline void part_stat_set_all(struct hd_struct *part, int value)
326{
ea5c48ab 327 int i;
28f13702 328
ea5c48ab
JM		 329 for_each_possible_cpu(i)
330 memset(per_cpu_ptr(part->dkstats, i), value,
28f13702 331 sizeof(struct disk_stats));
ea5c48ab 332}
c9959059 333
074a7aca 334static inline int init_part_stats(struct hd_struct *part)
ea5c48ab 335{
074a7aca
TH		 336 part->dkstats = alloc_percpu(struct disk_stats);
337 if (!part->dkstats)
338 return 0;
339 return 1;
1da177e4 340}
ea5c48ab 341
074a7aca 342static inline void free_part_stats(struct hd_struct *part)
ea5c48ab 343{
074a7aca 344 free_percpu(part->dkstats);
ea5c48ab
JM		 345}
346
074a7aca
TH		 347#else /* !CONFIG_SMP */
348#define part_stat_lock() ({ rcu_read_lock(); 0; })
349#define part_stat_unlock() rcu_read_unlock()
c9959059 350
074a7aca
TH		 351#define __part_stat_add(cpu, part, field, addnd) \
352 ((part)->dkstats.field += addnd)
1da177e4 353
074a7aca 354#define part_stat_read(part, field) ((part)->dkstats.field)
1da177e4 355
074a7aca 356static inline void part_stat_set_all(struct hd_struct *part, int value)
1da177e4 357{
074a7aca 358 memset(&part->dkstats, value, sizeof(struct disk_stats));
1da177e4 359}
ea5c48ab
JM		 360
361static inline int init_part_stats(struct hd_struct *part)
362{
ea5c48ab
JM		 363 return 1;
364}
365
366static inline void free_part_stats(struct hd_struct *part)
367{
ea5c48ab
JM		 368}
369
074a7aca 370#endif /* CONFIG_SMP */
1da177e4 371
074a7aca
TH		 372#define part_stat_add(cpu, part, field, addnd) do { \
373 __part_stat_add((cpu), (part), field, addnd); \
374 if ((part)->partno) \
375 __part_stat_add((cpu), &part_to_disk((part))->part0, \
376 field, addnd); \
377} while (0)
ea5c48ab 378
074a7aca
TH		 379#define part_stat_dec(cpu, gendiskp, field) \
380 part_stat_add(cpu, gendiskp, field, -1)
381#define part_stat_inc(cpu, gendiskp, field) \
382 part_stat_add(cpu, gendiskp, field, 1)
383#define part_stat_sub(cpu, gendiskp, field, subnd) \
384 part_stat_add(cpu, gendiskp, field, -subnd)
385
316d315b 386static inline void part_inc_in_flight(struct hd_struct *part, int rw)
ea5c48ab 387{
1e9bb880 388 atomic_inc(&part->in_flight[rw]);
074a7aca 389 if (part->partno)
1e9bb880 390 atomic_inc(&part_to_disk(part)->part0.in_flight[rw]);
ea5c48ab
JM		 391}
392
316d315b 393static inline void part_dec_in_flight(struct hd_struct *part, int rw)
ea5c48ab 394{
1e9bb880 395 atomic_dec(&part->in_flight[rw]);
074a7aca 396 if (part->partno)
1e9bb880 397 atomic_dec(&part_to_disk(part)->part0.in_flight[rw]);
316d315b
NK		 398}
399
400static inline int part_in_flight(struct hd_struct *part)
401{
1e9bb880 402 return atomic_read(&part->in_flight[0]) + atomic_read(&part->in_flight[1]);
ea5c48ab 403}
1da177e4 404
6d1d8050
WD		 405static inline struct partition_meta_info *alloc_part_info(struct gendisk *disk)
406{
407 if (disk)
408 return kzalloc_node(sizeof(struct partition_meta_info),
409 GFP_KERNEL, disk->node_id);
410 return kzalloc(sizeof(struct partition_meta_info), GFP_KERNEL);
411}
412
413static inline void free_part_info(struct hd_struct *part)
414{
415 kfree(part->info);
416}
417
d3992286 418/* block/blk-core.c */
c9959059 419extern void part_round_stats(int cpu, struct hd_struct *part);
1da177e4 420
32ca163c 421/* block/genhd.c */
1da177e4
LT		 422extern void add_disk(struct gendisk *disk);
423extern void del_gendisk(struct gendisk *gp);
cf771cb5 424extern struct gendisk *get_gendisk(dev_t dev, int *partno);
f331c029 425extern struct block_device *bdget_disk(struct gendisk *disk, int partno);
1da177e4
LT		 426
427extern void set_device_ro(struct block_device *bdev, int flag);
428extern void set_disk_ro(struct gendisk *disk, int flag);
429
b7db9956
TH		 430static inline int get_disk_ro(struct gendisk *disk)
431{
432 return disk->part0.policy;
433}
434
77ea887e
TH		 435extern void disk_block_events(struct gendisk *disk);
436extern void disk_unblock_events(struct gendisk *disk);
85ef06d1 437extern void disk_flush_events(struct gendisk *disk, unsigned int mask);
77ea887e
TH		 438extern unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask);
439
1da177e4
LT		 440/* drivers/char/random.c */
441extern void add_disk_randomness(struct gendisk *disk);
442extern void rand_initialize_disk(struct gendisk *disk);
443
444static inline sector_t get_start_sect(struct block_device *bdev)
445{
0762b8bd 446 return bdev->bd_part->start_sect;
1da177e4
LT		 447}
448static inline sector_t get_capacity(struct gendisk *disk)
449{
80795aef 450 return disk->part0.nr_sects;
1da177e4
LT		 451}
452static inline void set_capacity(struct gendisk *disk, sector_t size)
453{
80795aef 454 disk->part0.nr_sects = size;
1da177e4
LT		 455}
456
1da177e4
LT		 457#ifdef CONFIG_SOLARIS_X86_PARTITION
458
b84d8796 459#define SOLARIS_X86_NUMSLICE 16
1da177e4
LT		 460#define SOLARIS_X86_VTOC_SANE (0x600DDEEEUL)
461
462struct solaris_x86_slice {
463 __le16 s_tag; /* ID tag of partition */
464 __le16 s_flag; /* permission flags */
465 __le32 s_start; /* start sector no of partition */
466 __le32 s_size; /* # of blocks in partition */
467};
468
469struct solaris_x86_vtoc {
470 unsigned int v_bootinfo[3]; /* info needed by mboot (unsupported) */
471 __le32 v_sanity; /* to verify vtoc sanity */
472 __le32 v_version; /* layout version */
473 char v_volume[8]; /* volume name */
474 __le16 v_sectorsz; /* sector size in bytes */
475 __le16 v_nparts; /* number of partitions */
476 unsigned int v_reserved[10]; /* free space */
477 struct solaris_x86_slice
478 v_slice[SOLARIS_X86_NUMSLICE]; /* slice headers */
479 unsigned int timestamp[SOLARIS_X86_NUMSLICE]; /* timestamp (unsupported) */
480 char v_asciilabel[128]; /* for compatibility */
481};
482
483#endif /* CONFIG_SOLARIS_X86_PARTITION */
484
485#ifdef CONFIG_BSD_DISKLABEL
486/*
487 * BSD disklabel support by Yossi Gottlieb <yogo@math.tau.ac.il>
488 * updated by Marc Espie <Marc.Espie@openbsd.org>
489 */
490
491/* check against BSD src/sys/sys/disklabel.h for consistency */
492
493#define BSD_DISKMAGIC (0x82564557UL) /* The disk magic number */
494#define BSD_MAXPARTITIONS 16
495#define OPENBSD_MAXPARTITIONS 16
496#define BSD_FS_UNUSED 0 /* disklabel unused partition entry ID */
497struct bsd_disklabel {
498 __le32 d_magic; /* the magic number */
499 __s16 d_type; /* drive type */
500 __s16 d_subtype; /* controller/d_type specific */
501 char d_typename[16]; /* type name, e.g. "eagle" */
502 char d_packname[16]; /* pack identifier */
503 __u32 d_secsize; /* # of bytes per sector */
504 __u32 d_nsectors; /* # of data sectors per track */
505 __u32 d_ntracks; /* # of tracks per cylinder */
506 __u32 d_ncylinders; /* # of data cylinders per unit */
507 __u32 d_secpercyl; /* # of data sectors per cylinder */
508 __u32 d_secperunit; /* # of data sectors per unit */
509 __u16 d_sparespertrack; /* # of spare sectors per track */
510 __u16 d_sparespercyl; /* # of spare sectors per cylinder */
511 __u32 d_acylinders; /* # of alt. cylinders per unit */
512 __u16 d_rpm; /* rotational speed */
513 __u16 d_interleave; /* hardware sector interleave */
514 __u16 d_trackskew; /* sector 0 skew, per track */
515 __u16 d_cylskew; /* sector 0 skew, per cylinder */
516 __u32 d_headswitch; /* head switch time, usec */
517 __u32 d_trkseek; /* track-to-track seek, usec */
518 __u32 d_flags; /* generic flags */
519#define NDDATA 5
520 __u32 d_drivedata[NDDATA]; /* drive-type specific information */
521#define NSPARE 5
522 __u32 d_spare[NSPARE]; /* reserved for future use */
523 __le32 d_magic2; /* the magic number (again) */
524 __le16 d_checksum; /* xor of data incl. partitions */
525
526 /* filesystem and partition information: */
527 __le16 d_npartitions; /* number of partitions in following */
528 __le32 d_bbsize; /* size of boot area at sn0, bytes */
529 __le32 d_sbsize; /* max size of fs superblock, bytes */
530 struct bsd_partition { /* the partition table */
531 __le32 p_size; /* number of sectors in partition */
532 __le32 p_offset; /* starting sector */
533 __le32 p_fsize; /* filesystem basic fragment size */
534 __u8 p_fstype; /* filesystem type, see below */
535 __u8 p_frag; /* filesystem fragments per block */
536 __le16 p_cpg; /* filesystem cylinders per group */
537 } d_partitions[BSD_MAXPARTITIONS]; /* actually may be more */
538};
539
540#endif /* CONFIG_BSD_DISKLABEL */
541
542#ifdef CONFIG_UNIXWARE_DISKLABEL
543/*
544 * Unixware slices support by Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl>
545 * and Krzysztof G. Baranowski <kgb@knm.org.pl>
546 */
547
548#define UNIXWARE_DISKMAGIC (0xCA5E600DUL) /* The disk magic number */
549#define UNIXWARE_DISKMAGIC2 (0x600DDEEEUL) /* The slice table magic nr */
550#define UNIXWARE_NUMSLICE 16
551#define UNIXWARE_FS_UNUSED 0 /* Unused slice entry ID */
552
553struct unixware_slice {
554 __le16 s_label; /* label */
555 __le16 s_flags; /* permission flags */
556 __le32 start_sect; /* starting sector */
557 __le32 nr_sects; /* number of sectors in slice */
558};
559
560struct unixware_disklabel {
561 __le32 d_type; /* drive type */
562 __le32 d_magic; /* the magic number */
563 __le32 d_version; /* version number */
564 char d_serial[12]; /* serial number of the device */
565 __le32 d_ncylinders; /* # of data cylinders per device */
566 __le32 d_ntracks; /* # of tracks per cylinder */
567 __le32 d_nsectors; /* # of data sectors per track */
568 __le32 d_secsize; /* # of bytes per sector */
569 __le32 d_part_start; /* # of first sector of this partition */
570 __le32 d_unknown1[12]; /* ? */
571 __le32 d_alt_tbl; /* byte offset of alternate table */
572 __le32 d_alt_len; /* byte length of alternate table */
573 __le32 d_phys_cyl; /* # of physical cylinders per device */
574 __le32 d_phys_trk; /* # of physical tracks per cylinder */
575 __le32 d_phys_sec; /* # of physical sectors per track */
576 __le32 d_phys_bytes; /* # of physical bytes per sector */
577 __le32 d_unknown2; /* ? */
578 __le32 d_unknown3; /* ? */
579 __le32 d_pad[8]; /* pad */
580
581 struct unixware_vtoc {
582 __le32 v_magic; /* the magic number */
583 __le32 v_version; /* version number */
584 char v_name[8]; /* volume name */
585 __le16 v_nslices; /* # of slices */
586 __le16 v_unknown1; /* ? */
587 __le32 v_reserved[10]; /* reserved */
588 struct unixware_slice
589 v_slice[UNIXWARE_NUMSLICE]; /* slice headers */
590 } vtoc;
591
592}; /* 408 */
593
594#endif /* CONFIG_UNIXWARE_DISKLABEL */
595
596#ifdef CONFIG_MINIX_SUBPARTITION
597# define MINIX_NR_SUBPARTITIONS 4
598#endif /* CONFIG_MINIX_SUBPARTITION */
599
d18d7682
FMDN		 600#define ADDPART_FLAG_NONE 0
601#define ADDPART_FLAG_RAID 1
602#define ADDPART_FLAG_WHOLEDISK 2
603
bcce3de1
TH		 604extern int blk_alloc_devt(struct hd_struct *part, dev_t *devt);
605extern void blk_free_devt(dev_t devt);
cf771cb5
TH		 606extern dev_t blk_lookup_devt(const char *name, int partno);
607extern char *disk_name (struct gendisk *hd, int partno, char *buf);
1da177e4 608
540eed56 609extern int disk_expand_part_tbl(struct gendisk *disk, int target);
1da177e4 610extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
fe316bf2 611extern int invalidate_partitions(struct gendisk *disk, struct block_device *bdev);
ba32929a
TH		 612extern struct hd_struct * __must_check add_partition(struct gendisk *disk,
613 int partno, sector_t start,
6d1d8050
WD		 614 sector_t len, int flags,
615 struct partition_meta_info
616 *info);
6c23a968 617extern void __delete_partition(struct hd_struct *);
1da177e4 618extern void delete_partition(struct gendisk *, int);
dd2a345f 619extern void printk_all_partitions(void);
1da177e4 620
1946089a 621extern struct gendisk *alloc_disk_node(int minors, int node_id);
1da177e4
LT		 622extern struct gendisk *alloc_disk(int minors);
623extern struct kobject *get_disk(struct gendisk *disk);
624extern void put_disk(struct gendisk *disk);
edfaa7c3 625extern void blk_register_region(dev_t devt, unsigned long range,
1da177e4
LT		 626 struct module *module,
627 struct kobject *(*probe)(dev_t, int *, void *),
628 int (*lock)(dev_t, void *),
629 void *data);
edfaa7c3 630extern void blk_unregister_region(dev_t devt, unsigned long range);
1da177e4 631
e5610521
TH		 632extern ssize_t part_size_show(struct device *dev,
633 struct device_attribute *attr, char *buf);
074a7aca
TH		 634extern ssize_t part_stat_show(struct device *dev,
635 struct device_attribute *attr, char *buf);
316d315b
NK		 636extern ssize_t part_inflight_show(struct device *dev,
637 struct device_attribute *attr, char *buf);
eddb2e26
TH		 638#ifdef CONFIG_FAIL_MAKE_REQUEST
639extern ssize_t part_fail_show(struct device *dev,
640 struct device_attribute *attr, char *buf);
641extern ssize_t part_fail_store(struct device *dev,
642 struct device_attribute *attr,
643 const char *buf, size_t count);
644#endif /* CONFIG_FAIL_MAKE_REQUEST */
e5610521 645
6c23a968
JA		 646static inline void hd_ref_init(struct hd_struct *part)
647{
648 atomic_set(&part->ref, 1);
649 smp_mb();
650}
651
652static inline void hd_struct_get(struct hd_struct *part)
653{
654 atomic_inc(&part->ref);
655 smp_mb__after_atomic_inc();
656}
657
658static inline int hd_struct_try_get(struct hd_struct *part)
659{
660 return atomic_inc_not_zero(&part->ref);
661}
662
663static inline void hd_struct_put(struct hd_struct *part)
664{
665 if (atomic_dec_and_test(&part->ref))
666 __delete_partition(part);
667}
668
c83f6bf9
VG		 669/*
670 * Any access of part->nr_sects which is not protected by partition
671 * bd_mutex or gendisk bdev bd_mutex, should be done using this
672 * accessor function.
673 *
674 * Code written along the lines of i_size_read() and i_size_write().
675 * CONFIG_PREEMPT case optimizes the case of UP kernel with preemption
676 * on.
677 */
678static inline sector_t part_nr_sects_read(struct hd_struct *part)
679{
680#if BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_SMP)
681 sector_t nr_sects;
682 unsigned seq;
683 do {
684 seq = read_seqcount_begin(&part->nr_sects_seq);
685 nr_sects = part->nr_sects;
686 } while (read_seqcount_retry(&part->nr_sects_seq, seq));
687 return nr_sects;
688#elif BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_PREEMPT)
689 sector_t nr_sects;
690
691 preempt_disable();
692 nr_sects = part->nr_sects;
693 preempt_enable();
694 return nr_sects;
695#else
696 return part->nr_sects;
697#endif
698}
699
700/*
701 * Should be called with mutex lock held (typically bd_mutex) of partition
702 * to provide mutual exlusion among writers otherwise seqcount might be
703 * left in wrong state leaving the readers spinning infinitely.
704 */
705static inline void part_nr_sects_write(struct hd_struct *part, sector_t size)
706{
707#if BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_SMP)
708 write_seqcount_begin(&part->nr_sects_seq);
709 part->nr_sects = size;
710 write_seqcount_end(&part->nr_sects_seq);
711#elif BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_PREEMPT)
712 preempt_disable();
713 part->nr_sects = size;
714 preempt_enable();
715#else
716 part->nr_sects = size;
717#endif
718}
719
87c1efbf
JA		 720#else /* CONFIG_BLOCK */
721
722static inline void printk_all_partitions(void) { }
723
cf771cb5 724static inline dev_t blk_lookup_devt(const char *name, int partno)
edfaa7c3
KS		 725{
726 dev_t devt = MKDEV(0, 0);
727 return devt;
728}
729
446d64e3
MZ		 730static inline int blk_part_pack_uuid(const u8 *uuid_str, u8 *to)
731{
732 return -EINVAL;
733}
87c1efbf 734#endif /* CONFIG_BLOCK */
9361401e 735
a8ae50ba 736#endif /* _LINUX_GENHD_H */
kernel source for telekom puls (alcatel/mediatek)