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 ret;
int wd_fd;
volatile int wd_feed_time = 12;	// Feed watchdog every 12 second by default.
int wd_timeout = 15;			// Timeout time of watchdog. Reset event occurs if watchdog is not fed within this time.

/* a thread feed dog */
void *feedwdt_thd()
{
	    while(1) {
		
        // Feed (reset) watchdog.
        ret = ioctl(wd_fd, WDIOC_KEEPALIVE, 0);
        if (ret != 0) {
            printf("Feed watchdog failed. \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;
  	  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 < 0)
		
        printf("Failed to create feeddog thread!\n");
#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 (current feed time is %d seconds, timeout time is %d seconds):\n", wd_feed_time, wd_timeout);
		
        scanf("%s", str);
        //printf("debug why feedtime invarible  %s\n",str);

        		if (!strcmp(str,"e")) {
			
            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;
		}
		            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;
}