/*
 * Copyright 2003 Digi International (www.digi.com)
 *	Scott H Kilau <Scott_Kilau at digi dot com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * $Id: downld.c,v 1.6 2009/01/14 14:10:54 markh Exp $
 */

/*
** downld.c
**
**  This is the daemon that sends the fep, bios, and concentrator images
**  from user space to the driver.
** BUGS:
**  If the file changes in the middle of the download, you probably
**     will get what you deserve.
**
*/

#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/errno.h>

#include "dgap_types.h"
#include "digi.h"
#include "dgap_fep5.h"

#include "dgap_downld.h"

#include <string.h>
#include <malloc.h>
#include <stddef.h>
#include <unistd.h>

char		*pgm;
void		myperror();

/*
**  This structure is used to keep track of the different images available
**  to give to the driver.  It is arranged so that the things that are
**  constants or that have defaults are first inthe strucutre to simplify
**  the table of initializers.
*/
struct image_info {
	short	type;		/* bios, fep, conc */
	short	family;		/* boards this applies to */
	short	subtype;	/* subtype */
	int	len;		/* size of image */
	char	*image;		/* ioctl struct + image */
	char	*name;
	char	*fname;		/* filename of binary (i.e. "asfep.bin") */
	char	*pathname;	/* pathname to this binary ("/etc/dgap/xrfep.bin"); */
	time_t	mtime;		/* Last modification time */
};

#define IBIOS	0
#define	IFEP	1
#define	ICONC	2
#define ICONFIG	3
#define	IBAD	4

#define DEFAULT_LOC "/lib/firmware/dgap/"

struct image_info	*image_list;
int			nimages, count;

struct image_info images[] = {
{IBIOS, T_EPC,      SUBTYPE, 0, NULL, "EPC/X",	"fxbios.bin", DEFAULT_LOC "fxbios.bin", 0 },
{IFEP,  T_EPC,      SUBTYPE, 0, NULL, "EPC/X",	"fxfep.bin", DEFAULT_LOC "fxfep.bin", 0 },
{ICONC, T_EPC,      SUBTYPE, 0, NULL, "EPC/X",	"fxcon.bin", DEFAULT_LOC "fxcon.bin", 0 },

{IBIOS, T_CX,       SUBTYPE, 0, NULL, "C/X",	"cxbios.bin", DEFAULT_LOC "cxbios.bin", 0 },
{IFEP,  T_CX,       SUBTYPE, 0, NULL, "C/X",	"cxhost.bin", DEFAULT_LOC "cxhost.bin", 0 },

{IBIOS, T_CX,       T_PCIBUS, 0, NULL, "C/X PCI", "cxpbios.bin", DEFAULT_LOC "cxpbios.bin", 0 },
{IFEP,  T_CX,       T_PCIBUS, 0, NULL, "C/X PCI", "cxpfep.bin", DEFAULT_LOC "cxpfep.bin", 0 },

{ICONC, T_CX,       SUBTYPE, 0, NULL, "C/X",	"cxcon.bin", DEFAULT_LOC "cxcon.bin", 0 },
{ICONC, T_CX,       SUBTYPE, 0, NULL, "C/X",	"ibmcxcon.bin", DEFAULT_LOC "ibmcxcon.bin", 0 },
{ICONC, T_CX,       SUBTYPE, 0, NULL, "C/X",	"ibmencon.bin", DEFAULT_LOC "ibmencon.bin", 0 },

{IBIOS, FAMILY,   T_PCXR, 0, NULL, "PCXR",	"xrbios.bin", DEFAULT_LOC "xrbios.bin", 0 },
{IFEP,  FAMILY,   T_PCXR, 0,  NULL,  "PCXR",	"xrfep.bin", DEFAULT_LOC "xrfep.bin", 0  },

{IBIOS, T_PCLITE,   SUBTYPE, 0, NULL, "X/em",	"sxbios.bin", DEFAULT_LOC "sxbios.bin", 0 },
{IFEP,  T_PCLITE,   SUBTYPE, 0,  NULL,  "X/em",	"sxfep.bin", DEFAULT_LOC "sxfep.bin", 0  },

{IBIOS, T_EPC,      T_PCIBUS, 0, NULL, "PCI",	"pcibios.bin", DEFAULT_LOC "pcibios.bin", 0 },
{IFEP,  T_EPC,      T_PCIBUS, 0, NULL, "PCI",	"pcifep.bin", DEFAULT_LOC "pcifep.bin", 0 },
{ICONFIG, 0,	    0, 0, NULL,         NULL,	"dgap.conf",	"/etc/dgap.conf", 0 },

/* IBAD/NULL entry indicating end-of-table */

{IBAD,  0,     0, 0,  NULL,  NULL, NULL, NULL, 0 }

} ;

int 	errorprint = 1;
int 	nodldprint = 1;
int	debugflag;
int 	fd;

struct downld_t *ip;	/* Image pointer in current image  */
struct downld_t *dp; 	/* conc. download */


/*
 * The same for either the FEP or the BIOS.
 *  Append the downldio header, issue the ioctl, then free
 *  the buffer.  Not horribly CPU efficient, but quite RAM efficient.
 */

void squirt(int req_type, int bdid, struct image_info *ii)
{
	struct downldio	*dliop;
	int size_buf;
	int sfd;
	struct stat sb;

	/*
	 * If this binary comes from a file, stat it to see how
	 * large it is. Yes, we intentionally do this each
	 * time for the binary may change between loads.
	 */

	if (ii->pathname) {
		sfd = open(ii->pathname, O_RDONLY);

		if (sfd < 0 ) {
			myperror(ii->pathname);
			goto squirt_end;
		}

		if (fstat(sfd, &sb) == -1 ) {
			myperror(ii->pathname);
			goto squirt_end;
		}

		ii->len = sb.st_size;
	}

	size_buf = ii->len + sizeof(struct downldio);

	/*
	 * This buffer will be freed at the end of this function.  It is
	 * not resilient and should be around only long enough for the d/l
	 * to happen.
	 */
	dliop = (struct downldio *) malloc(size_buf);

	if (dliop == NULL) {
		fprintf(stderr,"%s: can't get %d bytes of memory; aborting\n",
			pgm, size_buf);
		exit (1);
	}

	/* Now, stick the image in fepimage.  This can come from either
	 *  the compiled-in image or from the filesystem.
	 */
	if (ii->pathname)
		read(sfd, dliop->image.fi.fepimage, ii->len);
	else
		memcpy(dliop ->image.fi.fepimage, ii->image, ii->len);

	dliop->req_type = req_type;
	dliop->bdid = bdid;

	dliop->image.fi.len = ii->len;

	if (debugflag)
		printf("sending %d bytes of %s %s from %s\n",
			ii->len,
			(ii->type == IFEP) ? "FEP" : (ii->type == IBIOS) ? "BIOS" : "CONFIG",
			ii->name ? ii->name : "",
			(ii->pathname) ? ii->pathname : "internal image" );

	if (ioctl(fd, DIGI_DLREQ_SET, (char *) dliop) == -1) {
		if(errorprint) {
			fprintf(stderr,
				"%s: warning - download ioctl failed\n",pgm);
			errorprint = 0;
		}
		sleep(2);
	}

squirt_end:

	if (ii->pathname) {
		close(sfd);
	}
	free(dliop);
}


/*
 *  See if we need to reload the download image in core
 *
 */
void consider_file_rescan(struct image_info *ii)
{
	int sfd;
	int len;
	struct stat 	sb;

	/* This operation only makes sense when we're working from a file */

	if (ii->pathname) {

		sfd = open (ii->pathname, O_RDONLY) ;
		if (sfd < 0 ) {
			myperror(ii->pathname);
			exit(1) ;
		}

		if( fstat(sfd,&sb) == -1 ) {
			myperror(ii->pathname);
			exit(1);
		}

		/* If the file hasn't changed since we last did this,
		 * and we have not done a free() on the image, bail
		 */
		if (ii->image && (sb.st_mtime == ii->mtime))
			goto end_rescan;

		ii->len = len = sb.st_size;

		/* Record the timestamp of the file */
		ii->mtime = sb.st_mtime;

		/* image should be NULL unless there is an image malloced
		 * in already.  Before we malloc again, make sure we don't
		 * have a memory leak.
		 */
		if ( ii->image ) {
			free( ii->image );
			/* ii->image = NULL; */ /* not necessary */
		}

		/* This image will be kept only long enough for the
		 * download to happen.  After sending the last block,
		 * it will be freed
		 */
		ii->image = malloc(len) ;

		if (ii->image == NULL) {
			fprintf(stderr,
				"%s: can't get %d bytes of memory; aborting\n",
				 pgm, len);
			exit (1);
		}

		if (read(sfd, ii->image, len) < len) {
			fprintf(stderr,"%s: read error on %s; aborting\n",
				pgm, ii->pathname);
			exit (1);
		}

end_rescan:
		close(sfd);

	}
}

/*
 * Scan for images to match the driver requests
 */

struct image_info * find_conc_image()
{
	int x;
	struct image_info *i = NULL;

	for ( x = 0; x < nimages; x++ ) {
		i=&image_list[x];

		if(i->type != ICONC)
			continue;

		consider_file_rescan(i) ;

		ip = (struct downld_t *) image_list[x].image;
		if (ip == NULL) continue;

		/*
		 * When I removed Clusterport, I kept only the code that I
		 * was SURE wasn't ClusterPort.  We may not need the next two
		 * lines of code.
		 */
		if ((dp->dl_type != 'P' ) && ( ip->dl_srev == dp->dl_srev ))
			return i;
	}
	return NULL;
}


int main(int argc, char **argv)
{
	struct downldio	dlio;
	int 		offset, bsize;
	int 		x;
	char 		*down, *image, *fname;
	struct image_info *ii;

	pgm = argv[0];
	dp = &dlio.image.dl;		/* conc. download */

	while((argc > 2) && !strcmp(argv[1],"-d")) {
		debugflag++ ;
		argc-- ;
		argv++ ;
	}

	if(argc < 2) {
		fprintf(stderr,
			"usage: %s download-device [image-file] ...\n",
			pgm);
		exit(1);
	}


	/*
	 * Daemonize, unless debugging is turned on.
	 */
	if (debugflag == 0) {
		switch (fork())
		{
		case 0:
			break;

		case -1:
			return 1;

		default:
			return 0;
		}

		setsid();

		/*
		 * The child no longer needs "stdin", "stdout", or "stderr",
		 * and should not block processes waiting for them to close.
		 */
		fclose(stdin);
		fclose(stdout);
		fclose(stderr);

	}

	while (1) {
		if( (fd = open(argv[1], O_RDWR)) == -1 ) {
			sleep(1);
		}
		else
			break;
	}

	/*
	** create a list of images to search through when trying to match
	** requests from the driver.  Put images from the command line in
	** the list before built in images so that the command line images
	** can override the built in ones.
	*/

	/* allocate space for the list */

	nimages = argc - 2;

	/* count the number of default list entries */

	for (count = 0; images[count].type != IBAD; ++count) ;

	nimages += count;

	/* Really should just remove the variable "image_list".... robertl */
	image_list = images;

	/* get the images from the command line */
	for(x = 2; x < argc; x++) {
		int xx;

		/*
		 * strip off any leading path information for
		 * determining file type
		 */
		if( (fname = strrchr(argv[x],'/')) == NULL)
			fname = argv[x];
		else
			fname++;	/* skip the slash */

		for (xx = 0; xx < count; xx++) {
			if (strcmp(fname, images[xx].fname) == 0 ) {
				images[xx].pathname = argv[x];

				/* image should be NULL until */
				/* space is malloced */
				images[xx].image = NULL;
			}
		}
	}

        sleep(3);

	/*
	** Endless loop: get a request from the fep, and service that request.
	*/
	for(;;) {
		/* get the request */
		if (debugflag)
			printf("b4 get ioctl...");

		if (ioctl(fd,DIGI_DLREQ_GET, &dlio) == -1 ) {
			if (errorprint) {
				fprintf(stderr,
					"%s: warning - download ioctl failed\n",
					pgm);
				errorprint = 0;
			}
			sleep(2);
		} else {
			if (debugflag)
				printf("dlio.req_type is %d bd %d\n",
					dlio.req_type,dlio.bdid);

			switch(dlio.req_type) {
			case DLREQ_BIOS:
				/*
				** find the bios image for this type
				*/
				for ( x = 0; x < nimages; x++ ) {
					if(image_list[x].type != IBIOS)
						continue;

					if ((dlio.image.fi.type & FAMILY) ==
						image_list[x].family) {

						if ( image_list[x].family == T_CX   ) {
							if ((dlio.image.fi.type & BUSTYPE)
								== T_PCIBUS ) {
								if ( image_list[x].subtype
									== T_PCIBUS )
									break;
							}
							else {
								break;
							}
						}
						else if ( image_list[x].family == T_EPC ) {
						/* If subtype of image is T_PCIBUS, it is */
						/* a PCI EPC image, so the board must */
						/* have bus type T_PCIBUS to match */
							if ((dlio.image.fi.type & BUSTYPE)
								== T_PCIBUS ) {
								if ( image_list[x].subtype
									== T_PCIBUS )
									break;
							}
							else {
							/* NON PCI EPC doesn't use PCI image */
								if ( image_list[x].subtype
									!= T_PCIBUS )
									break;
							}
						}
						else
							break;
					}
					else if ((dlio.image.fi.type & SUBTYPE) == image_list[x].subtype) {
						/* PCXR board will break out of the loop here */
						if ( image_list[x].subtype == T_PCXR   ) {
									break;
						}
					}
				}

				if ( x >= nimages) {
					/*
					** no valid images exist
					*/
					if(nodldprint) {
						fprintf(stderr,
						"%s: cannot find correct BIOS image\n",
							pgm);
						nodldprint = 0;
					}
					dlio.image.fi.type = -1;
					if (ioctl(fd, DIGI_DLREQ_SET, &dlio) == -1) {
						if (errorprint) {
							fprintf(stderr,
							"%s: warning - download ioctl failed\n",
							pgm);
							errorprint = 0;
						}
						sleep(2);
					}
					break;
				}
				squirt(dlio.req_type, dlio.bdid, &image_list[x]);
				break ;

			case DLREQ_FEP:
				/*
				** find the fep image for this type
				*/
				for ( x = 0; x < nimages; x++ ) {
					if(image_list[x].type != IFEP)
						continue;
					if( (dlio.image.fi.type & FAMILY) ==
						image_list[x].family ) {
						if ( image_list[x].family == T_CX   ) {
							/* C/X PCI board */
							if ((dlio.image.fi.type & BUSTYPE)
								== T_PCIBUS ) {
								if ( image_list[x].subtype
									== T_PCIBUS )
									break;
							}
							else {
							/* Regular CX */
								break;
							}
						}
						else if ( image_list[x].family == T_EPC   )  {
						/* If subtype of image is T_PCIBUS, it is */
						/* a PCI EPC image, so the board must */
						/* have bus type T_PCIBUS to match */
							if ((dlio.image.fi.type & BUSTYPE)
								== T_PCIBUS ) {
								if ( image_list[x].subtype
									== T_PCIBUS )
									break;
							}
							else {
							/* NON PCI EPC doesn't use PCI image */
								if ( image_list[x].subtype
									!= T_PCIBUS )
									break;
							}
						}
						else
							break;
					}
					else if ((dlio.image.fi.type & SUBTYPE) == image_list[x].subtype) {
						/* PCXR board will break out of the loop here */
						if ( image_list[x].subtype == T_PCXR   ) {
									break;
						}
					}
				}

				if ( x >= nimages) {
					/*
					** no valid images exist
					*/
					if(nodldprint) {
						fprintf(stderr,
						"%s: cannot find correct FEP image\n",
							pgm);
						nodldprint = 0;
					}
					dlio.image.fi.type=-1;
					if( ioctl(fd,DIGI_DLREQ_SET,&dlio) == -1 ) {
						if(errorprint) {
							fprintf(stderr,
						"%s: warning - download ioctl failed\n",
								pgm);
							errorprint=0;
						}
						sleep(2);
					}
					break;
				}
				squirt(dlio.req_type, dlio.bdid, &image_list[x]);
				break;

			case DLREQ_DEVCREATE:
				{
					char string[1024];
#if 0
					sprintf(string, "%s /proc/dgap/%d/mknod", DEFSHELL, dlio.bdid);
#endif
					sprintf(string, "%s /usr/sbin/dgap_updatedevs %d", DEFSHELL, dlio.bdid);
					system(string);

					if (debugflag)
						printf("Created Devices.\n");
					if (ioctl(fd, DIGI_DLREQ_SET, &dlio) == -1 ) {
						if(errorprint) {
							fprintf(stderr, "%s: warning - DEVCREATE ioctl failed\n",pgm);
							errorprint = 0;
						}
						sleep(2);
					}
					if (debugflag)
						printf("After ioctl set - Created Device.\n");
				}

				break;

			case DLREQ_CONFIG:
				for ( x = 0; x < nimages; x++ ) {
					if(image_list[x].type != ICONFIG)
						continue;
					else
						break;
				}

				if ( x >= nimages) {
					/*
					** no valid images exist
					*/
					if(nodldprint) {
						fprintf(stderr,
						"%s: cannot find correct CONFIG image\n",
							pgm);
						nodldprint = 0;
					}
					dlio.image.fi.type=-1;
					if (ioctl(fd, DIGI_DLREQ_SET, &dlio) == -1 ) {
						if(errorprint) {
							fprintf(stderr,
						"%s: warning - download ioctl failed\n",
								pgm);
							errorprint=0;
						}
						sleep(2);
					}
					break;
				}

				squirt(dlio.req_type, dlio.bdid, &image_list[x]);
				break;

			case DLREQ_CONC:
				/*
				** find the image needed for this download
				*/
				if ( dp->dl_seq == 0 ) {
					/*
					** find image for hardware rev range
					*/
					for ( x = 0; x < nimages; x++ ) {
						ii=&image_list[x];

						if(image_list[x].type != ICONC)
							continue;

						consider_file_rescan(ii) ;

						ip = (struct downld_t *) image_list[x].image;
						if (ip == NULL) continue;

						/*
						 * When I removed Clusterport, I kept only the
						 * code that I was SURE wasn't ClusterPort.
						 * We may not need the next four lines of code.
						 */

						if ((dp->dl_type != 'P' ) &&
						 (ip->dl_lrev <= dp->dl_lrev ) &&
						 ( dp->dl_lrev <= ip->dl_hrev))
							break;
					}

					if ( x >= nimages ) {
						/*
						** No valid images exist
						*/
						if(nodldprint) {
							fprintf(stderr,
						"%s: cannot find correct download image %d\n",
								pgm, dp->dl_lrev);
							nodldprint=0;
						}
						continue;
					}

				} else {
					/*
					** find image version required
					*/
					if ((ii = find_conc_image()) == NULL ) {
						/*
						** No valid images exist
						*/
						fprintf(stderr,
						"%s: can't find rest of download image??\n",
							pgm);
						continue;
					}
				}

				/*
				** download block of image
				*/

				offset = 1024 * dp->dl_seq;

				/*
				** test if block requested within image
				*/
				if ( offset < ii->len ) {

					/*
					** if it is, determine block size, set segment,
					** set size, set pointers, and copy block
					*/
					if (( bsize = ii->len - offset ) > 1024 )
						bsize = 1024;

					/*
					** copy image version info to download area
					*/
					dp->dl_srev = ip->dl_srev;
					dp->dl_lrev = ip->dl_lrev;
					dp->dl_hrev = ip->dl_hrev;

					dp->dl_seg = (64 * dp->dl_seq) + ip->dl_seg;
					dp->dl_size = bsize;

					down = (char *)&dp->dl_data[0];
					image = (char *)((char *)ip + offset);

					memcpy(down, image, bsize);
				}
				else {
					/*
					** Image has been downloaded, set segment and
					** size to indicate no more blocks
					*/
					dp->dl_seg = ip->dl_seg;
					dp->dl_size = 0;

					/* Now, we can release the concentrator */
					/* image from memory if we're running  */
					/* from filesystem images */

					if (ii->pathname)
						if (ii->image) {
							free(ii->image);
							ii->image = NULL;
						}
				}

				if (debugflag)
						printf(
						"sending conc dl section %d to %s from %s\n",
							dp->dl_seq, ii->name,
						ii->pathname ? ii->pathname : "Internal Image");

				if (ioctl(fd, DIGI_DLREQ_SET, &dlio) == -1 ) {
					if (errorprint) {
						fprintf(stderr,
						"%s: warning - download ioctl failed\n",
							pgm);
						errorprint=0;
					}
					sleep(2);
				}
				break;
			} /* switch */
		}
		if (debugflag > 1) {
			printf("pausing: "); fflush(stdout);
			fflush(stdin);
			while(getchar() != '\n');
				printf("continuing\n");
		}
	}
}

/*
** myperror()
**
**  Same as normal perror(), but places the program name at the beginning
**  of the message.
*/
void myperror(char *s)
{
	fprintf(stderr,"%s: %s: %s.\n",pgm, s, strerror(errno));
}