diff options
| author | Rob Landley <rob@landley.net> | 2006-05-07 23:34:15 +0000 |
|---|---|---|
| committer | Rob Landley <rob@landley.net> | 2006-05-07 23:34:15 +0000 |
| commit | 20deab0537020248d687bbffc22d1203b07519c2 (patch) | |
| tree | 818d81f9e0308b08f6b7230596c15daae238b873 /miscutils | |
| parent | 63e4c637cb5567949235b644b6daf8ed90c3caa2 (diff) | |
| download | busybox-w32-20deab0537020248d687bbffc22d1203b07519c2.tar.gz busybox-w32-20deab0537020248d687bbffc22d1203b07519c2.tar.bz2 busybox-w32-20deab0537020248d687bbffc22d1203b07519c2.zip | |
Cleanup patch from tito.
Diffstat (limited to 'miscutils')
| -rw-r--r-- | miscutils/hdparm.c | 537 |
1 files changed, 158 insertions, 379 deletions
diff --git a/miscutils/hdparm.c b/miscutils/hdparm.c index f473add90..e099c2be4 100644 --- a/miscutils/hdparm.c +++ b/miscutils/hdparm.c | |||
| @@ -25,6 +25,7 @@ | |||
| 25 | #include <sys/time.h> | 25 | #include <sys/time.h> |
| 26 | #include <sys/times.h> | 26 | #include <sys/times.h> |
| 27 | #include <sys/mount.h> | 27 | #include <sys/mount.h> |
| 28 | #include <getopt.h> | ||
| 28 | #include "busybox.h" | 29 | #include "busybox.h" |
| 29 | #include <linux/types.h> | 30 | #include <linux/types.h> |
| 30 | #include <linux/hdreg.h> | 31 | #include <linux/hdreg.h> |
| @@ -567,13 +568,6 @@ static uint16_t check_if_maj_and_set_val(uint16_t a, uint16_t b) | |||
| 567 | return a; | 568 | return a; |
| 568 | } | 569 | } |
| 569 | 570 | ||
| 570 | static unsigned long int set_flag(char *p, char max) | ||
| 571 | { | ||
| 572 | if (*p >= '0' && *p <= max ) | ||
| 573 | return 1; | ||
| 574 | return 0; | ||
| 575 | } | ||
| 576 | |||
| 577 | /* end of busybox specific stuff */ | 571 | /* end of busybox specific stuff */ |
| 578 | 572 | ||
| 579 | #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY | 573 | #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY |
| @@ -633,7 +627,6 @@ static void print_ascii(uint16_t *p, uint8_t length) { | |||
| 633 | others, though, were declared in hdparm.c with global scope; since other | 627 | others, though, were declared in hdparm.c with global scope; since other |
| 634 | functions in that file have static (file) scope, I assume the difference is | 628 | functions in that file have static (file) scope, I assume the difference is |
| 635 | intentional. */ | 629 | intentional. */ |
| 636 | |||
| 637 | static void identify(uint16_t *id_supplied) | 630 | static void identify(uint16_t *id_supplied) |
| 638 | { | 631 | { |
| 639 | uint16_t buf[256]; | 632 | uint16_t buf[256]; |
| @@ -1240,17 +1233,17 @@ static unsigned long set_apmmode, get_apmmode, apmmode; | |||
| 1240 | static int get_IDentity; | 1233 | static int get_IDentity; |
| 1241 | #endif | 1234 | #endif |
| 1242 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF | 1235 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF |
| 1243 | static int unregister_hwif; | 1236 | static unsigned long unregister_hwif; |
| 1244 | static int hwif; | 1237 | static unsigned long hwif; |
| 1245 | #endif | 1238 | #endif |
| 1246 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF | 1239 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF |
| 1247 | static int scan_hwif; | 1240 | static unsigned long scan_hwif; |
| 1248 | static int hwif_data; | 1241 | static unsigned long hwif_data; |
| 1249 | static int hwif_ctrl; | 1242 | static unsigned long hwif_ctrl; |
| 1250 | static int hwif_irq; | 1243 | static unsigned long hwif_irq; |
| 1251 | #endif | 1244 | #endif |
| 1252 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF | 1245 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF |
| 1253 | static int set_busstate, get_busstate, busstate; | 1246 | static unsigned long set_busstate, get_busstate, busstate; |
| 1254 | #endif | 1247 | #endif |
| 1255 | static int reread_partn; | 1248 | static int reread_partn; |
| 1256 | 1249 | ||
| @@ -1258,7 +1251,7 @@ static int reread_partn; | |||
| 1258 | static int perform_reset; | 1251 | static int perform_reset; |
| 1259 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */ | 1252 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */ |
| 1260 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF | 1253 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF |
| 1261 | static int perform_tristate, tristate; | 1254 | static unsigned long perform_tristate, tristate; |
| 1262 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */ | 1255 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */ |
| 1263 | 1256 | ||
| 1264 | // Historically, if there was no HDIO_OBSOLETE_IDENTITY, then | 1257 | // Historically, if there was no HDIO_OBSOLETE_IDENTITY, then |
| @@ -1839,14 +1832,14 @@ static void process_dev(char *devname) | |||
| 1839 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF | 1832 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF |
| 1840 | if (unregister_hwif) | 1833 | if (unregister_hwif) |
| 1841 | { | 1834 | { |
| 1842 | printf(" attempting to unregister hwif#%u\n", hwif); | 1835 | printf(" attempting to unregister hwif#%lu\n", hwif); |
| 1843 | bb_ioctl(fd, HDIO_UNREGISTER_HWIF,(int *)(unsigned long)hwif,"HDIO_UNREGISTER_HWIF"); | 1836 | bb_ioctl(fd, HDIO_UNREGISTER_HWIF,(int *)(unsigned long)hwif,"HDIO_UNREGISTER_HWIF"); |
| 1844 | } | 1837 | } |
| 1845 | #endif | 1838 | #endif |
| 1846 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF | 1839 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF |
| 1847 | if (scan_hwif) | 1840 | if (scan_hwif) |
| 1848 | { | 1841 | { |
| 1849 | printf(" attempting to scan hwif (0x%x, 0x%x, %u)\n", hwif_data, hwif_ctrl, hwif_irq); | 1842 | printf(" attempting to scan hwif (0x%lx, 0x%lx, %lu)\n", hwif_data, hwif_ctrl, hwif_irq); |
| 1850 | args[0] = hwif_data; | 1843 | args[0] = hwif_data; |
| 1851 | args[1] = hwif_ctrl; | 1844 | args[1] = hwif_ctrl; |
| 1852 | args[2] = hwif_irq; | 1845 | args[2] = hwif_irq; |
| @@ -2246,7 +2239,7 @@ static void process_dev(char *devname) | |||
| 2246 | { | 2239 | { |
| 2247 | if (get_busstate) | 2240 | if (get_busstate) |
| 2248 | { | 2241 | { |
| 2249 | printf(" setting bus state to %d", busstate); | 2242 | printf(" setting bus state to %ld", busstate); |
| 2250 | bus_state_value(busstate); | 2243 | bus_state_value(busstate); |
| 2251 | } | 2244 | } |
| 2252 | bb_ioctl(fd, HDIO_SET_BUSSTATE, (int *)(unsigned long)busstate, "HDIO_SET_BUSSTATE"); | 2245 | bb_ioctl(fd, HDIO_SET_BUSSTATE, (int *)(unsigned long)busstate, "HDIO_SET_BUSSTATE"); |
| @@ -2275,35 +2268,6 @@ static void process_dev(char *devname) | |||
| 2275 | close(fd); | 2268 | close(fd); |
| 2276 | } | 2269 | } |
| 2277 | 2270 | ||
| 2278 | static char * GET_NUMBER(char *p, unsigned long *flag, unsigned long *num) | ||
| 2279 | { | ||
| 2280 | *num = 0; | ||
| 2281 | while (isdigit(*p)) { | ||
| 2282 | *flag = 1; | ||
| 2283 | *num = (*num * 10) + (*p++ - '0'); | ||
| 2284 | } | ||
| 2285 | return p; | ||
| 2286 | } | ||
| 2287 | |||
| 2288 | static char * GET_STRING(char *p, unsigned long *flag, int *num) | ||
| 2289 | { | ||
| 2290 | char *tmpstr; | ||
| 2291 | char name[32]; | ||
| 2292 | tmpstr = name; | ||
| 2293 | tmpstr[0] = '\0'; | ||
| 2294 | while (isalnum(*p) && (tmpstr - name) < 31) { | ||
| 2295 | tmpstr[0] = *p++; | ||
| 2296 | tmpstr[1] = '\0'; | ||
| 2297 | ++tmpstr; | ||
| 2298 | } | ||
| 2299 | *num = translate_xfermode(name); | ||
| 2300 | if (*num == -1) | ||
| 2301 | *flag = 0; | ||
| 2302 | else | ||
| 2303 | *flag = 1; | ||
| 2304 | return p; | ||
| 2305 | } | ||
| 2306 | |||
| 2307 | #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY | 2271 | #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY |
| 2308 | static int fromhex(unsigned char c) | 2272 | static int fromhex(unsigned char c) |
| 2309 | { | 2273 | { |
| @@ -2333,351 +2297,166 @@ static void identify_from_stdin(void) | |||
| 2333 | } | 2297 | } |
| 2334 | #endif | 2298 | #endif |
| 2335 | 2299 | ||
| 2336 | static void missing_arg(int arg, char c, char* add) | 2300 | /* busybox specific stuff */ |
| 2301 | static void parse_opts(int flag, unsigned long *get, unsigned long *set, unsigned long *value, int min, int max) | ||
| 2337 | { | 2302 | { |
| 2338 | if (!arg) | 2303 | if (flag) { |
| 2339 | bb_error_msg("-%c: missing value %s", c, (add!=NULL)? add :""); | 2304 | /* noisy is a global var */ |
| 2305 | if (get) { /* *get is initialized to 0 */ | ||
| 2306 | *get = noisy; | ||
| 2307 | noisy = 1; | ||
| 2308 | } | ||
| 2309 | if (optarg) { | ||
| 2310 | *set = 1; | ||
| 2311 | *value = bb_xgetlarg(optarg, 10, min, max); | ||
| 2312 | } | ||
| 2313 | } | ||
| 2340 | } | 2314 | } |
| 2341 | 2315 | ||
| 2342 | /* our main() routine: */ | 2316 | #ifdef HDIO_DRIVE_CMD |
| 2343 | int hdparm_main(int argc, char **argv) | 2317 | static void parse_opts_v2(int flag, unsigned long *get, unsigned long *set) |
| 2344 | { | 2318 | { |
| 2345 | char c, *p; | 2319 | if (flag) { |
| 2320 | /* noisy is a global var */ | ||
| 2321 | *get = noisy; | ||
| 2322 | noisy = 1; | ||
| 2323 | *set = 1; | ||
| 2324 | } | ||
| 2325 | } | ||
| 2326 | #endif | ||
| 2346 | 2327 | ||
| 2347 | ++argv; | 2328 | static void parse_opts_v3(int flag, unsigned long *get, unsigned long *set, int *value) |
| 2348 | if (!--argc) | 2329 | { |
| 2349 | bb_show_usage(); | 2330 | if (flag) { |
| 2331 | /* noisy is a global var */ | ||
| 2332 | *get = noisy; | ||
| 2333 | noisy = 1; | ||
| 2334 | if (optarg) { | ||
| 2335 | *set = ((*value = translate_xfermode(optarg)) > -1); | ||
| 2336 | } | ||
| 2337 | } | ||
| 2338 | } | ||
| 2350 | 2339 | ||
| 2351 | while (argc--) | 2340 | /*-------------------------------------*/ |
| 2352 | { | 2341 | /* getopt long options */ |
| 2353 | if (ENABLE_FEATURE_HDPARM_GET_IDENTITY && !strcmp("-Istdin", *argv)) | 2342 | #if ENABLE_FEATURE_HDPARM_GET_IDENTITY |
| 2354 | identify_from_stdin(); | 2343 | static const struct option HDPARM_LONG_OPT[] = |
| 2355 | p = *argv++; | 2344 | { |
| 2356 | if (*p == '-') | 2345 | {"Istdin", 0, NULL, '\256'}, |
| 2357 | { | 2346 | {NULL, 0, NULL, 0} |
| 2358 | if (!*++p) | 2347 | }; |
| 2359 | bb_show_usage(); | 2348 | #else |
| 2360 | while ((c = *p++)) | 2349 | #define HDPARM_LONG_OPT NULL |
| 2361 | { | ||
| 2362 | ++flagcount; | ||
| 2363 | switch (c) | ||
| 2364 | { | ||
| 2365 | case 'V': | ||
| 2366 | /*bb_error_msg_and_die("%s", VERSION);*/ | ||
| 2367 | /* We have to return 0 here and not 1 */ | ||
| 2368 | printf("%s %s\n",bb_applet_name, VERSION); | ||
| 2369 | return EXIT_SUCCESS; | ||
| 2370 | case 'v': | ||
| 2371 | verbose = 1; | ||
| 2372 | break; | ||
| 2373 | #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY | ||
| 2374 | case 'I': | ||
| 2375 | get_IDentity = 1; | ||
| 2376 | break; | ||
| 2377 | case 'i': | ||
| 2378 | get_identity = 1; | ||
| 2379 | break; | ||
| 2380 | #endif | 2350 | #endif |
| 2381 | case 'g': | 2351 | /*-------------------------------------*/ |
| 2382 | get_geom = 1; | 2352 | /* getopt short options */ |
| 2383 | break; | 2353 | static const char hdparm_options[]= "Vvgfqu::n::p:r::m::c::k::a::B:tTh"\ |
| 2384 | case 'f': | 2354 | USE_FEATURE_HDPARM_GET_IDENTITY("\256iI") |
| 2385 | do_flush = 1; | 2355 | USE_FEATURE_HDPARM_HDIO_GETSET_DMA("d::") |
| 2386 | break; | ||
| 2387 | case 'q': | ||
| 2388 | quiet = 1; | ||
| 2389 | noisy = 0; | ||
| 2390 | break; | ||
| 2391 | case 'u': | ||
| 2392 | get_unmask = noisy; | ||
| 2393 | noisy = 1; | ||
| 2394 | if (!*p && argc && isdigit(**argv)) | ||
| 2395 | p = *argv++, --argc; | ||
| 2396 | if ((set_unmask = set_flag(p,'1'))==1) | ||
| 2397 | unmask = *p++ - '0'; | ||
| 2398 | break; | ||
| 2399 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA | ||
| 2400 | case 'd': | ||
| 2401 | get_dma = noisy; | ||
| 2402 | noisy = 1; | ||
| 2403 | if (!*p && argc && isdigit(**argv)) | ||
| 2404 | p = *argv++, --argc; | ||
| 2405 | if ((set_dma = set_flag(p,'9'))==1) | ||
| 2406 | dma = *p++ - '0'; | ||
| 2407 | break; | ||
| 2408 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA */ | ||
| 2409 | case 'n': | ||
| 2410 | get_nowerr = noisy; | ||
| 2411 | noisy = 1; | ||
| 2412 | if (!*p && argc && isdigit(**argv)) | ||
| 2413 | p = *argv++, --argc; | ||
| 2414 | if ((set_nowerr = set_flag(p,'1'))==1) | ||
| 2415 | nowerr = *p++ - '0'; | ||
| 2416 | break; | ||
| 2417 | case 'p': | ||
| 2418 | noisy_piomode = noisy; | ||
| 2419 | noisy = 1; | ||
| 2420 | if (!*p && argc && isalnum(**argv)) | ||
| 2421 | p = *argv++, --argc; | ||
| 2422 | p=GET_STRING(p,&set_piomode,&piomode); | ||
| 2423 | break; | ||
| 2424 | case 'r': | ||
| 2425 | get_readonly = noisy; | ||
| 2426 | noisy = 1; | ||
| 2427 | if (!*p && argc && isdigit(**argv)) | ||
| 2428 | p = *argv++, --argc; | ||
| 2429 | if ((set_readonly = set_flag(p,'1'))==1) | ||
| 2430 | readonly = *p++ - '0'; | ||
| 2431 | break; | ||
| 2432 | case 'm': | ||
| 2433 | get_mult = noisy; | ||
| 2434 | noisy = 1; | ||
| 2435 | if (!*p && argc && isalnum(**argv)) | ||
| 2436 | p = *argv++, --argc; | ||
| 2437 | p=GET_NUMBER(p,&set_mult,&mult); | ||
| 2438 | break; | ||
| 2439 | case 'c': | ||
| 2440 | get_io32bit = noisy; | ||
| 2441 | noisy = 1; | ||
| 2442 | if (!*p && argc && isalnum(**argv)) | ||
| 2443 | p = *argv++, --argc; | ||
| 2444 | p=GET_NUMBER(p,&set_io32bit,&io32bit); | ||
| 2445 | break; | ||
| 2446 | #ifdef HDIO_DRIVE_CMD | 2356 | #ifdef HDIO_DRIVE_CMD |
| 2447 | case 'S': | 2357 | "S::D::P::X::K::A::L::W::CyYzZ" |
| 2448 | get_standby = noisy; | 2358 | #endif |
| 2449 | noisy = 1; | 2359 | USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF("U:") |
| 2450 | if (!*p && argc && isalnum(**argv)) | ||
| 2451 | p = *argv++, --argc; | ||
| 2452 | p=GET_NUMBER(p,&set_standby,&standby_requested); | ||
| 2453 | missing_arg(set_standby, c, NULL); | ||
| 2454 | break; | ||
| 2455 | |||
| 2456 | case 'D': | ||
| 2457 | get_defects = noisy; | ||
| 2458 | noisy = 1; | ||
| 2459 | if (!*p && argc && isalnum(**argv)) | ||
| 2460 | p = *argv++, --argc; | ||
| 2461 | p=GET_NUMBER(p,&set_defects,&defects); | ||
| 2462 | missing_arg(set_defects, c, NULL); | ||
| 2463 | break; | ||
| 2464 | case 'P': | ||
| 2465 | get_prefetch = noisy; | ||
| 2466 | noisy = 1; | ||
| 2467 | if (!*p && argc && isalnum(**argv)) | ||
| 2468 | p = *argv++, --argc; | ||
| 2469 | p=GET_NUMBER(p,&set_prefetch,&prefetch); | ||
| 2470 | missing_arg(set_prefetch, c, NULL); | ||
| 2471 | break; | ||
| 2472 | |||
| 2473 | case 'X': | ||
| 2474 | get_xfermode = noisy; | ||
| 2475 | noisy = 1; | ||
| 2476 | if (!*p && argc && isalnum(**argv)) | ||
| 2477 | p = *argv++, --argc; | ||
| 2478 | p=GET_STRING(p,&set_xfermode,&xfermode_requested); | ||
| 2479 | missing_arg(set_xfermode, c, NULL); | ||
| 2480 | break; | ||
| 2481 | |||
| 2482 | case 'K': | ||
| 2483 | get_dkeep = noisy; | ||
| 2484 | noisy = 1; | ||
| 2485 | if (!*p && argc && isdigit(**argv)) | ||
| 2486 | p = *argv++, --argc; | ||
| 2487 | if ((set_dkeep = set_flag(p,'1'))==1) | ||
| 2488 | dkeep = *p++ - '0'; | ||
| 2489 | else | ||
| 2490 | goto missing_arg_error; | ||
| 2491 | break; | ||
| 2492 | |||
| 2493 | case 'A': | ||
| 2494 | get_lookahead = noisy; | ||
| 2495 | noisy = 1; | ||
| 2496 | if (!*p && argc && isdigit(**argv)) | ||
| 2497 | p = *argv++, --argc; | ||
| 2498 | if ((set_lookahead = set_flag(p,'1'))==1) | ||
| 2499 | lookahead = *p++ - '0'; | ||
| 2500 | else | ||
| 2501 | goto missing_arg_error; | ||
| 2502 | break; | ||
| 2503 | |||
| 2504 | case 'L': | ||
| 2505 | get_doorlock = noisy; | ||
| 2506 | noisy = 1; | ||
| 2507 | if (!*p && argc && isdigit(**argv)) | ||
| 2508 | p = *argv++, --argc; | ||
| 2509 | if ((set_doorlock = set_flag(p,'1'))==1) | ||
| 2510 | doorlock = *p++ - '0'; | ||
| 2511 | else | ||
| 2512 | goto missing_arg_error; | ||
| 2513 | break; | ||
| 2514 | |||
| 2515 | case 'W': | ||
| 2516 | get_wcache = noisy; | ||
| 2517 | noisy = 1; | ||
| 2518 | if (!*p && argc && isdigit(**argv)) | ||
| 2519 | p = *argv++, --argc; | ||
| 2520 | if ((set_wcache = set_flag(p,'1'))==1) | ||
| 2521 | wcache = *p++ - '0'; | ||
| 2522 | else | ||
| 2523 | missing_arg_error: | ||
| 2524 | missing_arg(1, c, "(0/1)"); | ||
| 2525 | break; | ||
| 2526 | |||
| 2527 | case 'C': | ||
| 2528 | get_powermode = noisy; | ||
| 2529 | noisy = 1; | ||
| 2530 | break; | ||
| 2531 | |||
| 2532 | case 'y': | ||
| 2533 | get_standbynow = noisy; | ||
| 2534 | noisy = 1; | ||
| 2535 | set_standbynow = 1; | ||
| 2536 | break; | ||
| 2537 | |||
| 2538 | case 'Y': | ||
| 2539 | get_sleepnow = noisy; | ||
| 2540 | noisy = 1; | ||
| 2541 | set_sleepnow = 1; | ||
| 2542 | break; | ||
| 2543 | |||
| 2544 | case 'z': | ||
| 2545 | reread_partn = 1; | ||
| 2546 | break; | ||
| 2547 | |||
| 2548 | case 'Z': | ||
| 2549 | get_seagate = noisy; | ||
| 2550 | noisy = 1; | ||
| 2551 | set_seagate = 1; | ||
| 2552 | break; | ||
| 2553 | #endif /* HDIO_DRIVE_CMD */ | ||
| 2554 | case 'k': | ||
| 2555 | get_keep = noisy; | ||
| 2556 | noisy = 1; | ||
| 2557 | if (!*p && argc && isdigit(**argv)) | ||
| 2558 | p = *argv++, --argc; | ||
| 2559 | if ((set_keep = set_flag(p,'1'))==1) | ||
| 2560 | keep = *p++ - '0'; | ||
| 2561 | break; | ||
| 2562 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF | ||
| 2563 | case 'U': | ||
| 2564 | if (!*p && argc && isdigit(**argv)) | ||
| 2565 | p = *argv++, --argc; | ||
| 2566 | if (! p) | ||
| 2567 | goto expected_hwif_error; /* "expected hwif_nr" */ | ||
| 2568 | |||
| 2569 | sscanf(p++, "%i", &hwif); | ||
| 2570 | |||
| 2571 | unregister_hwif = 1; | ||
| 2572 | break; | ||
| 2573 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF */ | ||
| 2574 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF | ||
| 2575 | case 'R': | ||
| 2576 | if (!*p && argc && isdigit(**argv)) | ||
| 2577 | p = *argv++, --argc; | ||
| 2578 | if (! p) | ||
| 2579 | goto expected_hwif_error; /* "expected hwif_data" */ | ||
| 2580 | |||
| 2581 | sscanf(p++, "%i", &hwif_data); | ||
| 2582 | |||
| 2583 | if (argc && isdigit(**argv)) | ||
| 2584 | p = *argv++, --argc; | ||
| 2585 | else | ||
| 2586 | goto expected_hwif_error; /* "expected hwif_ctrl" */ | ||
| 2587 | |||
| 2588 | sscanf(p, "%i", &hwif_ctrl); | ||
| 2589 | |||
| 2590 | if (argc && isdigit(**argv)) | ||
| 2591 | p = *argv++, --argc; | ||
| 2592 | else | ||
| 2593 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF */ | ||
| 2594 | #if defined CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF || defined CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF | ||
| 2595 | expected_hwif_error: | ||
| 2596 | bb_error_msg_and_die("expected hwif value"); /* "expected hwif_irq" */ | ||
| 2597 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF || CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF */ | ||
| 2598 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF | ||
| 2599 | |||
| 2600 | sscanf(p, "%i", &hwif_irq); | ||
| 2601 | |||
| 2602 | *p = '\0'; | ||
| 2603 | |||
| 2604 | scan_hwif = 1; | ||
| 2605 | break; | ||
| 2606 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF */ | ||
| 2607 | case 'Q': | ||
| 2608 | #ifdef HDIO_GET_QDMA | 2360 | #ifdef HDIO_GET_QDMA |
| 2609 | get_dma_q = noisy; | ||
| 2610 | noisy = 1; | ||
| 2611 | #ifdef HDIO_SET_QDMA | 2361 | #ifdef HDIO_SET_QDMA |
| 2612 | if (!*p && argc && isalnum(**argv)) | 2362 | "Q:" |
| 2613 | p = *argv++, --argc; | 2363 | #else |
| 2614 | p=GET_NUMBER(p,&set_dma_q,&dma_q); | 2364 | "Q" |
| 2615 | #ifdef HDIO_GET_QDMA | ||
| 2616 | dma_q = -dma_q; | ||
| 2617 | #endif | ||
| 2618 | #endif | 2365 | #endif |
| 2619 | #endif | 2366 | #endif |
| 2620 | break; | 2367 | USE_FEATURE_HDPARM_HDIO_DRIVE_RESET("w") |
| 2368 | USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF("x::b:") | ||
| 2369 | USE_FEATURE_HDPARM_HDIO_SCAN_HWIF("R:"); | ||
| 2370 | /*-------------------------------------*/ | ||
| 2621 | 2371 | ||
| 2622 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET | 2372 | /* our main() routine: */ |
| 2623 | case 'w': | 2373 | int hdparm_main(int argc, char **argv) ATTRIBUTE_NORETURN; |
| 2624 | perform_reset = 1; | 2374 | int hdparm_main(int argc, char **argv) |
| 2625 | break; | 2375 | { |
| 2626 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */ | 2376 | int c; |
| 2627 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF | 2377 | |
| 2628 | case 'x': | 2378 | while ((c = getopt_long (argc, argv, hdparm_options, HDPARM_LONG_OPT , NULL)) >= 0) { |
| 2629 | if (!*p && argc && isdigit(**argv)) | 2379 | /* When no flags are given (flagcount = 0), -acdgkmnru is assumed. */ |
| 2630 | p = *argv++, --argc; | 2380 | flagcount++; |
| 2631 | if ((perform_tristate = set_flag(p,'1'))==1) | 2381 | #if ENABLE_FEATURE_HDPARM_GET_IDENTITY |
| 2632 | tristate = *p++ - '0'; | 2382 | if (c == '\256') { |
| 2633 | else | 2383 | identify_from_stdin(); /* EXIT */ |
| 2634 | missing_arg(1, c, "(0/1)"); | 2384 | } |
| 2635 | break; | ||
| 2636 | |||
| 2637 | #endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */ | ||
| 2638 | case 'a': | ||
| 2639 | get_readahead = noisy; | ||
| 2640 | noisy = 1; | ||
| 2641 | if (!*p && argc && isalnum(**argv)) | ||
| 2642 | p = *argv++, --argc; | ||
| 2643 | p=GET_NUMBER(p,&set_readahead,&Xreadahead); | ||
| 2644 | break; | ||
| 2645 | case 'B': | ||
| 2646 | get_apmmode = noisy; | ||
| 2647 | noisy = 1; | ||
| 2648 | if (!*p && argc && isalnum(**argv)) | ||
| 2649 | p = *argv++, --argc; | ||
| 2650 | p=GET_NUMBER(p,&set_apmmode,&apmmode); | ||
| 2651 | missing_arg(set_apmmode, c, "(1-255)"); | ||
| 2652 | break; | ||
| 2653 | case 't': | ||
| 2654 | do_timings = 1; | ||
| 2655 | do_flush = 1; | ||
| 2656 | break; | ||
| 2657 | case 'T': | ||
| 2658 | do_ctimings = 1; | ||
| 2659 | do_flush = 1; | ||
| 2660 | break; | ||
| 2661 | #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF | ||
| 2662 | case 'b': | ||
| 2663 | get_busstate = noisy; | ||
| 2664 | noisy = 1; | ||
| 2665 | if (!*p && argc && isdigit(**argv)) | ||
| 2666 | p = *argv++, --argc; | ||
| 2667 | if ((set_busstate = set_flag(p,'2'))==1) | ||
| 2668 | busstate = *p++ - '0'; | ||
| 2669 | break; | ||
| 2670 | #endif | 2385 | #endif |
| 2671 | case 'h': | 2386 | if (c == 'V') { |
| 2672 | default: | 2387 | printf("%s %s\n",bb_applet_name, VERSION); |
| 2673 | bb_show_usage(); | 2388 | exit(EXIT_SUCCESS); |
| 2674 | } | 2389 | } |
| 2675 | } | 2390 | |
| 2676 | if (!argc) | 2391 | verbose = (c == 'v'); |
| 2677 | bb_show_usage(); | 2392 | USE_FEATURE_HDPARM_GET_IDENTITY(get_IDentity = (c == 'I')); |
| 2678 | } else { | 2393 | USE_FEATURE_HDPARM_GET_IDENTITY(get_identity = (c == 'i')); |
| 2679 | process_dev(p); | 2394 | get_geom = (c == 'g'); |
| 2395 | do_flush = (c == 'f'); | ||
| 2396 | if (c == 'q') { | ||
| 2397 | quiet = 1; | ||
| 2398 | noisy = 0; | ||
| 2399 | } | ||
| 2400 | parse_opts((c == 'u'), &get_unmask, &set_unmask, &unmask, 0, 1); | ||
| 2401 | USE_FEATURE_HDPARM_HDIO_GETSET_DMA(parse_opts((c == 'd'), &get_dma, &set_dma, &dma, 0, 9)); | ||
| 2402 | parse_opts((c == 'n'), &get_nowerr, &set_nowerr, &nowerr, 0, 1); | ||
| 2403 | parse_opts_v3((c == 'p'), &noisy_piomode, &set_piomode, &piomode); | ||
| 2404 | parse_opts((c == 'r'), &get_readonly, &set_readonly, &readonly, 0, 1); | ||
| 2405 | parse_opts((c == 'm'), &get_mult, &set_mult, &mult, 0, INT_MAX /*32*/); | ||
| 2406 | parse_opts((c == 'c'), &get_io32bit, &set_io32bit, &io32bit, 0, INT_MAX /*8*/); | ||
| 2407 | parse_opts((c == 'k'), &get_keep, &set_keep, &keep, 0, 1); | ||
| 2408 | parse_opts((c == 'a'), &get_readahead, &set_readahead, &Xreadahead, 0, INT_MAX); | ||
| 2409 | parse_opts((c == 'B'), &get_apmmode, &set_apmmode, &apmmode, 1, 255); | ||
| 2410 | do_flush |= do_timings = (c == 't'); | ||
| 2411 | do_flush |= do_ctimings = (c == 'T'); | ||
| 2412 | #ifdef HDIO_DRIVE_CMD | ||
| 2413 | parse_opts((c == 'S'), &get_standby, &set_standby, &standby_requested, 0, INT_MAX); | ||
| 2414 | parse_opts((c == 'D'), &get_defects, &set_defects, &defects, 0, INT_MAX); | ||
| 2415 | parse_opts((c == 'P'), &get_prefetch, &set_prefetch, &prefetch, 0, INT_MAX); | ||
| 2416 | parse_opts_v3((c == 'X'), &get_xfermode, &set_xfermode, &xfermode_requested); | ||
| 2417 | parse_opts((c == 'K'), &get_dkeep, &set_dkeep, &prefetch, 0, 1); | ||
| 2418 | parse_opts((c == 'A'), &get_lookahead, &set_lookahead, &lookahead, 0, 1); | ||
| 2419 | parse_opts((c == 'L'), &get_doorlock, &set_doorlock, &doorlock, 0, 1); | ||
| 2420 | parse_opts((c == 'W'), &get_wcache, &set_wcache, &wcache, 0, 1); | ||
| 2421 | parse_opts_v3((c == 'C'), &get_powermode, NULL, NULL); | ||
| 2422 | parse_opts_v2((c == 'y'), &get_standbynow, &set_standbynow); | ||
| 2423 | parse_opts_v2((c == 'Y'), &get_sleepnow, &set_sleepnow); | ||
| 2424 | reread_partn = (c == 'z'); | ||
| 2425 | parse_opts_v2((c == 'Z'), &get_seagate, &set_seagate); | ||
| 2426 | #endif | ||
| 2427 | USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(parse_opts((c == 'U'), NULL, &unregister_hwif, &hwif, 0, INT_MAX)); | ||
| 2428 | #ifdef HDIO_GET_QDMA | ||
| 2429 | #ifdef HDIO_SET_QDMA | ||
| 2430 | parse_opts((c == 'Q'), &get_dma_q, &set_dma_q, &dma_q, 0, INT_MAX); | ||
| 2431 | #else | ||
| 2432 | parse_opts((c == 'Q'), &get_dma_q, NULL, NULL, 0, 0); | ||
| 2433 | #endif | ||
| 2434 | #endif | ||
| 2435 | USE_FEATURE_HDPARM_HDIO_DRIVE_RESET( perform_reset = (c == 'r')); | ||
| 2436 | USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(parse_opts((c == 'x'), NULL, &perform_tristate, &tristate, 0, 1)); | ||
| 2437 | USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(parse_opts((c == 'b'), &get_busstate, &set_busstate, &busstate, 0, 2)); | ||
| 2438 | #if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF | ||
| 2439 | if (c == 'R') { | ||
| 2440 | parse_opts((c == 'R'), NULL, &scan_hwif, &hwif_data, 0, INT_MAX); | ||
| 2441 | hwif_ctrl = bb_xgetlarg((argv[optind]) ? argv[optind] : "", 10, 0, INT_MAX); | ||
| 2442 | hwif_irq = bb_xgetlarg((argv[optind+1]) ? argv[optind+1] : "", 10, 0, INT_MAX); | ||
| 2443 | /* Move past the 2 additional arguments */ | ||
| 2444 | argv += 2; | ||
| 2445 | argc -= 2; | ||
| 2680 | } | 2446 | } |
| 2447 | #endif | ||
| 2448 | } | ||
| 2449 | |||
| 2450 | argc -= optind; | ||
| 2451 | argv += optind; | ||
| 2452 | |||
| 2453 | if (argc < 1) { | ||
| 2454 | bb_show_usage(); | ||
| 2455 | } | ||
| 2456 | |||
| 2457 | while (argc--) { | ||
| 2458 | process_dev(*argv); | ||
| 2459 | argv++; | ||
| 2681 | } | 2460 | } |
| 2682 | return 0 ; | 2461 | exit(EXIT_SUCCESS); |
| 2683 | } | 2462 | } |
