Page Comparison

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/ioctl.h>

#define 	WATCHDOG_IOCTL_BASE     	'W'

#define 	WDIOC_SETOPTIONS        	_IOR(WATCHDOG_IOCTL_BASE, 4, int)
#define 	WDIOC_KEEPALIVE         		_IOR(WATCHDOG_IOCTL_BASE, 5, int)
#define 	WDIOC_SETTIMEOUT        _IOWR(WATCHDOG_IOCTL_BASE, 6, int)

#define WDIOS_DISABLECARD       1
#define 	WDIOS_ENABLECARD	2

#define	WDIOC_GETTIMELEFT	_IOR(WATCHDOG_IOCTL_BASE, 10, int)

int  2
ret;
int wd_fd;
volatile int wd_feed_time = 8;           12;	// Feed watchdog every 812 second by default.
int wd_timeout = 10;            15;			// Timeout time of watchdog. Reset event occurs if watchdog is not fed within this time.


//* Aa thread forfeed feedingdog watchdog.*/
void * feedwdt_thd()
{
	int  ret;  	while (1) {
		
        // Feed (reset) watchdog.
		
        ret = ioctl(wd_fd, WDIOC_KEEPALIVE, 0);
		
        if (ret != 0) {
	
            		printf("FailedFeed towatchdog feedfailed. watchdog!\n");
	            		close(wd_fd);
		
        } else {
	
            		printf("Feed watchdog every %d seconds.\n", wd_feed_time);
		}

		
        }

        sleep(wd_feed_time);
    }
}

/* a thread read counter and print the value */
void *readwdt_thd()
{
    int arg;
    int i;

    while(1)
    {
        ret = ioctl(wd_fd, WDIOC_GETTIMELEFT, &arg);
        if (ret != 0) {
            printf("get data failed. \n");
	
        }
        printf("cnt value is 0x%x\n", arg);
        usleep(200000);
    }
}

int main(void)
{
	
    pthread_t wd_feed_thread;
    pthread_t wd_read_thread;

	    int wd_option;
    	char str[10];
    	int num = 0;
	int ret
    char* ptr = str;

	    // Get file handle of watchdog device.
	    wd_fd = open("/dev/watchdog0", O_WRONLY);
  	  if (wd_fd == -1) {
		        perror("watchdog");
		
        exit(EXIT_FAILURE);
    	}

	    // Enable wacthdog.
	    wd_option = WDIOS_ENABLECARD;
   	 ret = ioctl(wd_fd, WDIOC_SETOPTIONS, &wd_option);
   	 if (ret != 0) {
		        printf("Failed to start watchdog!\n");
		
        close(wd_fd);
		
        return -1;
    	}

	    // Setup timeout time.
    	ret = ioctl(wd_fd, WDIOC_SETTIMEOUT, &wd_timeout);
    	if (ret != 0) {
		
        printf("Failed to set timeout time!\n");
		        close(wd_fd);
		
        return -1;
 	   } 
	
    // Create a thread for feeding watchdog.
   	 ret = pthread_create(&wd_feed_thread, NULL, feedwdt_thd, NULL);
	    if (ret<ret < 0)
	        printf("Failed to create feeddog thread!\n");

	while #if 0 
    // Create a thread for reading and printing counter value.
    ret = pthread_create(&wd_read_thread, NULL, readwdt_thd, NULL);
    if (ret < 0)
        printf("Failed to create read counter thread!\n");
#endif
    while(1) {
		        printf("Press 'e' to disable watchdog and exit.\n");
		        printf("Enter a number for new feed time (defaultcurrent feed time is 8%d seconds, timeout time is 10%d seconds):\n", wd_feed_time, wd_timeout);
		        scanf("%s", str);

		
        //printf("debug why feedtime invarible  %s\n",str);

        if (!strcmp(str,"e")) {
			// Disable watchdog.
			
            wd_option = WDIOS_DISABLECARD;
			
            ret = ioctl(wd_fd, WDIOC_SETOPTIONS, &wd_option);
			            if (ret != 0) {
				
                printf("Failed to stop watchdog!\n");
			}
			
            }
            printf("Disabled watchdog!\n");
			
            close(wd_fd);
			            break;
		}

		        }
        if (strspn(str, "0123456789") == strlen(str)) {
			
            // Get new feed time.
			
            num = atoi(str);
			            if (num > 0) {
				
                wd_feed_time = num;
			            } else {
				
                printf("Feed time can not be zero!\n");
			}
		
            }
        } else {
			
            printf("Invalid feed time!\n");
		}
	}

	
        }
    }
    return 0;
}