aboutsummaryrefslogtreecommitdiffstats
path: root/install-sh
blob: e9de23842dcd44d2953129c866b1ad25f7e1f1d9 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

#!/bin/sh
#
# install - install a program, script, or datafile
# This comes from X11R5 (mit/util/scripts/install.sh).
#
# Copyright 1991 by the Massachusetts Institute of Technology
#
# Permission to use, copy, modify, distribute, and sell this software and its
# documentation for any purpose is hereby granted without fee, provided that
# the above copyright notice appear in all copies and that both that
# copyright notice and this permission notice appear in supporting
# documentation, and that the name of M.I.T. not be used in advertising or
# publicity pertaining to distribution of the software without specific,
# written prior permission.  M.I.T. makes no representations about the
# suitability of this software for any purpose.  It is provided "as is"
# without express or implied warranty.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# `make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch.  It can only install one file at a time, a restriction
# shared with many OS's install programs.


# set DOITPROG to echo to test this script

# Don't use :- since 4.3BSD and earlier shells don't like it.
doit="${DOITPROG-}"


# put in absolute paths if you don't have them in your path; or use env. vars.

mvprog="${MVPROG-mv}"
cpprog="${CPPROG-cp}"
chmodprog="${CHMODPROG-chmod}"
chownprog="${CHOWNPROG-chown}"
chgrpprog="${CHGRPPROG-chgrp}"
stripprog="${STRIPPROG-strip}"
rmprog="${RMPROG-rm}"
mkdirprog="${MKDIRPROG-mkdir}"

transformbasename=""
transform_arg=""
instcmd="$mvprog"
chmodcmd="$chmodprog 0755"
chowncmd=""
chgrpcmd=""
stripcmd=""
rmcmd="$rmprog -f"
mvcmd="$mvprog"
src=""
dst=""
dir_arg=""

while [ x"$1" != x ]; do
    case $1 in
	-c) instcmd="$cpprog"
	    shift
	    continue;;

	-d) dir_arg=true
	    shift
	    continue;;

	-m) chmodcmd="$chmodprog $2"
	    shift
	    shift
	    continue;;

	-o) chowncmd="$chownprog $2"
	    shift
	    shift
	    continue;;

	-g) chgrpcmd="$chgrpprog $2"
	    shift
	    shift
	    continue;;

	-s) stripcmd="$stripprog"
	    shift
	    continue;;

	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
	    shift
	    continue;;

	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
	    shift
	    continue;;

	*)  if [ x"$src" = x ]
	    then
		src=$1
	    else
		# this colon is to work around a 386BSD /bin/sh bug
		:
		dst=$1
	    fi
	    shift
	    continue;;
    esac
done

if [ x"$src" = x ]
then
	echo "install:	no input file specified"
	exit 1
else
	true
fi

if [ x"$dir_arg" != x ]; then
	dst=$src
	src=""
	
	if [ -d $dst ]; then
		instcmd=:
		chmodcmd=""
	else
		instcmd=mkdir
	fi
else

# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
# might cause directories to be created, which would be especially bad 
# if $src (and thus $dsttmp) contains '*'.

	if [ -f $src -o -d $src ]
	then
		true
	else
		echo "install:  $src does not exist"
		exit 1
	fi
	
	if [ x"$dst" = x ]
	then
		echo "install:	no destination specified"
		exit 1
	else
		true
	fi

# If destination is a directory, append the input filename; if your system
# does not like double slashes in filenames, you may need to add some logic

	if [ -d $dst ]
	then
		dst="$dst"/`basename $src`
	else
		true
	fi
fi

## this sed command emulates the dirname command
dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`

# Make sure that the destination directory exists.
#  this part is taken from Noah Friedman's mkinstalldirs script

# Skip lots of stat calls in the usual case.
if [ ! -d "$dstdir" ]; then
defaultIFS='	
'
IFS="${IFS-${defaultIFS}}"

oIFS="${IFS}"
# Some sh's can't handle IFS=/ for some reason.
IFS='%'
set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
IFS="${oIFS}"

pathcomp=''

while [ $# -ne 0 ] ; do
	pathcomp="${pathcomp}${1}"
	shift

	if [ ! -d "${pathcomp}" ] ;
        then
		$mkdirprog "${pathcomp}"
	else
		true
	fi

	pathcomp="${pathcomp}/"
done
fi

if [ x"$dir_arg" != x ]
then
	$doit $instcmd $dst &&

	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
else

# If we're going to rename the final executable, determine the name now.

	if [ x"$transformarg" = x ] 
	then
		dstfile=`basename $dst`
	else
		dstfile=`basename $dst $transformbasename | 
			sed $transformarg`$transformbasename
	fi

# don't allow the sed command to completely eliminate the filename

	if [ x"$dstfile" = x ] 
	then
		dstfile=`basename $dst`
	else
		true
	fi

# Make a temp file name in the proper directory.

	dsttmp=$dstdir/#inst.$$#

# Move or copy the file name to the temp name

	$doit $instcmd $src $dsttmp &&

	trap "rm -f ${dsttmp}" 0 &&

# and set any options; do chmod last to preserve setuid bits

# If any of these fail, we abort the whole thing.  If we want to
# ignore errors from any of these, just make sure not to ignore
# errors from the above "$doit $instcmd $src $dsttmp" command.

	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&

# Now rename the file to the real destination.

	$doit $rmcmd -f $dstdir/$dstfile &&
	$doit $mvcmd $dsttmp $dstdir/$dstfile 

fi &&


exit 0
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-11 04:11:32 +0000
ass="p">, "Soekris", CAP_BUSY4BIT }, { 0xff, "Unknown", 0 } }; // **************************************** // *** hardware dependant functions *** // **************************************** static void wait_for_busy_flag(int controller) { unsigned char enable; unsigned int counter; unsigned char data=0xFF; unsigned char busymask=0; if (Bits==8) { busymask = 0x80; } else { /* Since in 4-Bit mode DB0 on the parport is mapped to DB4 on the LCD (and consequently, DB3 on the partport is mapped to DB7 on the LCD) we need to listen for DB3 on the parport to go low */ busymask = 0x8; } enable=SIGNAL_ENABLE; while (controller > 0) { if (controller&0x01 && enable!=0) { /* set data-lines to input*/ drv_generic_parport_direction(1); if (Bits==8) { // Set RW, clear RS drv_generic_parport_control(SIGNAL_RW|SIGNAL_RS,SIGNAL_RW); } else { drv_generic_parport_data(SIGNAL_RW); } // Address set-up time ndelay(T_AS); // rise ENABLE if (Bits==8) { drv_generic_parport_control(enable,enable); } else { drv_generic_parport_data(SIGNAL_RW|enable); } counter=0; while (1) { /* read the busy flag */ data = drv_generic_parport_read(); if ((data&busymask)==0) break; /* make sure we don't wait forever - but only check after 5 iterations that way, we won't slow down normal mode (where we don't need the timeout anyway) */ counter++; if (counter >= 5) { struct timeval now, end; if (counter == 5) { // determine the time when the timeout has expired gettimeofday (&end, NULL); end.tv_usec+=MAX_BUSYFLAG_WAIT; while (end.tv_usec>1000000) { end.tv_usec-=1000000; end.tv_sec++; } } // get the current time gettimeofday(&now, NULL); if (now.tv_sec==end.tv_sec?now.tv_usec>=end.tv_usec:now.tv_sec>=end.tv_sec) { error ("%s: timeout waiting for busy flag on controller %x (%x)", Name, controller, data); break; } } } // RS=low, RW=low, EN=low if (Bits==8) { // Lower EN drv_generic_parport_control(enable,0); // Address hold time ndelay(T_AH); drv_generic_parport_control(SIGNAL_RW|SIGNAL_RS,0); } else { // Lower EN drv_generic_parport_data(SIGNAL_RW); ndelay(T_AH); drv_generic_parport_data(0); } /* set data-lines to output*/ drv_generic_parport_direction(0); } enable=SIGNAL_ENABLE2; controller=controller >> 1; } } static void drv_HD_nibble(unsigned char controller, unsigned char nibble) { unsigned char enable; // enable signal: 'controller' is a bitmask // bit 0 .. send to controller #0 // bit 1 .. send to controller #1 // so we can send a byte to both controllers at the same time! enable=0; if (controller&0x01) enable|=SIGNAL_ENABLE; if (controller&0x02) enable|=SIGNAL_ENABLE2; // clear ENABLE // put data on DB1..DB4 // nibble already contains RS bit! drv_generic_parport_data(nibble); // Address set-up time ndelay(T_AS); // rise ENABLE drv_generic_parport_data(nibble | enable); // Enable pulse width ndelay(T_PW); // lower ENABLE drv_generic_parport_data(nibble); } static void drv_HD_byte (unsigned char controller, unsigned char data, unsigned char RS) { // send high nibble of the data drv_HD_nibble (controller, ((data>>4)&0x0f)|RS); // Make sure we honour T_CYCLE ndelay(T_CYCLE-T_AS-T_PW); // send low nibble of the data drv_HD_nibble(controller, (data&0x0f)|RS); } static void drv_HD_command (unsigned char controller, unsigned char cmd, int delay) { unsigned char enable; if (UseBusy) wait_for_busy_flag(controller); if (Bits==8) { // enable signal: 'controller' is a bitmask // bit 0 .. send to controller #0 // bit 1 .. send to controller #1 // so we can send a byte to both controllers at the same time! enable=0; if (controller&0x01) enable|=SIGNAL_ENABLE; if (controller&0x02) enable|=SIGNAL_ENABLE2; // put data on DB1..DB8 drv_generic_parport_data (cmd); // clear RW and RS drv_generic_parport_control (SIGNAL_RW | SIGNAL_RS, 0); // Address set-up time ndelay(T_AS); // send command drv_generic_parport_toggle (enable, 1, T_PW); } else { drv_HD_byte (controller, cmd, 0); } // wait for command completion if (!UseBusy) udelay(delay); } static void drv_HD_data (unsigned char controller, char *string, int len, int delay) { unsigned char enable; // sanity check if (len<=0) return; if (Bits==8) { // enable signal: 'controller' is a bitmask // bit 0 .. send to controller #0 // bit 1 .. send to controller #1 // so we can send a byte to both controllers at the same time! enable=0; if (controller&0x01) enable|=SIGNAL_ENABLE; if (controller&0x02) enable|=SIGNAL_ENABLE2; if (!UseBusy) { // clear RW, set RS drv_generic_parport_control (SIGNAL_RW | SIGNAL_RS, SIGNAL_RS); // Address set-up time ndelay(T_AS); } while (len--) { if (UseBusy) { wait_for_busy_flag(controller); // clear RW, set RS drv_generic_parport_control (SIGNAL_RW | SIGNAL_RS, SIGNAL_RS); // Address set-up time ndelay(T_AS); } // put data on DB1..DB8 drv_generic_parport_data (*(string++)); // send command drv_generic_parport_toggle (enable, 1, T_PW); // wait for command completion if (!UseBusy) udelay(delay); } } else { // 4 bit mode while (len--) { if (UseBusy) wait_for_busy_flag(controller); // send data with RS enabled drv_HD_byte (controller, *(string++), SIGNAL_RS); // wait for command completion if (!UseBusy) udelay(delay); } } } static void drv_HD_goto (int row, int col) { int pos; // handle multiple displays/controllers if (numControllers>1 && row>=DROWS/2) { row -= DROWS/2; currController = 2; } else { currController = 1; } // 16x1 Displays are organized as 8x2 :-( if (DCOLS==16 && DROWS==1 && col>7) { row++; col-=8; } // 16x4 Displays use a slightly different layout if (DCOLS==16 && DROWS==4) { pos=(row%2)*64+(row/2)*16+col; } else { pos=(row%2)*64+(row/2)*20+col; } drv_HD_command (currController, (0x80|pos), T_EXEC); } static void drv_HD_write (unsigned char *string, int len) { drv_HD_data (currController, string, len, T_EXEC); } static void drv_HD_defchar (int ascii, unsigned char *buffer) { // define chars on *both* controllers! drv_HD_command (allControllers, 0x40|8*ascii, T_EXEC); drv_HD_data (allControllers, buffer, 8, T_WRCG); } static int drv_HD_brightness (int brightness) { char cmd; if (!(Capabilities & CAP_BRIGHTNESS)) return -1; if (brightness<0) brightness=0; if (brightness>3) brightness=3; cmd='0'+brightness; drv_HD_command (allControllers, 0x38, T_EXEC); // enable function drv_HD_data (allControllers, &cmd, 1, T_WRCG); // set brightness return brightness; } // Fixme #if 0 static void drv_HD_setGPO (int bits) { if (Lcd.gpos>0) { // put data on DB1..DB8 drv_generic_parport_data (bits); // 74HCT573 set-up time ndelay(20); // send data // 74HCT573 enable pulse width = 24ns drv_generic_parport_toggle (SIGNAL_GPO, 1, 230); } } #endif static int drv_HD_start (char *section) { char *model, *s; int rows=-1, cols=-1, gpos=-1; model=cfg_get(section, "Model", "generic"); if (model!=NULL && *model!='\0') { int i; for (i=0; Models[i].type!=0xff; i++) { if (strcasecmp(Models[i].name, model)==0) break; } if (Models[i].type==0xff) { error ("%s: %s.Model '%s' is unknown from %s", Name, section, model, cfg_source()); return -1; } Model=i; Capabilities=Models[Model].capabilities; info ("%s: using model '%s'", Name, Models[Model].name); } else { error ("%s: empty '%s.Model' entry from %s", Name, section, cfg_source()); return -1; } s=cfg_get(section, "Size", NULL); if (s==NULL || *s=='\0') { error ("%s: no '%s.Size' entry from %s", Name, section, cfg_source()); return -1; } if (sscanf(s,"%dx%d",&cols,&rows)!=2 || rows<1 || cols<1) { error ("%s: bad size '%s'", Name, s); return -1; } if (cfg_number(section, "GPOs", 0, 0, 8, &gpos)<0) return -1; info ("%s: controlling %d GPO's", Name, gpos); if (cfg_number(section, "Controllers", 1, 1, 2, &numControllers)<0) return -1; info ("%s: using display with %d controllers", Name, numControllers); // current controller currController=1; // Bitmask for *all* Controllers allControllers = numControllers==2 ? 3 : 1; DROWS = rows; DCOLS = cols; GPOS = gpos; if (cfg_number(section, "Bits", 8, 4, 8, &Bits)<0) return -1; if (Bits!=4 && Bits!=8) { error ("%s: bad %s.Bits '%s' from %s, should be '4' or '8'", Name, section, s, cfg_source()); return -1; } info ("%s: using %d bit mode", Name, Bits); if (drv_generic_parport_open(section, Name) != 0) { error ("%s: could not initialize parallel port!", Name); return -1; } if (Bits==8) { if ((SIGNAL_RS = drv_generic_parport_wire_ctrl ("RS", "AUTOFD"))==0xff) return -1; if ((SIGNAL_RW = drv_generic_parport_wire_ctrl ("RW", "GND" ))==0xff) return -1; if ((SIGNAL_ENABLE = drv_generic_parport_wire_ctrl ("ENABLE", "STROBE"))==0xff) return -1; if ((SIGNAL_ENABLE2 = drv_generic_parport_wire_ctrl ("ENABLE2", "GND" ))==0xff) return -1; if ((SIGNAL_GPO = drv_generic_parport_wire_ctrl ("GPO", "GND" ))==0xff) return -1; } else { if ((SIGNAL_RS = drv_generic_parport_wire_data ("RS", "DB4"))==0xff) return -1; if ((SIGNAL_RW = drv_generic_parport_wire_data ("RW", "DB5"))==0xff) return -1; if ((SIGNAL_ENABLE = drv_generic_parport_wire_data ("ENABLE", "DB6"))==0xff) return -1; if ((SIGNAL_ENABLE2 = drv_generic_parport_wire_data ("ENABLE2", "GND"))==0xff) return -1; if ((SIGNAL_GPO = drv_generic_parport_wire_data ("GPO", "GND"))==0xff) return -1; } // clear all signals if (Bits==8) { drv_generic_parport_control (SIGNAL_RS|SIGNAL_RW|SIGNAL_ENABLE|SIGNAL_ENABLE2|SIGNAL_GPO, 0); } else { drv_generic_parport_data (0); } // set direction: write drv_generic_parport_direction (0); // initialize *both* displays if (Bits==8) { drv_HD_command (allControllers, 0x30, T_INIT1); // 8 Bit mode, wait 4.1 ms drv_HD_command (allControllers, 0x30, T_INIT2); // 8 Bit mode, wait 100 us drv_HD_command (allControllers, 0x38, T_EXEC); // 8 Bit mode, 1/16 duty cycle, 5x8 font } else { drv_HD_nibble (allControllers, 0x03); udelay(T_INIT1); // 4 Bit mode, wait 4.1 ms drv_HD_nibble (allControllers, 0x03); udelay(T_INIT2); // 4 Bit mode, wait 100 us drv_HD_nibble (allControllers, 0x03); udelay(T_INIT1); // 4 Bit mode, wait 4.1 ms drv_HD_nibble (allControllers, 0x02); udelay(T_INIT2); // 4 Bit mode, wait 100 us drv_HD_command (allControllers, 0x28, T_EXEC); // 4 Bit mode, 1/16 duty cycle, 5x8 font } drv_HD_command (allControllers, 0x08, T_EXEC); // Display off, cursor off, blink off drv_HD_command (allControllers, 0x0c, T_CLEAR); // Display on, cursor off, blink off, wait 1.64 ms drv_HD_command (allControllers, 0x06, T_EXEC); // curser moves to right, no shift // maybe use busy-flag from now on // (we can't use the busy flag during the init sequence) cfg_number(section, "UseBusy", 0, 0, 1, &UseBusy); // make sure we don't use the busy flag with RW wired to GND if (UseBusy && !SIGNAL_RW) { error("%s: Busyflag is to be used, but RW is wired to GND", Name); UseBusy=0; } // make sure the display supports busy-flag checking in 4-Bit-Mode // at the moment this is inly possible with Martin Hejl's gpio driver, // which allows to use 4 bits as input and 4 bits as output if (UseBusy && Bits==4 && !(Capabilities&CAP_BUSY4BIT)) { error("%s: Model '%s' does not support busy-flag checking in 4-bit-mode", Name, Models[Model].name); UseBusy=0; } info("%s: %susing busy-flag checking", Name, UseBusy?"":"not "); drv_HD_command (allControllers, 0x01, T_CLEAR); // clear *both* displays drv_HD_command (allControllers, 0x03, T_CLEAR); // return home // maybe set brightness if (Capabilities & CAP_BRIGHTNESS) { int brightness; if (cfg_number(section, "Brightness", 0, 0, 3, &brightness)==0) { drv_HD_brightness(brightness); } } return 0; } // **************************************** // *** plugins *** // **************************************** static void plugin_brightness (RESULT *result, RESULT *arg1) { double brightness; brightness=drv_HD_brightness(R2N(arg1)); SetResult(&result, R_NUMBER, &brightness); } // **************************************** // *** widget callbacks *** // **************************************** // using drv_generic_text_draw(W) // using drv_generic_text_icon_draw(W) // using drv_generic_text_bar_draw(W) // **************************************** // *** exported functions *** // **************************************** // list models int drv_HD_list (void) { int i; for (i=0; Models[i].type!=0xff; i++) { printf ("%s ", Models[i].name); } return 0; } // initialize driver & display int drv_HD_init (char *section) { WIDGET_CLASS wc; int asc255bug; int ret; // display preferences XRES = 5; // pixel width of one char YRES = 8; // pixel height of one char CHARS = 8; // number of user-defineable characters CHAR0 = 0; // ASCII of first user-defineable char GOTO_COST = 2; // number of bytes a goto command requires // real worker functions drv_generic_text_real_write = drv_HD_write; drv_generic_text_real_goto = drv_HD_goto; drv_generic_text_real_defchar = drv_HD_defchar; // start display if ((ret=drv_HD_start (section))!=0) return ret; // initialize generic text driver if ((ret=drv_generic_text_init(section, Name))!=0) return ret; // initialize generic icon driver if ((ret=drv_generic_text_icon_init())!=0) return ret; // initialize generic bar driver if ((ret=drv_generic_text_bar_init())!=0) return ret; // add fixed chars to the bar driver // most displays have a full block on ascii 255, but some have kind of // an 'inverted P'. If you specify 'asc255bug 1 in the config, this // char will not be used, but rendered by the bar driver cfg_number(section, "asc255bug", 0, 0, 1, &asc255bug); drv_generic_text_bar_add_segment ( 0, 0,255, 32); // ASCII 32 = blank if (!asc255bug) drv_generic_text_bar_add_segment (255,255,255,255); // ASCII 255 = block // register text widget wc=Widget_Text; wc.draw=drv_generic_text_draw; widget_register(&wc); // register icon widget wc=Widget_Icon; wc.draw=drv_generic_text_icon_draw; widget_register(&wc); // register bar widget wc=Widget_Bar; wc.draw=drv_generic_text_bar_draw; widget_register(&wc); // register plugins if (Capabilities & CAP_BRIGHTNESS) AddFunction ("brightness", 1, plugin_brightness); return 0; } // close driver & display int drv_HD_quit (void) { info("%s: shutting down.", Name); drv_generic_parport_close(); drv_generic_text_quit(); return (0); } DRIVER drv_HD44780 = { name: Name, list: drv_HD_list, init: drv_HD_init, quit: drv_HD_quit, };
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-11 04:11:32 +0000