Searched refs:geo (Results 1 - 115 of 115) sorted by relevance

/linux-4.1.27/drivers/net/wireless/ipw2x00/
H A Dlibipw_geo.c51 if (ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0) libipw_is_valid_channel()
55 for (i = 0; i < ieee->geo.bg_channels; i++) libipw_is_valid_channel()
59 if ((ieee->geo.bg[i].channel == channel) && libipw_is_valid_channel()
60 !(ieee->geo.bg[i].flags & LIBIPW_CH_INVALID) && libipw_is_valid_channel()
62 !(ieee->geo.bg[i].flags & LIBIPW_CH_B_ONLY))) libipw_is_valid_channel()
66 for (i = 0; i < ieee->geo.a_channels; i++) libipw_is_valid_channel()
67 if ((ieee->geo.a[i].channel == channel) && libipw_is_valid_channel()
68 !(ieee->geo.a[i].flags & LIBIPW_CH_INVALID)) libipw_is_valid_channel()
80 if (ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0) libipw_channel_to_index()
84 for (i = 0; i < ieee->geo.bg_channels; i++) libipw_channel_to_index()
85 if (ieee->geo.bg[i].channel == channel) libipw_channel_to_index()
89 for (i = 0; i < ieee->geo.a_channels; i++) libipw_channel_to_index()
90 if (ieee->geo.a[i].channel == channel) libipw_channel_to_index()
102 if (ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0) libipw_channel_to_freq()
117 if (ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0) libipw_freq_to_channel()
123 for (i = 0; i < ieee->geo.bg_channels; i++) libipw_freq_to_channel()
124 if (ieee->geo.bg[i].freq == freq) libipw_freq_to_channel()
125 return ieee->geo.bg[i].channel; libipw_freq_to_channel()
128 for (i = 0; i < ieee->geo.a_channels; i++) libipw_freq_to_channel()
129 if (ieee->geo.a[i].freq == freq) libipw_freq_to_channel()
130 return ieee->geo.a[i].channel; libipw_freq_to_channel()
136 const struct libipw_geo *geo) libipw_set_geo()
138 memcpy(ieee->geo.name, geo->name, 3); libipw_set_geo()
139 ieee->geo.name[3] = '\0'; libipw_set_geo()
140 ieee->geo.bg_channels = geo->bg_channels; libipw_set_geo()
141 ieee->geo.a_channels = geo->a_channels; libipw_set_geo()
142 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels * libipw_set_geo()
144 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels * libipw_set_geo()
150 return &ieee->geo; libipw_get_geo()
161 return ieee->geo.bg[index].flags; libipw_get_channel_flags()
163 return ieee->geo.a[index].flags; libipw_get_channel_flags()
181 return &ieee->geo.bg[index]; libipw_get_channel()
183 return &ieee->geo.a[index]; libipw_get_channel()
135 libipw_set_geo(struct libipw_device *ieee, const struct libipw_geo *geo) libipw_set_geo() argument
H A Dipw2200.c1919 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); show_channels() local
1924 "(802.11bg):\n", geo->bg_channels); show_channels()
1926 for (i = 0; i < geo->bg_channels; i++) { show_channels()
1928 geo->bg[i].channel, show_channels()
1929 geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT ? show_channels()
1931 ((geo->bg[i].flags & LIBIPW_CH_NO_IBSS) || show_channels()
1932 (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)) show_channels()
1934 geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY ? show_channels()
1936 geo->bg[i].flags & LIBIPW_CH_B_ONLY ? show_channels()
1942 "(802.11a):\n", geo->a_channels); show_channels()
1943 for (i = 0; i < geo->a_channels; i++) { show_channels()
1945 geo->a[i].channel, show_channels()
1946 geo->a[i].flags & LIBIPW_CH_RADAR_DETECT ? show_channels()
1948 ((geo->a[i].flags & LIBIPW_CH_NO_IBSS) || show_channels()
1949 (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)) show_channels()
1951 geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY ? show_channels()
2489 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); ipw_set_tx_power() local
2498 tx_power.num_channels = geo->bg_channels; ipw_set_tx_power()
2499 for (i = 0; i < geo->bg_channels; i++) { ipw_set_tx_power()
2500 max_power = geo->bg[i].max_power; ipw_set_tx_power()
2502 geo->bg[i].channel; ipw_set_tx_power()
2517 tx_power.num_channels = geo->a_channels; ipw_set_tx_power()
2519 max_power = geo->a[i].max_power; ipw_set_tx_power()
2521 geo->a[i].channel; ipw_set_tx_power()
5835 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); ipw_adhoc_create() local
5855 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY) { ipw_adhoc_create()
5857 priv->channel = geo->a[0].channel; ipw_adhoc_create()
5868 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) { ipw_adhoc_create()
5870 priv->channel = geo->bg[0].channel; ipw_adhoc_create()
5878 priv->channel = geo->a[0].channel; ipw_adhoc_create()
5881 priv->channel = geo->bg[0].channel; ipw_adhoc_create()
5884 priv->channel = geo->bg[0].channel; ipw_adhoc_create()
6183 const struct libipw_geo *geo; ipw_add_scan_channels() local
6186 geo = libipw_get_geo(priv->ieee); ipw_add_scan_channels()
6190 for (i = 0; i < geo->a_channels; i++) { ipw_add_scan_channels()
6192 geo->a[i].channel == priv->channel) ipw_add_scan_channels()
6195 scan->channels_list[channel_index] = geo->a[i].channel; ipw_add_scan_channels()
6197 geo->a[i]. ipw_add_scan_channels()
6248 geo->bg[index]. ipw_add_scan_channels()
6255 for (i = 0; i < geo->bg_channels; i++) { ipw_add_scan_channels()
6257 geo->bg[i].channel == priv->channel) ipw_add_scan_channels()
6261 geo->bg[i].channel; ipw_add_scan_channels()
6263 geo->bg[i]. ipw_add_scan_channels()
8675 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); ipw_wx_set_freq() local
8705 geo->bg[i].flags : geo->a[i].flags; ipw_wx_set_freq()
8740 wrqu->freq.m = priv->ieee->geo.a[i].freq * 100000; ipw_wx_get_freq()
8744 wrqu->freq.m = priv->ieee->geo.bg[i].freq * 100000; ipw_wx_get_freq()
8845 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); ipw_wx_get_range() local
8887 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) { ipw_wx_get_range()
8889 (geo->bg[j].flags & LIBIPW_CH_PASSIVE_ONLY)) ipw_wx_get_range()
8892 range->freq[i].i = geo->bg[j].channel; ipw_wx_get_range()
8893 range->freq[i].m = geo->bg[j].freq * 100000; ipw_wx_get_range()
8900 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) { ipw_wx_get_range()
8902 (geo->a[j].flags & LIBIPW_CH_PASSIVE_ONLY)) ipw_wx_get_range()
8905 range->freq[i].i = geo->a[j].channel; ipw_wx_get_range()
8906 range->freq[i].m = geo->a[j].freq * 100000; ipw_wx_get_range()
11354 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); ipw_wdev_init() local
11360 if (geo->bg_channels) { ipw_wdev_init()
11364 bg_band->n_channels = geo->bg_channels; ipw_wdev_init()
11365 bg_band->channels = kcalloc(geo->bg_channels, ipw_wdev_init()
11372 /* translate geo->bg to bg_band.channels */ ipw_wdev_init()
11373 for (i = 0; i < geo->bg_channels; i++) { ipw_wdev_init()
11375 bg_band->channels[i].center_freq = geo->bg[i].freq; ipw_wdev_init()
11376 bg_band->channels[i].hw_value = geo->bg[i].channel; ipw_wdev_init()
11377 bg_band->channels[i].max_power = geo->bg[i].max_power; ipw_wdev_init()
11378 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) ipw_wdev_init()
11381 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS) ipw_wdev_init()
11384 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT) ipw_wdev_init()
11399 if (geo->a_channels) { ipw_wdev_init()
11403 a_band->n_channels = geo->a_channels; ipw_wdev_init()
11404 a_band->channels = kcalloc(geo->a_channels, ipw_wdev_init()
11411 /* translate geo->a to a_band.channels */ ipw_wdev_init()
11412 for (i = 0; i < geo->a_channels; i++) { ipw_wdev_init()
11414 a_band->channels[i].center_freq = geo->a[i].freq; ipw_wdev_init()
11415 a_band->channels[i].hw_value = geo->a[i].channel; ipw_wdev_init()
11416 a_band->channels[i].max_power = geo->a[i].max_power; ipw_wdev_init()
11417 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY) ipw_wdev_init()
11420 if (geo->a[i].flags & LIBIPW_CH_NO_IBSS) ipw_wdev_init()
11423 if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT) ipw_wdev_init()
11774 priv->ieee->geo.name, priv->ieee->geo.bg_channels, ipw_pci_probe()
11775 priv->ieee->geo.a_channels); ipw_pci_probe()
H A Dlibipw.h726 struct libipw_geo geo; member in struct:libipw_device
972 void libipw_set_geo(struct libipw_device *ieee, const struct libipw_geo *geo);
H A Dipw2100.c1790 /* Initialize the geo */ ipw2100_up()
1906 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); ipw2100_wdev_init() local
1913 if (geo->bg_channels) { ipw2100_wdev_init()
1917 bg_band->n_channels = geo->bg_channels; ipw2100_wdev_init()
1918 bg_band->channels = kcalloc(geo->bg_channels, ipw2100_wdev_init()
1925 /* translate geo->bg to bg_band.channels */ ipw2100_wdev_init()
1926 for (i = 0; i < geo->bg_channels; i++) { ipw2100_wdev_init()
1928 bg_band->channels[i].center_freq = geo->bg[i].freq; ipw2100_wdev_init()
1929 bg_band->channels[i].hw_value = geo->bg[i].channel; ipw2100_wdev_init()
1930 bg_band->channels[i].max_power = geo->bg[i].max_power; ipw2100_wdev_init()
1931 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) ipw2100_wdev_init()
1934 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS) ipw2100_wdev_init()
1937 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT) ipw2100_wdev_init()
/linux-4.1.27/lib/
H A Dbtree.c135 static void dec_key(struct btree_geo *geo, unsigned long *key) dec_key() argument
140 for (i = geo->keylen - 1; i >= 0; i--) { dec_key()
148 static unsigned long *bkey(struct btree_geo *geo, unsigned long *node, int n) bkey() argument
150 return &node[n * geo->keylen]; bkey()
153 static void *bval(struct btree_geo *geo, unsigned long *node, int n) bval() argument
155 return (void *)node[geo->no_longs + n]; bval()
158 static void setkey(struct btree_geo *geo, unsigned long *node, int n, setkey() argument
161 longcpy(bkey(geo, node, n), key, geo->keylen); setkey()
164 static void setval(struct btree_geo *geo, unsigned long *node, int n, setval() argument
167 node[geo->no_longs + n] = (unsigned long) val; setval()
170 static void clearpair(struct btree_geo *geo, unsigned long *node, int n) clearpair() argument
172 longset(bkey(geo, node, n), 0, geo->keylen); clearpair()
173 node[geo->no_longs + n] = 0; clearpair()
207 void *btree_last(struct btree_head *head, struct btree_geo *geo, btree_last() argument
217 node = bval(geo, node, 0); btree_last()
219 longcpy(key, bkey(geo, node, 0), geo->keylen); btree_last()
220 return bval(geo, node, 0); btree_last()
224 static int keycmp(struct btree_geo *geo, unsigned long *node, int pos, keycmp() argument
227 return longcmp(bkey(geo, node, pos), key, geo->keylen); keycmp()
230 static int keyzero(struct btree_geo *geo, unsigned long *key) keyzero() argument
234 for (i = 0; i < geo->keylen; i++) keyzero()
241 void *btree_lookup(struct btree_head *head, struct btree_geo *geo, btree_lookup() argument
251 for (i = 0; i < geo->no_pairs; i++) btree_lookup()
252 if (keycmp(geo, node, i, key) <= 0) btree_lookup()
254 if (i == geo->no_pairs) btree_lookup()
256 node = bval(geo, node, i); btree_lookup()
264 for (i = 0; i < geo->no_pairs; i++) btree_lookup()
265 if (keycmp(geo, node, i, key) == 0) btree_lookup()
266 return bval(geo, node, i); btree_lookup()
271 int btree_update(struct btree_head *head, struct btree_geo *geo, btree_update() argument
281 for (i = 0; i < geo->no_pairs; i++) btree_update()
282 if (keycmp(geo, node, i, key) <= 0) btree_update()
284 if (i == geo->no_pairs) btree_update()
286 node = bval(geo, node, i); btree_update()
294 for (i = 0; i < geo->no_pairs; i++) btree_update()
295 if (keycmp(geo, node, i, key) == 0) { btree_update()
296 setval(geo, node, i, val); btree_update()
311 void *btree_get_prev(struct btree_head *head, struct btree_geo *geo, btree_get_prev() argument
316 unsigned long *retry_key = NULL, key[geo->keylen]; btree_get_prev()
318 if (keyzero(geo, __key)) btree_get_prev()
323 longcpy(key, __key, geo->keylen); btree_get_prev()
325 dec_key(geo, key); btree_get_prev()
329 for (i = 0; i < geo->no_pairs; i++) btree_get_prev()
330 if (keycmp(geo, node, i, key) <= 0) btree_get_prev()
332 if (i == geo->no_pairs) btree_get_prev()
335 node = bval(geo, node, i); btree_get_prev()
338 retry_key = bkey(geo, oldnode, i); btree_get_prev()
344 for (i = 0; i < geo->no_pairs; i++) { btree_get_prev()
345 if (keycmp(geo, node, i, key) <= 0) { btree_get_prev()
346 if (bval(geo, node, i)) { btree_get_prev()
347 longcpy(__key, bkey(geo, node, i), geo->keylen); btree_get_prev()
348 return bval(geo, node, i); btree_get_prev()
355 longcpy(key, retry_key, geo->keylen); btree_get_prev()
363 static int getpos(struct btree_geo *geo, unsigned long *node, getpos() argument
368 for (i = 0; i < geo->no_pairs; i++) { getpos()
369 if (keycmp(geo, node, i, key) <= 0) getpos()
375 static int getfill(struct btree_geo *geo, unsigned long *node, int start) getfill() argument
379 for (i = start; i < geo->no_pairs; i++) getfill()
380 if (!bval(geo, node, i)) getfill()
388 static unsigned long *find_level(struct btree_head *head, struct btree_geo *geo, find_level() argument
395 for (i = 0; i < geo->no_pairs; i++) find_level()
396 if (keycmp(geo, node, i, key) <= 0) find_level()
399 if ((i == geo->no_pairs) || !bval(geo, node, i)) { find_level()
404 setkey(geo, node, i, key); find_level()
407 node = bval(geo, node, i); find_level()
413 static int btree_grow(struct btree_head *head, struct btree_geo *geo, btree_grow() argument
423 fill = getfill(geo, head->node, 0); btree_grow()
424 setkey(geo, node, 0, bkey(geo, head->node, fill - 1)); btree_grow()
425 setval(geo, node, 0, head->node); btree_grow()
432 static void btree_shrink(struct btree_head *head, struct btree_geo *geo) btree_shrink() argument
441 fill = getfill(geo, node, 0); btree_shrink()
443 head->node = bval(geo, node, 0); btree_shrink()
448 static int btree_insert_level(struct btree_head *head, struct btree_geo *geo, btree_insert_level() argument
457 err = btree_grow(head, geo, gfp); btree_insert_level()
463 node = find_level(head, geo, key, level); btree_insert_level()
464 pos = getpos(geo, node, key); btree_insert_level()
465 fill = getfill(geo, node, pos); btree_insert_level()
467 BUG_ON(pos < fill && keycmp(geo, node, pos, key) == 0); btree_insert_level()
469 if (fill == geo->no_pairs) { btree_insert_level()
476 err = btree_insert_level(head, geo, btree_insert_level()
477 bkey(geo, node, fill / 2 - 1), btree_insert_level()
484 setkey(geo, new, i, bkey(geo, node, i)); btree_insert_level()
485 setval(geo, new, i, bval(geo, node, i)); btree_insert_level()
486 setkey(geo, node, i, bkey(geo, node, i + fill / 2)); btree_insert_level()
487 setval(geo, node, i, bval(geo, node, i + fill / 2)); btree_insert_level()
488 clearpair(geo, node, i + fill / 2); btree_insert_level()
491 setkey(geo, node, i, bkey(geo, node, fill - 1)); btree_insert_level()
492 setval(geo, node, i, bval(geo, node, fill - 1)); btree_insert_level()
493 clearpair(geo, node, fill - 1); btree_insert_level()
497 BUG_ON(fill >= geo->no_pairs); btree_insert_level()
501 setkey(geo, node, i, bkey(geo, node, i - 1)); btree_insert_level()
502 setval(geo, node, i, bval(geo, node, i - 1)); btree_insert_level()
504 setkey(geo, node, pos, key); btree_insert_level()
505 setval(geo, node, pos, val); btree_insert_level()
510 int btree_insert(struct btree_head *head, struct btree_geo *geo, btree_insert() argument
514 return btree_insert_level(head, geo, key, val, 1, gfp); btree_insert()
518 static void *btree_remove_level(struct btree_head *head, struct btree_geo *geo,
520 static void merge(struct btree_head *head, struct btree_geo *geo, int level, merge() argument
529 setkey(geo, left, lfill + i, bkey(geo, right, i)); merge()
530 setval(geo, left, lfill + i, bval(geo, right, i)); merge()
533 setval(geo, parent, lpos, right); merge()
534 setval(geo, parent, lpos + 1, left); merge()
536 btree_remove_level(head, geo, bkey(geo, parent, lpos), level + 1); merge()
540 static void rebalance(struct btree_head *head, struct btree_geo *geo, rebalance() argument
551 btree_remove_level(head, geo, key, level + 1); rebalance()
556 parent = find_level(head, geo, key, level + 1); rebalance()
557 i = getpos(geo, parent, key); rebalance()
558 BUG_ON(bval(geo, parent, i) != child); rebalance()
561 left = bval(geo, parent, i - 1); rebalance()
562 no_left = getfill(geo, left, 0); rebalance()
563 if (fill + no_left <= geo->no_pairs) { rebalance()
564 merge(head, geo, level, rebalance()
571 if (i + 1 < getfill(geo, parent, i)) { rebalance()
572 right = bval(geo, parent, i + 1); rebalance()
573 no_right = getfill(geo, right, 0); rebalance()
574 if (fill + no_right <= geo->no_pairs) { rebalance()
575 merge(head, geo, level, rebalance()
591 static void *btree_remove_level(struct btree_head *head, struct btree_geo *geo, btree_remove_level() argument
605 node = find_level(head, geo, key, level); btree_remove_level()
606 pos = getpos(geo, node, key); btree_remove_level()
607 fill = getfill(geo, node, pos); btree_remove_level()
608 if ((level == 1) && (keycmp(geo, node, pos, key) != 0)) btree_remove_level()
610 ret = bval(geo, node, pos); btree_remove_level()
614 setkey(geo, node, i, bkey(geo, node, i + 1)); btree_remove_level()
615 setval(geo, node, i, bval(geo, node, i + 1)); btree_remove_level()
617 clearpair(geo, node, fill - 1); btree_remove_level()
619 if (fill - 1 < geo->no_pairs / 2) { btree_remove_level()
621 rebalance(head, geo, key, level, node, fill - 1); btree_remove_level()
623 btree_shrink(head, geo); btree_remove_level()
629 void *btree_remove(struct btree_head *head, struct btree_geo *geo, btree_remove() argument
635 return btree_remove_level(head, geo, key, 1); btree_remove()
640 struct btree_geo *geo, gfp_t gfp) btree_merge()
642 unsigned long key[geo->keylen]; btree_merge()
643 unsigned long dup[geo->keylen]; btree_merge()
661 if (!btree_last(victim, geo, key)) btree_merge()
663 val = btree_lookup(victim, geo, key); btree_merge()
664 err = btree_insert(target, geo, key, val, gfp); btree_merge()
669 longcpy(dup, key, geo->keylen); btree_merge()
670 btree_remove(victim, geo, dup); btree_merge()
676 static size_t __btree_for_each(struct btree_head *head, struct btree_geo *geo, __btree_for_each() argument
686 for (i = 0; i < geo->no_pairs; i++) { __btree_for_each()
687 child = bval(geo, node, i); __btree_for_each()
691 count = __btree_for_each(head, geo, child, opaque, __btree_for_each()
694 func(child, opaque, bkey(geo, node, i), count++, __btree_for_each()
746 size_t btree_visitor(struct btree_head *head, struct btree_geo *geo, btree_visitor() argument
758 count = __btree_for_each(head, geo, head->node, opaque, func, btree_visitor()
764 size_t btree_grim_visitor(struct btree_head *head, struct btree_geo *geo, btree_grim_visitor() argument
776 count = __btree_for_each(head, geo, head->node, opaque, func, btree_grim_visitor()
639 btree_merge(struct btree_head *target, struct btree_head *victim, struct btree_geo *geo, gfp_t gfp) btree_merge() argument
/linux-4.1.27/fs/xfs/libxfs/
H A Dxfs_dir2.h89 int (*leaf_max_ents)(struct xfs_da_geometry *geo);
106 int (*free_max_bests)(struct xfs_da_geometry *geo);
108 xfs_dir2_db_t (*db_to_fdb)(struct xfs_da_geometry *geo,
110 int (*db_to_fdindex)(struct xfs_da_geometry *geo,
214 xfs_dir2_byte_to_db(struct xfs_da_geometry *geo, xfs_dir2_off_t by) xfs_dir2_byte_to_db() argument
216 return (xfs_dir2_db_t)(by >> geo->blklog); xfs_dir2_byte_to_db()
223 xfs_dir2_dataptr_to_db(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp) xfs_dir2_dataptr_to_db() argument
225 return xfs_dir2_byte_to_db(geo, xfs_dir2_dataptr_to_byte(dp)); xfs_dir2_dataptr_to_db()
232 xfs_dir2_byte_to_off(struct xfs_da_geometry *geo, xfs_dir2_off_t by) xfs_dir2_byte_to_off() argument
234 return (xfs_dir2_data_aoff_t)(by & (geo->blksize - 1)); xfs_dir2_byte_to_off()
241 xfs_dir2_dataptr_to_off(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp) xfs_dir2_dataptr_to_off() argument
243 return xfs_dir2_byte_to_off(geo, xfs_dir2_dataptr_to_byte(dp)); xfs_dir2_dataptr_to_off()
250 xfs_dir2_db_off_to_byte(struct xfs_da_geometry *geo, xfs_dir2_db_t db, xfs_dir2_db_off_to_byte() argument
253 return ((xfs_dir2_off_t)db << geo->blklog) + o; xfs_dir2_db_off_to_byte()
260 xfs_dir2_db_to_da(struct xfs_da_geometry *geo, xfs_dir2_db_t db) xfs_dir2_db_to_da() argument
262 return (xfs_dablk_t)(db << (geo->blklog - geo->fsblog)); xfs_dir2_db_to_da()
269 xfs_dir2_byte_to_da(struct xfs_da_geometry *geo, xfs_dir2_off_t by) xfs_dir2_byte_to_da() argument
271 return xfs_dir2_db_to_da(geo, xfs_dir2_byte_to_db(geo, by)); xfs_dir2_byte_to_da()
278 xfs_dir2_db_off_to_dataptr(struct xfs_da_geometry *geo, xfs_dir2_db_t db, xfs_dir2_db_off_to_dataptr() argument
281 return xfs_dir2_byte_to_dataptr(xfs_dir2_db_off_to_byte(geo, db, o)); xfs_dir2_db_off_to_dataptr()
288 xfs_dir2_da_to_db(struct xfs_da_geometry *geo, xfs_dablk_t da) xfs_dir2_da_to_db() argument
290 return (xfs_dir2_db_t)(da >> (geo->blklog - geo->fsblog)); xfs_dir2_da_to_db()
297 xfs_dir2_da_to_byte(struct xfs_da_geometry *geo, xfs_dablk_t da) xfs_dir2_da_to_byte() argument
299 return xfs_dir2_db_off_to_byte(geo, xfs_dir2_da_to_db(geo, da), 0); xfs_dir2_da_to_byte()
306 xfs_dir2_block_tail_p(struct xfs_da_geometry *geo, struct xfs_dir2_data_hdr *hdr) xfs_dir2_block_tail_p() argument
309 ((char *)hdr + geo->blksize)) - 1; xfs_dir2_block_tail_p()
313 xfs_dir2_leaf_tail_p(struct xfs_da_geometry *geo, struct xfs_dir2_leaf *lp) xfs_dir2_leaf_tail_p() argument
316 ((char *)lp + geo->blksize - xfs_dir2_leaf_tail_p()
H A Dxfs_attr_leaf.c107 struct xfs_da_geometry *geo, xfs_attr3_leaf_firstused_from_disk()
127 ASSERT(geo->blksize > USHRT_MAX); xfs_attr3_leaf_firstused_from_disk()
128 to->firstused = geo->blksize; xfs_attr3_leaf_firstused_from_disk()
134 struct xfs_da_geometry *geo, xfs_attr3_leaf_firstused_to_disk()
151 ASSERT(from->firstused == geo->blksize); xfs_attr3_leaf_firstused_to_disk()
165 struct xfs_da_geometry *geo, xfs_attr3_leaf_hdr_from_disk()
182 xfs_attr3_leaf_firstused_from_disk(geo, to, from); xfs_attr3_leaf_hdr_from_disk()
196 xfs_attr3_leaf_firstused_from_disk(geo, to, from); xfs_attr3_leaf_hdr_from_disk()
207 struct xfs_da_geometry *geo, xfs_attr3_leaf_hdr_to_disk()
224 xfs_attr3_leaf_firstused_to_disk(geo, to, from); xfs_attr3_leaf_hdr_to_disk()
239 xfs_attr3_leaf_firstused_to_disk(geo, to, from); xfs_attr3_leaf_hdr_to_disk()
789 nargs.geo = args->geo; xfs_attr_shortform_to_leaf()
885 tmpbuffer = kmem_alloc(args->geo->blksize, KM_SLEEP); xfs_attr3_leaf_to_shortform()
889 memcpy(tmpbuffer, bp->b_addr, args->geo->blksize); xfs_attr3_leaf_to_shortform()
892 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf); xfs_attr3_leaf_to_shortform()
896 memset(bp->b_addr, 0, args->geo->blksize); xfs_attr3_leaf_to_shortform()
918 nargs.geo = args->geo; xfs_attr3_leaf_to_shortform()
985 memcpy(bp2->b_addr, bp1->b_addr, args->geo->blksize); xfs_attr3_leaf_to_node()
990 xfs_trans_log_buf(args->trans, bp2, 0, args->geo->blksize - 1); xfs_attr3_leaf_to_node()
1003 xfs_attr3_leaf_hdr_from_disk(args->geo, &icleafhdr, leaf); xfs_attr3_leaf_to_node()
1011 xfs_trans_log_buf(args->trans, bp1, 0, args->geo->blksize - 1); xfs_attr3_leaf_to_node()
1047 memset(leaf, 0, args->geo->blksize); xfs_attr3_leaf_create()
1050 ichdr.firstused = args->geo->blksize; xfs_attr3_leaf_create()
1068 xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr); xfs_attr3_leaf_create()
1069 xfs_trans_log_buf(args->trans, bp, 0, args->geo->blksize - 1); xfs_attr3_leaf_create()
1153 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf); xfs_attr3_leaf_add()
1206 xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr); xfs_attr3_leaf_add()
1254 ASSERT(ichdr->freemap[mapindex].base < args->geo->blksize); xfs_attr3_leaf_add_work()
1258 ASSERT(ichdr->freemap[mapindex].size < args->geo->blksize); xfs_attr3_leaf_add_work()
1350 tmpbuffer = kmem_alloc(args->geo->blksize, KM_SLEEP); xfs_attr3_leaf_compact()
1351 memcpy(tmpbuffer, bp->b_addr, args->geo->blksize); xfs_attr3_leaf_compact()
1352 memset(bp->b_addr, 0, args->geo->blksize); xfs_attr3_leaf_compact()
1365 ichdr_dst->firstused = args->geo->blksize; xfs_attr3_leaf_compact()
1374 xfs_attr3_leaf_hdr_to_disk(args->geo, leaf_dst, ichdr_dst); xfs_attr3_leaf_compact()
1386 xfs_trans_log_buf(trans, bp, 0, args->geo->blksize - 1); xfs_attr3_leaf_compact()
1469 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr1, leaf1); xfs_attr3_leaf_rebalance()
1470 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr2, leaf2); xfs_attr3_leaf_rebalance()
1571 xfs_attr3_leaf_hdr_to_disk(state->args->geo, leaf1, &ichdr1); xfs_attr3_leaf_rebalance()
1572 xfs_attr3_leaf_hdr_to_disk(state->args->geo, leaf2, &ichdr2); xfs_attr3_leaf_rebalance()
1573 xfs_trans_log_buf(args->trans, blk1->bp, 0, args->geo->blksize - 1); xfs_attr3_leaf_rebalance()
1574 xfs_trans_log_buf(args->trans, blk2->bp, 0, args->geo->blksize - 1); xfs_attr3_leaf_rebalance()
1671 lastdelta = state->args->geo->blksize; xfs_attr3_leaf_figure_balance()
1765 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr, leaf); xfs_attr3_leaf_toosmall()
1769 if (bytes > (state->args->geo->blksize >> 1)) { xfs_attr3_leaf_toosmall()
1821 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr2, bp->b_addr); xfs_attr3_leaf_toosmall()
1823 bytes = state->args->geo->blksize - xfs_attr3_leaf_toosmall()
1824 (state->args->geo->blksize >> 2) - xfs_attr3_leaf_toosmall()
1886 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf); xfs_attr3_leaf_remove()
1888 ASSERT(ichdr.count > 0 && ichdr.count < args->geo->blksize / 8); xfs_attr3_leaf_remove()
1896 ASSERT(be16_to_cpu(entry->nameidx) < args->geo->blksize); xfs_attr3_leaf_remove()
1911 ASSERT(ichdr.freemap[i].base < args->geo->blksize); xfs_attr3_leaf_remove()
1912 ASSERT(ichdr.freemap[i].size < args->geo->blksize); xfs_attr3_leaf_remove()
1989 tmp = args->geo->blksize; xfs_attr3_leaf_remove()
1993 ASSERT(be16_to_cpu(entry->nameidx) < args->geo->blksize); xfs_attr3_leaf_remove()
2003 xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr); xfs_attr3_leaf_remove()
2015 return tmp < args->geo->magicpct; /* leaf is < 37% full */ xfs_attr3_leaf_remove()
2037 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &drophdr, drop_leaf); xfs_attr3_leaf_unbalance()
2038 xfs_attr3_leaf_hdr_from_disk(state->args->geo, &savehdr, save_leaf); xfs_attr3_leaf_unbalance()
2076 tmp_leaf = kmem_zalloc(state->args->geo->blksize, KM_SLEEP); xfs_attr3_leaf_unbalance()
2089 tmphdr.firstused = state->args->geo->blksize; xfs_attr3_leaf_unbalance()
2092 xfs_attr3_leaf_hdr_to_disk(state->args->geo, tmp_leaf, &tmphdr); xfs_attr3_leaf_unbalance()
2114 memcpy(save_leaf, tmp_leaf, state->args->geo->blksize); xfs_attr3_leaf_unbalance()
2119 xfs_attr3_leaf_hdr_to_disk(state->args->geo, save_leaf, &savehdr); xfs_attr3_leaf_unbalance()
2121 state->args->geo->blksize - 1); xfs_attr3_leaf_unbalance()
2165 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf); xfs_attr3_leaf_lookup_int()
2167 ASSERT(ichdr.count < args->geo->blksize / 8); xfs_attr3_leaf_lookup_int()
2270 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf); xfs_attr3_leaf_getvalue()
2271 ASSERT(ichdr.count < args->geo->blksize / 8); xfs_attr3_leaf_getvalue()
2349 ASSERT(ichdr_s->count > 0 && ichdr_s->count < args->geo->blksize / 8); xfs_attr3_leaf_moveents()
2352 ASSERT(ichdr_d->count < args->geo->blksize / 8); xfs_attr3_leaf_moveents()
2404 <= args->geo->blksize); xfs_attr3_leaf_moveents()
2408 <= args->geo->blksize); xfs_attr3_leaf_moveents()
2429 ((char *)leaf_s + args->geo->blksize)); xfs_attr3_leaf_moveents()
2444 ((char *)leaf_s + args->geo->blksize)); xfs_attr3_leaf_moveents()
2520 if (size < xfs_attr_leaf_entsize_local_max(args->geo->blksize)) { xfs_attr_leaf_newentsize()
2567 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf); xfs_attr3_leaf_clearflag()
2631 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf); xfs_attr3_leaf_setflag()
2710 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr1, leaf1); xfs_attr3_leaf_flipflags()
2714 xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr2, leaf2); xfs_attr3_leaf_flipflags()
106 xfs_attr3_leaf_firstused_from_disk( struct xfs_da_geometry *geo, struct xfs_attr3_icleaf_hdr *to, struct xfs_attr_leafblock *from) xfs_attr3_leaf_firstused_from_disk() argument
133 xfs_attr3_leaf_firstused_to_disk( struct xfs_da_geometry *geo, struct xfs_attr_leafblock *to, struct xfs_attr3_icleaf_hdr *from) xfs_attr3_leaf_firstused_to_disk() argument
164 xfs_attr3_leaf_hdr_from_disk( struct xfs_da_geometry *geo, struct xfs_attr3_icleaf_hdr *to, struct xfs_attr_leafblock *from) xfs_attr3_leaf_hdr_from_disk() argument
206 xfs_attr3_leaf_hdr_to_disk( struct xfs_da_geometry *geo, struct xfs_attr_leafblock *to, struct xfs_attr3_icleaf_hdr *from) xfs_attr3_leaf_hdr_to_disk() argument
H A Dxfs_da_format.c427 xfs_dir2_max_leaf_ents(struct xfs_da_geometry *geo) xfs_dir2_max_leaf_ents() argument
429 return (geo->blksize - sizeof(struct xfs_dir2_leaf_hdr)) / xfs_dir2_max_leaf_ents()
440 xfs_dir3_max_leaf_ents(struct xfs_da_geometry *geo) xfs_dir3_max_leaf_ents() argument
442 return (geo->blksize - sizeof(struct xfs_dir3_leaf_hdr)) / xfs_dir3_max_leaf_ents()
593 xfs_dir2_free_max_bests(struct xfs_da_geometry *geo) xfs_dir2_free_max_bests() argument
595 return (geo->blksize - sizeof(struct xfs_dir2_free_hdr)) / xfs_dir2_free_max_bests()
609 xfs_dir2_db_to_fdb(struct xfs_da_geometry *geo, xfs_dir2_db_t db) xfs_dir2_db_to_fdb() argument
611 return xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET) + xfs_dir2_db_to_fdb()
612 (db / xfs_dir2_free_max_bests(geo)); xfs_dir2_db_to_fdb()
619 xfs_dir2_db_to_fdindex(struct xfs_da_geometry *geo, xfs_dir2_db_t db) xfs_dir2_db_to_fdindex() argument
621 return db % xfs_dir2_free_max_bests(geo); xfs_dir2_db_to_fdindex()
625 xfs_dir3_free_max_bests(struct xfs_da_geometry *geo) xfs_dir3_free_max_bests() argument
627 return (geo->blksize - sizeof(struct xfs_dir3_free_hdr)) / xfs_dir3_free_max_bests()
641 xfs_dir3_db_to_fdb(struct xfs_da_geometry *geo, xfs_dir2_db_t db) xfs_dir3_db_to_fdb() argument
643 return xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET) + xfs_dir3_db_to_fdb()
644 (db / xfs_dir3_free_max_bests(geo)); xfs_dir3_db_to_fdb()
651 xfs_dir3_db_to_fdindex(struct xfs_da_geometry *geo, xfs_dir2_db_t db) xfs_dir3_db_to_fdindex() argument
653 return db % xfs_dir3_free_max_bests(geo); xfs_dir3_db_to_fdindex()
H A Dxfs_dir2.c243 args->geo = dp->i_mount->m_dir_geo; xfs_dir_init()
281 args->geo = dp->i_mount->m_dir_geo; xfs_dir_createname()
378 args->geo = dp->i_mount->m_dir_geo; xfs_dir_lookup()
450 args->geo = dp->i_mount->m_dir_geo; xfs_dir_removename()
515 args->geo = dp->i_mount->m_dir_geo; xfs_dir_replace()
593 count = args->geo->fsbcount; xfs_dir2_grow_inode()
599 *dbp = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)bno); xfs_dir2_grow_inode()
629 rval = XFS_FSB_TO_B(args->dp->i_mount, last) == args->geo->blksize; xfs_dir2_isblock()
630 ASSERT(rval == 0 || args->dp->i_d.di_size == args->geo->blksize); xfs_dir2_isblock()
648 *vp = last == args->geo->leafblk + args->geo->fsbcount; xfs_dir2_isleaf()
676 da = xfs_dir2_db_to_da(args->geo, db); xfs_dir2_shrink_inode()
680 if ((error = xfs_bunmapi(tp, dp, da, args->geo->fsbcount, xfs_dir2_shrink_inode()
707 if (db >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET)) xfs_dir2_shrink_inode()
712 if (dp->i_d.di_size > xfs_dir2_db_off_to_byte(args->geo, db + 1, 0)) xfs_dir2_shrink_inode()
721 if (db == args->geo->datablk) xfs_dir2_shrink_inode()
H A Dxfs_dir2_leaf.c94 struct xfs_da_geometry *geo = mp->m_dir_geo; xfs_dir3_leaf_check_int() local
108 ltp = xfs_dir2_leaf_tail_p(geo, leaf); xfs_dir3_leaf_check_int()
115 if (hdr->count > ops->leaf_max_ents(geo)) xfs_dir3_leaf_check_int()
350 ASSERT(bno >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET) && xfs_dir3_leaf_get_buf()
351 bno < xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET)); xfs_dir3_leaf_get_buf()
353 error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, bno), xfs_dir3_leaf_get_buf()
404 ldb = xfs_dir2_da_to_db(args->geo, blkno); xfs_dir2_block_to_leaf()
405 ASSERT(ldb == xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET)); xfs_dir2_block_to_leaf()
416 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_block_to_leaf()
444 (xfs_dir2_data_aoff_t)((char *)hdr + args->geo->blksize - xfs_dir2_block_to_leaf()
462 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir2_block_to_leaf()
640 error = xfs_dir3_leaf_read(tp, dp, args->geo->leafblk, -1, &lbp); xfs_dir2_leaf_addname()
652 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir2_leaf_addname()
669 i = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address)); xfs_dir2_leaf_addname()
828 xfs_dir2_db_to_da(args->geo, use_block), xfs_dir2_leaf_addname()
890 xfs_dir2_db_off_to_dataptr(args->geo, use_block, xfs_dir2_leaf_addname()
1066 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir3_leaf_log_bests()
1138 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir3_leaf_log_tail()
1140 (uint)(args->geo->blksize - 1)); xfs_dir3_leaf_log_tail()
1186 xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address))); xfs_dir2_leaf_lookup()
1232 error = xfs_dir3_leaf_read(tp, dp, args->geo->leafblk, -1, &lbp); xfs_dir2_leaf_lookup_int()
1261 newdb = xfs_dir2_dataptr_to_db(args->geo, xfs_dir2_leaf_lookup_int()
1271 xfs_dir2_db_to_da(args->geo, newdb), xfs_dir2_leaf_lookup_int()
1283 xfs_dir2_dataptr_to_off(args->geo, xfs_dir2_leaf_lookup_int()
1313 xfs_dir2_db_to_da(args->geo, cidb), xfs_dir2_leaf_lookup_int()
1379 db = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address)); xfs_dir2_leaf_removename()
1381 xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address))); xfs_dir2_leaf_removename()
1384 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir2_leaf_removename()
1424 args->geo->blksize - dp->d_ops->data_entry_offset) { xfs_dir2_leaf_removename()
1425 ASSERT(db != args->geo->datablk); xfs_dir2_leaf_removename()
1467 else if (db != args->geo->datablk) xfs_dir2_leaf_removename()
1515 xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address))); xfs_dir2_leaf_replace()
1607 error = xfs_dir3_data_read(tp, dp, xfs_dir2_db_to_da(args->geo, db), xfs_dir2_leaf_trim_data()
1613 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir2_leaf_trim_data()
1623 args->geo->blksize - dp->d_ops->data_entry_offset); xfs_dir2_leaf_trim_data()
1710 fo -= args->geo->fsbcount; xfs_dir2_node_to_leaf()
1717 while (fo > args->geo->freeblk) { xfs_dir2_node_to_leaf()
1722 fo -= args->geo->fsbcount; xfs_dir2_node_to_leaf()
1735 if (XFS_FSB_TO_B(mp, fo) > XFS_DIR2_LEAF_OFFSET + args->geo->blksize) xfs_dir2_node_to_leaf()
1747 error = xfs_dir2_free_read(tp, dp, args->geo->freeblk, &fbp); xfs_dir2_node_to_leaf()
1759 if (xfs_dir3_leaf_size(&leafhdr, freehdr.nvalid) > args->geo->blksize) { xfs_dir2_node_to_leaf()
1779 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir2_node_to_leaf()
1798 xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET), xfs_dir2_node_to_leaf()
H A Dxfs_dir2_block.c374 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_block_addname()
628 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_block_lookup()
634 xfs_dir2_dataptr_to_off(args->geo, xfs_dir2_block_lookup()
681 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_block_lookup_int()
719 ((char *)hdr + xfs_dir2_dataptr_to_off(args->geo, addr)); xfs_dir2_block_lookup_int()
784 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_block_removename()
790 xfs_dir2_dataptr_to_off(args->geo, xfs_dir2_block_removename()
858 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_block_replace()
864 xfs_dir2_dataptr_to_off(args->geo, xfs_dir2_block_replace()
932 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir2_leaf_to_block()
942 while (dp->i_d.di_size > args->geo->blksize) { xfs_dir2_leaf_to_block()
948 args->geo->blksize - hdrsz) { xfs_dir2_leaf_to_block()
960 error = xfs_dir3_data_read(tp, dp, args->geo->datablk, -1, &dbp); xfs_dir2_leaf_to_block()
976 tagp = (__be16 *)((char *)hdr + args->geo->blksize) - 1; xfs_dir2_leaf_to_block()
995 xfs_dir2_data_use_free(args, dbp, dup, args->geo->blksize - size, size, xfs_dir2_leaf_to_block()
1000 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_leaf_to_block()
1025 error = xfs_da_shrink_inode(args, args->geo->leafblk, lbp); xfs_dir2_leaf_to_block()
1134 xfs_dir2_data_use_free(args, bp, dup, args->geo->blksize - i, xfs_dir2_sf_to_block()
1140 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_sf_to_block()
H A Dxfs_attr_leaf.h103 void xfs_attr3_leaf_hdr_from_disk(struct xfs_da_geometry *geo,
106 void xfs_attr3_leaf_hdr_to_disk(struct xfs_da_geometry *geo,
H A Dxfs_dir2_node.c207 error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, fbno), xfs_dir3_free_get_buf()
314 ASSERT(fdb == xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET)); xfs_dir2_leaf_to_node()
325 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); xfs_dir2_leaf_to_node()
327 (uint)dp->i_d.di_size / args->geo->blksize); xfs_dir2_leaf_to_node()
410 if (leafhdr.count == dp->d_ops->leaf_max_ents(args->geo)) { xfs_dir2_leafn_add()
445 lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(args->geo, xfs_dir2_leafn_add()
572 newdb = xfs_dir2_dataptr_to_db(args->geo, xfs_dir2_leafn_lookup_for_addname()
590 newfdb = dp->d_ops->db_to_fdb(args->geo, newdb); xfs_dir2_leafn_lookup_for_addname()
602 xfs_dir2_db_to_da(args->geo, xfs_dir2_leafn_lookup_for_addname()
614 fi = dp->d_ops->db_to_fdindex(args->geo, curdb); xfs_dir2_leafn_lookup_for_addname()
719 newdb = xfs_dir2_dataptr_to_db(args->geo, xfs_dir2_leafn_lookup_for_entry()
745 xfs_dir2_db_to_da(args->geo, xfs_dir2_leafn_lookup_for_entry()
758 xfs_dir2_dataptr_to_off(args->geo, xfs_dir2_leafn_lookup_for_entry()
1188 db = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address)); xfs_dir2_leafn_remove()
1190 off = xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address)); xfs_dir2_leafn_remove()
1240 fdb = dp->d_ops->db_to_fdb(args->geo, db); xfs_dir2_leafn_remove()
1242 xfs_dir2_db_to_da(args->geo, fdb), xfs_dir2_leafn_remove()
1251 ASSERT(freehdr.firstdb == dp->d_ops->free_max_bests(args->geo) * xfs_dir2_leafn_remove()
1252 (fdb - xfs_dir2_byte_to_db(args->geo, xfs_dir2_leafn_remove()
1259 findex = dp->d_ops->db_to_fdindex(args->geo, db); xfs_dir2_leafn_remove()
1265 if (longest == args->geo->blksize - xfs_dir2_leafn_remove()
1300 args->geo->magicpct; xfs_dir2_leafn_remove()
1331 error = xfs_dir3_leaf_get_buf(args, xfs_dir2_da_to_db(args->geo, blkno), xfs_dir2_leafn_split()
1405 if (bytes > (state->args->geo->blksize >> 1)) { xfs_dir2_leafn_toosmall()
1458 bytes = state->args->geo->blksize - xfs_dir2_leafn_toosmall()
1459 (state->args->geo->blksize >> 2); xfs_dir2_leafn_toosmall()
1723 lastfbno = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)fo); xfs_dir2_node_addname_int()
1741 fbno = xfs_dir2_byte_to_db(args->geo, xfs_dir2_node_addname_int()
1760 xfs_dir2_db_to_da(args->geo, fbno), xfs_dir2_node_addname_int()
1829 fbno = dp->d_ops->db_to_fdb(args->geo, dbno); xfs_dir2_node_addname_int()
1831 xfs_dir2_db_to_da(args->geo, fbno), xfs_dir2_node_addname_int()
1846 if (dp->d_ops->db_to_fdb(args->geo, dbno) != fbno) { xfs_dir2_node_addname_int()
1852 args->geo, dbno), xfs_dir2_node_addname_int()
1884 (fbno - xfs_dir2_byte_to_db(args->geo, xfs_dir2_node_addname_int()
1886 dp->d_ops->free_max_bests(args->geo); xfs_dir2_node_addname_int()
1896 findex = dp->d_ops->db_to_fdindex(args->geo, dbno); xfs_dir2_node_addname_int()
1902 ASSERT(findex < dp->d_ops->free_max_bests(args->geo)); xfs_dir2_node_addname_int()
1942 xfs_dir2_db_to_da(args->geo, dbno), xfs_dir2_node_addname_int()
2187 xfs_dir2_dataptr_to_off(args->geo, xfs_dir2_node_replace()
2262 xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)fo), bp); xfs_dir2_node_trim_free()
H A Dxfs_dir2_data.c64 struct xfs_da_geometry *geo; __xfs_dir3_data_check() local
67 geo = mp->m_dir_geo; __xfs_dir3_data_check()
81 btp = xfs_dir2_block_tail_p(geo, hdr); __xfs_dir3_data_check()
97 endp = (char *)hdr + geo->blksize; __xfs_dir3_data_check()
175 addr = xfs_dir2_db_off_to_dataptr(geo, geo->datablk, __xfs_dir3_data_check()
514 struct xfs_da_geometry *geo = dp->i_mount->m_dir_geo; xfs_dir2_data_freescan() local
533 btp = xfs_dir2_block_tail_p(geo, hdr); xfs_dir2_data_freescan()
536 endp = (char *)hdr + geo->blksize; xfs_dir2_data_freescan()
590 error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, blkno), xfs_dir3_data_init()
626 t = args->geo->blksize - (uint)dp->d_ops->data_entry_offset; xfs_dir3_data_init()
741 endptr = (char *)hdr + args->geo->blksize; xfs_dir2_data_make_free()
747 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_data_make_free()
H A Dxfs_dir2_sf.c81 struct xfs_da_geometry *geo; xfs_dir2_block_sfsize() local
84 geo = mp->m_dir_geo; xfs_dir2_block_sfsize()
93 btp = xfs_dir2_block_tail_p(geo, hdr); xfs_dir2_block_sfsize()
106 xfs_dir2_dataptr_to_off(geo, addr)); xfs_dir2_block_sfsize()
196 btp = xfs_dir2_block_tail_p(args->geo, hdr); xfs_dir2_block_to_sf()
248 error = xfs_dir2_shrink_inode(args, args->geo->datablk, bp); xfs_dir2_block_to_sf()
577 if (used + (holefit ? 0 : size) > args->geo->blksize) xfs_dir2_sf_addname_pick()
587 if (used + size > args->geo->blksize) xfs_dir2_sf_addname_pick()
635 (uint)sizeof(xfs_dir2_block_tail_t) <= args->geo->blksize); xfs_dir2_sf_check()
H A Dxfs_da_btree.c597 (args->whichfork == XFS_DATA_FORK) ? args->geo->leafblk : 0, xfs_da3_root_split()
615 ASSERT(blk1->blkno >= args->geo->leafblk && xfs_da3_root_split()
616 blk1->blkno < args->geo->freeblk); xfs_da3_root_split()
617 ASSERT(blk2->blkno >= args->geo->leafblk && xfs_da3_root_split()
618 blk2->blkno < args->geo->freeblk); xfs_da3_root_split()
662 if (nodehdr.count + newcount > state->args->geo->node_ents) { xfs_da3_node_split()
893 ASSERT(newblk->blkno >= state->args->geo->leafblk && xfs_da3_node_add()
894 newblk->blkno < state->args->geo->freeblk); xfs_da3_node_add()
1088 memcpy(root_blk->bp->b_addr, bp->b_addr, args->geo->blksize); xfs_da3_root_join()
1096 args->geo->blksize - 1); xfs_da3_root_join()
1139 if (nodehdr.count > (state->args->geo->node_ents >> 1)) { xfs_da3_node_toosmall()
1176 count = state->args->geo->node_ents; xfs_da3_node_toosmall()
1177 count -= state->args->geo->node_ents >> 2; xfs_da3_node_toosmall()
1472 blkno = (args->whichfork == XFS_DATA_FORK)? args->geo->leafblk : 0; xfs_da3_node_lookup_int()
2094 bno = args->geo->leafblk; xfs_da_grow_inode()
2095 error = xfs_da_grow_inode_int(args, &bno, args->geo->fsbcount); xfs_da_grow_inode()
2150 lastoff = args->geo->freeblk; xfs_da3_swap_lastblock()
2162 last_blkno = (xfs_dablk_t)lastoff - args->geo->fsbcount; xfs_da3_swap_lastblock()
2169 memcpy(dead_buf->b_addr, last_buf->b_addr, args->geo->blksize); xfs_da3_swap_lastblock()
2170 xfs_trans_log_buf(tp, dead_buf, 0, args->geo->blksize - 1); xfs_da3_swap_lastblock()
2239 par_blkno = args->geo->leafblk; xfs_da3_swap_lastblock()
2347 count = args->geo->fsbcount; xfs_da_shrink_inode()
H A Dxfs_da_btree.h62 struct xfs_da_geometry *geo; /* da block geometry */ member in struct:xfs_da_args
H A Dxfs_attr.c88 args->geo = dp->i_mount->m_attr_geo; xfs_attr_args_init()
177 if (size > (args->geo->blksize / 2)) { xfs_attr_calc_size()
863 * External routines when attribute list size > geo->blksize
H A Dxfs_bmap.c1076 dargs.geo = ip->i_mount->m_dir_geo; xfs_bmap_add_attrfork_local()
1080 dargs.total = dargs.geo->fsbcount; xfs_bmap_add_attrfork_local()
/linux-4.1.27/block/partitions/
H A Dibm.c30 static sector_t cchh2blk(struct vtoc_cchh *ptr, struct hd_geometry *geo) cchh2blk() argument
40 return cyl * geo->heads * geo->sectors + cchh2blk()
41 head * geo->sectors; cchh2blk()
48 static sector_t cchhb2blk(struct vtoc_cchhb *ptr, struct hd_geometry *geo) cchhb2blk() argument
58 return cyl * geo->heads * geo->sectors + cchhb2blk()
59 head * geo->sectors + cchhb2blk()
65 struct hd_geometry *geo, find_label()
133 struct hd_geometry *geo, find_vol1_partitions()
154 blk = cchhb2blk(&label->vol.vtoc, geo) + 1; find_vol1_partitions()
174 offset = cchh2blk(&f1.DS1EXT1.llimit, geo); find_vol1_partitions()
175 size = cchh2blk(&f1.DS1EXT1.ulimit, geo) - find_vol1_partitions()
176 offset + geo->sectors; find_vol1_partitions()
195 struct hd_geometry *geo, find_lnx1_partitions()
215 * 'size based on geo == size based on i_size' is true, then find_lnx1_partitions()
220 geo_size = geo->cylinders * geo->heads find_lnx1_partitions()
221 * geo->sectors * secperblk; find_lnx1_partitions()
242 struct hd_geometry *geo, find_cms1_partitions()
295 struct hd_geometry *geo; ibm_partition() local
311 geo = kmalloc(sizeof(struct hd_geometry), GFP_KERNEL); ibm_partition()
312 if (geo == NULL) ibm_partition()
317 if (ioctl_by_bdev(bdev, HDIO_GETGEO, (unsigned long)geo) != 0) ibm_partition()
324 if (find_label(state, info, geo, blocksize, &labelsect, name, type, ibm_partition()
327 res = find_vol1_partitions(state, geo, blocksize, name, ibm_partition()
330 res = find_lnx1_partitions(state, geo, blocksize, name, ibm_partition()
334 res = find_cms1_partitions(state, geo, blocksize, name, ibm_partition()
359 kfree(geo); ibm_partition()
63 find_label(struct parsed_partitions *state, dasd_information2_t *info, struct hd_geometry *geo, int blocksize, sector_t *labelsect, char name[], char type[], union label_t *label) find_label() argument
132 find_vol1_partitions(struct parsed_partitions *state, struct hd_geometry *geo, int blocksize, char name[], union label_t *label) find_vol1_partitions() argument
194 find_lnx1_partitions(struct parsed_partitions *state, struct hd_geometry *geo, int blocksize, char name[], union label_t *label, sector_t labelsect, loff_t i_size, dasd_information2_t *info) find_lnx1_partitions() argument
241 find_cms1_partitions(struct parsed_partitions *state, struct hd_geometry *geo, int blocksize, char name[], union label_t *label, sector_t labelsect) find_cms1_partitions() argument
/linux-4.1.27/fs/xfs/
H A Dxfs_dir2_readdir.c71 struct xfs_da_geometry *geo = args->geo; xfs_dir2_sf_getdents() local
92 if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk) xfs_dir2_sf_getdents()
99 * geo->datablk xfs_dir2_sf_getdents()
101 dot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk, xfs_dir2_sf_getdents()
103 dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk, xfs_dir2_sf_getdents()
132 off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk, xfs_dir2_sf_getdents()
149 ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) & xfs_dir2_sf_getdents()
173 struct xfs_da_geometry *geo = args->geo; xfs_dir2_block_getdents() local
178 if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk) xfs_dir2_block_getdents()
189 wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos); xfs_dir2_block_getdents()
195 btp = xfs_dir2_block_tail_p(geo, hdr); xfs_dir2_block_getdents()
227 cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk, xfs_dir2_block_getdents()
247 ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) & xfs_dir2_block_getdents()
283 struct xfs_da_geometry *geo = args->geo; xfs_dir2_leaf_readbuf() local
293 mip->map_blocks -= geo->fsbcount; xfs_dir2_leaf_readbuf()
298 for (i = geo->fsbcount; i > 0; ) { xfs_dir2_leaf_readbuf()
317 mip->ra_want = howmany(bufsize + geo->blksize, (1 << geo->fsblog)) - 1; xfs_dir2_leaf_readbuf()
325 mip->map_off < xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET)) { xfs_dir2_leaf_readbuf()
332 xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET) - xfs_dir2_leaf_readbuf()
353 mip->map_off = xfs_dir2_byte_to_da(geo, xfs_dir2_leaf_readbuf()
379 *curoff = xfs_dir2_da_to_byte(geo, mip->map_off); xfs_dir2_leaf_readbuf()
386 mip->curdb = xfs_dir2_da_to_db(geo, map->br_startoff); xfs_dir2_leaf_readbuf()
388 map->br_blockcount >= geo->fsbcount ? xfs_dir2_leaf_readbuf()
402 mip->ra_current -= geo->fsbcount; xfs_dir2_leaf_readbuf()
410 i += geo->fsbcount) { xfs_dir2_leaf_readbuf()
416 map[mip->ra_index].br_blockcount >= geo->fsbcount) { xfs_dir2_leaf_readbuf()
439 for (j = 0; j < geo->fsbcount; j += length ) { xfs_dir2_leaf_readbuf()
444 length = min_t(int, geo->fsbcount, xfs_dir2_leaf_readbuf()
487 struct xfs_da_geometry *geo = args->geo; xfs_dir2_leaf_getdents() local
501 length = howmany(bufsize + geo->blksize, (1 << geo->fsblog)); xfs_dir2_leaf_getdents()
517 map_info->map_off = xfs_dir2_db_to_da(geo, xfs_dir2_leaf_getdents()
518 xfs_dir2_byte_to_db(geo, curoff)); xfs_dir2_leaf_getdents()
531 if (!bp || ptr >= (char *)bp->b_addr + geo->blksize) { xfs_dir2_leaf_getdents()
541 newoff = xfs_dir2_db_off_to_byte(geo, xfs_dir2_leaf_getdents()
552 ASSERT(xfs_dir2_byte_to_db(geo, curoff) == xfs_dir2_leaf_getdents()
560 byteoff = xfs_dir2_byte_to_off(geo, curoff); xfs_dir2_leaf_getdents()
589 xfs_dir2_db_off_to_byte(geo, xfs_dir2_leaf_getdents()
590 xfs_dir2_byte_to_db(geo, curoff), xfs_dir2_leaf_getdents()
592 if (ptr >= (char *)hdr + geo->blksize) { xfs_dir2_leaf_getdents()
667 args.geo = dp->i_mount->m_dir_geo; xfs_readdir()
H A Dxfs_fsops.c51 xfs_fsop_geom_t *geo, xfs_fs_geometry()
55 memset(geo, 0, sizeof(*geo)); xfs_fs_geometry()
57 geo->blocksize = mp->m_sb.sb_blocksize; xfs_fs_geometry()
58 geo->rtextsize = mp->m_sb.sb_rextsize; xfs_fs_geometry()
59 geo->agblocks = mp->m_sb.sb_agblocks; xfs_fs_geometry()
60 geo->agcount = mp->m_sb.sb_agcount; xfs_fs_geometry()
61 geo->logblocks = mp->m_sb.sb_logblocks; xfs_fs_geometry()
62 geo->sectsize = mp->m_sb.sb_sectsize; xfs_fs_geometry()
63 geo->inodesize = mp->m_sb.sb_inodesize; xfs_fs_geometry()
64 geo->imaxpct = mp->m_sb.sb_imax_pct; xfs_fs_geometry()
65 geo->datablocks = mp->m_sb.sb_dblocks; xfs_fs_geometry()
66 geo->rtblocks = mp->m_sb.sb_rblocks; xfs_fs_geometry()
67 geo->rtextents = mp->m_sb.sb_rextents; xfs_fs_geometry()
68 geo->logstart = mp->m_sb.sb_logstart; xfs_fs_geometry()
69 ASSERT(sizeof(geo->uuid)==sizeof(mp->m_sb.sb_uuid)); xfs_fs_geometry()
70 memcpy(geo->uuid, &mp->m_sb.sb_uuid, sizeof(mp->m_sb.sb_uuid)); xfs_fs_geometry()
72 geo->sunit = mp->m_sb.sb_unit; xfs_fs_geometry()
73 geo->swidth = mp->m_sb.sb_width; xfs_fs_geometry()
76 geo->version = XFS_FSOP_GEOM_VERSION; xfs_fs_geometry()
77 geo->flags = XFS_FSOP_GEOM_FLAGS_NLINK | xfs_fs_geometry()
105 geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ? xfs_fs_geometry()
107 geo->rtsectsize = mp->m_sb.sb_blocksize; xfs_fs_geometry()
108 geo->dirblocksize = mp->m_dir_geo->blksize; xfs_fs_geometry()
111 geo->flags |= xfs_fs_geometry()
114 geo->logsunit = mp->m_sb.sb_logsunit; xfs_fs_geometry()
49 xfs_fs_geometry( xfs_mount_t *mp, xfs_fsop_geom_t *geo, int new_version) xfs_fs_geometry() argument
H A Dxfs_fsops.h21 extern int xfs_fs_geometry(xfs_mount_t *mp, xfs_fsop_geom_t *geo, int nversion);
H A Dxfs_attr_list.c449 args.geo = context->dp->i_mount->m_attr_geo; xfs_attr3_leaf_list_int()
/linux-4.1.27/drivers/media/platform/s5p-tv/
H A Dmixer_video.c174 static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo) mxr_geometry_dump() argument
177 geo->src.full_width, geo->src.full_height); mxr_geometry_dump()
179 geo->src.width, geo->src.height); mxr_geometry_dump()
181 geo->src.x_offset, geo->src.y_offset); mxr_geometry_dump()
183 geo->dst.full_width, geo->dst.full_height); mxr_geometry_dump()
185 geo->dst.width, geo->dst.height); mxr_geometry_dump()
187 geo->dst.x_offset, geo->dst.y_offset); mxr_geometry_dump()
189 geo->x_ratio, geo->y_ratio); mxr_geometry_dump()
197 memset(&layer->geo, 0, sizeof(layer->geo)); mxr_layer_default_geo()
201 layer->geo.dst.full_width = mbus_fmt.width; mxr_layer_default_geo()
202 layer->geo.dst.full_height = mbus_fmt.height; mxr_layer_default_geo()
203 layer->geo.dst.width = layer->geo.dst.full_width; mxr_layer_default_geo()
204 layer->geo.dst.height = layer->geo.dst.full_height; mxr_layer_default_geo()
205 layer->geo.dst.field = mbus_fmt.field; mxr_layer_default_geo()
207 layer->geo.src.full_width = mbus_fmt.width; mxr_layer_default_geo()
208 layer->geo.src.full_height = mbus_fmt.height; mxr_layer_default_geo()
209 layer->geo.src.width = layer->geo.src.full_width; mxr_layer_default_geo()
210 layer->geo.src.height = layer->geo.src.full_height; mxr_layer_default_geo()
212 mxr_geometry_dump(mdev, &layer->geo); mxr_layer_default_geo()
214 mxr_geometry_dump(mdev, &layer->geo); mxr_layer_default_geo()
224 if (layer->geo.dst.full_width == mbus_fmt.width && mxr_layer_update_output()
225 layer->geo.dst.full_height == mbus_fmt.width) mxr_layer_update_output()
228 layer->geo.dst.full_width = mbus_fmt.width; mxr_layer_update_output()
229 layer->geo.dst.full_height = mbus_fmt.height; mxr_layer_update_output()
230 layer->geo.dst.field = mbus_fmt.field; mxr_layer_update_output()
233 mxr_geometry_dump(mdev, &layer->geo); mxr_layer_update_output()
305 pix->width = layer->geo.src.full_width; mxr_g_fmt()
306 pix->height = layer->geo.src.full_height; mxr_g_fmt()
322 struct mxr_geometry *geo = &layer->geo; mxr_s_fmt() local
335 geo->src.full_width = max(geo->dst.full_width, pix->width); mxr_s_fmt()
336 geo->src.full_height = max(geo->dst.full_height, pix->height); mxr_s_fmt()
338 mxr_geometry_dump(mdev, &layer->geo); mxr_s_fmt()
340 geo->src.width = pix->width; mxr_s_fmt()
341 geo->src.height = pix->height; mxr_s_fmt()
342 geo->src.x_offset = 0; mxr_s_fmt()
343 geo->src.y_offset = 0; mxr_s_fmt()
346 mxr_geometry_dump(mdev, &layer->geo); mxr_s_fmt()
348 geo->src.full_width = 0; mxr_s_fmt()
349 geo->src.full_height = 0; mxr_s_fmt()
351 mxr_geometry_dump(mdev, &layer->geo); mxr_s_fmt()
363 struct mxr_geometry *geo = &layer->geo; mxr_g_selection() local
373 s->r.left = geo->src.x_offset; mxr_g_selection()
374 s->r.top = geo->src.y_offset; mxr_g_selection()
375 s->r.width = geo->src.width; mxr_g_selection()
376 s->r.height = geo->src.height; mxr_g_selection()
382 s->r.width = geo->src.full_width; mxr_g_selection()
383 s->r.height = geo->src.full_height; mxr_g_selection()
387 s->r.left = geo->dst.x_offset; mxr_g_selection()
388 s->r.top = geo->dst.y_offset; mxr_g_selection()
389 s->r.width = geo->dst.width; mxr_g_selection()
390 s->r.height = geo->dst.height; mxr_g_selection()
396 s->r.width = geo->dst.full_width; mxr_g_selection()
397 s->r.height = geo->dst.full_height; mxr_g_selection()
424 struct mxr_geometry *geo = &layer->geo; mxr_s_selection() local
443 res.width = geo->src.full_width; mxr_s_selection()
444 res.height = geo->src.full_height; mxr_s_selection()
450 res.width = geo->dst.full_width; mxr_s_selection()
451 res.height = geo->dst.full_height; mxr_s_selection()
455 target = &geo->src; mxr_s_selection()
460 target = &geo->dst; mxr_s_selection()
469 memcpy(&tmp, geo, sizeof(tmp)); mxr_s_selection()
485 mxr_geometry_dump(layer->mdev, &layer->geo); mxr_s_selection()
501 memcpy(geo, &tmp, sizeof(tmp)); mxr_s_selection()
899 mxr_mplane_fill(planes, fmt, layer->geo.src.full_width, queue_setup()
900 layer->geo.src.full_height); queue_setup()
H A Dmixer_reg.c137 const struct mxr_format *fmt, const struct mxr_geometry *geo) mxr_reg_graph_format()
150 mxr_write(mdev, MXR_GRAPHIC_SPAN(idx), geo->src.full_width); mxr_reg_graph_format()
151 val = MXR_GRP_WH_WIDTH(geo->src.width); mxr_reg_graph_format()
152 val |= MXR_GRP_WH_HEIGHT(geo->src.height); mxr_reg_graph_format()
153 val |= MXR_GRP_WH_H_SCALE(geo->x_ratio); mxr_reg_graph_format()
154 val |= MXR_GRP_WH_V_SCALE(geo->y_ratio); mxr_reg_graph_format()
158 val = MXR_GRP_SXY_SX(geo->src.x_offset); mxr_reg_graph_format()
159 val |= MXR_GRP_SXY_SY(geo->src.y_offset); mxr_reg_graph_format()
163 val = MXR_GRP_DXY_DX(geo->dst.x_offset); mxr_reg_graph_format()
164 val |= MXR_GRP_DXY_DY(geo->dst.y_offset); mxr_reg_graph_format()
172 const struct mxr_format *fmt, const struct mxr_geometry *geo) mxr_reg_vp_format()
182 vp_write(mdev, VP_IMG_SIZE_Y, VP_IMG_HSIZE(geo->src.full_width) | mxr_reg_vp_format()
183 VP_IMG_VSIZE(geo->src.full_height)); mxr_reg_vp_format()
185 vp_write(mdev, VP_IMG_SIZE_C, VP_IMG_HSIZE(geo->src.full_width) | mxr_reg_vp_format()
186 VP_IMG_VSIZE(geo->src.full_height / 2)); mxr_reg_vp_format()
188 vp_write(mdev, VP_SRC_WIDTH, geo->src.width); mxr_reg_vp_format()
189 vp_write(mdev, VP_SRC_HEIGHT, geo->src.height); mxr_reg_vp_format()
191 VP_SRC_H_POSITION_VAL(geo->src.x_offset)); mxr_reg_vp_format()
192 vp_write(mdev, VP_SRC_V_POSITION, geo->src.y_offset); mxr_reg_vp_format()
194 vp_write(mdev, VP_DST_WIDTH, geo->dst.width); mxr_reg_vp_format()
195 vp_write(mdev, VP_DST_H_POSITION, geo->dst.x_offset); mxr_reg_vp_format()
196 if (geo->dst.field == V4L2_FIELD_INTERLACED) { mxr_reg_vp_format()
197 vp_write(mdev, VP_DST_HEIGHT, geo->dst.height / 2); mxr_reg_vp_format()
198 vp_write(mdev, VP_DST_V_POSITION, geo->dst.y_offset / 2); mxr_reg_vp_format()
200 vp_write(mdev, VP_DST_HEIGHT, geo->dst.height); mxr_reg_vp_format()
201 vp_write(mdev, VP_DST_V_POSITION, geo->dst.y_offset); mxr_reg_vp_format()
204 vp_write(mdev, VP_H_RATIO, geo->x_ratio); mxr_reg_vp_format()
205 vp_write(mdev, VP_V_RATIO, geo->y_ratio); mxr_reg_vp_format()
136 mxr_reg_graph_format(struct mxr_device *mdev, int idx, const struct mxr_format *fmt, const struct mxr_geometry *geo) mxr_reg_graph_format() argument
171 mxr_reg_vp_format(struct mxr_device *mdev, const struct mxr_format *fmt, const struct mxr_geometry *geo) mxr_reg_vp_format() argument
H A Dmixer_vp_layer.c107 &layer->fmt->plane[0], layer->geo.src.full_width, mxr_vp_buffer_set()
108 layer->geo.src.full_height); mxr_vp_buffer_set()
114 luma_addr[1] = luma_addr[0] + layer->geo.src.full_width; mxr_vp_buffer_set()
127 mxr_reg_vp_format(layer->mdev, layer->fmt, &layer->geo); mxr_vp_format_set()
145 struct mxr_geometry *geo = &layer->geo; mxr_vp_fix_geometry() local
146 struct mxr_crop *src = &geo->src; mxr_vp_fix_geometry()
147 struct mxr_crop *dst = &geo->dst; mxr_vp_fix_geometry()
191 geo->x_ratio = (src->width << 16) / dst->width; mxr_vp_fix_geometry()
192 geo->y_ratio = (src->height << 16) / dst->height; mxr_vp_fix_geometry()
H A Dmixer_grp_layer.c101 layer->fmt, &layer->geo); mxr_graph_format_set()
151 struct mxr_geometry *geo = &layer->geo; mxr_graph_fix_geometry() local
152 struct mxr_crop *src = &geo->src; mxr_graph_fix_geometry()
153 struct mxr_crop *dst = &geo->dst; mxr_graph_fix_geometry()
202 geo->x_ratio = 0; mxr_graph_fix_geometry()
204 geo->x_ratio = 1; mxr_graph_fix_geometry()
213 geo->y_ratio = 0; mxr_graph_fix_geometry()
215 geo->y_ratio = 1; mxr_graph_fix_geometry()
H A Dmixer.h185 struct mxr_geometry geo; member in struct:mxr_layer
356 const struct mxr_format *fmt, const struct mxr_geometry *geo);
362 const struct mxr_format *fmt, const struct mxr_geometry *geo);
/linux-4.1.27/include/linux/
H A Dbtree.h23 * Each key here is an array of unsigned longs, geo->no_longs in total. The
24 * number of keys and values (N) is geo->no_pairs.
94 * @geo: the btree geometry
99 void *btree_lookup(struct btree_head *head, struct btree_geo *geo,
106 * @geo: the btree geometry
114 int __must_check btree_insert(struct btree_head *head, struct btree_geo *geo,
120 * @geo: the btree geometry
127 int btree_update(struct btree_head *head, struct btree_geo *geo,
133 * @geo: the btree geometry
139 void *btree_remove(struct btree_head *head, struct btree_geo *geo,
147 * @geo: the btree geometry
158 struct btree_geo *geo, gfp_t gfp);
164 * @geo: btree geometry
171 void *btree_last(struct btree_head *head, struct btree_geo *geo,
178 * @geo: btree geometry
185 void *btree_get_prev(struct btree_head *head, struct btree_geo *geo,
190 size_t btree_visitor(struct btree_head *head, struct btree_geo *geo,
198 size_t btree_grim_visitor(struct btree_head *head, struct btree_geo *geo,
H A Ddevice-mapper.h417 int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
418 int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
/linux-4.1.27/drivers/media/pci/bt8xx/
H A Dbttv-risc.c336 bttv_calc_geo_old(struct bttv *btv, struct bttv_geometry *geo, bttv_calc_geo_old() argument
356 geo->hscale = ((totalwidth*4096UL)/xsf-4096); bttv_calc_geo_old()
357 geo->hdelay = tvnorm->hdelayx1; bttv_calc_geo_old()
358 geo->hdelay = (geo->hdelay*width)/swidth; bttv_calc_geo_old()
359 geo->hdelay &= 0x3fe; bttv_calc_geo_old()
361 geo->vscale = (0x10000UL-sr) & 0x1fff; bttv_calc_geo_old()
362 geo->crop = ((width>>8)&0x03) | ((geo->hdelay>>6)&0x0c) | bttv_calc_geo_old()
364 geo->vscale |= interleaved ? (BT848_VSCALE_INT<<8) : 0; bttv_calc_geo_old()
365 geo->vdelay = vdelay; bttv_calc_geo_old()
366 geo->width = width; bttv_calc_geo_old()
367 geo->sheight = tvnorm->sheight; bttv_calc_geo_old()
368 geo->vtotal = tvnorm->vtotal; bttv_calc_geo_old()
371 geo->vtc = (width < 193) ? 2 : ((width < 385) ? 1 : 0); bttv_calc_geo_old()
372 geo->comb = (width < 769) ? 1 : 0; bttv_calc_geo_old()
374 geo->vtc = 0; bttv_calc_geo_old()
375 geo->comb = 0; bttv_calc_geo_old()
381 struct bttv_geometry * geo, bttv_calc_geo()
398 bttv_calc_geo_old(btv, geo, width, height, bttv_calc_geo()
408 geo->width = width; bttv_calc_geo()
409 geo->hscale = (c_width * 4096U + (width >> 1)) / width - 4096; bttv_calc_geo()
411 geo->hdelay = ((crop->left * width + c_width) / c_width) & ~1; bttv_calc_geo()
413 geo->sheight = c_height; bttv_calc_geo()
414 geo->vdelay = crop->top - tvnorm->cropcap.bounds.top + MIN_VDELAY; bttv_calc_geo()
417 geo->vscale = (0x10000UL - sr) & 0x1fff; bttv_calc_geo()
418 geo->vscale |= both_fields ? (BT848_VSCALE_INT << 8) : 0; bttv_calc_geo()
419 geo->vtotal = tvnorm->vtotal; bttv_calc_geo()
421 geo->crop = (((geo->width >> 8) & 0x03) | bttv_calc_geo()
422 ((geo->hdelay >> 6) & 0x0c) | bttv_calc_geo()
423 ((geo->sheight >> 4) & 0x30) | bttv_calc_geo()
424 ((geo->vdelay >> 2) & 0xc0)); bttv_calc_geo()
427 geo->vtc = (width < 193) ? 2 : ((width < 385) ? 1 : 0); bttv_calc_geo()
428 geo->comb = (width < 769) ? 1 : 0; bttv_calc_geo()
430 geo->vtc = 0; bttv_calc_geo()
431 geo->comb = 0; bttv_calc_geo()
436 bttv_apply_geo(struct bttv *btv, struct bttv_geometry *geo, int odd) bttv_apply_geo() argument
440 if (geo->comb) bttv_apply_geo()
445 btwrite(geo->vtc, BT848_E_VTC+off); bttv_apply_geo()
446 btwrite(geo->hscale >> 8, BT848_E_HSCALE_HI+off); bttv_apply_geo()
447 btwrite(geo->hscale & 0xff, BT848_E_HSCALE_LO+off); bttv_apply_geo()
448 btaor((geo->vscale>>8), 0xe0, BT848_E_VSCALE_HI+off); bttv_apply_geo()
449 btwrite(geo->vscale & 0xff, BT848_E_VSCALE_LO+off); bttv_apply_geo()
450 btwrite(geo->width & 0xff, BT848_E_HACTIVE_LO+off); bttv_apply_geo()
451 btwrite(geo->hdelay & 0xff, BT848_E_HDELAY_LO+off); bttv_apply_geo()
452 btwrite(geo->sheight & 0xff, BT848_E_VACTIVE_LO+off); bttv_apply_geo()
453 btwrite(geo->vdelay & 0xff, BT848_E_VDELAY_LO+off); bttv_apply_geo()
454 btwrite(geo->crop, BT848_E_CROP+off); bttv_apply_geo()
455 btwrite(geo->vtotal>>8, BT848_VTOTAL_HI); bttv_apply_geo()
456 btwrite(geo->vtotal & 0xff, BT848_VTOTAL_LO); bttv_apply_geo()
618 if (vbi->geo.vdelay > vdelay) { bttv_buffer_activate_vbi()
619 vdelay = vbi->geo.vdelay & 0xfe; bttv_buffer_activate_vbi()
620 crop = (crop & 0x3f) | ((vbi->geo.vdelay >> 2) & 0xc0); bttv_buffer_activate_vbi()
664 bttv_apply_geo(btv, &set->top->geo, 1); bttv_buffer_activate_video()
665 bttv_apply_geo(btv, &set->bottom->geo,0); bttv_buffer_activate_video()
678 bttv_apply_geo(btv, &set->top->geo,1); bttv_buffer_activate_video()
679 bttv_apply_geo(btv, &set->top->geo,0); bttv_buffer_activate_video()
689 bttv_apply_geo(btv, &set->bottom->geo,1); bttv_buffer_activate_video()
690 bttv_apply_geo(btv, &set->bottom->geo,0); bttv_buffer_activate_video()
721 bttv_calc_geo(btv,&buf->geo,buf->vb.width,buf->vb.height, bttv_buffer_risc()
775 bttv_calc_geo(btv,&buf->geo,buf->vb.width, bttv_buffer_risc()
784 bttv_calc_geo(btv,&buf->geo,buf->vb.width, bttv_buffer_risc()
793 bttv_calc_geo(btv,&buf->geo,buf->vb.width, bttv_buffer_risc()
816 bttv_calc_geo(btv,&buf->geo,buf->vb.width, bttv_buffer_risc()
848 bttv_calc_geo(btv,&buf->geo,tvnorm->swidth,tvnorm->sheight, bttv_buffer_risc()
878 bttv_calc_geo(btv,&buf->geo,ov->w.width,ov->w.height, bttv_overlay_risc()
380 bttv_calc_geo(struct bttv * btv, struct bttv_geometry * geo, unsigned int width, unsigned int height, int both_fields, const struct bttv_tvnorm * tvnorm, const struct v4l2_rect * crop) bttv_calc_geo() argument
H A Dbttv-vbi.c196 buf->geo.vdelay = min_vdelay; vbi_buffer_prepare()
H A Dbttvp.h165 struct bttv_geometry geo; member in struct:bttv_buffer
/linux-4.1.27/drivers/media/platform/
H A Dsh_vou.c531 static void vou_adjust_input(struct sh_vou_geometry *geo, v4l2_std_id std) vou_adjust_input() argument
543 v4l_bound_align_image(&geo->in_width, 0, VOU_MAX_IMAGE_WIDTH, 2, vou_adjust_input()
544 &geo->in_height, 0, img_height_max, 1, 0); vou_adjust_input()
549 unsigned int found = geo->output.width * vou_scale_h_den[i] / vou_adjust_input()
556 err = abs(found - geo->in_width); vou_adjust_input()
566 geo->in_width = best; vou_adjust_input()
567 geo->scale_idx_h = idx; vou_adjust_input()
574 unsigned int found = geo->output.height * vou_scale_v_den[i] / vou_adjust_input()
581 err = abs(found - geo->in_height); vou_adjust_input()
591 geo->in_height = best; vou_adjust_input()
592 geo->scale_idx_v = idx; vou_adjust_input()
599 static void vou_adjust_output(struct sh_vou_geometry *geo, v4l2_std_id std) vou_adjust_output() argument
601 unsigned int best_err = UINT_MAX, best = geo->in_width, vou_adjust_output()
618 unsigned int found = geo->in_width * vou_scale_h_num[i] / vou_adjust_output()
625 err = abs(found - geo->output.width); vou_adjust_output()
635 geo->output.width = best; vou_adjust_output()
636 geo->scale_idx_h = idx; vou_adjust_output()
637 if (geo->output.left + best > width_max) vou_adjust_output()
638 geo->output.left = width_max - best; vou_adjust_output()
640 pr_debug("%s(): W %u * %u/%u = %u\n", __func__, geo->in_width, vou_adjust_output()
648 unsigned int found = geo->in_height * vou_scale_v_num[i] / vou_adjust_output()
655 err = abs(found - geo->output.height); vou_adjust_output()
665 geo->output.height = best; vou_adjust_output()
666 geo->scale_idx_v = idx; vou_adjust_output()
667 if (geo->output.top + best > height_max) vou_adjust_output()
668 geo->output.top = height_max - best; vou_adjust_output()
670 pr_debug("%s(): H %u * %u/%u = %u\n", __func__, geo->in_height, vou_adjust_output()
681 struct sh_vou_geometry geo; sh_vou_s_fmt_vid_out() local
717 geo.in_width = pix->width; sh_vou_s_fmt_vid_out()
718 geo.in_height = pix->height; sh_vou_s_fmt_vid_out()
719 geo.output = vou_dev->rect; sh_vou_s_fmt_vid_out()
721 vou_adjust_output(&geo, vou_dev->std); sh_vou_s_fmt_vid_out()
723 mbfmt.width = geo.output.width; sh_vou_s_fmt_vid_out()
724 mbfmt.height = geo.output.height; sh_vou_s_fmt_vid_out()
732 geo.output.width, geo.output.height, mbfmt.width, mbfmt.height); sh_vou_s_fmt_vid_out()
740 if (mbfmt.width != geo.output.width || sh_vou_s_fmt_vid_out()
741 mbfmt.height != geo.output.height) { sh_vou_s_fmt_vid_out()
742 geo.output.width = mbfmt.width; sh_vou_s_fmt_vid_out()
743 geo.output.height = mbfmt.height; sh_vou_s_fmt_vid_out()
745 vou_adjust_input(&geo, vou_dev->std); sh_vou_s_fmt_vid_out()
749 vou_dev->rect = geo.output; sh_vou_s_fmt_vid_out()
750 pix->width = geo.in_width; sh_vou_s_fmt_vid_out()
751 pix->height = geo.in_height; sh_vou_s_fmt_vid_out()
761 geo.scale_idx_h, geo.scale_idx_v); sh_vou_s_fmt_vid_out()
944 struct sh_vou_geometry geo; sh_vou_s_crop() local
974 geo.output = *rect; sh_vou_s_crop()
975 geo.in_width = pix->width; sh_vou_s_crop()
976 geo.in_height = pix->height; sh_vou_s_crop()
979 sd_crop.c.width = geo.output.width; sh_vou_s_crop()
980 sd_crop.c.height = geo.output.height; sh_vou_s_crop()
987 mbfmt.width = geo.output.width; sh_vou_s_crop()
988 mbfmt.height = geo.output.height; sh_vou_s_crop()
1001 geo.output.width = mbfmt.width; sh_vou_s_crop()
1002 geo.output.height = mbfmt.height; sh_vou_s_crop()
1008 vou_adjust_input(&geo, vou_dev->std); sh_vou_s_crop()
1011 vou_dev->rect = geo.output; sh_vou_s_crop()
1012 pix->width = geo.in_width; sh_vou_s_crop()
1013 pix->height = geo.in_height; sh_vou_s_crop()
1016 geo.scale_idx_h, geo.scale_idx_v); sh_vou_s_crop()
/linux-4.1.27/drivers/md/
H A Draid10.c552 static void __raid10_find_phys(struct geom *geo, struct r10bio *r10bio) __raid10_find_phys() argument
562 last_far_set_start = (geo->raid_disks / geo->far_set_size) - 1; __raid10_find_phys()
563 last_far_set_start *= geo->far_set_size; __raid10_find_phys()
565 last_far_set_size = geo->far_set_size; __raid10_find_phys()
566 last_far_set_size += (geo->raid_disks % geo->far_set_size); __raid10_find_phys()
569 chunk = r10bio->sector >> geo->chunk_shift; __raid10_find_phys()
570 sector = r10bio->sector & geo->chunk_mask; __raid10_find_phys()
572 chunk *= geo->near_copies; __raid10_find_phys()
574 dev = sector_div(stripe, geo->raid_disks); __raid10_find_phys()
575 if (geo->far_offset) __raid10_find_phys()
576 stripe *= geo->far_copies; __raid10_find_phys()
578 sector += stripe << geo->chunk_shift; __raid10_find_phys()
581 for (n = 0; n < geo->near_copies; n++) { __raid10_find_phys()
589 for (f = 1; f < geo->far_copies; f++) { __raid10_find_phys()
590 set = d / geo->far_set_size; __raid10_find_phys()
591 d += geo->near_copies; __raid10_find_phys()
593 if ((geo->raid_disks % geo->far_set_size) && __raid10_find_phys()
599 d %= geo->far_set_size; __raid10_find_phys()
600 d += geo->far_set_size * set; __raid10_find_phys()
602 s += geo->stride; __raid10_find_phys()
608 if (dev >= geo->raid_disks) { __raid10_find_phys()
610 sector += (geo->chunk_mask + 1); __raid10_find_phys()
617 struct geom *geo = &conf->geo; raid10_find_phys() local
623 geo = &conf->prev; raid10_find_phys()
627 __raid10_find_phys(geo, r10bio); raid10_find_phys()
636 struct geom *geo = &conf->geo; raid10_find_virt() local
637 int far_set_start = (dev / geo->far_set_size) * geo->far_set_size; raid10_find_virt()
638 int far_set_size = geo->far_set_size; raid10_find_virt()
641 if (geo->raid_disks % geo->far_set_size) { raid10_find_virt()
642 last_far_set_start = (geo->raid_disks / geo->far_set_size) - 1; raid10_find_virt()
643 last_far_set_start *= geo->far_set_size; raid10_find_virt()
646 far_set_size = geo->far_set_size; raid10_find_virt()
647 far_set_size += (geo->raid_disks % geo->far_set_size); raid10_find_virt()
652 offset = sector & geo->chunk_mask; raid10_find_virt()
653 if (geo->far_offset) { raid10_find_virt()
655 chunk = sector >> geo->chunk_shift; raid10_find_virt()
656 fc = sector_div(chunk, geo->far_copies); raid10_find_virt()
657 dev -= fc * geo->near_copies; raid10_find_virt()
661 while (sector >= geo->stride) { raid10_find_virt()
662 sector -= geo->stride; raid10_find_virt()
663 if (dev < (geo->near_copies + far_set_start)) raid10_find_virt()
664 dev += far_set_size - geo->near_copies; raid10_find_virt()
666 dev -= geo->near_copies; raid10_find_virt()
668 chunk = sector >> geo->chunk_shift; raid10_find_virt()
670 vchunk = chunk * geo->raid_disks + dev; raid10_find_virt()
671 sector_div(vchunk, geo->near_copies); raid10_find_virt()
672 return (vchunk << geo->chunk_shift) + offset; raid10_find_virt()
694 struct geom *geo = &conf->geo; raid10_mergeable_bvec() local
696 chunk_sectors = (conf->geo.chunk_mask & conf->prev.chunk_mask) + 1; raid10_mergeable_bvec()
700 geo = &conf->prev; raid10_mergeable_bvec()
702 if (geo->near_copies < geo->raid_disks) { raid10_mergeable_bvec()
793 struct geom *geo = &conf->geo; read_balance() local
874 if (geo->near_copies > 1 && !atomic_read(&rdev->nr_pending)) read_balance()
878 if (geo->far_copies > 1) read_balance()
923 (i < conf->geo.raid_disks || i < conf->prev.raid_disks) raid10_congested()
1539 sector_t chunk_mask = (conf->geo.chunk_mask & conf->prev.chunk_mask); make_request()
1559 && (conf->geo.near_copies < conf->geo.raid_disks make_request()
1583 if (conf->geo.near_copies < conf->geo.raid_disks) status()
1585 if (conf->geo.near_copies > 1) status()
1586 seq_printf(seq, " %d near-copies", conf->geo.near_copies); status()
1587 if (conf->geo.far_copies > 1) { status()
1588 if (conf->geo.far_offset) status()
1589 seq_printf(seq, " %d offset-copies", conf->geo.far_copies); status()
1591 seq_printf(seq, " %d far-copies", conf->geo.far_copies); status()
1593 seq_printf(seq, " [%d/%d] [", conf->geo.raid_disks, status()
1594 conf->geo.raid_disks - mddev->degraded); status()
1595 for (i = 0; i < conf->geo.raid_disks; i++) status()
1616 disks = conf->geo.raid_disks; _enough()
1617 ncopies = conf->geo.near_copies; _enough()
1645 /* when calling 'enough', both 'prev' and 'geo' must enough()
1689 mdname(mddev), conf->geo.raid_disks - mddev->degraded); error()
1702 printk(KERN_DEBUG " --- wd:%d rd:%d\n", conf->geo.raid_disks - conf->mddev->degraded, print_conf()
1703 conf->geo.raid_disks); print_conf()
1705 for (i = 0; i < conf->geo.raid_disks; i++) { print_conf()
1737 for (i = 0; i < conf->geo.raid_disks; i++) { raid10_spare_active()
1779 int last = conf->geo.raid_disks - 1; raid10_add_disk()
1884 number < conf->geo.raid_disks && raid10_remove_disk()
2849 for (i = 0; i < conf->geo.raid_disks; i++) init_resync()
2903 sector_t chunk_mask = conf->geo.chunk_mask; sync_request()
2949 else for (i = 0; i < conf->geo.raid_disks; i++) { sync_request()
2963 for (i = 0; i < conf->geo.raid_disks; i++) sync_request()
2980 if (chunks_skipped >= conf->geo.raid_disks) { sync_request()
2994 if (conf->geo.near_copies < conf->geo.raid_disks && sync_request()
3019 for (i = 0 ; i < conf->geo.raid_disks; i++) { sync_request()
3080 for (j = 0; j < conf->geo.raid_disks; j++) sync_request()
3423 raid_disks = min(conf->geo.raid_disks, raid10_size()
3428 size = sectors >> conf->geo.chunk_shift; raid10_size()
3429 sector_div(size, conf->geo.far_copies); raid10_size()
3431 sector_div(size, conf->geo.near_copies); raid10_size()
3433 return size << conf->geo.chunk_shift; raid10_size()
3443 size = size >> conf->geo.chunk_shift; calc_sectors()
3444 sector_div(size, conf->geo.far_copies); calc_sectors()
3445 size = size * conf->geo.raid_disks; calc_sectors()
3446 sector_div(size, conf->geo.near_copies); calc_sectors()
3454 size = DIV_ROUND_UP_SECTOR_T(size, conf->geo.raid_disks); calc_sectors()
3456 conf->dev_sectors = size << conf->geo.chunk_shift; calc_sectors()
3458 if (conf->geo.far_offset) calc_sectors()
3459 conf->geo.stride = 1 << conf->geo.chunk_shift; calc_sectors()
3461 sector_div(size, conf->geo.far_copies); calc_sectors()
3462 conf->geo.stride = size << conf->geo.chunk_shift; calc_sectors()
3467 static int setup_geo(struct geom *geo, struct mddev *mddev, enum geo_type new) setup_geo() argument
3498 geo->raid_disks = disks; setup_geo()
3499 geo->near_copies = nc; setup_geo()
3500 geo->far_copies = fc; setup_geo()
3501 geo->far_offset = fo; setup_geo()
3502 geo->far_set_size = (layout & (1<<17)) ? disks / fc : disks; setup_geo()
3503 geo->chunk_mask = chunk - 1; setup_geo()
3504 geo->chunk_shift = ffz(~chunk); setup_geo()
3512 struct geom geo; setup_conf() local
3515 copies = setup_geo(&geo, mddev, geo_new); setup_conf()
3546 conf->geo = geo; setup_conf()
3555 conf->prev = conf->geo; setup_conf()
3627 if (conf->geo.raid_disks % conf->geo.near_copies) run()
3628 blk_queue_io_opt(mddev->queue, chunk_size * conf->geo.raid_disks); run()
3631 (conf->geo.raid_disks / conf->geo.near_copies)); run()
3641 if (disk_idx >= conf->geo.raid_disks && rdev_for_each()
3693 if (conf->geo.far_copies != 1 &&
3694 conf->geo.far_offset == 0)
3703 i < conf->geo.raid_disks
3733 mdname(mddev), conf->geo.raid_disks - mddev->degraded,
3734 conf->geo.raid_disks);
3744 int stripe = conf->geo.raid_disks *
3751 stripe /= conf->geo.near_copies;
3764 after_length = ((1 << conf->geo.chunk_shift) *
3765 conf->geo.far_copies);
3843 if (conf->geo.far_copies > 1 && !conf->geo.far_offset) raid10_resize()
3946 struct geom geo; raid10_check_reshape() local
3948 if (conf->geo.far_copies != 1 && !conf->geo.far_offset) raid10_check_reshape()
3951 if (setup_geo(&geo, mddev, geo_start) != conf->copies) raid10_check_reshape()
3954 if (geo.far_copies > 1 && !geo.far_offset) raid10_check_reshape()
3958 if (mddev->array_sectors & geo.chunk_mask) raid10_check_reshape()
4013 if (conf->geo.raid_disks == conf->prev.raid_disks) calc_degraded()
4017 for (i = 0; i < conf->geo.raid_disks; i++) { calc_degraded()
4027 if (conf->geo.raid_disks <= conf->prev.raid_disks) calc_degraded()
4066 after_length = ((1 << conf->geo.chunk_shift) * raid10_start_reshape()
4067 conf->geo.far_copies); raid10_start_reshape()
4102 setup_geo(&conf->geo, mddev, geo_start);
4122 conf->geo.raid_disks),
4154 mddev->raid_disks = conf->geo.raid_disks;
4178 conf->geo = conf->prev;
4179 mddev->raid_disks = conf->geo.raid_disks;
4196 static sector_t last_dev_address(sector_t s, struct geom *geo) last_dev_address() argument
4198 s = (s | geo->chunk_mask) + 1; last_dev_address()
4199 s >>= geo->chunk_shift; last_dev_address()
4200 s *= geo->near_copies; last_dev_address()
4201 s = DIV_ROUND_UP_SECTOR_T(s, geo->raid_disks); last_dev_address()
4202 s *= geo->far_copies; last_dev_address()
4203 s <<= geo->chunk_shift; last_dev_address()
4211 static sector_t first_dev_address(sector_t s, struct geom *geo) first_dev_address() argument
4213 s >>= geo->chunk_shift; first_dev_address()
4214 s *= geo->near_copies; first_dev_address()
4215 sector_div(s, geo->raid_disks); first_dev_address()
4216 s *= geo->far_copies; first_dev_address()
4217 s <<= geo->chunk_shift; first_dev_address()
4299 &conf->geo); reshape_request()
4311 sector_nr = last & ~(sector_t)(conf->geo.chunk_mask reshape_request()
4319 next = last_dev_address(conf->reshape_progress, &conf->geo); reshape_request()
4333 last = sector_nr | (conf->geo.chunk_mask reshape_request()
4402 __raid10_find_phys(&conf->geo, r10_bio); reshape_request()
4535 conf->prev = conf->geo; end_reshape()
4546 int stripe = conf->geo.raid_disks * end_reshape()
4548 stripe /= conf->geo.near_copies; end_reshape()
4673 for (d = conf->geo.raid_disks ; raid10_finish_reshape()
4674 d < conf->geo.raid_disks - mddev->delta_disks; raid10_finish_reshape()
4685 mddev->chunk_sectors = 1 << conf->geo.chunk_shift; raid10_finish_reshape()
H A Draid10.h43 } prev, geo; member in struct:r10conf
H A Ddm.c549 static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo) dm_blk_getgeo() argument
553 return dm_get_geometry(md, geo); dm_blk_getgeo()
855 int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo) dm_get_geometry() argument
857 *geo = md->geometry; dm_get_geometry()
865 int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo) dm_set_geometry() argument
867 sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors; dm_set_geometry()
869 if (geo->start > sz) { dm_set_geometry()
874 md->geometry = *geo; dm_set_geometry()
H A Dmd.c6517 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo) md_getgeo() argument
6521 geo->heads = 2; md_getgeo()
6522 geo->sectors = 4; md_getgeo()
6523 geo->cylinders = mddev->array_sectors / 8; md_getgeo()
/linux-4.1.27/drivers/mtd/nand/gpmi-nand/
H A Dgpmi-nand.c109 struct bch_geometry *geo = &this->bch_geometry; get_ecc_strength() local
113 ecc_strength = ((mtd->oobsize - geo->metadata_size) * 8) get_ecc_strength()
114 / (geo->gf_len * geo->ecc_chunk_count); get_ecc_strength()
122 struct bch_geometry *geo = &this->bch_geometry; gpmi_check_ecc() local
127 if (geo->gf_len == 14) gpmi_check_ecc()
130 return geo->ecc_strength <= this->devdata->bch_max_ecc_strength; gpmi_check_ecc()
141 struct bch_geometry *geo = &this->bch_geometry; set_geometry_by_ecc_info() local
152 geo->gf_len = 13; set_geometry_by_ecc_info()
155 geo->gf_len = 14; set_geometry_by_ecc_info()
163 geo->ecc_chunk_size = chip->ecc_step_ds; set_geometry_by_ecc_info()
164 geo->ecc_strength = round_up(chip->ecc_strength_ds, 2); set_geometry_by_ecc_info()
169 if (geo->ecc_chunk_size < mtd->oobsize) { set_geometry_by_ecc_info()
177 geo->metadata_size = 10; set_geometry_by_ecc_info()
179 geo->ecc_chunk_count = mtd->writesize / geo->ecc_chunk_size; set_geometry_by_ecc_info()
229 geo->page_size = mtd->writesize + geo->metadata_size + set_geometry_by_ecc_info()
230 (geo->gf_len * geo->ecc_strength * geo->ecc_chunk_count) / 8; set_geometry_by_ecc_info()
233 if (geo->page_size < mtd->writesize + mtd->oobsize) { set_geometry_by_ecc_info()
234 of->offset = geo->page_size - mtd->writesize; set_geometry_by_ecc_info()
238 geo->payload_size = mtd->writesize; set_geometry_by_ecc_info()
240 geo->auxiliary_status_offset = ALIGN(geo->metadata_size, 4); set_geometry_by_ecc_info()
241 geo->auxiliary_size = ALIGN(geo->metadata_size, 4) set_geometry_by_ecc_info()
242 + ALIGN(geo->ecc_chunk_count, 4); set_geometry_by_ecc_info()
249 (geo->ecc_strength * geo->gf_len * (geo->ecc_chunk_count - 1) set_geometry_by_ecc_info()
250 + geo->metadata_size * 8); set_geometry_by_ecc_info()
252 geo->block_mark_byte_offset = block_mark_bit_offset / 8; set_geometry_by_ecc_info()
253 geo->block_mark_bit_offset = block_mark_bit_offset % 8; set_geometry_by_ecc_info()
259 struct bch_geometry *geo = &this->bch_geometry; legacy_set_geometry() local
270 geo->metadata_size = 10; legacy_set_geometry()
273 geo->gf_len = 13; legacy_set_geometry()
276 geo->ecc_chunk_size = 512; legacy_set_geometry()
277 while (geo->ecc_chunk_size < mtd->oobsize) { legacy_set_geometry()
278 geo->ecc_chunk_size *= 2; /* keep C >= O */ legacy_set_geometry()
279 geo->gf_len = 14; legacy_set_geometry()
282 geo->ecc_chunk_count = mtd->writesize / geo->ecc_chunk_size; legacy_set_geometry()
285 geo->ecc_strength = get_ecc_strength(this); legacy_set_geometry()
289 geo->ecc_strength, legacy_set_geometry()
294 geo->page_size = mtd->writesize + mtd->oobsize; legacy_set_geometry()
295 geo->payload_size = mtd->writesize; legacy_set_geometry()
303 metadata_size = ALIGN(geo->metadata_size, 4); legacy_set_geometry()
304 status_size = ALIGN(geo->ecc_chunk_count, 4); legacy_set_geometry()
306 geo->auxiliary_size = metadata_size + status_size; legacy_set_geometry()
307 geo->auxiliary_status_offset = metadata_size; legacy_set_geometry()
359 (geo->ecc_strength * geo->gf_len * (geo->ecc_chunk_count - 1) legacy_set_geometry()
360 + geo->metadata_size * 8); legacy_set_geometry()
362 geo->block_mark_byte_offset = block_mark_bit_offset / 8; legacy_set_geometry()
363 geo->block_mark_bit_offset = block_mark_bit_offset % 8; legacy_set_geometry()
805 struct bch_geometry *geo = &this->bch_geometry; gpmi_alloc_dma_buffer() local
835 this->page_buffer_size = geo->payload_size + geo->auxiliary_size; gpmi_alloc_dma_buffer()
848 this->auxiliary_virt = this->payload_virt + geo->payload_size; gpmi_alloc_dma_buffer()
849 this->auxiliary_phys = this->payload_phys + geo->payload_size; gpmi_alloc_dma_buffer()
1080 struct bch_geometry *geo = &this->bch_geometry; gpmi_ecc_read_subpage() local
1091 ecc_parity_size = geo->gf_len * geo->ecc_strength / 8; gpmi_ecc_read_subpage()
1105 marker_pos = geo->block_mark_byte_offset / size; gpmi_ecc_read_subpage()
1114 meta = geo->metadata_size; gpmi_ecc_read_subpage()
1141 geo->ecc_chunk_count = n; gpmi_ecc_read_subpage()
1142 geo->payload_size = n * size; gpmi_ecc_read_subpage()
1143 geo->page_size = page_size; gpmi_ecc_read_subpage()
1144 geo->auxiliary_status_offset = ALIGN(meta, 4); gpmi_ecc_read_subpage()
H A Dgpmi-lib.c207 struct bch_geometry *geo = &this->bch_geometry; gpmi_dump_info() local
235 geo->gf_len, gpmi_dump_info()
236 geo->ecc_strength, gpmi_dump_info()
237 geo->page_size, gpmi_dump_info()
238 geo->metadata_size, gpmi_dump_info()
239 geo->ecc_chunk_size, gpmi_dump_info()
240 geo->ecc_chunk_count, gpmi_dump_info()
241 geo->payload_size, gpmi_dump_info()
242 geo->auxiliary_size, gpmi_dump_info()
243 geo->auxiliary_status_offset, gpmi_dump_info()
244 geo->block_mark_byte_offset, gpmi_dump_info()
245 geo->block_mark_bit_offset); gpmi_dump_info()
1233 struct bch_geometry *geo = &this->bch_geometry; gpmi_send_page() local
1260 pio[3] = geo->page_size; gpmi_send_page()
1278 struct bch_geometry *geo = &this->bch_geometry; gpmi_read_page() local
1317 | BF_GPMI_CTRL0_XFER_COUNT(geo->page_size); gpmi_read_page()
1323 pio[3] = geo->page_size; gpmi_read_page()
1342 | BF_GPMI_CTRL0_XFER_COUNT(geo->page_size); gpmi_read_page()
/linux-4.1.27/drivers/block/rsxx/
H A Ddev.c85 static int rsxx_getgeo(struct block_device *bdev, struct hd_geometry *geo) rsxx_getgeo() argument
92 * geo->start, so we won't either. rsxx_getgeo()
95 geo->heads = 64; rsxx_getgeo()
96 geo->sectors = 16; rsxx_getgeo()
97 do_div(blocks, (geo->heads * geo->sectors)); rsxx_getgeo()
98 geo->cylinders = blocks; rsxx_getgeo()
100 geo->heads = 0; rsxx_getgeo()
101 geo->sectors = 0; rsxx_getgeo()
102 geo->cylinders = 0; rsxx_getgeo()
/linux-4.1.27/arch/m68k/emu/
H A Dnfblock.c82 static int nfhd_getgeo(struct block_device *bdev, struct hd_geometry *geo) nfhd_getgeo() argument
86 geo->cylinders = dev->blocks >> (6 - dev->bshift); nfhd_getgeo()
87 geo->heads = 4; nfhd_getgeo()
88 geo->sectors = 16; nfhd_getgeo()
/linux-4.1.27/block/
H A Dioctl.c333 struct hd_geometry geo; blkdev_ioctl() local
344 memset(&geo, 0, sizeof(geo)); blkdev_ioctl()
345 geo.start = get_start_sect(bdev); blkdev_ioctl()
346 ret = disk->fops->getgeo(bdev, &geo); blkdev_ioctl()
349 if (copy_to_user((struct hd_geometry __user *)arg, &geo, blkdev_ioctl()
350 sizeof(geo))) blkdev_ioctl()
H A Dcompat_ioctl.c54 struct hd_geometry geo; compat_hdio_getgeo() local
62 memset(&geo, 0, sizeof(geo)); compat_hdio_getgeo()
67 geo.start = get_start_sect(bdev); compat_hdio_getgeo()
68 ret = disk->fops->getgeo(bdev, &geo); compat_hdio_getgeo()
72 ret = copy_to_user(ugeo, &geo, 4); compat_hdio_getgeo()
73 ret |= put_user(geo.start, &ugeo->start); compat_hdio_getgeo()
/linux-4.1.27/drivers/block/aoe/
H A Daoeblk.c297 aoeblk_getgeo(struct block_device *bdev, struct hd_geometry *geo) aoeblk_getgeo() argument
306 geo->cylinders = d->geo.cylinders; aoeblk_getgeo()
307 geo->heads = d->geo.heads; aoeblk_getgeo()
308 geo->sectors = d->geo.sectors; aoeblk_getgeo()
H A Daoecmd.c1009 d->geo.cylinders = ssize; ataid_complete()
1010 d->geo.cylinders /= (255 * 63); ataid_complete()
1011 d->geo.heads = 255; ataid_complete()
1012 d->geo.sectors = 63; ataid_complete()
1020 d->geo.cylinders = get_unaligned_le16(&id[54 << 1]); ataid_complete()
1021 d->geo.heads = get_unaligned_le16(&id[55 << 1]); ataid_complete()
1022 d->geo.sectors = get_unaligned_le16(&id[56 << 1]); ataid_complete()
1037 d->geo.start = 0; ataid_complete()
H A Daoe.h168 struct hd_geometry geo; member in struct:aoedev
/linux-4.1.27/arch/x86/include/asm/numachip/
H A Dnumachip_csr.h28 /* 32K CSR space, b15 indicates geo/non-geo */
/linux-4.1.27/drivers/s390/block/
H A Dxpram.c230 static int xpram_getgeo(struct block_device *bdev, struct hd_geometry *geo) xpram_getgeo() argument
240 geo->cylinders = size >> 6; xpram_getgeo()
241 geo->heads = 4; xpram_getgeo()
242 geo->sectors = 16; xpram_getgeo()
243 geo->start = 4; xpram_getgeo()
H A Ddasd_diag.c475 dasd_diag_fill_geometry(struct dasd_block *block, struct hd_geometry *geo) dasd_diag_fill_geometry() argument
479 geo->cylinders = (block->blocks << block->s2b_shift) >> 10; dasd_diag_fill_geometry()
480 geo->heads = 16; dasd_diag_fill_geometry()
481 geo->sectors = 128 >> block->s2b_shift; dasd_diag_fill_geometry()
H A Ddasd_fba.c214 struct hd_geometry *geo) dasd_fba_fill_geometry()
218 geo->cylinders = (block->blocks << block->s2b_shift) >> 10; dasd_fba_fill_geometry()
219 geo->heads = 16; dasd_fba_fill_geometry()
220 geo->sectors = 128 >> block->s2b_shift; dasd_fba_fill_geometry()
213 dasd_fba_fill_geometry(struct dasd_block *block, struct hd_geometry *geo) dasd_fba_fill_geometry() argument
H A Ddasd_eckd.c202 static void set_ch_t(struct ch_t *geo, __u32 cyl, __u8 head) set_ch_t() argument
204 geo->cyl = (__u16) cyl; set_ch_t()
205 geo->head = cyl >> 16; set_ch_t()
206 geo->head <<= 4; set_ch_t()
207 geo->head |= head; set_ch_t()
2075 dasd_eckd_fill_geometry(struct dasd_block *block, struct hd_geometry *geo) dasd_eckd_fill_geometry() argument
2081 geo->sectors = recs_per_track(&private->rdc_data, dasd_eckd_fill_geometry()
2084 geo->cylinders = private->rdc_data.no_cyl; dasd_eckd_fill_geometry()
2085 geo->heads = private->rdc_data.trk_per_cyl; dasd_eckd_fill_geometry()
H A Ddasd.c3113 static int dasd_getgeo(struct block_device *bdev, struct hd_geometry *geo) dasd_getgeo() argument
3126 base->discipline->fill_geometry(base->block, geo); dasd_getgeo()
3127 geo->start = get_start_sect(bdev) >> base->block->s2b_shift; dasd_getgeo()
/linux-4.1.27/drivers/pcmcia/
H A Dcistpl.c1205 static int parse_device_geo(tuple_t *tuple, cistpl_device_geo_t *geo) parse_device_geo() argument
1216 geo->geo[n].buswidth = p[0]; parse_device_geo()
1217 geo->geo[n].erase_block = 1 << (p[1]-1); parse_device_geo()
1218 geo->geo[n].read_block = 1 << (p[2]-1); parse_device_geo()
1219 geo->geo[n].write_block = 1 << (p[3]-1); parse_device_geo()
1220 geo->geo[n].partition = 1 << (p[4]-1); parse_device_geo()
1221 geo->geo[n].interleave = 1 << (p[5]-1); parse_device_geo()
1224 geo->ngeo = n; parse_device_geo()
/linux-4.1.27/drivers/ide/
H A Dide-gd.c275 static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo) ide_gd_getgeo() argument
280 geo->heads = drive->bios_head; ide_gd_getgeo()
281 geo->sectors = drive->bios_sect; ide_gd_getgeo()
282 geo->cylinders = (u16)drive->bios_cyl; /* truncate */ ide_gd_getgeo()
/linux-4.1.27/drivers/mtd/
H A Dssfdc.c409 static int ssfdcr_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo) ssfdcr_getgeo() argument
416 geo->heads = ssfdc->heads; ssfdcr_getgeo()
417 geo->sectors = ssfdc->sectors; ssfdcr_getgeo()
418 geo->cylinders = ssfdc->cylinders; ssfdcr_getgeo()
H A Drfd_ftl.c746 static int rfd_ftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo) rfd_ftl_getgeo() argument
750 geo->heads = 1; rfd_ftl_getgeo()
751 geo->sectors = SECTORS_PER_TRACK; rfd_ftl_getgeo()
752 geo->cylinders = part->cylinders; rfd_ftl_getgeo()
H A Dmtd_blkdevs.c268 static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo) blktrans_getgeo() argument
281 ret = dev->tr->getgeo ? dev->tr->getgeo(dev, geo) : 0; blktrans_getgeo()
H A Dftl.c981 static int ftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo) ftl_getgeo() argument
989 geo->heads = 1; ftl_getgeo()
990 geo->sectors = 8; ftl_getgeo()
991 geo->cylinders = sect >> 3; ftl_getgeo()
H A Dinftlcore.c929 static int inftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo) inftl_getgeo() argument
933 geo->heads = inftl->heads; inftl_getgeo()
934 geo->sectors = inftl->sectors; inftl_getgeo()
935 geo->cylinders = inftl->cylinders; inftl_getgeo()
H A Dnftlcore.c780 static int nftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo) nftl_getgeo() argument
784 geo->heads = nftl->heads; nftl_getgeo()
785 geo->sectors = nftl->sectors; nftl_getgeo()
786 geo->cylinders = nftl->cylinders; nftl_getgeo()
H A Dsm_ftl.c1119 static int sm_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo) sm_getgeo() argument
1122 geo->heads = ftl->heads; sm_getgeo()
1123 geo->sectors = ftl->sectors; sm_getgeo()
1124 geo->cylinders = ftl->cylinders; sm_getgeo()
/linux-4.1.27/drivers/block/paride/
H A Dpd.c19 drive3 <prt>,<pro>,<uni>,<mod>,<geo>,<sby>,<dly>,<slv>
41 <geo> this defaults to 0 to indicate that the driver
754 static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo) pd_getgeo() argument
759 geo->heads = PD_LOG_HEADS; pd_getgeo()
760 geo->sectors = PD_LOG_SECTS; pd_getgeo()
761 geo->cylinders = disk->capacity / (geo->heads * geo->sectors); pd_getgeo()
763 geo->heads = disk->heads; pd_getgeo()
764 geo->sectors = disk->sectors; pd_getgeo()
765 geo->cylinders = disk->cylinders; pd_getgeo()
H A Dpf.c212 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
329 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo) pf_getgeo() argument
335 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT); pf_getgeo()
336 geo->heads = PF_FD_HDS; pf_getgeo()
337 geo->sectors = PF_FD_SPT; pf_getgeo()
339 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT); pf_getgeo()
340 geo->heads = PF_HD_HDS; pf_getgeo()
341 geo->sectors = PF_HD_SPT; pf_getgeo()
/linux-4.1.27/drivers/mtd/maps/
H A Dpcmciamtd.c401 dev->pcmcia_map.bankwidth = t->geo[0].buswidth; pcmciamtd_cistpl_geo()
404 pr_debug("region: %d bankwidth = %u\n", i, t->geo[i].buswidth); pcmciamtd_cistpl_geo()
405 pr_debug("region: %d erase_block = %u\n", i, t->geo[i].erase_block); pcmciamtd_cistpl_geo()
406 pr_debug("region: %d read_block = %u\n", i, t->geo[i].read_block); pcmciamtd_cistpl_geo()
407 pr_debug("region: %d write_block = %u\n", i, t->geo[i].write_block); pcmciamtd_cistpl_geo()
408 pr_debug("region: %d partition = %u\n", i, t->geo[i].partition); pcmciamtd_cistpl_geo()
409 pr_debug("region: %d interleave = %u\n", i, t->geo[i].interleave); pcmciamtd_cistpl_geo()
/linux-4.1.27/drivers/block/
H A Dvirtio_blk.c278 static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo) virtblk_getgeo() argument
285 geometry.cylinders, &geo->cylinders); virtblk_getgeo()
287 geometry.heads, &geo->heads); virtblk_getgeo()
289 geometry.sectors, &geo->sectors); virtblk_getgeo()
292 geo->heads = 1 << 6; virtblk_getgeo()
293 geo->sectors = 1 << 5; virtblk_getgeo()
294 geo->cylinders = get_capacity(bd->bd_disk) >> 11; virtblk_getgeo()
H A Dsunvdc.c110 static int vdc_getgeo(struct block_device *bdev, struct hd_geometry *geo) vdc_getgeo() argument
116 geo->heads = 0xff; vdc_getgeo()
117 geo->sectors = 0x3f; vdc_getgeo()
118 sector_div(cylinders, geo->heads * geo->sectors); vdc_getgeo()
119 geo->cylinders = cylinders; vdc_getgeo()
120 if ((sector_t)(geo->cylinders + 1) * geo->heads * geo->sectors < nsect) vdc_getgeo()
121 geo->cylinders = 0xffff; vdc_getgeo()
H A Dhd.c661 static int hd_getgeo(struct block_device *bdev, struct hd_geometry *geo) hd_getgeo() argument
665 geo->heads = disk->head; hd_getgeo()
666 geo->sectors = disk->sect; hd_getgeo()
667 geo->cylinders = disk->cyl; hd_getgeo()
H A Dswim.c724 static int floppy_getgeo(struct block_device *bdev, struct hd_geometry *geo) floppy_getgeo() argument
734 geo->heads = g->head; floppy_getgeo()
735 geo->sectors = g->sect; floppy_getgeo()
736 geo->cylinders = g->track; floppy_getgeo()
H A Dcpqarray.c165 static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo);
1123 static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo) ida_getgeo() argument
1128 geo->heads = drv->heads; ida_getgeo()
1129 geo->sectors = drv->sectors; ida_getgeo()
1130 geo->cylinders = drv->cylinders; ida_getgeo()
1132 geo->heads = 0xff; ida_getgeo()
1133 geo->sectors = 0x3f; ida_getgeo()
1134 geo->cylinders = drv->nr_blks / (0xff*0x3f); ida_getgeo()
H A Dumem.c767 static int mm_getgeo(struct block_device *bdev, struct hd_geometry *geo) mm_getgeo() argument
777 geo->heads = 64; mm_getgeo()
778 geo->sectors = 32; mm_getgeo()
779 geo->cylinders = size / (geo->heads * geo->sectors); mm_getgeo()
H A Dmg_disk.c769 static int mg_getgeo(struct block_device *bdev, struct hd_geometry *geo) mg_getgeo() argument
773 geo->cylinders = (unsigned short)host->cyls; mg_getgeo()
774 geo->heads = (unsigned char)host->heads; mg_getgeo()
775 geo->sectors = (unsigned char)host->sectors; mg_getgeo()
H A Dxsysace.c937 static int ace_getgeo(struct block_device *bdev, struct hd_geometry *geo) ace_getgeo() argument
944 geo->heads = cf_id[ATA_ID_HEADS]; ace_getgeo()
945 geo->sectors = cf_id[ATA_ID_SECTORS]; ace_getgeo()
946 geo->cylinders = cf_id[ATA_ID_CYLS]; ace_getgeo()
H A Dsx8.c410 static int carm_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo);
436 static int carm_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo) carm_bdev_getgeo() argument
440 geo->heads = (u8) port->dev_geom_head; carm_bdev_getgeo()
441 geo->sectors = (u8) port->dev_geom_sect; carm_bdev_getgeo()
442 geo->cylinders = port->dev_geom_cyl; carm_bdev_getgeo()
H A DDAC960.c107 static int DAC960_getgeo(struct block_device *bdev, struct hd_geometry *geo) DAC960_getgeo() argument
114 geo->heads = p->V1.GeometryTranslationHeads; DAC960_getgeo()
115 geo->sectors = p->V1.GeometryTranslationSectors; DAC960_getgeo()
116 geo->cylinders = p->V1.LogicalDriveInformation[drive_nr]. DAC960_getgeo()
117 LogicalDriveSize / (geo->heads * geo->sectors); DAC960_getgeo()
123 geo->heads = 128; DAC960_getgeo()
124 geo->sectors = 32; DAC960_getgeo()
127 geo->heads = 255; DAC960_getgeo()
128 geo->sectors = 63; DAC960_getgeo()
136 geo->cylinders = i->ConfigurableDeviceSize / DAC960_getgeo()
137 (geo->heads * geo->sectors); DAC960_getgeo()
H A Damiflop.c1453 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo) fd_getgeo() argument
1457 geo->heads = unit[drive].type->heads; fd_getgeo()
1458 geo->sectors = unit[drive].dtype->sects * unit[drive].type->sect_mult; fd_getgeo()
1459 geo->cylinders = unit[drive].type->tracks; fd_getgeo()
H A Dnvme-core.c1970 static int nvme_getgeo(struct block_device *bd, struct hd_geometry *geo) nvme_getgeo() argument
1973 geo->heads = 1 << 6; nvme_getgeo()
1974 geo->sectors = 1 << 5; nvme_getgeo()
1975 geo->cylinders = get_capacity(bd->bd_disk) >> 11; nvme_getgeo()
H A Dcciss.c173 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
1262 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo) cciss_getgeo() argument
1269 geo->heads = drv->heads; cciss_getgeo()
1270 geo->sectors = drv->sectors; cciss_getgeo()
1271 geo->cylinders = drv->cylinders; cciss_getgeo()
H A Dfloppy.c3364 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo) fd_getgeo() argument
3375 geo->heads = g->head; fd_getgeo()
3376 geo->sectors = g->sect; fd_getgeo()
3377 geo->cylinders = g->track; fd_getgeo()
H A Dskd_main.c4728 static int skd_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo) skd_bdev_getgeo() argument
4741 geo->heads = 64; skd_bdev_getgeo()
4742 geo->sectors = 255; skd_bdev_getgeo()
4743 geo->cylinders = (capacity) / (255 * 64); skd_bdev_getgeo()
/linux-4.1.27/drivers/video/fbdev/mb862xx/
H A Dmb862xxfb.h71 void __iomem *geo; member in struct:mb862xxfb_par
H A Dmb862xxfb_accel.c37 outreg(geo, GDC_GEO_REG_INPUT_FIFO, data[total]); mb862xxfb_write_fifo()
H A Dmb862xxfbdrv.c568 ptr += sprintf(ptr, "geo %08x = %08x\n", mb862xxfb_show_dispregs()
569 reg, inreg(geo, reg)); mb862xxfb_show_dispregs()
640 par->geo = par->mmio_base + MB862XX_GEO_BASE; mb862xx_gdc_init()
855 par->geo = par->mmio_base + MB862XX_GEO_BASE; coralp_init()
/linux-4.1.27/include/linux/mtd/
H A Dblktrans.h72 int (*getgeo)(struct mtd_blktrans_dev *dev, struct hd_geometry *geo);
/linux-4.1.27/drivers/mtd/ubi/
H A Dblock.c280 static int ubiblock_getgeo(struct block_device *bdev, struct hd_geometry *geo) ubiblock_getgeo() argument
283 geo->heads = 1; ubiblock_getgeo()
284 geo->cylinders = 1; ubiblock_getgeo()
285 geo->sectors = get_capacity(bdev->bd_disk); ubiblock_getgeo()
286 geo->start = 0; ubiblock_getgeo()
/linux-4.1.27/drivers/staging/lustre/lustre/libcfs/
H A Dprng.c45 From: George Marsaglia <geo@stat.fsu.edu>
/linux-4.1.27/arch/powerpc/platforms/85xx/
H A Dge_imp3a.c190 seq_printf(m, "cPCI geo. addr\t: %u\n", ge_imp3a_get_cpci_geo_addr()); ge_imp3a_show_cpuinfo()
/linux-4.1.27/arch/powerpc/platforms/86xx/
H A Dgef_ppc9a.c156 seq_printf(m, "VME geo. addr\t: %u\n", gef_ppc9a_get_vme_geo_addr()); gef_ppc9a_show_cpuinfo()
/linux-4.1.27/arch/ia64/sn/pci/pcibr/
H A Dpcibr_provider.c15 #include <asm/sn/geo.h>
H A Dpcibr_dma.c13 #include <asm/sn/geo.h>
/linux-4.1.27/arch/um/drivers/
H A Dubd_kern.c93 static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo);
1331 static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo) ubd_getgeo() argument
1335 geo->heads = 128; ubd_getgeo()
1336 geo->sectors = 32; ubd_getgeo()
1337 geo->cylinders = ubd_dev->size / (128 * 32 * 512); ubd_getgeo()
/linux-4.1.27/drivers/memstick/core/
H A Dmspro_block.c235 struct hd_geometry *geo) mspro_block_bd_getgeo()
239 geo->heads = msb->heads; mspro_block_bd_getgeo()
240 geo->sectors = msb->sectors_per_track; mspro_block_bd_getgeo()
241 geo->cylinders = msb->cylinders; mspro_block_bd_getgeo()
234 mspro_block_bd_getgeo(struct block_device *bdev, struct hd_geometry *geo) mspro_block_bd_getgeo() argument
H A Dms_block.c1996 struct hd_geometry *geo) msb_bd_getgeo()
1999 *geo = msb->geometry; msb_bd_getgeo()
1995 msb_bd_getgeo(struct block_device *bdev, struct hd_geometry *geo) msb_bd_getgeo() argument
/linux-4.1.27/drivers/staging/i2o/
H A Di2o_block.c634 static int i2o_block_getgeo(struct block_device *bdev, struct hd_geometry *geo) i2o_block_getgeo() argument
637 &geo->cylinders, &geo->heads, &geo->sectors); i2o_block_getgeo()
/linux-4.1.27/arch/ia64/sn/kernel/
H A Dbte_error.c14 #include <asm/sn/geo.h>
H A Dhuberror.c16 #include <asm/sn/geo.h>
H A Dio_common.c15 #include <asm/sn/geo.h>
H A Dsetup.c50 #include <asm/sn/geo.h>
/linux-4.1.27/arch/arm/crypto/
H A Dsha256-armv4.pl706 s/\`([^\`]*)\`/eval $1/geo;
708 s/\b(sha256\w+)\s+(q.*)/unsha256($1,$2)/geo;
/linux-4.1.27/drivers/char/
H A Dsnsc.c28 #include <asm/sn/geo.h>
/linux-4.1.27/include/pcmcia/
H A Dcistpl.h499 } geo[CISTPL_MAX_DEVICES]; member in struct:cistpl_device_geo_t
/linux-4.1.27/arch/ia64/include/asm/sn/
H A Dklconfig.h190 geoid_t brd_geoid; /* geo id */
H A Dsn_sal.h18 #include <asm/sn/geo.h>
/linux-4.1.27/drivers/mmc/card/
H A Dblock.c325 mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo) mmc_blk_getgeo() argument
327 geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16); mmc_blk_getgeo()
328 geo->heads = 4; mmc_blk_getgeo()
329 geo->sectors = 16; mmc_blk_getgeo()
/linux-4.1.27/drivers/scsi/
H A Dsd.c13 * - Jirka Hanika <geo@ff.cuni.cz> support more scsi disks using
1258 static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo) sd_getgeo() argument
1277 geo->heads = diskinfo[0]; sd_getgeo()
1278 geo->sectors = diskinfo[1]; sd_getgeo()
1279 geo->cylinders = diskinfo[2]; sd_getgeo()
/linux-4.1.27/drivers/block/mtip32xx/
H A Dmtip32xx.c3616 * @geo Pointer to a hd_geometry structure.
3623 struct hd_geometry *geo) mtip_block_getgeo()
3637 geo->heads = 224; mtip_block_getgeo()
3638 geo->sectors = 56; mtip_block_getgeo()
3639 sector_div(capacity, (geo->heads * geo->sectors)); mtip_block_getgeo()
3640 geo->cylinders = capacity; mtip_block_getgeo()
3622 mtip_block_getgeo(struct block_device *dev, struct hd_geometry *geo) mtip_block_getgeo() argument
/linux-4.1.27/drivers/net/wireless/iwlwifi/
H A Diwl-eeprom-parse.c291 * @EEPROM_CHANNEL_VALID: channel is usable for this SKU/geo
H A Diwl-nvm-parse.c182 * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
/linux-4.1.27/drivers/pci/hotplug/
H A Dsgi_hotplug.c24 #include <asm/sn/geo.h>
/linux-4.1.27/arch/ia64/sn/kernel/sn2/
H A Dsn_hwperf.c45 #include <asm/sn/geo.h>
/linux-4.1.27/drivers/crypto/vmx/
H A Daesp8-ppc.pl1880 s/\`([^\`]*)\`/eval($1)/geo;
/linux-4.1.27/drivers/net/wireless/iwlegacy/
H A D3945.c2060 * (for this geo/SKU) channel, at all Tx data rates, based on eeprom values
H A Dcommon.h208 EEPROM_CHANNEL_VALID = (1 << 0), /* usable for this SKU/geo */
H A Dcommon.c3429 * il_init_geos - Initialize mac80211's geo/channel info based from eeprom

Completed in 4777 milliseconds