OpenCores
URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk

Subversion Repositories or1k_old

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /or1k_old/trunk/rc203soc/sw/uClinux/include/asm-m68k
    from Rev 1765 to Rev 1782
    ↔ Reverse comparison
  •

Rev 1765 → Rev 1782

/traps.h
0,0 → 1,241
/*
* linux/include/asm/traps.h
*
* Copyright (C) 1993 Hamish Macdonald
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of this archive
* for more details.
*/
 
#ifndef _M68K_TRAPS_H
#define _M68K_TRAPS_H
 
typedef void (*e_vector)(void);
 
extern e_vector vectors[];
 
#define VEC_BUSERR (2)
#define VEC_ADDRERR (3)
#define VEC_ILLEGAL (4)
#define VEC_ZERODIV (5)
#define VEC_CHK (6)
#define VEC_TRAP (7)
#define VEC_PRIV (8)
#define VEC_TRACE (9)
#define VEC_LINE10 (10)
#define VEC_LINE11 (11)
#define VEC_RESV1 (12)
#define VEC_COPROC (13)
#define VEC_FORMAT (14)
#define VEC_UNINT (15)
#define VEC_SPUR (24)
#define VEC_INT1 (25)
#define VEC_INT2 (26)
#define VEC_INT3 (27)
#define VEC_INT4 (28)
#define VEC_INT5 (29)
#define VEC_INT6 (30)
#define VEC_INT7 (31)
#define VEC_SYS (32)
#define VEC_TRAP1 (33)
#define VEC_TRAP2 (34)
#define VEC_TRAP3 (35)
#define VEC_TRAP4 (36)
#define VEC_TRAP5 (37)
#define VEC_TRAP6 (38)
#define VEC_TRAP7 (39)
#define VEC_TRAP8 (40)
#define VEC_TRAP9 (41)
#define VEC_TRAP10 (42)
#define VEC_TRAP11 (43)
#define VEC_TRAP12 (44)
#define VEC_TRAP13 (45)
#define VEC_TRAP14 (46)
#define VEC_TRAP15 (47)
#define VEC_FPBRUC (48)
#define VEC_FPIR (49)
#define VEC_FPDIVZ (50)
#define VEC_FPUNDER (51)
#define VEC_FPOE (52)
#define VEC_FPOVER (53)
#define VEC_FPNAN (54)
#define VEC_FPUNSUP (55)
#define VEC_UNIMPEA (60)
#define VEC_UNIMPII (61)
 
#define VECOFF(vec) ((vec)<<2)
 
/* Status register bits */
#define PS_T (0x8000)
#define PS_S (0x2000)
#define PS_M (0x1000)
#define PS_C (0x0001)
 
/* bits for 68020/68030 special status word */
 
#define FC (0x8000)
#define FB (0x4000)
#define RC (0x2000)
#define RB (0x1000)
#define DF (0x0100)
#define RM (0x0080)
#define RW (0x0040)
#define SZ (0x0030)
#define DFC (0x0007)
 
/* bits for 68030 MMU status register (mmusr,psr) */
 
#define MMU_B (0x8000) /* bus error */
#define MMU_L (0x4000) /* limit violation */
#define MMU_S (0x2000) /* supervisor violation */
#define MMU_WP (0x0800) /* write-protected */
#define MMU_I (0x0400) /* invalid descriptor */
#define MMU_M (0x0200) /* ATC entry modified */
#define MMU_T (0x0040) /* transparent translation */
#define MMU_NUM (0x0007) /* number of levels traversed */
 
 
/* bits for 68040 special status word */
#define CP_040 (0x8000)
#define CU_040 (0x4000)
#define CT_040 (0x2000)
#define CM_040 (0x1000)
#define MA_040 (0x0800)
#define ATC_040 (0x0400)
#define LK_040 (0x0200)
#define RW_040 (0x0100)
#define SIZ_040 (0x0060)
#define TT_040 (0x0018)
#define TM_040 (0x0007)
 
/* bits for 68040 write back status word */
#define WBV_040 (0x80)
#define WBSIZ_040 (0x60)
#define WBBYT_040 (0x20)
#define WBWRD_040 (0x40)
#define WBLNG_040 (0x00)
#define WBTT_040 (0x18)
#define WBTM_040 (0x07)
 
/* bus access size codes */
#define BA_SIZE_BYTE (0x20)
#define BA_SIZE_WORD (0x40)
#define BA_SIZE_LONG (0x00)
#define BA_SIZE_LINE (0x60)
 
/* bus access transfer type codes */
#define BA_TT_MOVE16 (0x08)
 
/* bits for 68040 MMU status register (mmusr) */
#define MMU_B_040 (0x0800)
#define MMU_G_040 (0x0400)
#define MMU_S_040 (0x0080)
#define MMU_CM_040 (0x0060)
#define MMU_M_040 (0x0010)
#define MMU_WP_040 (0x0004)
#define MMU_T_040 (0x0002)
#define MMU_R_040 (0x0001)
 
/* bits in the 68060 fault status long word (FSLW) */
#define MMU060_MA (0x08000000) /* misaligned */
#define MMU060_LK (0x02000000) /* locked transfer */
#define MMU060_RW (0x01800000) /* read/write */
# define MMU060_RW_W (0x00800000) /* write */
# define MMU060_RW_R (0x01000000) /* read */
# define MMU060_RW_RMW (0x01800000) /* read/modify/write */
# define MMU060_W (0x00800000) /* general write, includes rmw */
#define MMU060_SIZ (0x00600000) /* transfer size */
#define MMU060_TT (0x00180000) /* transfer type (TT) bits */
#define MMU060_TM (0x00070000) /* transfer modifier (TM) bits */
#define MMU060_IO (0x00008000) /* instruction or operand */
#define MMU060_PBE (0x00004000) /* push buffer bus error */
#define MMU060_SBE (0x00002000) /* store buffer bus error */
#define MMU060_PTA (0x00001000) /* pointer A fault */
#define MMU060_PTB (0x00000800) /* pointer B fault */
#define MMU060_IL (0x00000400) /* double indirect descr fault */
#define MMU060_PF (0x00000200) /* page fault (invalid descr) */
#define MMU060_SP (0x00000100) /* supervisor protection */
#define MMU060_WP (0x00000080) /* write protection */
#define MMU060_TWE (0x00000040) /* bus error on table search */
#define MMU060_RE (0x00000020) /* bus error on read */
#define MMU060_WE (0x00000010) /* bus error on write */
#define MMU060_TTR (0x00000008) /* error caused by TTR translation */
#define MMU060_BPE (0x00000004) /* branch prediction error */
#define MMU060_SEE (0x00000001) /* software emulated error */
 
/* cases of missing or invalid descriptors */
#define MMU060_DESC_ERR (MMU060_TWE | MMU060_PTA | MMU060_PTB | \
MMU060_IL | MMU060_PF)
/* bits that indicate real errors */
#define MMU060_ERR_BITS (MMU060_PBE | MMU060_SBE | MMU060_DESC_ERR | \
MMU060_SP | MMU060_WP | MMU060_RE | \
MMU060_WE)
 
/* structure for stack frames */
 
struct frame {
struct pt_regs ptregs;
union {
struct {
unsigned long iaddr; /* instruction address */
} fmt2;
struct {
unsigned long effaddr; /* effective address */
} fmt3;
struct {
unsigned long effaddr; /* effective address */
unsigned long pc; /* pc of faulted instr */
} fmt4;
struct {
unsigned long effaddr; /* effective address */
unsigned short ssw; /* special status word */
unsigned short wb3s; /* write back 3 status */
unsigned short wb2s; /* write back 2 status */
unsigned short wb1s; /* write back 1 status */
unsigned long faddr; /* fault address */
unsigned long wb3a; /* write back 3 address */
unsigned long wb3d; /* write back 3 data */
unsigned long wb2a; /* write back 2 address */
unsigned long wb2d; /* write back 2 data */
unsigned long wb1a; /* write back 1 address */
unsigned long wb1dpd0; /* write back 1 data/push data 0*/
unsigned long pd1; /* push data 1*/
unsigned long pd2; /* push data 2*/
unsigned long pd3; /* push data 3*/
} fmt7;
struct {
unsigned long iaddr; /* instruction address */
unsigned short int1[4]; /* internal registers */
} fmt9;
struct {
unsigned short int1;
unsigned short ssw; /* special status word */
unsigned short isc; /* instruction stage c */
unsigned short isb; /* instruction stage b */
unsigned long daddr; /* data cycle fault address */
unsigned short int2[2];
unsigned long dobuf; /* data cycle output buffer */
unsigned short int3[2];
} fmta;
struct {
unsigned short int1;
unsigned short ssw; /* special status word */
unsigned short isc; /* instruction stage c */
unsigned short isb; /* instruction stage b */
unsigned long daddr; /* data cycle fault address */
unsigned short int2[2];
unsigned long dobuf; /* data cycle output buffer */
unsigned short int3[4];
unsigned long baddr; /* stage B address */
unsigned short int4[2];
unsigned long dibuf; /* data cycle input buffer */
unsigned short int5[3];
unsigned ver : 4; /* stack frame version # */
unsigned int6:12;
unsigned short int7[18];
} fmtb;
} un;
};
 
#endif /* _M68K_TRAPS_H */
/byteorder.h
0,0 → 1,14
#ifndef _M68K_BYTEORDER_H
#define _M68K_BYTEORDER_H
 
#ifdef __KERNEL__
#define __BIG_ENDIAN
#endif
#define __BIG_ENDIAN_BITFIELD
 
#define ntohl(x) x
#define ntohs(x) x
#define htonl(x) x
#define htons(x) x
 
#endif
/atarihw.h
0,0 → 1,633
/*
** linux/atarihw.h -- This header defines some macros and pointers for
** the various Atari custom hardware registers.
**
 
**
** 5/1/94 Roman Hodek:
** Added definitions for TT specific chips.
**
** This file is subject to the terms and conditions of the GNU General Public
** License. See the file COPYING in the main directory of this archive
** for more details.
**
*/
 
#ifndef _LINUX_ATARIHW_H_
#define _LINUX_ATARIHW_H_
 
#include <linux/types.h>
 
/* Reading the MFP port register gives a machine independent delay, since the
* MFP always has a 8 MHz clock. This avoids problems with the varying length
* of nops on various machines. Somebody claimed that the tstb takes 600 ns.
*/
#define MFPDELAY() \
__asm__ __volatile__ ( "tstb %0" : : "m" (mfp.par_dt_reg) : "cc" );
 
/* Memory used for screen ram and stdma buffers */
void atari_stram_init (void);
void *atari_stram_alloc (long size, unsigned long *start_mem );
void atari_stram_free (void *);
 
extern int is_medusa;
 
/* Do cache push/invalidate for DMA read/write. This function obeys the
* snooping on some machines (Medusa) and processors: The Medusa itself can
* snoop, but only the '040 can source data from its cache to DMA writes i.e.,
* reads from memory). Both '040 and '060 invalidate cache entries on snooped
* DMA reads (i.e., writes to memory).
*/
 
#include <linux/mm.h>
#include <asm/pgtable.h>
 
static inline void dma_cache_maintenance( unsigned long paddr,
unsigned long len,
int writeflag )
 
{
if (writeflag) {
if (!is_medusa || m68k_is040or060 == 6)
cache_push( paddr, len );
}
else {
if (!is_medusa)
cache_clear( paddr, len );
}
}
 
 
/*
** Shifter
*/
#define ST_LOW 0
#define ST_MID 1
#define ST_HIGH 2
#define TT_LOW 7
#define TT_MID 4
#define TT_HIGH 6
 
#define SHF_BAS (0xffff8200)
struct SHIFTER
{
u_char pad1;
u_char bas_hi;
u_char pad2;
u_char bas_md;
u_char pad3;
u_char volatile vcounthi;
u_char pad4;
u_char volatile vcountmid;
u_char pad5;
u_char volatile vcountlow;
u_char volatile syncmode;
u_char pad6;
u_char pad7;
u_char bas_lo;
};
# define shifter ((*(volatile struct SHIFTER *)SHF_BAS))
 
#define SHF_FBAS (0xffff820e)
struct SHIFTER_F030
{
u_short off_next;
u_short scn_width;
};
# define shifter_f030 ((*(volatile struct SHIFTER_F030 *)SHF_FBAS))
 
 
#define SHF_TBAS (0xffff8200)
struct SHIFTER_TT {
u_char char_dummy0;
u_char bas_hi; /* video mem base addr, high and mid byte */
u_char char_dummy1;
u_char bas_md;
u_char char_dummy2;
u_char vcount_hi; /* pointer to currently displayed byte */
u_char char_dummy3;
u_char vcount_md;
u_char char_dummy4;
u_char vcount_lo;
u_short st_sync; /* ST compatible sync mode register, unused */
u_char char_dummy5;
u_char bas_lo; /* video mem addr, low byte */
u_char char_dummy6[2+3*16];
/* $ffff8240: */
u_short color_reg[16]; /* 16 color registers */
u_char st_shiftmode; /* ST compatible shift mode register, unused */
u_char char_dummy7;
u_short tt_shiftmode; /* TT shift mode register */
 
 
};
#define shifter_tt ((*(volatile struct SHIFTER_TT *)SHF_TBAS))
 
/* values for shifter_tt->tt_shiftmode */
#define TT_SHIFTER_STLOW 0x0000
#define TT_SHIFTER_STMID 0x0100
#define TT_SHIFTER_STHIGH 0x0200
#define TT_SHIFTER_TTLOW 0x0700
#define TT_SHIFTER_TTMID 0x0400
#define TT_SHIFTER_TTHIGH 0x0600
#define TT_SHIFTER_MODEMASK 0x0700
#define TT_SHIFTER_NUMMODE 0x0008
#define TT_SHIFTER_PALETTE_MASK 0x000f
#define TT_SHIFTER_GRAYMODE 0x1000
 
/* 256 TT palette registers */
#define TT_PALETTE_BASE (0xffff8400)
#define tt_palette ((volatile u_short *)TT_PALETTE_BASE)
 
#define TT_PALETTE_RED_MASK 0x0f00
#define TT_PALETTE_GREEN_MASK 0x00f0
#define TT_PALETTE_BLUE_MASK 0x000f
 
/*
** Falcon030 VIDEL Video Controller
** for description see File 'linux\tools\atari\hardware.txt
*/
#define f030_col ((u_long *) 0xffff9800)
#define f030_xreg ((u_short*) 0xffff8282)
#define f030_yreg ((u_short*) 0xffff82a2)
#define f030_creg ((u_short*) 0xffff82c0)
#define f030_sreg ((u_short*) 0xffff8260)
#define f030_mreg ((u_short*) 0xffff820a)
#define f030_linewidth ((u_short*) 0xffff820e)
#define f030_hscroll ((u_char*) 0xffff8265)
 
#define VIDEL_BAS (0xffff8260)
struct VIDEL {
u_short st_shift;
u_short pad1;
u_char xoffset_s;
u_char xoffset;
u_short f_shift;
u_char pad2[0x1a];
u_short hht;
u_short hbb;
u_short hbe;
u_short hdb;
u_short hde;
u_short hss;
u_char pad3[0x14];
u_short vft;
u_short vbb;
u_short vbe;
u_short vdb;
u_short vde;
u_short vss;
u_char pad4[0x12];
u_short control;
u_short mode;
};
#define videl ((*(volatile struct VIDEL *)VIDEL_BAS))
 
/*
** DMA/WD1772 Disk Controller
*/
#define FWD_BAS (0xffff8604)
struct DMA_WD
{
u_short fdc_acces_seccount;
u_short dma_mode_status;
u_char dma_vhi; /* Some extended ST-DMAs can handle 32 bit addresses */
u_char dma_hi;
u_char char_dummy2;
u_char dma_md;
u_char char_dummy3;
u_char dma_lo;
u_short fdc_speed;
};
# define dma_wd ((*(volatile struct DMA_WD *)FWD_BAS))
/* alias */
#define st_dma dma_wd
/* The two highest bytes of an extended DMA as a short; this is a must
* for the Medusa.
*/
#define st_dma_ext_dmahi (*((volatile unsigned short *)0xffff8608))
 
/*
** YM2149 Sound Chip
** access in bytes
*/
 
#define YM_BAS (0xffff8800)
struct SOUND_YM
{
u_char rd_data_reg_sel;
u_char char_dummy1;
u_char wd_data;
};
#define sound_ym ((*(volatile struct SOUND_YM *)YM_BAS))
 
/* TT SCSI DMA */
 
#define TT_SCSI_DMA_BAS (0xffff8700)
struct TT_DMA {
u_char char_dummy0;
u_char dma_addr_hi;
u_char char_dummy1;
u_char dma_addr_hmd;
u_char char_dummy2;
u_char dma_addr_lmd;
u_char char_dummy3;
u_char dma_addr_lo;
u_char char_dummy4;
u_char dma_cnt_hi;
u_char char_dummy5;
u_char dma_cnt_hmd;
u_char char_dummy6;
u_char dma_cnt_lmd;
u_char char_dummy7;
u_char dma_cnt_lo;
u_long dma_restdata;
u_short dma_ctrl;
};
#define tt_scsi_dma ((*(volatile struct TT_DMA *)TT_SCSI_DMA_BAS))
 
/* TT SCSI Controller 5380 */
 
#define TT_5380_BAS (0xffff8781)
struct TT_5380 {
u_char scsi_data;
u_char char_dummy1;
u_char scsi_icr;
u_char char_dummy2;
u_char scsi_mode;
u_char char_dummy3;
u_char scsi_tcr;
u_char char_dummy4;
u_char scsi_idstat;
u_char char_dummy5;
u_char scsi_dmastat;
u_char char_dummy6;
u_char scsi_targrcv;
u_char char_dummy7;
u_char scsi_inircv;
};
#define tt_scsi ((*(volatile struct TT_5380 *)TT_5380_BAS))
#define tt_scsi_regp ((volatile char *)TT_5380_BAS)
 
 
/*
** Falcon DMA Sound Subsystem
** not implemented yet
*/
 
/*
** Falcon Blitter
*/
 
#define BLT_BAS (0xffff8a00)
 
struct BLITTER
{
u_short halftone[16];
u_short src_x_inc;
u_short src_y_inc;
u_long src_address;
u_short endmask1;
u_short endmask2;
u_short endmask3;
u_short dst_x_inc;
u_short dst_y_inc;
u_long dst_address;
u_short wd_per_line;
u_short ln_per_bb;
u_short hlf_op_reg;
u_short log_op_reg;
u_short lin_nm_reg;
u_short skew_reg;
};
# define blitter ((*(volatile struct BLITTER *)BLT_BAS))
 
 
/*
** SCC Z8530
*/
#define SCC_BAS (0xffff8c81)
struct SCC
{
u_char cha_a_ctrl;
u_char char_dummy1;
u_char cha_a_data;
u_char char_dummy2;
u_char cha_b_ctrl;
u_char char_dummy3;
u_char cha_b_data;
};
# define scc ((*(volatile struct SCC*)SCC_BAS))
 
/* The ESCC (Z85230) in an Atari ST. The channels are revered! */
# define st_escc ((*(volatile struct SCC*)0xfffffa31))
# define st_escc_dsr ((*(volatile char *)0xfffffa39))
 
/* TT SCC DMA Controller (same chip as SCSI DMA) */
 
#define TT_SCC_DMA_BAS (0xffff8c01)
#define tt_scc_dma ((*(volatile struct TT_DMA *)TT_SCC_DMA_BAS))
 
/*
** VIDEL Palette Register
*/
 
#define FPL_BAS (0xffff9800)
struct VIDEL_PALETTE
{
u_long reg[256];
};
# define videl_palette ((*(volatile struct VIDEL_PALETTE*)FPL_BAS))
 
 
/*
** Falcon DSP Host Interface
** not implemented yet
*/
/*
** MFP 68901
*/
#define MFP_BAS (0xfffffa01)
struct MFP
{
u_char par_dt_reg;
u_char char_dummy1;
u_char active_edge;
u_char char_dummy2;
u_char data_dir;
u_char char_dummy3;
u_char int_en_a;
u_char char_dummy4;
u_char int_en_b;
u_char char_dummy5;
u_char int_pn_a;
u_char char_dummy6;
u_char int_pn_b;
u_char char_dummy7;
u_char int_sv_a;
u_char char_dummy8;
u_char int_sv_b;
u_char char_dummy9;
u_char int_mk_a;
u_char char_dummy10;
u_char int_mk_b;
u_char char_dummy11;
u_char vec_adr;
u_char char_dummy12;
u_char tim_ct_a;
u_char char_dummy13;
u_char tim_ct_b;
u_char char_dummy14;
u_char tim_ct_cd;
u_char char_dummy15;
u_char tim_dt_a;
u_char char_dummy16;
u_char tim_dt_b;
u_char char_dummy17;
u_char tim_dt_c;
u_char char_dummy18;
u_char tim_dt_d;
u_char char_dummy19;
u_char sync_char;
u_char char_dummy20;
u_char usart_ctr;
u_char char_dummy21;
u_char rcv_stat;
u_char char_dummy22;
u_char trn_stat;
u_char char_dummy23;
u_char usart_dta;
};
# define mfp ((*(volatile struct MFP*)MFP_BAS))
 
/* TT's second MFP */
 
#define TT_MFP_BAS (0xfffffa81)
# define tt_mfp ((*(volatile struct MFP*)TT_MFP_BAS))
 
 
/* TT System Control Unit */
 
#define TT_SCU_BAS (0xffff8e01)
struct TT_SCU {
u_char sys_mask;
u_char char_dummy1;
u_char sys_stat;
u_char char_dummy2;
u_char softint;
u_char char_dummy3;
u_char vmeint;
u_char char_dummy4;
u_char gp_reg1;
u_char char_dummy5;
u_char gp_reg2;
u_char char_dummy6;
u_char vme_mask;
u_char char_dummy7;
u_char vme_stat;
};
#define tt_scu ((*(volatile struct TT_SCU *)TT_SCU_BAS))
 
/* TT real time clock */
 
#define TT_RTC_BAS (0xffff8961)
struct TT_RTC {
u_char regsel;
u_char dummy;
u_char data;
};
#define tt_rtc ((*(volatile struct TT_RTC *)TT_RTC_BAS))
 
 
/*
** ACIA 6850
*/
/* constants for the ACIA registers */
 
/* baudrate selection and reset (Baudrate = clock/factor) */
#define ACIA_DIV1 0
#define ACIA_DIV16 1
#define ACIA_DIV64 2
#define ACIA_RESET 3
 
/* character format */
#define ACIA_D7E2S (0<<2) /* 7 data, even parity, 2 stop */
#define ACIA_D7O2S (1<<2) /* 7 data, odd parity, 2 stop */
#define ACIA_D7E1S (2<<2) /* 7 data, even parity, 1 stop */
#define ACIA_D7O1S (3<<2) /* 7 data, odd parity, 1 stop */
#define ACIA_D8N2S (4<<2) /* 8 data, no parity, 2 stop */
#define ACIA_D8N1S (5<<2) /* 8 data, no parity, 1 stop */
#define ACIA_D8E1S (6<<2) /* 8 data, even parity, 1 stop */
#define ACIA_D8O1S (7<<2) /* 8 data, odd parity, 1 stop */
 
/* transmit control */
#define ACIA_RLTID (0<<5) /* RTS low, TxINT disabled */
#define ACIA_RLTIE (1<<5) /* RTS low, TxINT enabled */
#define ACIA_RHTID (2<<5) /* RTS high, TxINT disabled */
#define ACIA_RLTIDSB (3<<5) /* RTS low, TxINT disabled, send break */
 
/* receive control */
#define ACIA_RID (0<<7) /* RxINT disabled */
#define ACIA_RIE (1<<7) /* RxINT enabled */
 
/* status fields of the ACIA */
#define ACIA_RDRF 1 /* Receive Data Register Full */
#define ACIA_TDRE (1<<1) /* Transmit Data Register Empty */
#define ACIA_DCD (1<<2) /* Data Carrier Detect */
#define ACIA_CTS (1<<3) /* Clear To Send */
#define ACIA_FE (1<<4) /* Framing Error */
#define ACIA_OVRN (1<<5) /* Receiver Overrun */
#define ACIA_PE (1<<6) /* Parity Error */
#define ACIA_IRQ (1<<7) /* Interrupt Request */
 
#define ACIA_BAS (0xfffffc00)
struct ACIA
{
u_char key_ctrl;
u_char char_dummy1;
u_char key_data;
u_char char_dummy2;
u_char mid_ctrl;
u_char char_dummy3;
u_char mid_data;
};
# define acia ((*(volatile struct ACIA*)ACIA_BAS))
 
#define TT_DMASND_BAS (0xffff8900)
struct TT_DMASND {
u_char int_ctrl; /* Falcon: Interrupt control */
u_char ctrl;
u_char pad2;
u_char bas_hi;
u_char pad3;
u_char bas_mid;
u_char pad4;
u_char bas_low;
u_char pad5;
u_char addr_hi;
u_char pad6;
u_char addr_mid;
u_char pad7;
u_char addr_low;
u_char pad8;
u_char end_hi;
u_char pad9;
u_char end_mid;
u_char pad10;
u_char end_low;
u_char pad11[12];
u_char track_select; /* Falcon */
u_char mode;
u_char pad12[14];
/* Falcon only: */
u_short cbar_src;
u_short cbar_dst;
u_char ext_div;
u_char int_div;
u_char rec_track_select;
u_char dac_src;
u_char adc_src;
u_char input_gain;
u_short output_atten;
};
# define tt_dmasnd ((*(volatile struct TT_DMASND *)TT_DMASND_BAS))
 
#define DMASND_CTRL_OFF 0x00
#define DMASND_CTRL_ON 0x01
#define DMASND_CTRL_REPEAT 0x02
#define DMASND_MODE_MONO 0x80
#define DMASND_MODE_STEREO 0x00
#define DMASND_MODE_8BIT 0x00
#define DMASND_MODE_16BIT 0x40 /* Falcon only */
#define DMASND_MODE_6KHZ 0x00 /* Falcon: mute */
#define DMASND_MODE_12KHZ 0x01
#define DMASND_MODE_25KHZ 0x02
#define DMASND_MODE_50KHZ 0x03
 
#define DMASNDSetBase(bufstart) \
do { \
tt_dmasnd.bas_hi = (unsigned char)(((bufstart) & 0xff0000) >> 16); \
tt_dmasnd.bas_mid = (unsigned char)(((bufstart) & 0x00ff00) >> 8); \
tt_dmasnd.bas_low = (unsigned char) ((bufstart) & 0x0000ff); \
} while( 0 )
 
#define DMASNDGetAdr() ((tt_dmasnd.addr_hi << 16) + \
(tt_dmasnd.addr_mid << 8) + \
(tt_dmasnd.addr_low))
 
#define DMASNDSetEnd(bufend) \
do { \
tt_dmasnd.end_hi = (unsigned char)(((bufend) & 0xff0000) >> 16); \
tt_dmasnd.end_mid = (unsigned char)(((bufend) & 0x00ff00) >> 8); \
tt_dmasnd.end_low = (unsigned char) ((bufend) & 0x0000ff); \
} while( 0 )
 
 
#define TT_MICROWIRE_BAS (0xffff8922)
struct TT_MICROWIRE {
u_short data;
u_short mask;
};
# define tt_microwire ((*(volatile struct TT_MICROWIRE *)TT_MICROWIRE_BAS))
 
#define MW_LM1992_ADDR 0x0400
 
#define MW_LM1992_VOLUME(dB) \
(0x0c0 | ((dB) < -80 ? 0 : (dB) > 0 ? 40 : (((dB) + 80) / 2)))
#define MW_LM1992_BALLEFT(dB) \
(0x140 | ((dB) < -40 ? 0 : (dB) > 0 ? 20 : (((dB) + 40) / 2)))
#define MW_LM1992_BALRIGHT(dB) \
(0x100 | ((dB) < -40 ? 0 : (dB) > 0 ? 20 : (((dB) + 40) / 2)))
#define MW_LM1992_TREBLE(dB) \
(0x080 | ((dB) < -12 ? 0 : (dB) > 12 ? 12 : (((dB) / 2) + 6)))
#define MW_LM1992_BASS(dB) \
(0x040 | ((dB) < -12 ? 0 : (dB) > 12 ? 12 : (((dB) / 2) + 6)))
 
#define MW_LM1992_PSG_LOW 0x000
#define MW_LM1992_PSG_HIGH 0x001
#define MW_LM1992_PSG_OFF 0x002
 
#define MSTE_RTC_BAS (0xfffffc21)
 
struct MSTE_RTC {
u_char sec_ones;
u_char dummy1;
u_char sec_tens;
u_char dummy2;
u_char min_ones;
u_char dummy3;
u_char min_tens;
u_char dummy4;
u_char hr_ones;
u_char dummy5;
u_char hr_tens;
u_char dummy6;
u_char weekday;
u_char dummy7;
u_char day_ones;
u_char dummy8;
u_char day_tens;
u_char dummy9;
u_char mon_ones;
u_char dummy10;
u_char mon_tens;
u_char dummy11;
u_char year_ones;
u_char dummy12;
u_char year_tens;
u_char dummy13;
u_char mode;
u_char dummy14;
u_char test;
u_char dummy15;
u_char reset;
};
 
#define mste_rtc ((*(volatile struct MSTE_RTC *)MSTE_RTC_BAS))
 
#endif /* linux/atarihw.h */
 
/unaligned.h
0,0 → 1,16
#ifndef __M68K_UNALIGNED_H
#define __M68K_UNALIGNED_H
 
/*
* The m68k can do unaligned accesses itself.
*
* The strange macros are there to make sure these can't
* be misused in a way that makes them not work on other
* architectures where unaligned accesses aren't as simple.
*/
 
#define get_unaligned(ptr) (*(ptr))
 
#define put_unaligned(val, ptr) ((void)( *(ptr) = (val) ))
 
#endif
/elf.h
0,0 → 1,62
#ifndef __ASMm68k_ELF_H
#define __ASMm68k_ELF_H
 
/*
* ELF register definitions..
*/
 
#include <asm/ptrace.h>
 
typedef unsigned long elf_greg_t;
 
#define ELF_NGREG 20 /* d1-d7/a0-a6/d0/usp/orig_d0/sr/pc/fmtvec */
typedef elf_greg_t elf_gregset_t[ELF_NGREG];
 
typedef struct user_m68kfp_struct elf_fpregset_t;
 
/*
* This is used to ensure we don't load something for the wrong architecture.
*/
#define elf_check_arch(x) ((x) == EM_68K)
 
/*
* These are used to set parameters in the core dumps.
*/
#define ELF_CLASS ELFCLASS32
#define ELF_DATA ELFDATA2MSB;
#define ELF_ARCH EM_68K
 
/* For SVR4/m68k the function pointer to be registered with
`atexit' is passed in %a1. Although my copy of the ABI has
no such statement, it is actually used on ASV. */
#define ELF_PLAT_INIT(_r) _r->a1 = 0
 
#define USE_ELF_CORE_DUMP
#define ELF_EXEC_PAGESIZE 4096
 
#define ELF_CORE_COPY_REGS(pr_reg, regs) \
/* Bleech. */ \
pr_reg[0] = regs->d1; \
pr_reg[1] = regs->d2; \
pr_reg[2] = regs->d3; \
pr_reg[3] = regs->d4; \
pr_reg[4] = regs->d5; \
pr_reg[7] = regs->a0; \
pr_reg[8] = regs->a1; \
pr_reg[14] = regs->d0; \
pr_reg[15] = rdusp(); \
pr_reg[16] = 0; /* orig_d0 */ \
pr_reg[17] = regs->sr; \
pr_reg[18] = regs->pc; \
{ \
struct switch_stack *sw = ((struct switch_stack *)regs) - 1; \
pr_reg[5] = sw->d6; \
pr_reg[6] = sw->d7; \
pr_reg[9] = sw->a2; \
pr_reg[10] = sw->a3; \
pr_reg[11] = sw->a4; \
pr_reg[12] = sw->a5; \
pr_reg[13] = sw->a6; \
}
 
#endif
/font.h
0,0 → 1,35
/*
* asm-m68k/font.h -- `Soft' font definitions
*
* Created 1995 by Geert Uytterhoeven
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of this archive
* for more details.
*/
 
#ifndef _ASM_M68K_FONT_H_
#define _ASM_M68K_FONT_H_
 
#include <linux/types.h>
 
 
/*
* Find a font with a specific name
*/
 
extern int findsoftfont(char *name, int *width, int *height, u_char *data[]);
 
 
/*
* Get the default font for a specific screen size
*/
 
extern void getdefaultfont(int xres, int yres, char *name[], int *width,
int *height, u_char *data[]);
 
 
/* Max. length for the name of a predefined font */
#define MAX_FONT_NAME 32
 
#endif /* _ASM_M68K_FONT_H_ */
/atari_mouse.h
0,0 → 1,20
#ifndef _LINUX_ATARI_MOUSE_H
#define _LINUX_ATARI_MOUSE_H
 
/*
* linux/include/linux/atari_mouse.h
* header file for Atari Mouse driver
* by Robert de Vries (robert@and.nl) on 19Jul93
*/
 
struct mouse_status {
char buttons;
short dx;
short dy;
int ready;
int active;
struct wait_queue *wait;
struct fasync_struct *fasyncptr;
};
 
#endif
/ioctl.h
0,0 → 1,80
/* $Id: ioctl.h,v 1.1 2005-12-20 11:40:20 jcastillo Exp $
*
* linux/ioctl.h for Linux by H.H. Bergman.
*/
 
#ifndef _M68K_IOCTL_H
#define _M68K_IOCTL_H
 
/* ioctl command encoding: 32 bits total, command in lower 16 bits,
* size of the parameter structure in the lower 14 bits of the
* upper 16 bits.
* Encoding the size of the parameter structure in the ioctl request
* is useful for catching programs compiled with old versions
* and to avoid overwriting user space outside the user buffer area.
* The highest 2 bits are reserved for indicating the ``access mode''.
* NOTE: This limits the max parameter size to 16kB -1 !
*/
 
/*
* I don't really have any idea about what this should look like, so
* for the time being, this is heavily based on the PC definitions.
*/
 
/*
* The following is for compatibility across the various Linux
* platforms. The i386 ioctl numbering scheme doesn't really enforce
* a type field. De facto, however, the top 8 bits of the lower 16
* bits are indeed used as a type field, so we might just as well make
* this explicit here. Please be sure to use the decoding macros
* below from now on.
*/
#define _IOC_NRBITS 8
#define _IOC_TYPEBITS 8
#define _IOC_SIZEBITS 14
#define _IOC_DIRBITS 2
 
#define _IOC_NRMASK ((1 << _IOC_NRBITS)-1)
#define _IOC_TYPEMASK ((1 << _IOC_TYPEBITS)-1)
#define _IOC_SIZEMASK ((1 << _IOC_SIZEBITS)-1)
#define _IOC_DIRMASK ((1 << _IOC_DIRBITS)-1)
 
#define _IOC_NRSHIFT 0
#define _IOC_TYPESHIFT (_IOC_NRSHIFT+_IOC_NRBITS)
#define _IOC_SIZESHIFT (_IOC_TYPESHIFT+_IOC_TYPEBITS)
#define _IOC_DIRSHIFT (_IOC_SIZESHIFT+_IOC_SIZEBITS)
 
/*
* Direction bits.
*/
#define _IOC_NONE 0U
#define _IOC_WRITE 1U
#define _IOC_READ 2U
 
#define _IOC(dir,type,nr,size) \
(((dir) << _IOC_DIRSHIFT) | \
((type) << _IOC_TYPESHIFT) | \
((nr) << _IOC_NRSHIFT) | \
((size) << _IOC_SIZESHIFT))
 
/* used to create numbers */
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
 
/* used to decode ioctl numbers.. */
#define _IOC_DIR(nr) (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
#define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#define _IOC_NR(nr) (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
#define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
 
/* ...and for the drivers/sound files... */
 
#define IOC_IN (_IOC_WRITE << _IOC_DIRSHIFT)
#define IOC_OUT (_IOC_READ << _IOC_DIRSHIFT)
#define IOC_INOUT ((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
#define IOCSIZE_MASK (_IOC_SIZEMASK << _IOC_SIZESHIFT)
#define IOCSIZE_SHIFT (_IOC_SIZESHIFT)
 
#endif /* _M68K_IOCTL_H */
/user.h
0,0 → 1,72
#ifndef _M68K_USER_H
#define _M68K_USER_H
 
#include <asm/page.h>
#include <linux/ptrace.h>
/* Core file format: The core file is written in such a way that gdb
can understand it and provide useful information to the user (under
linux we use the 'trad-core' bfd). There are quite a number of
obstacles to being able to view the contents of the floating point
registers, and until these are solved you will not be able to view the
contents of them. Actually, you can read in the core file and look at
the contents of the user struct to find out what the floating point
registers contain.
The actual file contents are as follows:
UPAGE: 1 page consisting of a user struct that tells gdb what is present
in the file. Directly after this is a copy of the task_struct, which
is currently not used by gdb, but it may come in useful at some point.
All of the registers are stored as part of the upage. The upage should
always be only one page.
DATA: The data area is stored. We use current->end_text to
current->brk to pick up all of the user variables, plus any memory
that may have been malloced. No attempt is made to determine if a page
is demand-zero or if a page is totally unused, we just cover the entire
range. All of the addresses are rounded in such a way that an integral
number of pages is written.
STACK: We need the stack information in order to get a meaningful
backtrace. We need to write the data from (esp) to
current->start_stack, so we round each of these off in order to be able
to write an integer number of pages.
The minimum core file size is 3 pages, or 12288 bytes.
*/
 
struct user_m68kfp_struct {
unsigned long fpregs[8*3]; /* fp0-fp7 registers */
unsigned long fpcntl[3]; /* fp control regs */
};
 
/* When the kernel dumps core, it starts by dumping the user struct -
this will be used by gdb to figure out where the data and stack segments
are within the file, and what virtual addresses to use. */
struct user{
/* We start with the registers, to mimic the way that "memory" is returned
from the ptrace(3,...) function. */
struct pt_regs regs; /* Where the registers are actually stored */
struct switch_stack regs2; /* Backward compatibility, sort of */
/* ptrace does not yet supply these. Someday.... */
int u_fpvalid; /* True if math co-processor being used. */
/* for this mess. Not yet used. */
struct user_m68kfp_struct m68kfp; /* Math Co-processor registers. */
/* The rest of this junk is to help gdb figure out what goes where */
unsigned long int u_tsize; /* Text segment size (pages). */
unsigned long int u_dsize; /* Data segment size (pages). */
unsigned long int u_ssize; /* Stack segment size (pages). */
unsigned long start_code; /* Starting virtual address of text. */
unsigned long start_stack; /* Starting virtual address of stack area.
This is actually the bottom of the stack,
the top of the stack is always found in the
esp register. */
long int signal; /* Signal that caused the core dump. */
int reserved; /* No longer used */
struct pt_regs * u_ar0; /* Used by gdb to help find the values for */
/* the registers. */
struct user_m68kfp_struct* u_fpstate; /* Math Co-processor pointer. */
unsigned long magic; /* To uniquely identify a core file */
char u_comm[32]; /* User command that was responsible */
};
#define NBPG PAGE_SIZE
#define UPAGES 1
#define HOST_TEXT_START_ADDR (u.start_code)
#define HOST_STACK_END_ADDR (u.start_stack + u.u_ssize * NBPG)
 
#endif
/atari_joystick.h
0,0 → 1,22
#ifndef _LINUX_ATARI_JOYSTICK_H
#define _LINUX_ATARI_JOYSTICK_H
 
/*
* linux/include/linux/atari_joystick.h
* header file for Atari Joystick driver
* by Robert de Vries (robert@and.nl) on 19Jul93
*/
 
void atari_joystick_interrupt(char*);
int atari_joystick_init(void);
extern int atari_mouse_buttons;
 
struct joystick_status {
char fire;
char dir;
int ready;
int active;
struct wait_queue *wait;
};
 
#endif
/a.out.h
0,0 → 1,26
#ifndef __M68K_A_OUT_H__
#define __M68K_A_OUT_H__
 
struct exec
{
unsigned long a_info; /* Use macros N_MAGIC, etc for access */
unsigned a_text; /* length of text, in bytes */
unsigned a_data; /* length of data, in bytes */
unsigned a_bss; /* length of uninitialized data area for file, in bytes */
unsigned a_syms; /* length of symbol table data in file, in bytes */
unsigned a_entry; /* start address */
unsigned a_trsize; /* length of relocation info for text, in bytes */
unsigned a_drsize; /* length of relocation info for data, in bytes */
};
 
#define N_TRSIZE(a) ((a).a_trsize)
#define N_DRSIZE(a) ((a).a_drsize)
#define N_SYMSIZE(a) ((a).a_syms)
 
#ifdef __KERNEL__
 
#define STACK_TOP TASK_SIZE
 
#endif
 
#endif /* __M68K_A_OUT_H__ */
/amigamouse.h
0,0 → 1,26
#ifndef _ASMm68k_AMIGAMOUSE_H
#define _ASMm68k_AMIGAMOUSE_H
 
/*
* linux/include/asm-m68k/amigamouse.h: header file for Amiga Mouse driver
* by Michael Rausch
*/
 
/*
#define MSE_INT_OFF() outb(MSE_DISABLE_INTERRUPTS, MSE_CONTROL_PORT)
#define MSE_INT_ON() outb(MSE_ENABLE_INTERRUPTS, MSE_CONTROL_PORT)
*/
 
struct mouse_status {
unsigned char buttons;
unsigned char latch_buttons;
int dx;
int dy;
int present;
int ready;
int active;
struct wait_queue *wait;
struct fasync_struct *fasyncptr;
};
 
#endif
/irq.h
0,0 → 1,116
#ifndef _M68K_IRQ_H_
#define _M68K_IRQ_H_
 
extern void disable_irq(unsigned int);
extern void enable_irq(unsigned int);
 
#include <linux/config.h>
 
/*
* This should be the same as the max(NUM_X_SOURCES) for all the
* different m68k hosts compiled into the kernel.
* Currently the Atari has 72 and the Amiga 24, but if both are
* supported in the kernel it is better to make room for 72.
*/
#if defined(CONFIG_ATARI)
#define NR_IRQS 72
#else
#define NR_IRQS 24
#endif
 
/*
* Interrupt source definitions
* General interrupt sources are the level 1-7.
* Adding an interrupt service routine for one of these sources
* results in the addition of that routine to a chain of routines.
* Each one is called in succession. Each individual interrupt
* service routine should determine if the device associated with
* that routine requires service.
*/
 
#define IRQ1 (1) /* level 1 interrupt */
#define IRQ2 (2) /* level 2 interrupt */
#define IRQ3 (3) /* level 3 interrupt */
#define IRQ4 (4) /* level 4 interrupt */
#define IRQ5 (5) /* level 5 interrupt */
#define IRQ6 (6) /* level 6 interrupt */
#define IRQ7 (7) /* level 7 interrupt (non-maskable) */
 
/*
* "Generic" interrupt sources
*/
 
#define IRQ_SCHED_TIMER (8) /* interrupt source for scheduling timer */
 
/*
* Machine specific interrupt sources.
*
* Adding an interrupt service routine for a source with this bit
* set indicates a special machine specific interrupt source.
* The machine specific files define these sources.
*/
 
#define IRQ_MACHSPEC (0x10000000L)
 
#ifndef ISRFUNC_T
struct pt_regs;
typedef void (*isrfunc) (int irq, struct pt_regs * regs, void *data);
#define ISRFUNC_T
#endif /* ISRFUNC_T */
 
/*
* This structure is used to chain together the ISRs for a particular
* interrupt source (if it supports chaining).
*/
typedef struct isr_node {
isrfunc isr;
int pri;
void *data;
char *name;
struct isr_node *next;
} isr_node_t;
 
/* count of spurious interrupts */
extern volatile unsigned long num_spurious;
 
/*
* This function returns a new isr_node_t
*/
extern isr_node_t *new_isr_node(void);
 
/*
* This function is used to add a specific interrupt service routine
* for the specified interrupt source.
*
* If the source is machine specific, it will be passed along to the
* machine specific routine.
*
* "data" is user specified data which will be passed to the isr routine.
*
* (isrfunc is defined in linux/config.h)
*/
extern int add_isr (unsigned long source, isrfunc isr, int pri, void
*data, char *name);
 
/*
* This routine will remove an isr for the specified interrupt source.
*/
extern int remove_isr (unsigned long source, isrfunc isr, void *data);
 
/*
* This routine will insert an isr_node_t into a chain of nodes, using
* the priority stored in the node.
*/
extern void insert_isr (isr_node_t **listp, isr_node_t *node);
 
/*
* This routine will delete the isr node for isr from a chain of nodes
*/
extern void delete_isr (isr_node_t **listp, isrfunc isr, void *data);
 
/*
* This routine may be used to call the isr routines in the passed list.
*/
extern void call_isr_list (int irq, isr_node_t *p, struct pt_regs *fp);
 
#endif /* _M68K_IRQ_H_ */
/ioctls.h
0,0 → 1,74
#ifndef __ARCH_M68K_IOCTLS_H__
#define __ARCH_M68K_IOCTLS_H__
 
#include <asm/ioctl.h>
 
/* 0x54 is just a magic number to make these relatively unique ('T') */
 
#define TCGETS 0x5401
#define TCSETS 0x5402
#define TCSETSW 0x5403
#define TCSETSF 0x5404
#define TCGETA 0x5405
#define TCSETA 0x5406
#define TCSETAW 0x5407
#define TCSETAF 0x5408
#define TCSBRK 0x5409
#define TCXONC 0x540A
#define TCFLSH 0x540B
#define TIOCEXCL 0x540C
#define TIOCNXCL 0x540D
#define TIOCSCTTY 0x540E
#define TIOCGPGRP 0x540F
#define TIOCSPGRP 0x5410
#define TIOCOUTQ 0x5411
#define TIOCSTI 0x5412
#define TIOCGWINSZ 0x5413
#define TIOCSWINSZ 0x5414
#define TIOCMGET 0x5415
#define TIOCMBIS 0x5416
#define TIOCMBIC 0x5417
#define TIOCMSET 0x5418
#define TIOCGSOFTCAR 0x5419
#define TIOCSSOFTCAR 0x541A
#define FIONREAD 0x541B
#define TIOCINQ FIONREAD
#define TIOCLINUX 0x541C
#define TIOCCONS 0x541D
#define TIOCGSERIAL 0x541E
#define TIOCSSERIAL 0x541F
#define TIOCPKT 0x5420
#define FIONBIO 0x5421
#define TIOCNOTTY 0x5422
#define TIOCSETD 0x5423
#define TIOCGETD 0x5424
#define TCSBRKP 0x5425 /* Needed for POSIX tcsendbreak() */
#define TIOCTTYGSTRUCT 0x5426 /* For debugging only */
#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */
#define FIOCLEX 0x5451
#define FIOASYNC 0x5452
#define TIOCSERCONFIG 0x5453
#define TIOCSERGWILD 0x5454
#define TIOCSERSWILD 0x5455
#define TIOCGLCKTRMIOS 0x5456
#define TIOCSLCKTRMIOS 0x5457
#define TIOCSERGSTRUCT 0x5458 /* For debugging only */
#define TIOCSERGETLSR 0x5459 /* Get line status register */
#define TIOCSERGETMULTI 0x545A /* Get multiport config */
#define TIOCSERSETMULTI 0x545B /* Set multiport config */
 
#define TIOCMIWAIT 0x545C /* wait for a change on serial input line(s) */
#define TIOCGICOUNT 0x545D /* read serial port inline interrupt counts */
 
/* Used for packet mode */
#define TIOCPKT_DATA 0
#define TIOCPKT_FLUSHREAD 1
#define TIOCPKT_FLUSHWRITE 2
#define TIOCPKT_STOP 4
#define TIOCPKT_START 8
#define TIOCPKT_NOSTOP 16
#define TIOCPKT_DOSTOP 32
 
#define TIOCSER_TEMT 0x01 /* Transmitter physically empty */
 
#endif /* __ARCH_M68K_IOCTLS_H__ */
/delay.h
0,0 → 1,48
#ifndef _M68K_DELAY_H
#define _M68K_DELAY_H
 
/*
* Copyright (C) 1994 Hamish Macdonald
*
* Delay routines, using a pre-computed "loops_per_second" value.
*/
 
extern __inline__ void __delay(int loops)
{
__asm__ __volatile__ ("\n\tmovel %0,%/d0\n1:\tsubql #1,%/d0\n\t"
"bpls 1b\n"
: /* no outputs */
: "g" (loops)
: "d0");
}
 
/*
* Use only for very small delays ( < 1 msec). Should probably use a
* lookup table, really, as the multiplications take much too long with
* short delays. This is a "reasonable" implementation, though (and the
* first constant multiplications gets optimized away if the delay is
* a constant)
*/
extern __inline__ void udelay(unsigned long usecs)
{
usecs *= 0x000010c6; /* 2**32 / 1000000 */
 
__asm__ __volatile__ ("mulul %1,%0:%2"
: "=d" (usecs)
: "d" (usecs),
"d" (loops_per_sec));
__delay(usecs);
}
 
extern __inline__ unsigned long muldiv(unsigned long a, unsigned long b, unsigned long c)
{
__asm__ ("mulul %1,%/d0:%0\n\tdivul %2,%/d0:%0"
:"=d" (a)
:"d" (b),
"d" (c),
"0" (a)
:"d0");
return a;
}
 
#endif /* defined(_M68K_DELAY_H) */
/param.h
0,0 → 1,20
#ifndef _M68K_PARAM_H
#define _M68K_PARAM_H
 
#ifndef HZ
#define HZ 100
#endif
 
#define EXEC_PAGESIZE 4096
 
#ifndef NGROUPS
#define NGROUPS 32
#endif
 
#ifndef NOGROUP
#define NOGROUP (-1)
#endif
 
#define MAXHOSTNAMELEN 64 /* max length of hostname */
 
#endif /* _M68K_PARAM_H */
/bitops.h
0,0 → 1,242
#ifndef _M68K_BITOPS_H
#define _M68K_BITOPS_H
/*
* Copyright 1992, Linus Torvalds.
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of this archive
* for more details.
*/
 
/*
* Require 68020 or better.
*
* They use the standard big-endian m680x0 bit ordering.
*/
 
extern __inline__ int set_bit(int nr,void * vaddr)
{
char retval;
 
__asm__ __volatile__ ("bfset %2@{%1:#1}; sne %0"
: "=d" (retval) : "d" (nr^31), "a" (vaddr));
 
return retval;
}
 
extern __inline__ int clear_bit(int nr, void * vaddr)
{
char retval;
 
__asm__ __volatile__ ("bfclr %2@{%1:#1}; sne %0"
: "=d" (retval) : "d" (nr^31), "a" (vaddr));
 
return retval;
}
 
extern __inline__ int change_bit(int nr, void * vaddr)
{
char retval;
 
__asm__ __volatile__ ("bfchg %2@{%1:#1}; sne %0"
: "=d" (retval) : "d" (nr^31), "a" (vaddr));
 
return retval;
}
 
extern __inline__ int test_bit(int nr, const void * vaddr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) vaddr)[nr >> 5])) != 0;
}
 
extern __inline__ int find_first_zero_bit(void * vaddr, unsigned size)
{
unsigned long *p = vaddr, *addr = vaddr;
unsigned long allones = ~0UL;
int res;
unsigned long num;
 
if (!size)
return 0;
 
while (*p++ == allones)
{
if (size <= 32)
return (p - addr) << 5;
size -= 32;
}
 
num = ~*--p;
__asm__ __volatile__ ("bfffo %1{#0,#0},%0"
: "=d" (res) : "d" (num & -num));
return ((p - addr) << 5) + (res ^ 31);
}
 
extern __inline__ int find_next_zero_bit (void *vaddr, int size,
int offset)
{
unsigned long *addr = vaddr;
unsigned long *p = addr + (offset >> 5);
int set = 0, bit = offset & 31UL, res;
 
if (offset >= size)
return size;
 
if (bit) {
unsigned long num = ~*p & (~0UL << bit);
 
/* Look for zero in first longword */
__asm__ __volatile__ ("bfffo %1{#0,#0},%0"
: "=d" (res) : "d" (num & -num));
if (res < 32)
return (offset & ~31UL) + (res ^ 31);
set = 32 - bit;
p++;
}
/* No zero yet, search remaining full bytes for a zero */
res = find_first_zero_bit (p, size - 32 * (p - addr));
return (offset + set + res);
}
 
/*
* ffz = Find First Zero in word. Undefined if no zero exists,
* so code should check against ~0UL first..
*/
extern __inline__ unsigned long ffz(unsigned long word)
{
int res;
 
__asm__ __volatile__ ("bfffo %1{#0,#0},%0"
: "=d" (res) : "d" (~word & -~word));
return res ^ 31;
}
 
/* Bitmap functions for the minix filesystem */
 
extern __inline__ int
minix_find_first_zero_bit (const void *vaddr, unsigned size)
{
const unsigned short *p = vaddr, *addr = vaddr;
int res;
unsigned short num;
 
if (!size)
return 0;
 
while (*p++ == 0xffff)
{
if (size <= 16)
return (p - addr) << 4;
size -= 16;
}
 
num = ~*--p;
__asm__ __volatile__ ("bfffo %1{#16,#16},%0"
: "=d" (res) : "d" (num & -num));
return ((p - addr) << 4) + (res ^ 31);
}
 
extern __inline__ int
minix_set_bit (int nr, void *vaddr)
{
char retval;
 
__asm__ __volatile__ ("bfset %2{%1:#1}; sne %0"
: "=d" (retval) : "d" (nr^15), "m" (*(char *)vaddr));
 
return retval;
}
 
extern __inline__ int
minix_clear_bit (int nr, void *vaddr)
{
char retval;
 
__asm__ __volatile__ ("bfclr %2{%1:#1}; sne %0"
: "=d" (retval) : "d" (nr^15), "m" (*(char *) vaddr));
 
return retval;
}
 
extern __inline__ int
minix_test_bit (int nr, const void *vaddr)
{
return ((1U << (nr & 15)) & (((const unsigned short *) vaddr)[nr >> 4])) != 0;
}
 
/* Bitmap functions for the ext2 filesystem. */
 
extern __inline__ int
ext2_set_bit (int nr, void *vaddr)
{
char retval;
 
__asm__ __volatile__ ("bfset %2{%1,#1}; sne %0"
: "=d" (retval) : "d" (nr^7), "m" (*(char *) vaddr));
 
return retval;
}
 
extern __inline__ int
ext2_clear_bit (int nr, void *vaddr)
{
char retval;
 
__asm__ __volatile__ ("bfclr %2{%1,#1}; sne %0"
: "=d" (retval) : "d" (nr^7), "m" (*(char *) vaddr));
 
return retval;
}
 
extern __inline__ int
ext2_test_bit (int nr, const void *vaddr)
{
return ((1U << (nr & 7)) & (((const unsigned char *) vaddr)[nr >> 3])) != 0;
}
 
extern __inline__ int
ext2_find_first_zero_bit (const void *vaddr, unsigned size)
{
const unsigned long *p = vaddr, *addr = vaddr;
int res;
 
if (!size)
return 0;
 
while (*p++ == ~0UL)
{
if (size <= 32)
return (p - addr) << 5;
size -= 32;
}
 
--p;
for (res = 0; res < 32; res++)
if (!ext2_test_bit (res, p))
break;
return (p - addr) * 32 + res;
}
 
extern __inline__ int
ext2_find_next_zero_bit (const void *vaddr, unsigned size, unsigned offset)
{
const unsigned long *addr = vaddr;
const unsigned long *p = addr + (offset >> 5);
int bit = offset & 31UL, res;
 
if (offset >= size)
return size;
 
if (bit) {
/* Look for zero in first longword */
for (res = bit; res < 32; res++)
if (!ext2_test_bit (res, p))
return (p - addr) * 32 + res;
p++;
}
/* No zero yet, search remaining full bytes for a zero */
res = ext2_find_first_zero_bit (p, size - 32 * (p - addr));
return (p - addr) * 32 + res;
}
 
#endif /* _M68K_BITOPS_H */
/bugs.h
0,0 → 1,16
/*
* include/asm-m68k/bugs.h
*
* Copyright (C) 1994 Linus Torvalds
*/
 
/*
* This is included by init/main.c to check for architecture-dependent bugs.
*
* Needs:
* void check_bugs(void);
*/
 
static void check_bugs(void)
{
}
/machdep.h
0,0 → 1,47
#ifndef _M68K_MACHDEP_H
#define _M68K_MACHDEP_H
 
struct pt_regs;
struct kbd_repeat;
struct mktime;
struct hwclk_time;
struct gendisk;
struct buffer_head;
 
#ifndef ISRFUNC_T
typedef void (*isrfunc) (int irq, struct pt_regs *fp, void *data);
#define ISRFUNC_T
#endif /* ISRFUNC_T */
 
extern void (*mach_sched_init)(isrfunc);
extern int (*mach_keyb_init) (void);
extern int (*mach_kbdrate) (struct kbd_repeat *);
extern void (*mach_kbd_leds) (unsigned int);
extern void (*mach_init_INTS) (void);
extern int (*mach_add_isr) (unsigned long source, isrfunc handler,
int pri, void *data, char *name);
extern int (*mach_remove_isr) (unsigned long source, isrfunc handler,
void *data);
extern int (*mach_get_irq_list)(char *buf, int len);
extern void (*mach_process_int) (int level, struct pt_regs *fp);
extern void (*mach_enable_irq) (unsigned);
extern void (*mach_disable_irq) (unsigned);
extern unsigned long (*mach_gettimeoffset)(void);
extern void (*mach_gettod)(int *year, int *mon, int *day, int *hour,
int *min, int *sec);
extern int (*mach_hwclk)(int, struct hwclk_time*);
extern int (*mach_set_clock_mmss)(unsigned long);
extern void (*mach_mksound)( unsigned int count, unsigned int ticks );
extern void (*mach_reset)( void );
extern int (*mach_floppy_init) (void);
extern unsigned long (*mach_hd_init) (unsigned long, unsigned long);
extern void (*mach_hd_setup)(char *, int *);
extern void (*waitbut)(void);
extern struct fb_info *(*mach_fb_init)(long *);
extern long mach_max_dma_address;
extern void (*mach_debug_init)(void);
extern void (*mach_video_setup)(char *, int *);
extern void (*mach_floppy_setup)(char *, int *);
extern void (*mach_floppy_eject)(void);
 
#endif /* _M68K_MACHDEP_H */
/dma.h
0,0 → 1,12
#ifndef _M68K_DMA_H
#define _M68K_DMA_H 1
 
/* Don't define MAX_DMA_ADDRESS; it's useless on the m68k and any
occurrence should be flagged as an error. */
 
#define MAX_DMA_CHANNELS 8
 
extern int request_dma(unsigned int dmanr, const char * device_id); /* reserve a DMA channel */
extern void free_dma(unsigned int dmanr); /* release it again */
 
#endif /* _M68K_DMA_H */
/mmu_context.h
0,0 → 1,9
#ifndef __68K_MMU_CONTEXT_H
#define __68K_MMU_CONTEXT_H
 
/*
* get a new mmu context.. do we need this on the m68k?
*/
#define get_mmu_context(x) do { } while (0)
 
#endif
/checksum.h
0,0 → 1,113
#ifndef _M68K_CHECKSUM_H
#define _M68K_CHECKSUM_H
 
/*
* computes the checksum of a memory block at buff, length len,
* and adds in "sum" (32-bit)
*
* returns a 32-bit number suitable for feeding into itself
* or csum_tcpudp_magic
*
* this function must be called with even lengths, except
* for the last fragment, which may be odd
*
* it's best to have buff aligned on a 32-bit boundary
*/
unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum);
 
/*
* the same as csum_partial_copy, but copies from src while it
* checksums
*
* here even more important to align src and dst on a 32-bit (or even
* better 64-bit) boundary
*/
 
unsigned int csum_partial_copy(const char *src, char *dst, int len, int sum);
 
 
/*
* the same as csum_partial_copy, but copies from user space.
*
* here even more important to align src and dst on a 32-bit (or even
* better 64-bit) boundary
*/
 
unsigned int csum_partial_copy_fromuser(const char *src, char *dst, int len, int sum);
 
 
/*
* This is a version of ip_compute_csum() optimized for IP headers,
* which always checksum on 4 octet boundaries.
*
*/
static inline unsigned short
ip_fast_csum(unsigned char *iph, unsigned int ihl)
{
unsigned int sum = 0;
 
__asm__ ("subqw #1,%2\n"
"1:\t"
"movel %1@+,%/d0\n\t"
"addxl %/d0,%0\n\t"
"dbra %2,1b\n\t"
"movel %0,%/d0\n\t"
"swap %/d0\n\t"
"addxw %/d0,%0\n\t"
"clrw %/d0\n\t"
"addxw %/d0,%0\n\t"
: "=d" (sum), "=a" (iph), "=d" (ihl)
: "0" (sum), "1" (iph), "2" (ihl)
: "d0");
return ~sum;
}
 
/*
* Fold a partial checksum
*/
 
static inline unsigned int csum_fold(unsigned int sum)
{
unsigned int tmp = sum;
__asm__("swap %1\n\t"
"addw %1, %0\n\t"
"clrw %1\n\t"
"addxw %1, %0"
: "=&d" (sum), "=&d" (tmp)
: "0" (sum), "1" (sum));
return ~sum;
}
 
 
/*
* computes the checksum of the TCP/UDP pseudo-header
* returns a 16-bit checksum, already complemented
*/
 
static inline unsigned short int
csum_tcpudp_magic(unsigned long saddr, unsigned long daddr, unsigned short len,
unsigned short proto, unsigned int sum)
{
__asm__ ("addl %1,%0\n\t"
"addxl %4,%0\n\t"
"addxl %5,%0\n\t"
"clrl %1\n\t"
"addxl %1,%0"
: "=&d" (sum), "=&d" (saddr)
: "0" (daddr), "1" (saddr), "d" (len + proto),
"d"(sum));
return csum_fold(sum);
}
 
/*
* this routine is used for miscellaneous IP-like checksums, mainly
* in icmp.c
*/
 
static inline unsigned short
ip_compute_csum(unsigned char * buff, int len)
{
return csum_fold (csum_partial(buff, len, 0));
}
 
#endif /* _M68K_CHECKSUM_H */
/statfs.h
0,0 → 1,25
#ifndef _M68K_STATFS_H
#define _M68K_STATFS_H
 
#ifndef __KERNEL_STRICT_NAMES
 
#include <linux/types.h>
 
typedef __kernel_fsid_t fsid_t;
 
#endif
 
struct statfs {
long f_type;
long f_bsize;
long f_blocks;
long f_bfree;
long f_bavail;
long f_files;
long f_ffree;
__kernel_fsid_t f_fsid;
long f_namelen;
long f_spare[6];
};
 
#endif /* _M68K_STATFS_H */
/cachectl.h
0,0 → 1,14
#ifndef _M68K_CACHECTL_H
#define _M68K_CACHECTL_H
 
/* Definitions for the cacheflush system call. */
 
#define FLUSH_SCOPE_LINE 1 /* Flush a cache line */
#define FLUSH_SCOPE_PAGE 2 /* Flush a page */
#define FLUSH_SCOPE_ALL 3 /* Flush the whole cache -- superuser only */
 
#define FLUSH_CACHE_DATA 1 /* Writeback and flush data cache */
#define FLUSH_CACHE_INSN 2 /* Flush instruction cache */
#define FLUSH_CACHE_BOTH 3 /* Flush both caches */
 
#endif /* _M68K_CACHECTL_H */
/shmparam.h
0,0 → 1,44
#ifndef _M68K_SHMPARAM_H
#define _M68K_SHMPARAM_H
 
/* address range for shared memory attaches if no address passed to shmat() */
#define SHM_RANGE_START 0xC0000000
#define SHM_RANGE_END 0xD0000000
 
/*
* Format of a swap-entry for shared memory pages currently out in
* swap space (see also mm/swap.c).
*
* SWP_TYPE = SHM_SWP_TYPE
* SWP_OFFSET is used as follows:
*
* bits 0..6 : id of shared memory segment page belongs to (SHM_ID)
* bits 7..21: index of page within shared memory segment (SHM_IDX)
* (actually fewer bits get used since SHMMAX is so low)
*/
 
/*
* Keep _SHM_ID_BITS as low as possible since SHMMNI depends on it and
* there is a static array of size SHMMNI.
*/
#define _SHM_ID_BITS 7
#define SHM_ID_MASK ((1<<_SHM_ID_BITS)-1)
 
#define SHM_IDX_SHIFT (_SHM_ID_BITS)
#define _SHM_IDX_BITS 15
#define SHM_IDX_MASK ((1<<_SHM_IDX_BITS)-1)
 
/*
* _SHM_ID_BITS + _SHM_IDX_BITS must be <= 24 on the i386 and
* SHMMAX <= (PAGE_SIZE << _SHM_IDX_BITS).
*/
 
#define SHMMAX 0x1000000 /* max shared seg size (bytes) */
#define SHMMIN 1 /* really PAGE_SIZE */ /* min shared seg size (bytes) */
#define SHMMNI (1<<_SHM_ID_BITS) /* max num of segs system wide */
#define SHMALL /* max shm system wide (pages) */ \
(1<<(_SHM_IDX_BITS+_SHM_ID_BITS))
#define SHMLBA PAGE_SIZE /* attach addr a multiple of this */
#define SHMSEG SHMMNI /* max shared segs per process */
 
#endif /* _M68K_SHMPARAM_H */
/amigaints.h
0,0 → 1,99
/*
** amigaints.h -- Amiga Linux interrupt handling structs and prototypes
**
** Copyright 1992 by Greg Harp
**
** This file is subject to the terms and conditions of the GNU General Public
** License. See the file COPYING in the main directory of this archive
** for more details.
**
** Created 10/2/92 by Greg Harp
*/
 
#ifndef _ASMm68k_AMIGAINTS_H_
#define _ASMm68k_AMIGAINTS_H_
 
/*
** Amiga Interrupt sources.
**
*/
 
#define NUM_AMIGA_SOURCES (24)
 
/* vertical blanking interrupt */
#define IRQ_AMIGA_VERTB (IRQ_MACHSPEC | 0)
 
/* copper interrupt */
#define IRQ_AMIGA_COPPER (IRQ_MACHSPEC | 1)
 
/* Audio interrupts */
#define IRQ_AMIGA_AUD0 (IRQ_MACHSPEC | 2)
#define IRQ_AMIGA_AUD1 (IRQ_MACHSPEC | 3)
#define IRQ_AMIGA_AUD2 (IRQ_MACHSPEC | 4)
#define IRQ_AMIGA_AUD3 (IRQ_MACHSPEC | 5)
 
/* Blitter done interrupt */
#define IRQ_AMIGA_BLIT (IRQ_MACHSPEC | 6)
 
/* floppy disk interrupts */
#define IRQ_AMIGA_DSKSYN (IRQ_MACHSPEC | 7)
#define IRQ_AMIGA_DSKBLK (IRQ_MACHSPEC | 8)
 
/* builtin serial port interrupts */
#define IRQ_AMIGA_RBF (IRQ_MACHSPEC | 9)
#define IRQ_AMIGA_TBE (IRQ_MACHSPEC | 10)
 
/* CIA interrupt sources */
#define IRQ_AMIGA_CIAA_TA (IRQ_MACHSPEC | 11)
#define IRQ_AMIGA_CIAA_TB (IRQ_MACHSPEC | 12)
#define IRQ_AMIGA_CIAA_ALRM (IRQ_MACHSPEC | 13)
#define IRQ_AMIGA_CIAA_SP (IRQ_MACHSPEC | 14)
#define IRQ_AMIGA_CIAA_FLG (IRQ_MACHSPEC | 15)
#define IRQ_AMIGA_CIAB_TA (IRQ_MACHSPEC | 16)
#define IRQ_AMIGA_CIAB_TB (IRQ_MACHSPEC | 17)
#define IRQ_AMIGA_CIAB_ALRM (IRQ_MACHSPEC | 18)
#define IRQ_AMIGA_CIAB_SP (IRQ_MACHSPEC | 19)
#define IRQ_AMIGA_CIAB_FLG (IRQ_MACHSPEC | 20)
 
#define IRQ_AMIGA_SOFT (IRQ_MACHSPEC | 21)
 
#define IRQ_AMIGA_PORTS (IRQ_MACHSPEC | 22)
#define IRQ_AMIGA_EXTER (IRQ_MACHSPEC | 23)
 
#define IRQ_FLOPPY IRQ_AMIGA_DSKBLK
 
/* INTREQR masks */
#define IRQ1_MASK 0x0007 /* INTREQR mask for IRQ 1 */
#define IRQ2_MASK 0x0008 /* INTREQR mask for IRQ 2 */
#define IRQ3_MASK 0x0070 /* INTREQR mask for IRQ 3 */
#define IRQ4_MASK 0x0780 /* INTREQR mask for IRQ 4 */
#define IRQ5_MASK 0x1800 /* INTREQR mask for IRQ 5 */
#define IRQ6_MASK 0x2000 /* INTREQR mask for IRQ 6 */
#define IRQ7_MASK 0x4000 /* INTREQR mask for IRQ 7 */
 
#define IF_SETCLR 0x8000 /* set/clr bit */
#define IF_INTEN 0x4000 /* master interrupt bit in INT* registers */
#define IF_EXTER 0x2000 /* external level 6 and CIA B interrupt */
#define IF_DSKSYN 0x1000 /* disk sync interrupt */
#define IF_RBF 0x0800 /* serial receive buffer full interrupt */
#define IF_AUD3 0x0400 /* audio channel 3 done interrupt */
#define IF_AUD2 0x0200 /* audio channel 2 done interrupt */
#define IF_AUD1 0x0100 /* audio channel 1 done interrupt */
#define IF_AUD0 0x0080 /* audio channel 0 done interrupt */
#define IF_BLIT 0x0040 /* blitter done interrupt */
#define IF_VERTB 0x0020 /* vertical blanking interrupt */
#define IF_COPER 0x0010 /* copper interrupt */
#define IF_PORTS 0x0008 /* external level 2 and CIA A interrupt */
#define IF_SOFT 0x0004 /* software initiated interrupt */
#define IF_DSKBLK 0x0002 /* diskblock DMA finished */
#define IF_TBE 0x0001 /* serial transmit buffer empty interrupt */
 
/* CIA interrupt control register bits */
 
#define CIA_ICR_TA 0x01
#define CIA_ICR_TB 0x02
#define CIA_ICR_ALRM 0x04
#define CIA_ICR_SP 0x08
#define CIA_ICR_FLG 0x10
 
#endif /* asm-m68k/amigaints.h */
/atomic.h
0,0 → 1,42
#ifndef __ARCH_M68K_ATOMIC__
#define __ARCH_M68K_ATOMIC__
 
/*
* Atomic operations that C can't guarantee us. Useful for
* resource counting etc..
*/
 
/*
* We do not have SMP m68k systems, so we don't have to deal with that.
*/
 
typedef int atomic_t;
 
static __inline__ void atomic_add(atomic_t i, atomic_t *v)
{
__asm__ __volatile__("addl %1,%0" : : "m" (*v), "id" (i));
}
 
static __inline__ void atomic_sub(atomic_t i, atomic_t *v)
{
__asm__ __volatile__("subl %1,%0" : : "m" (*v), "id" (i));
}
 
static __inline__ void atomic_inc(atomic_t *v)
{
__asm__ __volatile__("addql #1,%0" : : "m" (*v));
}
 
static __inline__ void atomic_dec(atomic_t *v)
{
__asm__ __volatile__("subql #1,%0" : : "m" (*v));
}
 
static __inline__ int atomic_dec_and_test(atomic_t *v)
{
char c;
__asm__ __volatile__("subql #1,%1; seq %0" : "=d" (c) : "m" (*v));
return c != 0;
}
 
#endif /* __ARCH_M68K_ATOMIC __ */
/atafdreg.h
0,0 → 1,79
#ifndef _LINUX_FDREG_H
#define _LINUX_FDREG_H
 
/*
** WD1772 stuff
*/
 
/* register codes */
 
#define FDCSELREG_STP (0x80) /* command/status register */
#define FDCSELREG_TRA (0x82) /* track register */
#define FDCSELREG_SEC (0x84) /* sector register */
#define FDCSELREG_DTA (0x86) /* data register */
 
/* register names for FDC_READ/WRITE macros */
 
#define FDCREG_CMD 0
#define FDCREG_STATUS 0
#define FDCREG_TRACK 2
#define FDCREG_SECTOR 4
#define FDCREG_DATA 6
 
/* command opcodes */
 
#define FDCCMD_RESTORE (0x00) /* - */
#define FDCCMD_SEEK (0x10) /* | */
#define FDCCMD_STEP (0x20) /* | TYP 1 Commands */
#define FDCCMD_STIN (0x40) /* | */
#define FDCCMD_STOT (0x60) /* - */
#define FDCCMD_RDSEC (0x80) /* - TYP 2 Commands */
#define FDCCMD_WRSEC (0xa0) /* - " */
#define FDCCMD_RDADR (0xc0) /* - */
#define FDCCMD_RDTRA (0xe0) /* | TYP 3 Commands */
#define FDCCMD_WRTRA (0xf0) /* - */
#define FDCCMD_FORCI (0xd0) /* - TYP 4 Command */
 
/* command modifier bits */
 
#define FDCCMDADD_SR6 (0x00) /* step rate settings */
#define FDCCMDADD_SR12 (0x01)
#define FDCCMDADD_SR2 (0x02)
#define FDCCMDADD_SR3 (0x03)
#define FDCCMDADD_V (0x04) /* verify */
#define FDCCMDADD_H (0x08) /* wait for spin-up */
#define FDCCMDADD_U (0x10) /* update track register */
#define FDCCMDADD_M (0x10) /* multiple sector access */
#define FDCCMDADD_E (0x04) /* head settling flag */
#define FDCCMDADD_P (0x02) /* precompensation off */
#define FDCCMDADD_A0 (0x01) /* DAM flag */
 
/* status register bits */
 
#define FDCSTAT_MOTORON (0x80) /* motor on */
#define FDCSTAT_WPROT (0x40) /* write protected (FDCCMD_WR*) */
#define FDCSTAT_SPINUP (0x20) /* motor speed stable (Type I) */
#define FDCSTAT_DELDAM (0x20) /* sector has deleted DAM (Type II+III) */
#define FDCSTAT_RECNF (0x10) /* record not found */
#define FDCSTAT_CRC (0x08) /* CRC error */
#define FDCSTAT_TR00 (0x04) /* Track 00 flag (Type I) */
#define FDCSTAT_LOST (0x04) /* Lost Data (Type II+III) */
#define FDCSTAT_IDX (0x02) /* Index status (Type I) */
#define FDCSTAT_DRQ (0x02) /* DRQ status (Type II+III) */
#define FDCSTAT_BUSY (0x01) /* FDC is busy */
 
 
/* PSG Port A Bit Nr 0 .. Side Sel .. 0 -> Side 1 1 -> Side 2 */
#define DSKSIDE (0x01)
#define DSKDRVNONE (0x06)
#define DSKDRV0 (0x02)
#define DSKDRV1 (0x04)
 
/* step rates */
#define FDCSTEP_6 0x00
#define FDCSTEP_12 0x01
#define FDCSTEP_2 0x02
#define FDCSTEP_3 0x03
 
#endif
/pgtable.h
0,0 → 1,689
#ifndef _M68K_PGTABLE_H
#define _M68K_PGTABLE_H
 
#ifndef __ASSEMBLY__
 
/*
* This file contains the functions and defines necessary to modify and use
* the m68k page table tree.
*/
 
#define __flush_tlb() \
do { \
if (m68k_is040or060) \
__asm__ __volatile__(".word 0xf510\n"::); /* pflushan */ \
else \
__asm__ __volatile__("pflusha\n"::); \
} while (0)
 
static inline void __flush_tlb_one(unsigned long addr)
{
if (m68k_is040or060) {
register unsigned long a0 __asm__ ("a0") = addr;
__asm__ __volatile__(".word 0xf508" /* pflush (%a0) */
: : "a" (a0));
} else
__asm__ __volatile__("pflush #0,#0,(%0)" : : "a" (addr));
}
 
#define flush_tlb() __flush_tlb()
#define flush_tlb_all() flush_tlb()
 
static inline void flush_tlb_mm(struct mm_struct *mm)
{
if (mm == current->mm)
__flush_tlb();
}
 
static inline void flush_tlb_page(struct vm_area_struct *vma,
unsigned long addr)
{
if (vma->vm_mm == current->mm)
__flush_tlb_one(addr);
}
 
static inline void flush_tlb_range(struct mm_struct *mm,
unsigned long start, unsigned long end)
{
if (mm == current->mm)
__flush_tlb();
}
 
/* Certain architectures need to do special things when pte's
* within a page table are directly modified. Thus, the following
* hook is made available.
*/
#define set_pte(pteptr, pteval) ((*(pteptr)) = (pteval))
 
/* PMD_SHIFT determines the size of the area a second-level page table can map */
#define PMD_SHIFT 22
#define PMD_SIZE (1UL << PMD_SHIFT)
#define PMD_MASK (~(PMD_SIZE-1))
 
/* PGDIR_SHIFT determines what a third-level page table entry can map */
#define PGDIR_SHIFT 25
#define PGDIR_SIZE (1UL << PGDIR_SHIFT)
#define PGDIR_MASK (~(PGDIR_SIZE-1))
 
/*
* entries per page directory level: the m68k is configured as three-level,
* so we do have PMD level physically.
*/
#define PTRS_PER_PTE 1024
#define PTRS_PER_PMD 8
#define PTRS_PER_PGD 128
 
/* the no. of pointers that fit on a page: this will go away */
#define PTRS_PER_PAGE (PAGE_SIZE/sizeof(void*))
 
typedef pgd_t pgd_table[PTRS_PER_PGD];
typedef pmd_t pmd_table[PTRS_PER_PMD];
typedef pte_t pte_table[PTRS_PER_PTE];
 
#define PGD_TABLES_PER_PAGE (PAGE_SIZE/sizeof(pgd_table))
#define PMD_TABLES_PER_PAGE (PAGE_SIZE/sizeof(pmd_table))
#define PTE_TABLES_PER_PAGE (PAGE_SIZE/sizeof(pte_table))
 
typedef pgd_table pgd_tablepage[PGD_TABLES_PER_PAGE];
typedef pmd_table pmd_tablepage[PMD_TABLES_PER_PAGE];
typedef pte_table pte_tablepage[PTE_TABLES_PER_PAGE];
 
/* Just any arbitrary offset to the start of the vmalloc VM area: the
* current 8MB value just means that there will be a 8MB "hole" after the
* physical memory until the kernel virtual memory starts. That means that
* any out-of-bounds memory accesses will hopefully be caught.
* The vmalloc() routines leaves a hole of 4kB between each vmalloced
* area for the same reason. ;)
*/
#define VMALLOC_OFFSET (8*1024*1024)
#define VMALLOC_START ((high_memory + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
#define VMALLOC_VMADDR(x) ((unsigned long)(x))
 
#endif /* __ASSEMBLY__ */
 
/*
* Definitions for MMU descriptors
*/
#define _PAGE_PRESENT 0x001
#define _PAGE_SHORT 0x002
#define _PAGE_RONLY 0x004
#define _PAGE_ACCESSED 0x008
#define _PAGE_DIRTY 0x010
#define _PAGE_GLOBAL040 0x400 /* 68040 global bit, used for kva descs */
#define _PAGE_COW 0x800 /* implemented in software */
#define _PAGE_NOCACHE030 0x040 /* 68030 no-cache mode */
#define _PAGE_NOCACHE 0x060 /* 68040 cache mode, non-serialized */
#define _PAGE_NOCACHE_S 0x040 /* 68040 no-cache mode, serialized */
#define _PAGE_CACHE040 0x020 /* 68040 cache mode, cachable, copyback */
#define _PAGE_CACHE040W 0x000 /* 68040 cache mode, cachable, write-through */
 
#define _DESCTYPE_MASK 0x003
 
#define _CACHEMASK040 (~0x060)
#define _TABLE_MASK (0xfffffff0)
 
#define _PAGE_TABLE (_PAGE_SHORT)
#define _PAGE_CHG_MASK (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY | _PAGE_NOCACHE)
 
#ifndef __ASSEMBLY__
 
#define PAGE_NONE __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED | _PAGE_CACHE040)
#define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_CACHE040)
#define PAGE_COPY __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED | _PAGE_CACHE040)
#define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED | _PAGE_CACHE040)
#define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_CACHE040)
 
/*
* The m68k can't do page protection for execute, and considers that the same are read.
* Also, write permissions imply read permissions. This is the closest we can get..
*/
#define __P000 PAGE_NONE
#define __P001 PAGE_READONLY
#define __P010 PAGE_COPY
#define __P011 PAGE_COPY
#define __P100 PAGE_READONLY
#define __P101 PAGE_READONLY
#define __P110 PAGE_COPY
#define __P111 PAGE_COPY
 
#define __S000 PAGE_NONE
#define __S001 PAGE_READONLY
#define __S010 PAGE_SHARED
#define __S011 PAGE_SHARED
#define __S100 PAGE_READONLY
#define __S101 PAGE_READONLY
#define __S110 PAGE_SHARED
#define __S111 PAGE_SHARED
 
/* zero page used for uninitialized stuff */
extern unsigned long empty_zero_page;
 
/*
* BAD_PAGETABLE is used when we need a bogus page-table, while
* BAD_PAGE is used for a bogus page.
*
* ZERO_PAGE is a global shared page that is always zero: used
* for zero-mapped memory areas etc..
*/
extern pte_t __bad_page(void);
extern pte_t * __bad_pagetable(void);
 
#define BAD_PAGETABLE __bad_pagetable()
#define BAD_PAGE __bad_page()
#define ZERO_PAGE empty_zero_page
 
/* number of bits that fit into a memory pointer */
#define BITS_PER_PTR (8*sizeof(unsigned long))
 
/* to align the pointer to a pointer address */
#define PTR_MASK (~(sizeof(void*)-1))
 
/* sizeof(void*)==1<<SIZEOF_PTR_LOG2 */
/* 64-bit machines, beware! SRB. */
#define SIZEOF_PTR_LOG2 2
 
/* to find an entry in a page-table */
#define PAGE_PTR(address) \
((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
 
extern unsigned long high_memory;
 
/* For virtual address to physical address conversion */
extern unsigned long mm_vtop(unsigned long addr) __attribute__ ((const));
extern unsigned long mm_ptov(unsigned long addr) __attribute__ ((const));
#define VTOP(addr) (mm_vtop((unsigned long)(addr)))
#define PTOV(addr) (mm_ptov((unsigned long)(addr)))
 
/*
* Conversion functions: convert a page and protection to a page entry,
* and a page entry and page directory to the page they refer to.
*/
extern inline pte_t mk_pte(unsigned long page, pgprot_t pgprot)
{ pte_t pte; pte_val(pte) = VTOP(page) | pgprot_val(pgprot); return pte; }
 
extern inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
{ pte_val(pte) = (pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot); return pte; }
 
extern inline void pmd_set(pmd_t * pmdp, pte_t * ptep)
{
int i;
 
ptep = (pte_t *) VTOP(ptep);
for (i = 0; i < 16; i++, ptep += PTRS_PER_PTE/16)
pmdp->pmd[i] = _PAGE_TABLE | (unsigned long)ptep;
}
 
/* early termination version of the above */
extern inline void pmd_set_et(pmd_t * pmdp, pte_t * ptep)
{
int i;
 
ptep = (pte_t *) VTOP(ptep);
for (i = 0; i < 16; i++, ptep += PTRS_PER_PTE/16)
pmdp->pmd[i] = _PAGE_PRESENT | (unsigned long)ptep;
}
 
extern inline void pgd_set(pgd_t * pgdp, pmd_t * pmdp)
{ pgd_val(*pgdp) = _PAGE_TABLE | VTOP(pmdp); }
 
extern inline unsigned long pte_page(pte_t pte)
{ return PTOV(pte_val(pte) & PAGE_MASK); }
 
extern inline unsigned long pmd_page2(pmd_t *pmd)
{ return PTOV(pmd_val(*pmd) & _TABLE_MASK); }
#define pmd_page(pmd) pmd_page2(&(pmd))
 
extern inline unsigned long pgd_page(pgd_t pgd)
{ return PTOV(pgd_val(pgd) & _TABLE_MASK); }
 
extern inline int pte_none(pte_t pte) { return !pte_val(pte); }
extern inline int pte_present(pte_t pte) { return pte_val(pte) & _PAGE_PRESENT; }
extern inline void pte_clear(pte_t *ptep) { pte_val(*ptep) = 0; }
 
extern inline int pmd_none2(pmd_t *pmd) { return !pmd_val(*pmd); }
#define pmd_none(pmd) pmd_none2(&(pmd))
extern inline int pmd_bad2(pmd_t *pmd) { return (pmd_val(*pmd) & _DESCTYPE_MASK) != _PAGE_TABLE || pmd_page(*pmd) > high_memory; }
#define pmd_bad(pmd) pmd_bad2(&(pmd))
extern inline int pmd_present2(pmd_t *pmd) { return pmd_val(*pmd) & _PAGE_TABLE; }
#define pmd_present(pmd) pmd_present2(&(pmd))
extern inline void pmd_clear(pmd_t * pmdp)
{
short i;
 
for (i = 15; i >= 0; i--)
pmdp->pmd[i] = 0;
}
 
extern inline int pgd_none(pgd_t pgd) { return !pgd_val(pgd); }
extern inline int pgd_bad(pgd_t pgd) { return (pgd_val(pgd) & _DESCTYPE_MASK) != _PAGE_TABLE || pgd_page(pgd) > high_memory; }
extern inline int pgd_present(pgd_t pgd) { return pgd_val(pgd) & _PAGE_TABLE; }
 
extern inline void pgd_clear(pgd_t * pgdp) { pgd_val(*pgdp) = 0; }
 
/*
* The following only work if pte_present() is true.
* Undefined behaviour if not..
*/
extern inline int pte_read(pte_t pte) { return 1; }
extern inline int pte_write(pte_t pte) { return !(pte_val(pte) & _PAGE_RONLY); }
extern inline int pte_exec(pte_t pte) { return 1; }
extern inline int pte_dirty(pte_t pte) { return pte_val(pte) & _PAGE_DIRTY; }
extern inline int pte_young(pte_t pte) { return pte_val(pte) & _PAGE_ACCESSED; }
 
extern inline pte_t pte_wrprotect(pte_t pte) { pte_val(pte) |= _PAGE_RONLY; return pte; }
extern inline pte_t pte_rdprotect(pte_t pte) { return pte; }
extern inline pte_t pte_exprotect(pte_t pte) { return pte; }
extern inline pte_t pte_mkclean(pte_t pte) { pte_val(pte) &= ~_PAGE_DIRTY; return pte; }
extern inline pte_t pte_mkold(pte_t pte) { pte_val(pte) &= ~_PAGE_ACCESSED; return pte; }
extern inline pte_t pte_mkwrite(pte_t pte) { pte_val(pte) &= ~_PAGE_RONLY; return pte; }
extern inline pte_t pte_mkread(pte_t pte) { return pte; }
extern inline pte_t pte_mkexec(pte_t pte) { return pte; }
extern inline pte_t pte_mkdirty(pte_t pte) { pte_val(pte) |= _PAGE_DIRTY; return pte; }
extern inline pte_t pte_mkyoung(pte_t pte) { pte_val(pte) |= _PAGE_ACCESSED; return pte; }
extern inline pte_t pte_mknocache(pte_t pte)
{
pte_val(pte) = (pte_val(pte) & _CACHEMASK040) | m68k_pgtable_cachemode;
return pte;
}
extern inline pte_t pte_mkcache(pte_t pte) { pte_val(pte) = (pte_val(pte) & _CACHEMASK040) | _PAGE_CACHE040; return pte; }
 
/* to set the page-dir */
extern inline void SET_PAGE_DIR(struct task_struct * tsk, pgd_t * pgdir)
{
tsk->tss.pagedir_v = (unsigned long *)pgdir;
tsk->tss.pagedir_p = VTOP(pgdir);
tsk->tss.crp[0] = 0x80000000 | _PAGE_SHORT;
tsk->tss.crp[1] = tsk->tss.pagedir_p;
if (tsk == current) {
if (m68k_is040or060)
__asm__ __volatile__ (".word 0xf510\n\t" /* pflushan */
"movel %0@,%/d0\n\t"
".long 0x4e7b0806\n\t"
/* movec d0,urp */
: : "a" (&tsk->tss.crp[1])
: "d0");
else
__asm__ __volatile__ ("movec %/cacr,%/d0\n\t"
"oriw #0x0808,%/d0\n\t"
"movec %/d0,%/cacr\n\t"
"pmove %0@,%/crp\n\t"
: : "a" (&tsk->tss.crp[0])
: "d0");
}
}
 
#define PAGE_DIR_OFFSET(tsk,address) pgd_offset((tsk),(address))
 
/* to find an entry in a page-table-directory */
extern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
{
return mm->pgd + (address >> PGDIR_SHIFT);
}
 
extern pgd_t swapper_pg_dir[128];
extern pgd_t kernel_pg_dir[128];
 
extern inline pgd_t * pgd_offset_k(unsigned long address)
{
return kernel_pg_dir + (address >> PGDIR_SHIFT);
}
 
 
/* Find an entry in the second-level page table.. */
extern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
{
return (pmd_t *) pgd_page(*dir) + ((address >> PMD_SHIFT) & (PTRS_PER_PMD-1));
}
 
/* Find an entry in the third-level page table.. */
extern inline pte_t * pte_offset(pmd_t * pmdp, unsigned long address)
{
return (pte_t *) pmd_page(*pmdp) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
}
 
/*
* Allocate and free page tables. The xxx_kernel() versions are
* used to allocate a kernel page table - this turns on ASN bits
* if any.
*/
 
extern inline void nocache_page (unsigned long vaddr)
{
if (m68k_is040or060) {
pgd_t *dir;
pmd_t *pmdp;
pte_t *ptep;
 
dir = pgd_offset_k(vaddr);
pmdp = pmd_offset(dir,vaddr);
ptep = pte_offset(pmdp,vaddr);
*ptep = pte_mknocache(*ptep);
}
}
 
static inline void cache_page (unsigned long vaddr)
{
if (m68k_is040or060) {
pgd_t *dir;
pmd_t *pmdp;
pte_t *ptep;
 
dir = pgd_offset_k(vaddr);
pmdp = pmd_offset(dir,vaddr);
ptep = pte_offset(pmdp,vaddr);
*ptep = pte_mkcache(*ptep);
}
}
 
 
extern const char PgtabStr_bad_pmd[];
extern const char PgtabStr_bad_pgd[];
extern const char PgtabStr_bad_pmdk[];
extern const char PgtabStr_bad_pgdk[];
 
extern inline void pte_free(pte_t * pte)
{
cache_page((unsigned long)pte);
free_page((unsigned long) pte);
}
 
extern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
{
address = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
if (pmd_none(*pmd)) {
pte_t * page = (pte_t *)get_free_page(GFP_KERNEL);
if (pmd_none(*pmd)) {
if (page) {
nocache_page((unsigned long)page);
pmd_set(pmd,page);
return page + address;
}
pmd_set(pmd, BAD_PAGETABLE);
return NULL;
}
free_page((unsigned long)page);
}
if (pmd_bad(*pmd)) {
printk(PgtabStr_bad_pmd, pmd_val(*pmd));
pmd_set(pmd, BAD_PAGETABLE);
return NULL;
}
return (pte_t *) pmd_page(*pmd) + address;
}
 
extern pmd_t *get_pointer_table (void);
extern void free_pointer_table (pmd_t *);
extern pmd_t *get_kpointer_table (void);
extern void free_kpointer_table (pmd_t *);
 
extern inline void pmd_free(pmd_t * pmd)
{
free_pointer_table (pmd);
}
 
extern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
{
address = (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
if (pgd_none(*pgd)) {
pmd_t *page = get_pointer_table();
if (pgd_none(*pgd)) {
if (page) {
pgd_set(pgd, page);
return page + address;
}
pgd_set(pgd, (pmd_t *)BAD_PAGETABLE);
return NULL;
}
free_pointer_table(page);
}
if (pgd_bad(*pgd)) {
printk(PgtabStr_bad_pgd, pgd_val(*pgd));
pgd_set(pgd, (pmd_t *)BAD_PAGETABLE);
return NULL;
}
return (pmd_t *) pgd_page(*pgd) + address;
}
 
extern inline void pte_free_kernel(pte_t * pte)
{
cache_page((unsigned long)pte);
free_page((unsigned long) pte);
}
 
extern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
{
address = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
if (pmd_none(*pmd)) {
pte_t * page = (pte_t *) get_free_page(GFP_KERNEL);
if (pmd_none(*pmd)) {
if (page) {
nocache_page((unsigned long)page);
pmd_set(pmd, page);
return page + address;
}
pmd_set(pmd, BAD_PAGETABLE);
return NULL;
}
free_page((unsigned long) page);
}
if (pmd_bad(*pmd)) {
printk(PgtabStr_bad_pmdk, pmd_val(*pmd));
pmd_set(pmd, BAD_PAGETABLE);
return NULL;
}
return (pte_t *) pmd_page(*pmd) + address;
}
 
extern inline void pmd_free_kernel(pmd_t * pmd)
{
free_kpointer_table(pmd);
}
 
extern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
{
address = (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
if (pgd_none(*pgd)) {
pmd_t *page = get_kpointer_table();
if (pgd_none(*pgd)) {
if (page) {
pgd_set(pgd, page);
return page + address;
}
pgd_set(pgd, (pmd_t *)BAD_PAGETABLE);
return NULL;
}
free_kpointer_table(page);
}
if (pgd_bad(*pgd)) {
printk(PgtabStr_bad_pgdk, pgd_val(*pgd));
pgd_set(pgd, (pmd_t *)BAD_PAGETABLE);
return NULL;
}
return (pmd_t *) pgd_page(*pgd) + address;
}
 
extern inline void pgd_free(pgd_t * pgd)
{
free_pointer_table ((pmd_t *) pgd);
}
 
extern inline pgd_t * pgd_alloc(void)
{
return (pgd_t *)get_pointer_table ();
}
 
#define flush_icache() \
do { \
if (m68k_is040or060) \
asm ("nop; .word 0xf498 /* cinva %%ic */"); \
else \
asm ("movec %/cacr,%/d0;" \
"oriw %0,%/d0;" \
"movec %/d0,%/cacr" \
: /* no outputs */ \
: "i" (FLUSH_I) \
: "d0"); \
} while (0)
 
/*
* invalidate the cache for the specified memory range.
* It starts at the physical address specified for
* the given number of bytes.
*/
extern void cache_clear (unsigned long paddr, int len);
/*
* push any dirty cache in the specified memory range.
* It starts at the physical address specified for
* the given number of bytes.
*/
extern void cache_push (unsigned long paddr, int len);
 
/*
* push and invalidate pages in the specified user virtual
* memory range.
*/
extern void cache_push_v (unsigned long vaddr, int len);
 
/* cache code */
#define FLUSH_I_AND_D (0x00000808)
#define FLUSH_I (0x00000008)
 
/* This is needed whenever the virtual mapping of the current
process changes. */
#define __flush_cache_all() \
do { \
if (m68k_is040or060) \
__asm__ __volatile__ ("nop; .word 0xf478\n" ::); \
else \
__asm__ __volatile__ ("movec %%cacr,%%d0\n\t" \
"orw %0,%%d0\n\t" \
"movec %%d0,%%cacr" \
: : "di" (FLUSH_I_AND_D) : "d0"); \
} while (0)
 
#define __flush_cache_030() \
do { \
if (m68k_is040or060 == 0) \
__asm__ __volatile__ ("movec %%cacr,%%d0\n\t" \
"orw %0,%%d0\n\t" \
"movec %%d0,%%cacr" \
: : "di" (FLUSH_I_AND_D) : "d0"); \
} while (0)
 
#define flush_cache_all() __flush_cache_all()
 
extern inline void flush_cache_mm(struct mm_struct *mm)
{
if (mm == current->mm) __flush_cache_all();
}
 
extern inline void flush_cache_range(struct mm_struct *mm,
unsigned long start,
unsigned long end)
{
if (mm == current->mm){
if (m68k_is040or060)
cache_push_v(start, end-start);
else
__flush_cache_030();
}
}
 
extern inline void flush_cache_page(struct vm_area_struct *vma,
unsigned long vmaddr)
{
if (vma->vm_mm == current->mm){
if (m68k_is040or060)
cache_push_v(vmaddr, PAGE_SIZE);
else
__flush_cache_030();
}
}
 
/* Push the page at kernel virtual address and clear the icache */
extern inline void flush_page_to_ram (unsigned long address)
{
if (m68k_is040or060) {
register unsigned long tmp __asm ("a0") = VTOP(address);
__asm__ __volatile__ ("nop\n\t"
".word 0xf470 /* cpushp %%dc,(%0) */\n\t"
".word 0xf490 /* cinvp %%ic,(%0) */"
: : "a" (tmp));
}
else
__asm volatile ("movec %%cacr,%%d0\n\t"
"orw %0,%%d0\n\t"
"movec %%d0,%%cacr"
: : "di" (FLUSH_I) : "d0");
}
 
/* Push n pages at kernel virtual address and clear the icache */
extern inline void flush_pages_to_ram (unsigned long address, int n)
{
if (m68k_is040or060) {
while (n--) {
register unsigned long tmp __asm ("a0") = VTOP(address);
__asm__ __volatile__ ("nop\n\t"
".word 0xf470 /* cpushp %%dc,(%0) */\n\t"
".word 0xf490 /* cinvp %%ic,(%0) */"
: : "a" (tmp));
address += PAGE_SIZE;
}
}
else
__asm volatile ("movec %%cacr,%%d0\n\t"
"orw %0,%%d0\n\t"
"movec %%d0,%%cacr"
: : "di" (FLUSH_I) : "d0");
}
 
/*
* Check if the addr/len goes up to the end of a physical
* memory chunk. Used for DMA functions.
*/
int mm_end_of_chunk (unsigned long addr, int len);
 
/*
* Map some physical address range into the kernel address space. The
* code is copied and adapted from map_chunk().
*/
extern unsigned long kernel_map(unsigned long paddr, unsigned long size,
int nocacheflag, unsigned long *memavailp );
/*
* Change the cache mode of some kernel address range.
*/
extern void kernel_set_cachemode( unsigned long address, unsigned long size,
unsigned cmode );
 
/* Values for nocacheflag and cmode */
#define KERNELMAP_FULL_CACHING 0
#define KERNELMAP_NOCACHE_SER 1
#define KERNELMAP_NOCACHE_NONSER 2
#define KERNELMAP_NO_COPYBACK 3
 
/*
* The m68k doesn't have any external MMU info: the kernel page
* tables contain all the necessary information.
*/
extern inline void update_mmu_cache(struct vm_area_struct * vma,
unsigned long address, pte_t pte)
{
}
 
/*
* I don't know what is going on here, but since these were changed,
* swapping hasn't been working on the 68040.
*/
 
#define SWP_TYPE(entry) (((entry) >> 2) & 0x7f)
#if 0
#define SWP_OFFSET(entry) ((entry) >> 9)
#define SWP_ENTRY(type,offset) (((type) << 2) | ((offset) << 9))
#else
#define SWP_OFFSET(entry) ((entry) >> PAGE_SHIFT)
#define SWP_ENTRY(type,offset) (((type) << 2) | ((offset) << PAGE_SHIFT))
#endif
 
#endif /* __ASSEMBLY__ */
 
#endif /* _M68K_PGTABLE_H */
/amifdreg.h
0,0 → 1,81
#ifndef _LINUX_AMIFDREG_H
#define _LINUX_AMIFDREG_H
 
/*
** CIAAPRA bits (read only)
*/
 
#define DSKRDY (0x1<<5) /* disk ready when low */
#define DSKTRACK0 (0x1<<4) /* head at track zero when low */
#define DSKPROT (0x1<<3) /* disk protected when low */
#define DSKCHANGE (0x1<<2) /* low when disk removed */
 
/*
** CIAAPRB bits (read/write)
*/
 
#define DSKMOTOR (0x1<<7) /* motor on when low */
#define DSKSEL3 (0x1<<6) /* select drive 3 when low */
#define DSKSEL2 (0x1<<5) /* select drive 2 when low */
#define DSKSEL1 (0x1<<4) /* select drive 1 when low */
#define DSKSEL0 (0x1<<3) /* select drive 0 when low */
#define DSKSIDE (0x1<<2) /* side selection: 0 = upper, 1 = lower */
#define DSKDIREC (0x1<<1) /* step direction: 0=in, 1=out (to trk 0) */
#define DSKSTEP (0x1) /* pulse low to step head 1 track */
 
/*
** DSKBYTR bits (read only)
*/
 
#define DSKBYT (1<<15) /* register contains valid byte when set */
#define DMAON (1<<14) /* disk DMA enabled */
#define DISKWRITE (1<<13) /* disk write bit in DSKLEN enabled */
#define WORDEQUAL (1<<12) /* DSKSYNC register match when true */
/* bits 7-0 are data */
 
/*
** ADKCON/ADKCONR bits
*/
 
#ifndef SETCLR
#define ADK_SETCLR (1<<15) /* control bit */
#endif
#define ADK_PRECOMP1 (1<<14) /* precompensation selection */
#define ADK_PRECOMP0 (1<<13) /* 00=none, 01=140ns, 10=280ns, 11=500ns */
#define ADK_MFMPREC (1<<12) /* 0=GCR precomp., 1=MFM precomp. */
#define ADK_WORDSYNC (1<<10) /* enable DSKSYNC auto DMA */
#define ADK_MSBSYNC (1<<9) /* when 1, enable sync on MSbit (for GCR) */
#define ADK_FAST (1<<8) /* bit cell: 0=2us (GCR), 1=1us (MFM) */
/*
** DSKLEN bits
*/
 
#define DSKLEN_DMAEN (1<<15)
#define DSKLEN_WRITE (1<<14)
 
/*
** INTENA/INTREQ bits
*/
 
#define DSKINDEX (0x1<<4) /* DSKINDEX bit */
 
/*
** Misc
*/
#define MFM_SYNC 0x4489 /* standard MFM sync value */
 
/* Values for FD_COMMAND */
#define FD_RECALIBRATE 0x07 /* move to track 0 */
#define FD_SEEK 0x0F /* seek track */
#define FD_READ 0xE6 /* read with MT, MFM, SKip deleted */
#define FD_WRITE 0xC5 /* write with MT, MFM */
#define FD_SENSEI 0x08 /* Sense Interrupt Status */
#define FD_SPECIFY 0x03 /* specify HUT etc */
#define FD_FORMAT 0x4D /* format one track */
#define FD_VERSION 0x10 /* get version code */
#define FD_CONFIGURE 0x13 /* configure FIFO operation */
#define FD_PERPENDICULAR 0x12 /* perpendicular r/w mode */
 
#endif /* _LINUX_AMIFDREG_H */
/bootinfo.h
0,0 → 1,289
/*
** asm/bootinfo.h -- Definition of the Linux/68K boot information structure
**
** Copyright 1992 by Greg Harp
**
** This file is subject to the terms and conditions of the GNU General Public
** License. See the file COPYING in the main directory of this archive
** for more details.
**
** Created 09/29/92 by Greg Harp
**
** 5/2/94 Roman Hodek:
** Added bi_atari part of the machine dependent union bi_un; for now it
** contains just a model field to distinguish between TT and Falcon.
*/
 
#ifndef BOOTINFO_H
#define BOOTINFO_H
 
#include <asm/zorro.h>
 
/*
* Amiga specific part of bootinfo structure.
*/
 
#define NUM_AUTO 16
 
#ifndef __ASSEMBLY__
 
#define AMIGAHW_DECLARE(name) unsigned name : 1
#define AMIGAHW_SET(name) (boot_info.bi_amiga.hw_present.name = 1)
#define AMIGAHW_PRESENT(name) (boot_info.bi_amiga.hw_present.name)
 
struct bi_Amiga {
int model; /* Amiga Model (3000?) */
int num_autocon; /* # of autoconfig devices found */
struct ConfigDev autocon[NUM_AUTO]; /* up to 16 autoconfig devices */
#ifdef HACKER_KERNEL
void (*exit_func)(void); /* addr of function to exit kernel */
unsigned long chip_addr; /* start of chip memory (bytes) */
#endif
unsigned long chip_size; /* size of chip memory (bytes) */
unsigned char vblank; /* VBLANK frequency */
unsigned char psfreq; /* power supply frequency */
unsigned long eclock; /* EClock frequency */
unsigned long chipset; /* native chipset present */
struct {
/* video hardware */
AMIGAHW_DECLARE(AMI_VIDEO); /* Amiga Video */
AMIGAHW_DECLARE(AMI_BLITTER); /* Amiga Blitter */
AMIGAHW_DECLARE(AMBER_FF); /* Amber Flicker Fixer */
/* sound hardware */
AMIGAHW_DECLARE(AMI_AUDIO); /* Amiga Audio */
/* disk storage interfaces */
AMIGAHW_DECLARE(AMI_FLOPPY); /* Amiga Floppy */
AMIGAHW_DECLARE(A3000_SCSI); /* SCSI (wd33c93, A3000 alike) */
AMIGAHW_DECLARE(A4000_SCSI); /* SCSI (ncr53c710, A4000T alike) */
AMIGAHW_DECLARE(A1200_IDE); /* IDE (A1200 alike) */
AMIGAHW_DECLARE(A4000_IDE); /* IDE (A4000 alike) */
AMIGAHW_DECLARE(CD_ROM); /* CD ROM drive */
/* other I/O hardware */
AMIGAHW_DECLARE(AMI_KEYBOARD); /* Amiga Keyboard */
AMIGAHW_DECLARE(AMI_MOUSE); /* Amiga Mouse */
AMIGAHW_DECLARE(AMI_SERIAL); /* Amiga Serial */
AMIGAHW_DECLARE(AMI_PARALLEL); /* Amiga Parallel */
/* real time clocks */
AMIGAHW_DECLARE(A2000_CLK); /* Hardware Clock (A2000 alike) */
AMIGAHW_DECLARE(A3000_CLK); /* Hardware Clock (A3000 alike) */
/* supporting hardware */
AMIGAHW_DECLARE(CHIP_RAM); /* Chip RAM */
AMIGAHW_DECLARE(PAULA); /* Paula (8364) */
AMIGAHW_DECLARE(DENISE); /* Denise (8362) */
AMIGAHW_DECLARE(DENISE_HR); /* Denise (8373) */
AMIGAHW_DECLARE(LISA); /* Lisa (8375) */
AMIGAHW_DECLARE(AGNUS_PAL); /* Normal/Fat PAL Agnus (8367/8371) */
AMIGAHW_DECLARE(AGNUS_NTSC); /* Normal/Fat NTSC Agnus (8361/8370) */
AMIGAHW_DECLARE(AGNUS_HR_PAL); /* Fat Hires PAL Agnus (8372) */
AMIGAHW_DECLARE(AGNUS_HR_NTSC); /* Fat Hires NTSC Agnus (8372) */
AMIGAHW_DECLARE(ALICE_PAL); /* PAL Alice (8374) */
AMIGAHW_DECLARE(ALICE_NTSC); /* NTSC Alice (8374) */
AMIGAHW_DECLARE(MAGIC_REKICK); /* A3000 Magic Hard Rekick */
AMIGAHW_DECLARE(ZORRO); /* Zorro AutoConfig */
} hw_present;
};
 
#else /* __ASSEMBLY__ */
BI_amiga_model = BI_un
BI_amiga_num_autcon = BI_amiga_model+4
BI_amiga_autocon = BI_amiga_num_autcon+4
#ifdef HACKER_KERNEL
BI_amiga_exit_func = BI_amiga_autocon+(CD_sizeof*NUM_AUTO)
BI_amiga_chip_addr = BI_amiga_exit_func+4
BI_amiga_chip_size = BI_amiga_chip_addr+4
#else
BI_amiga_chip_size = BI_amiga_autocon+(CD_sizeof*NUM_AUTO)
#endif
BI_amiga_vblank = BI_amiga_chip_size+4
BI_amiga_psfreq = BI_amiga_vblank+1
BI_amiga_eclock = BI_amiga_psfreq+1
BI_amiga_chipset = BI_amiga_eclock+4
BI_amiga_hw_present = BI_amiga_chipset+4
 
#endif /* __ASSEMBLY__ */
 
/* Atari specific part of bootinfo */
 
/*
* Define several Hardware-Chips for indication so that for the ATARI we do
* no longer decide whether it is a Falcon or other machine . It's just
* important what hardware the machine uses
*/
 
/* ++roman 08/08/95: rewritten from ORing constants to a C bitfield */
 
#ifndef __ASSEMBLY__
 
#define ATARIHW_DECLARE(name) unsigned name : 1
#define ATARIHW_SET(name) (boot_info.bi_atari.hw_present.name = 1)
#define ATARIHW_PRESENT(name) (boot_info.bi_atari.hw_present.name)
 
struct bi_Atari {
struct {
/* video hardware */
ATARIHW_DECLARE(STND_SHIFTER); /* ST-Shifter - no base low ! */
ATARIHW_DECLARE(EXTD_SHIFTER); /* STe-Shifter - 24 bit address */
ATARIHW_DECLARE(TT_SHIFTER); /* TT-Shifter */
ATARIHW_DECLARE(VIDEL_SHIFTER); /* Falcon-Shifter */
/* sound hardware */
ATARIHW_DECLARE(YM_2149); /* Yamaha YM 2149 */
ATARIHW_DECLARE(PCM_8BIT); /* PCM-Sound in STe-ATARI */
ATARIHW_DECLARE(CODEC); /* CODEC Sound (Falcon) */
/* disk storage interfaces */
ATARIHW_DECLARE(TT_SCSI); /* Directly mapped NCR5380 */
ATARIHW_DECLARE(ST_SCSI); /* NCR5380 via ST-DMA (Falcon) */
ATARIHW_DECLARE(ACSI); /* Standard ACSI like in STs */
ATARIHW_DECLARE(IDE); /* IDE Interface */
ATARIHW_DECLARE(FDCSPEED); /* 8/16 MHz switch for FDC */
/* other I/O hardware */
ATARIHW_DECLARE(ST_MFP); /* The ST-MFP (there should
be no Atari without
it... but who knows?) */
ATARIHW_DECLARE(TT_MFP); /* 2nd MFP */
ATARIHW_DECLARE(SCC); /* Serial Communications Contr. */
ATARIHW_DECLARE(ST_ESCC); /* SCC Z83230 in an ST */
ATARIHW_DECLARE(ANALOG_JOY); /* Paddle Interface for STe
and Falcon */
ATARIHW_DECLARE(MICROWIRE); /* Microwire Interface */
/* DMA */
ATARIHW_DECLARE(STND_DMA); /* 24 Bit limited ST-DMA */
ATARIHW_DECLARE(EXTD_DMA); /* 32 Bit ST-DMA */
ATARIHW_DECLARE(SCSI_DMA); /* DMA for the NCR5380 */
ATARIHW_DECLARE(SCC_DMA); /* DMA for the SCC */
/* real time clocks */
ATARIHW_DECLARE(TT_CLK); /* TT compatible clock chip */
ATARIHW_DECLARE(MSTE_CLK); /* Mega ST(E) clock chip */
/* supporting hardware */
ATARIHW_DECLARE(SCU); /* System Control Unit */
ATARIHW_DECLARE(BLITTER); /* Blitter */
ATARIHW_DECLARE(VME); /* VME Bus */
} hw_present;
unsigned long mch_cookie; /* _MCH cookie from TOS */
};
 
/* mch_cookie values (upper word) */
#define ATARI_MCH_ST 0
#define ATARI_MCH_STE 1
#define ATARI_MCH_TT 2
#define ATARI_MCH_FALCON 3
 
struct mem_info {
unsigned long addr; /* physical address of memory chunk */
unsigned long size; /* length of memory chunk (in bytes) */
};
 
#else /* __ASSEMBLY__ */
 
MI_addr = 0
MI_size = MI_addr+4
MI_sizeof = MI_size+4
 
#endif /* __ASSEMBLY__ */
 
#define NUM_MEMINFO 4
 
#define MACH_AMIGA 1
#define MACH_ATARI 2
#define MACH_MAC 3
 
/*
* CPU and FPU types
*/
 
#define CPUB_68020 0
#define CPUB_68030 1
#define CPUB_68040 2
#define CPUB_68060 3
#define FPUB_68881 5
#define FPUB_68882 6
#define FPUB_68040 7 /* Internal FPU */
#define FPUB_68060 8 /* Internal FPU */
 
#define CPU_68020 (1<<CPUB_68020)
#define CPU_68030 (1<<CPUB_68030)
#define CPU_68040 (1<<CPUB_68040)
#define CPU_68060 (1<<CPUB_68060)
#define CPU_MASK (31)
#define FPU_68881 (1<<FPUB_68881)
#define FPU_68882 (1<<FPUB_68882)
#define FPU_68040 (1<<FPUB_68040) /* Internal FPU */
#define FPU_68060 (1<<FPUB_68060) /* Internal FPU */
 
#define CL_SIZE (256)
 
#ifndef __ASSEMBLY__
 
#define MACH_IS_AMIGA (boot_info.machtype == MACH_AMIGA)
#define MACH_IS_ATARI (boot_info.machtype == MACH_ATARI)
 
struct bootinfo {
unsigned long machtype; /* machine type */
unsigned long cputype; /* system CPU & FPU */
struct mem_info memory[NUM_MEMINFO]; /* memory description */
int num_memory; /* # of memory blocks found */
unsigned long ramdisk_size; /* ramdisk size in 1024 byte blocks */
unsigned long ramdisk_addr; /* address of the ram disk in mem */
char command_line[CL_SIZE]; /* kernel command line parameters */
union {
struct bi_Amiga bi_ami; /* Amiga specific information */
struct bi_Atari bi_ata; /* Atari specific information */
} bi_un;
};
#define bi_amiga bi_un.bi_ami
#define bi_atari bi_un.bi_ata
#define bi_mac bi_un.bi_mac
 
extern struct bootinfo
boot_info;
 
#else /* __ASSEMBLY__ */
 
BI_machtype = 0
BI_cputype = BI_machtype+4
BI_memory = BI_cputype+4
BI_num_memory = BI_memory+(MI_sizeof*NUM_MEMINFO)
BI_ramdisk_size = BI_num_memory+4
BI_ramdisk_addr = BI_ramdisk_size+4
BI_command_line = BI_ramdisk_addr+4
BI_un = BI_command_line+CL_SIZE
 
#endif /* __ASSEMBLY__ */
 
 
/*
* Stuff for bootinfo interface versioning
*
* At the start of kernel code, a 'struct bootversion' is located. bootstrap
* checks for a matching version of the interface before booting a kernel, to
* avoid user confusion if kernel and bootstrap don't work together :-)
*
* If incompatible changes are made to the bootinfo interface, the major
* number below should be stepped (and the minor reset to 0) for the
* appropriate machine. If a change is backward-compatible, the minor should
* be stepped. "Backwards-compatible" means that booting will work, but
* certain features may not.
*/
 
#define BOOTINFOV_MAGIC 0x4249561A /* 'BIV^Z' */
#define MK_BI_VERSION(major,minor) (((major)<<16)+(minor))
#define BI_VERSION_MAJOR(v) (((v) >> 16) & 0xffff)
#define BI_VERSION_MINOR(v) ((v) & 0xffff)
 
#ifndef __ASSEMBLY__
 
struct bootversion {
unsigned short branch;
unsigned long magic;
struct {
unsigned long machtype;
unsigned long version;
} machversions[0];
};
 
#endif /* __ASSEMBLY__ */
 
#define AMIGA_BOOTI_VERSION MK_BI_VERSION( 1, 0 )
#define ATARI_BOOTI_VERSION MK_BI_VERSION( 1, 0 )
 
#endif /* BOOTINFO_H */
/amihdreg.h
0,0 → 1,31
#ifndef _LINUX_AMIHDREG_H
#define _LINUX_AMIHDREG_H
 
/*
* This file contains some defines for the Amiga IDE hd controller.
* Various sources. Check out some definitions (see comments with
* a ques).
*/
 
#define IDE_DISABLE_IRQ 0x02
#define IDE_ENABLE_IRQ 0x00
/* Bases of the hard drive controller */
#define HD_BASE_A4000 0xdd2020
#define HD_BASE_A1200 0xda0000
 
/* Offsets from one of the above bases */
#define AMI_HD_ERROR (0x06) /* see err-bits */
#define AMI_HD_NSECTOR (0x0a) /* nr of sectors to read/write */
#define AMI_HD_SECTOR (0x0e) /* starting sector */
#define AMI_HD_LCYL (0x12) /* starting cylinder */
#define AMI_HD_HCYL (0x16) /* high byte of starting cyl */
#define AMI_HD_SELECT (0x1a) /* 101dhhhh , d=drive, hhhh=head */
#define AMI_HD_STATUS (0x1e) /* see status-bits */
#define AMI_HD_CMD (0x101a)
 
/* These are at different offsets from the base */
#define HD_A4000_IRQ (0xdd3020) /* MSB = 1, Harddisk is source of interrupt */
#define HD_A1200_IRQ (0xda9000) /* MSB = 1, Harddisk is source of interrupt */
 
#endif
/termios.h
0,0 → 1,90
#ifndef _M68K_TERMIOS_H
#define _M68K_TERMIOS_H
 
#include <asm/termbits.h>
#include <asm/ioctls.h>
struct winsize {
unsigned short ws_row;
unsigned short ws_col;
unsigned short ws_xpixel;
unsigned short ws_ypixel;
};
 
#define NCC 8
struct termio {
unsigned short c_iflag; /* input mode flags */
unsigned short c_oflag; /* output mode flags */
unsigned short c_cflag; /* control mode flags */
unsigned short c_lflag; /* local mode flags */
unsigned char c_line; /* line discipline */
unsigned char c_cc[NCC]; /* control characters */
};
 
#ifdef __KERNEL__
/* intr=^C quit=^| erase=del kill=^U
eof=^D vtime=\0 vmin=\1 sxtc=\0
start=^Q stop=^S susp=^Z eol=\0
reprint=^R discard=^U werase=^W lnext=^V
eol2=\0
*/
#define INIT_C_CC "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0"
#endif
 
/* modem lines */
#define TIOCM_LE 0x001
#define TIOCM_DTR 0x002
#define TIOCM_RTS 0x004
#define TIOCM_ST 0x008
#define TIOCM_SR 0x010
#define TIOCM_CTS 0x020
#define TIOCM_CAR 0x040
#define TIOCM_RNG 0x080
#define TIOCM_DSR 0x100
#define TIOCM_CD TIOCM_CAR
#define TIOCM_RI TIOCM_RNG
 
/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
 
/* line disciplines */
#define N_TTY 0
#define N_SLIP 1
#define N_MOUSE 2
#define N_PPP 3
#define N_STRIP 4
#define N_AX25 5
 
#ifdef __KERNEL__
 
/*
* Translate a "termio" structure into a "termios". Ugh.
*/
extern inline void trans_from_termio(struct termio * termio,
struct termios * termios)
{
#define SET_LOW_BITS(x,y) ((x) = (0xffff0000 & (x)) | (y))
SET_LOW_BITS(termios->c_iflag, termio->c_iflag);
SET_LOW_BITS(termios->c_oflag, termio->c_oflag);
SET_LOW_BITS(termios->c_cflag, termio->c_cflag);
SET_LOW_BITS(termios->c_lflag, termio->c_lflag);
#undef SET_LOW_BITS
memcpy(termios->c_cc, termio->c_cc, NCC);
}
 
/*
* Translate a "termios" structure into a "termio". Ugh.
*/
extern inline void trans_to_termio(struct termios * termios,
struct termio * termio)
{
termio->c_iflag = termios->c_iflag;
termio->c_oflag = termios->c_oflag;
termio->c_cflag = termios->c_cflag;
termio->c_lflag = termios->c_lflag;
termio->c_line = termios->c_line;
memcpy(termio->c_cc, termios->c_cc, NCC);
}
 
#endif /* __KERNEL__ */
 
#endif /* _M68K_TERMIOS_H */
/termbits.h
0,0 → 1,162
#ifndef __ARCH_M68K_TERMBITS_H__
#define __ARCH_M68K_TERMBITS_H__
 
#include <linux/posix_types.h>
 
typedef unsigned char cc_t;
typedef unsigned int speed_t;
typedef unsigned int tcflag_t;
 
#define NCCS 19
struct termios {
tcflag_t c_iflag; /* input mode flags */
tcflag_t c_oflag; /* output mode flags */
tcflag_t c_cflag; /* control mode flags */
tcflag_t c_lflag; /* local mode flags */
cc_t c_line; /* line discipline */
cc_t c_cc[NCCS]; /* control characters */
};
 
/* c_cc characters */
#define VINTR 0
#define VQUIT 1
#define VERASE 2
#define VKILL 3
#define VEOF 4
#define VTIME 5
#define VMIN 6
#define VSWTC 7
#define VSTART 8
#define VSTOP 9
#define VSUSP 10
#define VEOL 11
#define VREPRINT 12
#define VDISCARD 13
#define VWERASE 14
#define VLNEXT 15
#define VEOL2 16
 
 
/* c_iflag bits */
#define IGNBRK 0000001
#define BRKINT 0000002
#define IGNPAR 0000004
#define PARMRK 0000010
#define INPCK 0000020
#define ISTRIP 0000040
#define INLCR 0000100
#define IGNCR 0000200
#define ICRNL 0000400
#define IUCLC 0001000
#define IXON 0002000
#define IXANY 0004000
#define IXOFF 0010000
#define IMAXBEL 0020000
 
/* c_oflag bits */
#define OPOST 0000001
#define OLCUC 0000002
#define ONLCR 0000004
#define OCRNL 0000010
#define ONOCR 0000020
#define ONLRET 0000040
#define OFILL 0000100
#define OFDEL 0000200
#define NLDLY 0000400
#define NL0 0000000
#define NL1 0000400
#define CRDLY 0003000
#define CR0 0000000
#define CR1 0001000
#define CR2 0002000
#define CR3 0003000
#define TABDLY 0014000
#define TAB0 0000000
#define TAB1 0004000
#define TAB2 0010000
#define TAB3 0014000
#define XTABS 0014000
#define BSDLY 0020000
#define BS0 0000000
#define BS1 0020000
#define VTDLY 0040000
#define VT0 0000000
#define VT1 0040000
#define FFDLY 0100000
#define FF0 0000000
#define FF1 0100000
 
/* c_cflag bit meaning */
#define CBAUD 0010017
#define B0 0000000 /* hang up */
#define B50 0000001
#define B75 0000002
#define B110 0000003
#define B134 0000004
#define B150 0000005
#define B200 0000006
#define B300 0000007
#define B600 0000010
#define B1200 0000011
#define B1800 0000012
#define B2400 0000013
#define B4800 0000014
#define B9600 0000015
#define B19200 0000016
#define B38400 0000017
#define EXTA B19200
#define EXTB B38400
#define CSIZE 0000060
#define CS5 0000000
#define CS6 0000020
#define CS7 0000040
#define CS8 0000060
#define CSTOPB 0000100
#define CREAD 0000200
#define PARENB 0000400
#define PARODD 0001000
#define HUPCL 0002000
#define CLOCAL 0004000
#define CBAUDEX 0010000
#define B57600 0010001
#define B115200 0010002
#define B230400 0010003
#define B460800 0010004
#define CIBAUD 002003600000 /* input baud rate (not used) */
#define CRTSCTS 020000000000 /* flow control */
 
/* c_lflag bits */
#define ISIG 0000001
#define ICANON 0000002
#define XCASE 0000004
#define ECHO 0000010
#define ECHOE 0000020
#define ECHOK 0000040
#define ECHONL 0000100
#define NOFLSH 0000200
#define TOSTOP 0000400
#define ECHOCTL 0001000
#define ECHOPRT 0002000
#define ECHOKE 0004000
#define FLUSHO 0010000
#define PENDIN 0040000
#define IEXTEN 0100000
 
 
/* tcflow() and TCXONC use these */
#define TCOOFF 0
#define TCOON 1
#define TCIOFF 2
#define TCION 3
 
/* tcflush() and TCFLSH use these */
#define TCIFLUSH 0
#define TCOFLUSH 1
#define TCIOFLUSH 2
 
/* tcsetattr uses these */
#define TCSANOW 0
#define TCSADRAIN 1
#define TCSAFLUSH 2
 
#endif /* __ARCH_M68K_TERMBITS_H__ */
/atariints.h
0,0 → 1,220
/*
** atariints.h -- Atari Linux interrupt handling structs and prototypes
**
 
**
** 5/2/94 Roman Hodek:
** TT interrupt definitions added.
**
** 12/02/96: (Roman)
** Adapted to new int handling scheme (see ataints.c); revised numbering
**
** This file is subject to the terms and conditions of the GNU General Public
** License. See the file COPYING in the main directory of this archive
** for more details.
**
*/
 
#ifndef _LINUX_ATARIINTS_H_
#define _LINUX_ATARIINTS_H_
 
#include <asm/irq.h>
#include <asm/atarihw.h>
 
/*
** Atari Interrupt sources.
**
*/
 
#define STMFP_SOURCE_BASE 8
#define TTMFP_SOURCE_BASE 24
#define SCC_SOURCE_BASE 40
#define VME_SOURCE_BASE 56
#define VME_MAX_SOURCES 16
 
#define NUM_ATARI_SOURCES (VME_SOURCE_BASE+VME_MAX_SOURCES-STMFP_SOURCE_BASE)
 
/* convert vector number to int source number */
#define IRQ_VECTOR_TO_SOURCE(v) ((v) - ((v) < 0x20 ? 0x18 : (0x40-8)))
 
/* convert irq_handler index to vector number */
#define IRQ_SOURCE_TO_VECTOR(i) ((i) + ((i) < 8 ? 0x18 : (0x40-8)))
 
/* interrupt service types */
#define IRQ_TYPE_SLOW 0
#define IRQ_TYPE_FAST 1
#define IRQ_TYPE_PRIO 2
 
#define IRQ_SPURIOUS (IRQ_MACHSPEC | 0)
 
/* auto-vector interrupts */
#define IRQ_AUTO_1 (IRQ_MACHSPEC | 1)
#define IRQ_AUTO_2 (IRQ_MACHSPEC | 2)
#define IRQ_AUTO_3 (IRQ_MACHSPEC | 3)
#define IRQ_AUTO_4 (IRQ_MACHSPEC | 4)
#define IRQ_AUTO_5 (IRQ_MACHSPEC | 5)
#define IRQ_AUTO_6 (IRQ_MACHSPEC | 6)
#define IRQ_AUTO_7 (IRQ_MACHSPEC | 7)
 
/* ST-MFP interrupts */
#define IRQ_MFP_BUSY (IRQ_MACHSPEC | 8)
#define IRQ_MFP_DCD (IRQ_MACHSPEC | 9)
#define IRQ_MFP_CTS (IRQ_MACHSPEC | 10)
#define IRQ_MFP_GPU (IRQ_MACHSPEC | 11)
#define IRQ_MFP_TIMD (IRQ_MACHSPEC | 12)
#define IRQ_MFP_TIMC (IRQ_MACHSPEC | 13)
#define IRQ_MFP_ACIA (IRQ_MACHSPEC | 14)
#define IRQ_MFP_FDC (IRQ_MACHSPEC | 15)
#define IRQ_MFP_ACSI IRQ_MFP_FDC
#define IRQ_MFP_FSCSI IRQ_MFP_FDC
#define IRQ_MFP_IDE IRQ_MFP_FDC
#define IRQ_MFP_TIMB (IRQ_MACHSPEC | 16)
#define IRQ_MFP_SERERR (IRQ_MACHSPEC | 17)
#define IRQ_MFP_SEREMPT (IRQ_MACHSPEC | 18)
#define IRQ_MFP_RECERR (IRQ_MACHSPEC | 19)
#define IRQ_MFP_RECFULL (IRQ_MACHSPEC | 20)
#define IRQ_MFP_TIMA (IRQ_MACHSPEC | 21)
#define IRQ_MFP_RI (IRQ_MACHSPEC | 22)
#define IRQ_MFP_MMD (IRQ_MACHSPEC | 23)
 
/* TT-MFP interrupts */
#define IRQ_TT_MFP_IO0 (IRQ_MACHSPEC | 24)
#define IRQ_TT_MFP_IO1 (IRQ_MACHSPEC | 25)
#define IRQ_TT_MFP_SCC (IRQ_MACHSPEC | 26)
#define IRQ_TT_MFP_RI (IRQ_MACHSPEC | 27)
#define IRQ_TT_MFP_TIMD (IRQ_MACHSPEC | 28)
#define IRQ_TT_MFP_TIMC (IRQ_MACHSPEC | 29)
#define IRQ_TT_MFP_DRVRDY (IRQ_MACHSPEC | 30)
#define IRQ_TT_MFP_SCSIDMA (IRQ_MACHSPEC | 31)
#define IRQ_TT_MFP_TIMB (IRQ_MACHSPEC | 32)
#define IRQ_TT_MFP_SERERR (IRQ_MACHSPEC | 33)
#define IRQ_TT_MFP_SEREMPT (IRQ_MACHSPEC | 34)
#define IRQ_TT_MFP_RECERR (IRQ_MACHSPEC | 35)
#define IRQ_TT_MFP_RECFULL (IRQ_MACHSPEC | 36)
#define IRQ_TT_MFP_TIMA (IRQ_MACHSPEC | 37)
#define IRQ_TT_MFP_RTC (IRQ_MACHSPEC | 38)
#define IRQ_TT_MFP_SCSI (IRQ_MACHSPEC | 39)
 
/* SCC interrupts */
#define IRQ_SCCB_TX (IRQ_MACHSPEC | 40)
#define IRQ_SCCB_STAT (IRQ_MACHSPEC | 42)
#define IRQ_SCCB_RX (IRQ_MACHSPEC | 44)
#define IRQ_SCCB_SPCOND (IRQ_MACHSPEC | 46)
#define IRQ_SCCA_TX (IRQ_MACHSPEC | 48)
#define IRQ_SCCA_STAT (IRQ_MACHSPEC | 50)
#define IRQ_SCCA_RX (IRQ_MACHSPEC | 52)
#define IRQ_SCCA_SPCOND (IRQ_MACHSPEC | 54)
 
 
#define INT_CLK 24576 /* CLK while int_clk =2.456MHz and divide = 100 */
#define INT_TICKS 246 /* to make sched_time = 99.902... HZ */
 
 
#define MFP_ENABLE 0
#define MFP_PENDING 1
#define MFP_SERVICE 2
#define MFP_MASK 3
 
/* Utility functions for setting/clearing bits in the interrupt registers of
* the MFP. 'type' should be constant, if 'irq' is constant, too, code size is
* reduced. set_mfp_bit() is nonsense for PENDING and SERVICE registers. */
 
static inline int get_mfp_bit( unsigned irq, int type )
 
{ unsigned char mask, *reg;
mask = 1 << (irq & 7);
reg = (unsigned char *)&mfp.int_en_a + type*4 +
((irq & 8) >> 2) + (((irq-8) & 16) << 3);
return( *reg & mask );
}
 
static inline void set_mfp_bit( unsigned irq, int type )
 
{ unsigned char mask, *reg;
mask = 1 << (irq & 7);
reg = (unsigned char *)&mfp.int_en_a + type*4 +
((irq & 8) >> 2) + (((irq-8) & 16) << 3);
__asm__ __volatile__ ( "orb %0,%1"
: : "di" (mask), "m" (*reg) : "memory" );
}
 
static inline void clear_mfp_bit( unsigned irq, int type )
 
{ unsigned char mask, *reg;
mask = ~(1 << (irq & 7));
reg = (unsigned char *)&mfp.int_en_a + type*4 +
((irq & 8) >> 2) + (((irq-8) & 16) << 3);
if (type == MFP_PENDING || type == MFP_SERVICE)
__asm__ __volatile__ ( "moveb %0,%1"
: : "di" (mask), "m" (*reg) : "memory" );
else
__asm__ __volatile__ ( "andb %0,%1"
: : "di" (mask), "m" (*reg) : "memory" );
}
 
/*
* {en,dis}able_irq have the usual semantics of temporary blocking the
* interrupt, but not loosing requests that happen between disabling and
* enabling. This is done with the MFP mask registers.
*/
 
static inline void atari_enable_irq( unsigned irq )
 
{
irq &= ~IRQ_MACHSPEC;
if (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE) return;
set_mfp_bit( irq, MFP_MASK );
}
 
static inline void atari_disable_irq( unsigned irq )
 
{
irq &= ~IRQ_MACHSPEC;
if (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE) return;
clear_mfp_bit( irq, MFP_MASK );
}
 
/*
* In opposite to {en,dis}able_irq, requests between turn{off,on}_irq are not
* "stored"
*/
 
extern inline void atari_turnon_irq( unsigned irq )
 
{
irq &= ~IRQ_MACHSPEC;
if (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE) return;
set_mfp_bit( irq, MFP_ENABLE );
}
 
extern inline void atari_turnoff_irq( unsigned irq )
 
{
irq &= ~IRQ_MACHSPEC;
if (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE) return;
clear_mfp_bit( irq, MFP_ENABLE );
clear_mfp_bit( irq, MFP_PENDING );
}
 
extern inline void atari_clear_pending_irq( unsigned irq )
 
{
irq &= ~IRQ_MACHSPEC;
if (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE) return;
clear_mfp_bit( irq, MFP_PENDING );
}
 
extern inline int atari_irq_pending( unsigned irq )
 
{
irq &= ~IRQ_MACHSPEC;
if (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE) return( 0 );
return( get_mfp_bit( irq, MFP_PENDING ) );
}
 
unsigned long atari_register_vme_int( void );
 
#endif /* linux/atariints.h */
/ide.h
0,0 → 1,246
#ifndef _M68K_IDE_H
#define _M68K_IDE_H
 
/* Copyright(c) 1996 Kars de Jong */
/* Based on the ide driver from 1.2.13pl8 */
 
#include <linux/config.h>
 
#ifdef CONFIG_AMIGA
#include <asm/amigahw.h>
#include <asm/amihdreg.h>
#include <asm/amigaints.h>
#endif /* CONFIG_AMIGA */
 
#ifdef CONFIG_ATARI
#include <asm/atarihw.h>
#include <asm/atarihdreg.h>
#include <asm/atariints.h>
#include <asm/atari_stdma.h>
#endif /* CONFIG_ATARI */
 
#include <asm/bootinfo.h>
 
struct hd_regs_struct {
unsigned int hd_error,
hd_nsector,
hd_sector,
hd_lcyl,
hd_hcyl,
hd_select,
hd_status;
};
 
static struct hd_regs_struct hd_regs;
static void probe_m68k_ide (void);
 
/* Undefine these again, they were defined for the PC. */
#undef IDE_ERROR_OFFSET
#undef IDE_NSECTOR_OFFSET
#undef IDE_SECTOR_OFFSET
#undef IDE_LCYL_OFFSET
#undef IDE_HCYL_OFFSET
#undef IDE_SELECT_OFFSET
#undef IDE_STATUS_OFFSET
#undef IDE_FEATURE_OFFSET
#undef IDE_COMMAND_OFFSET
#undef SELECT_DRIVE
 
#define IDE_ERROR_OFFSET hd_regs.hd_error
#define IDE_NSECTOR_OFFSET hd_regs.hd_nsector
#define IDE_SECTOR_OFFSET hd_regs.hd_sector
#define IDE_LCYL_OFFSET hd_regs.hd_lcyl
#define IDE_HCYL_OFFSET hd_regs.hd_hcyl
#define IDE_SELECT_OFFSET hd_regs.hd_select
#define IDE_STATUS_OFFSET hd_regs.hd_status
#define IDE_FEATURE_OFFSET IDE_ERROR_OFFSET
#define IDE_COMMAND_OFFSET IDE_STATUS_OFFSET
 
#undef SUPPORT_VLB_SYNC
#define SUPPORT_VLB_SYNC 0
 
#undef HD_DATA
#define HD_DATA NULL
 
/* MSch: changed sti() to STI() wherever possible in ide.c; moved STI() def.
* to asm/ide.h
*/
/* The Atari interrupt structure strictly requires that the IPL isn't lowered
* uncontrolled in an interrupt handler. In the concrete case, the IDE
* interrupt is already a slow int, so the irq is already disabled at the time
* the handler is called, and the IPL has been lowered to the minimum value
* possible. To avoid going below that, STI() checks for being called inside
* an interrupt, and in that case it does nothing. Hope that is reasonable and
* works. (Roman)
*/
#if defined(CONFIG_ATARI) && !defined(CONFIG_AMIGA)
#define STI() \
do { \
if (!intr_count) sti(); \
} while(0)
#elif defined(CONFIG_ATARI)
#define STI() \
do { \
if (!MACH_IS_ATARI || !intr_count) sti(); \
} while(0)
#else /* !defined(CONFIG_ATARI) */
#define STI() sti()
#endif
 
#define SELECT_DRIVE(hwif,drive) OUT_BYTE((drive)->select.all, hwif->io_base+IDE_SELECT_OFFSET);
 
#define insl(data_reg, buffer, wcount) insw(data_reg, buffer, wcount<<1)
#define outsl(data_reg, buffer, wcount) outsw(data_reg, buffer, wcount<<1)
 
#define insw(port, buf, nr) \
if (nr % 16) \
__asm__ __volatile__ \
("movel %0,%/a0; \
movel %1,%/a1; \
movel %2,%/d6; \
subql #1,%/d6; \
1:movew %/a0@,%/a1@+; \
dbra %/d6,1b" : \
: "g" (port), "g" (buf), "g" (nr) \
: "a0", "a1", "d6"); \
else \
__asm__ __volatile__ \
("movel %0,%/a0; \
movel %1,%/a1; \
movel %2,%/d6; \
lsrl #4,%/d6; \
subql #1,%/d6; \
1:movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
movew %/a0@,%/a1@+; \
dbra %/d6,1b" : \
: "g" (port), "g" (buf), "g" (nr) \
: "a0", "a1", "d6");
 
#define outsw(port, buf, nr) \
if (nr % 16) \
__asm__ __volatile__ \
("movel %0,%/a0; \
movel %1,%/a1; \
movel %2,%/d6; \
subql #1,%/d6; \
1:movew %/a1@+,%/a0@; \
dbra %/d6,1b" : \
: "g" (port), "g" (buf), "g" (nr) \
: "a0", "a1", "d6"); \
else \
__asm__ __volatile__ \
("movel %0,%/a0; \
movel %1,%/a1; \
movel %2,%/d6; \
lsrl #4,%/d6; \
subql #1,%/d6; \
1:movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
movew %/a1@+,%/a0@; \
dbra %/d6,1b" : \
: "g" (port), "g" (buf), "g" (nr) \
: "a0", "a1", "d6");
 
#define T_CHAR (0x0000) /* char: don't touch */
#define T_SHORT (0x4000) /* short: 12 -> 21 */
#define T_INT (0x8000) /* int: 1234 -> 4321 */
#define T_TEXT (0xc000) /* text: 12 -> 21 */
 
#define T_MASK_TYPE (0xc000)
#define T_MASK_COUNT (0x3fff)
 
#define D_CHAR(cnt) (T_CHAR | (cnt))
#define D_SHORT(cnt) (T_SHORT | (cnt))
#define D_INT(cnt) (T_INT | (cnt))
#define D_TEXT(cnt) (T_TEXT | (cnt))
 
static u_short driveid_types[] = {
D_SHORT(10), /* config - vendor2 */
D_TEXT(20), /* serial_no */
D_SHORT(3), /* buf_type - ecc_bytes */
D_TEXT(48), /* fw_rev - model */
D_CHAR(2), /* max_multsect - vendor3 */
D_SHORT(1), /* dword_io */
D_CHAR(2), /* vendor4 - capability */
D_SHORT(1), /* reserved50 */
D_CHAR(4), /* vendor5 - tDMA */
D_SHORT(4), /* field_valid - cur_sectors */
D_INT(1), /* cur_capacity */
D_CHAR(2), /* multsect - multsect_valid */
D_INT(1), /* lba_capacity */
D_SHORT(194) /* dma_1word - reservedyy */
};
 
#define num_driveid_types (sizeof(driveid_types)/sizeof(*driveid_types))
 
static __inline__ void big_endianize_driveid(struct hd_driveid *id)
{
u_char *p = (u_char *)id;
int i, j, cnt;
u_char t;
 
for (i = 0; i < num_driveid_types; i++) {
cnt = driveid_types[i] & T_MASK_COUNT;
switch (driveid_types[i] & T_MASK_TYPE) {
case T_CHAR:
p += cnt;
break;
case T_SHORT:
for (j = 0; j < cnt; j++) {
t = p[0];
p[0] = p[1];
p[1] = t;
p += 2;
}
break;
case T_INT:
for (j = 0; j < cnt; j++) {
t = p[0];
p[0] = p[3];
p[3] = t;
t = p[1];
p[1] = p[2];
p[2] = t;
p += 4;
}
break;
case T_TEXT:
for (j = 0; j < cnt; j += 2) {
t = p[0];
p[0] = p[1];
p[1] = t;
p += 2;
}
break;
}
}
}
 
#endif /* _M68K_IDE_H */
/segment.h
0,0 → 1,363
#ifndef _M68K_SEGMENT_H
#define _M68K_SEGMENT_H
 
/* define constants */
/* Address spaces (FC0-FC2) */
#define USER_DATA (1)
#ifndef USER_DS
#define USER_DS (USER_DATA)
#endif
#define USER_PROGRAM (2)
#define SUPER_DATA (5)
#ifndef KERNEL_DS
#define KERNEL_DS (SUPER_DATA)
#endif
#define SUPER_PROGRAM (6)
#define CPU_SPACE (7)
 
#ifndef __ASSEMBLY__
 
/*
* Uh, these should become the main single-value transfer routines..
* They automatically use the right size if we just have the right
* pointer type..
*/
#define put_user(x,ptr) __put_user((unsigned long)(x),(ptr),sizeof(*(ptr)))
#define get_user(ptr) ((__typeof__(*(ptr)))__get_user((ptr),sizeof(*(ptr))))
 
/*
* This is a silly but good way to make sure that
* the __put_user function is indeed always optimized,
* and that we use the correct sizes..
*/
extern int bad_user_access_length(void);
 
#define __ptr(x) ((unsigned long *)(x))
 
static inline void __put_user(unsigned long x, void * y, int size)
{
switch (size) {
case 1:
__asm__ ("movesb %0,%1"
: /* no outputs */
:"r" (x),"m" (*__ptr(y)) : "memory");
break;
case 2:
__asm__ ("movesw %0,%1"
: /* no outputs */
:"r" (x),"m" (*__ptr(y)) : "memory");
break;
case 4:
__asm__ ("movesl %0,%1"
: /* no outputs */
:"r" (x),"m" (*__ptr(y)) : "memory");
break;
default:
bad_user_access_length();
}
}
 
static inline unsigned long __get_user(const void * y, int size)
{
unsigned long result;
 
switch (size) {
case 1:
__asm__ ("movesb %1,%0"
:"=r" (result)
:"m" (*__ptr(y)));
return (unsigned char) result;
case 2:
__asm__ ("movesw %1,%0"
:"=r" (result)
:"m" (*__ptr(y)));
return (unsigned short) result;
case 4:
__asm__ ("movesl %1,%0"
:"=r" (result)
:"m" (*__ptr(y)));
return result;
default:
return bad_user_access_length();
}
}
#undef __ptr
 
/*
* These are deprecated..
*
* Use "put_user()" and "get_user()" with the proper pointer types instead.
*/
 
#define get_fs_byte(addr) __get_user((const unsigned char *)(addr),1)
#define get_fs_word(addr) __get_user((const unsigned short *)(addr),2)
#define get_fs_long(addr) __get_user((const unsigned int *)(addr),4)
 
#define put_fs_byte(x,addr) __put_user((x),(unsigned char *)(addr),1)
#define put_fs_word(x,addr) __put_user((x),(unsigned short *)(addr),2)
#define put_fs_long(x,addr) __put_user((x),(unsigned int *)(addr),4)
 
#ifdef WE_REALLY_WANT_TO_USE_A_BROKEN_INTERFACE
 
static inline unsigned char get_user_byte(const char * addr)
{
return __get_user(addr,1);
}
 
static inline unsigned short get_user_word(const short *addr)
{
return __get_user(addr,2);
}
 
static inline unsigned long get_user_long(const int *addr)
{
return __get_user(addr,4);
}
 
static inline void put_user_byte(char val,char *addr)
{
__put_user(val, addr, 1);
}
 
static inline void put_user_word(short val,short * addr)
{
__put_user(val, addr, 2);
}
 
static inline void put_user_long(unsigned long val,int * addr)
{
__put_user(val, addr, 4);
}
 
#endif
 
static inline void __generic_memcpy_tofs(void * to, const void * from, unsigned long n)
{
unsigned long tmp;
if (n == 0) return;
tmp = n;
n >>= 2;
if (n != 0)
__asm__ ("1:\t"
"movel %1@+,%/d0\n\t"
"movesl %/d0,%2@+\n\t"
"dbra %0,1b\n\t"
"clrw %0\n\t"
"subql #1,%0\n\t"
"bccs 1b\n\t"
: "=d" (n), "=a" (from), "=a" (to)
: "0" (n-1), "1" (from), "2" (to)
: "d0", "memory");
if (tmp & 2)
__asm__ ("movew %0@+,%/d0\n\t"
"movesw %/d0,%1@+\n\t"
: "=a" (from), "=a" (to)
: "0" (from), "1" (to)
: "d0", "memory");
if (tmp & 1)
__asm__ __volatile__ ("moveb %0@,%/d0\n\t"
"movesb %/d0,%1@\n\t"
: /* no outputs */
: "a" (from), "a" (to)
: "d0", "memory");
}
 
static inline void __constant_memcpy_tofs(void * to, const void * from, unsigned long n)
{
switch (n) {
case 0:
return;
case 1:
__put_user(*(const char *) from, (char *) to, 1);
return;
case 2:
__put_user(*(const short *) from, (short *) to, 2);
return;
case 3:
__put_user(*(const short *) from, (short *) to, 2);
__put_user(*(2+(const char *) from), 2+(char *) to, 1);
return;
case 4:
__put_user(*(const int *) from, (int *) to, 4);
return;
case 8:
__put_user(*(const int *) from, (int *) to, 4);
__put_user(*(1+(const int *) from), 1+(int *) to, 4);
return;
case 12:
__put_user(*(const int *) from, (int *) to, 4);
__put_user(*(1+(const int *) from), 1+(int *) to, 4);
__put_user(*(2+(const int *) from), 2+(int *) to, 4);
return;
case 16:
__put_user(*(const int *) from, (int *) to, 4);
__put_user(*(1+(const int *) from), 1+(int *) to, 4);
__put_user(*(2+(const int *) from), 2+(int *) to, 4);
__put_user(*(3+(const int *) from), 3+(int *) to, 4);
return;
}
#define COMMON(x) \
__asm__ __volatile__ ("1:\n\t" \
"movel %1@+,%/d0\n\t" \
"movesl %/d0,%2@+\n\t" \
"dbra %0,1b\n\t" \
"clrw %0\n\t" \
"subql #1,%0\n\t" \
"bccs 1b\n\t" \
x \
: "=d" (n), "=a" (from), "=a" (to) \
: "1" (from), "2" (to), "0" (n/4-1) \
: "d0", "memory");
 
switch (n % 4) {
case 0:
COMMON("");
return;
case 1:
COMMON("moveb %1@+,%/d0; movesb %/d0,%2@+");
return;
case 2:
COMMON("movew %1@+,%/d0; movesw %/d0,%2@+");
return;
case 3:
COMMON("movew %1@+,%/d0; movesw %/d0,%2@+\n\t"
"moveb %1@+,%/d0; movesb %/d0,%2@+");
return;
}
#undef COMMON
}
 
static inline void __generic_memcpy_fromfs(void * to, const void * from, unsigned long n)
{
unsigned long tmp;
if (n == 0) return;
tmp = n;
n >>= 2;
if (n != 0)
__asm__ ("1:\t"
"movesl %1@+,%/d0\n\t"
"movel %/d0,%2@+\n\t"
"dbra %0,1b\n\t"
"clrw %0\n\t"
"subql #1,%0\n\t"
"bccs 1b\n\t"
: "=d" (n), "=a" (from), "=a" (to)
: "0" (n-1), "1" (from), "2" (to)
: "d0", "memory");
if (tmp & 2)
__asm__ ("movesw %0@+,%/d0\n\t"
"movew %/d0,%1@+\n\t"
: "=a" (from), "=a" (to)
: "0" (from), "1" (to)
: "d0", "memory");
if (tmp & 1)
__asm__ __volatile__ ("movesb %0@,%/d0\n\t"
"moveb %/d0,%1@\n\t"
: /* no outputs */
: "a" (from), "a" (to)
: "d0", "memory");
}
 
static inline void __constant_memcpy_fromfs(void * to, const void * from, unsigned long n)
{
switch (n) {
case 0:
return;
case 1:
*(char *)to = __get_user((const char *) from, 1);
return;
case 2:
*(short *)to = __get_user((const short *) from, 2);
return;
case 3:
*(short *) to = __get_user((const short *) from, 2);
*((char *) to + 2) = __get_user(2+(const char *) from, 1);
return;
case 4:
*(int *) to = __get_user((const int *) from, 4);
return;
case 8:
*(int *) to = __get_user((const int *) from, 4);
*(1+(int *) to) = __get_user(1+(const int *) from, 4);
return;
case 12:
*(int *) to = __get_user((const int *) from, 4);
*(1+(int *) to) = __get_user(1+(const int *) from, 4);
*(2+(int *) to) = __get_user(2+(const int *) from, 4);
return;
case 16:
*(int *) to = __get_user((const int *) from, 4);
*(1+(int *) to) = __get_user(1+(const int *) from, 4);
*(2+(int *) to) = __get_user(2+(const int *) from, 4);
*(3+(int *) to) = __get_user(3+(const int *) from, 4);
return;
}
#define COMMON(x) \
__asm__ __volatile__ ("1:\n\t" \
"movesl %1@+,%/d0\n\t" \
"movel %/d0,%2@+\n\t" \
"dbra %0,1b\n\t" \
"clrw %0\n\t" \
"subql #1,%0\n\t" \
"bccs 1b\n\t" \
x \
: "=d" (n), "=a" (from), "=a" (to) \
: "1" (from), "2" (to), "0" (n/4-1) \
: "d0", "memory");
 
switch (n % 4) {
case 0:
COMMON("");
return;
case 1:
COMMON("movesb %1@+,%/d0; moveb %/d0,%2@+");
return;
case 2:
COMMON("movesw %1@+,%/d0; movew %/d0,%2@+");
return;
case 3:
COMMON("movesw %1@+,%/d0; movew %/d0,%2@+\n\t"
"movesb %1@+,%/d0; moveb %/d0,%2@+");
return;
}
#undef COMMON
}
 
#define memcpy_fromfs(to, from, n) \
(__builtin_constant_p(n) ? \
__constant_memcpy_fromfs((to),(from),(n)) : \
__generic_memcpy_fromfs((to),(from),(n)))
 
#define memcpy_tofs(to, from, n) \
(__builtin_constant_p(n) ? \
__constant_memcpy_tofs((to),(from),(n)) : \
__generic_memcpy_tofs((to),(from),(n)))
 
/*
* Get/set the SFC/DFC registers for MOVES instructions
*/
 
static inline unsigned long get_fs(void)
{
unsigned long _v;
__asm__ ("movec %/dfc,%0":"=r" (_v):);
 
return _v;
}
 
static inline unsigned long get_ds(void)
{
/* return the supervisor data space code */
return KERNEL_DS;
}
 
static inline void set_fs(unsigned long val)
{
__asm__ __volatile__ ("movec %0,%/sfc\n\t"
"movec %0,%/dfc\n\t"
: /* no outputs */ : "r" (val) : "memory");
}
 
#endif /* __ASSEMBLY__ */
 
#endif /* _M68K_SEGMENT_H */
/types.h
0,0 → 1,52
#ifndef _M68K_TYPES_H
#define _M68K_TYPES_H
 
/*
* This file is never included by application software unless
* explicitly requested (e.g., via linux/types.h) in which case the
* application is Linux specific so (user-) name space pollution is
* not a major issue. However, for interoperability, libraries still
* need to be careful to avoid a name clashes.
*/
 
typedef unsigned short umode_t;
 
/*
* __xx is ok: it doesn't pollute the POSIX namespace. Use these in the
* header files exported to user space
*/
 
typedef __signed__ char __s8;
typedef unsigned char __u8;
 
typedef __signed__ short __s16;
typedef unsigned short __u16;
 
typedef __signed__ int __s32;
typedef unsigned int __u32;
 
#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
typedef __signed__ long long __s64;
typedef unsigned long long __u64;
#endif
 
/*
* These aren't exported outside the kernel to avoid name space clashes
*/
#ifdef __KERNEL__
 
typedef signed char s8;
typedef unsigned char u8;
 
typedef signed short s16;
typedef unsigned short u16;
 
typedef signed int s32;
typedef unsigned int u32;
 
typedef signed long long s64;
typedef unsigned long long u64;
 
#endif /* __KERNEL__ */
 
#endif /* _M68K_TYPES_H */
/fcntl.h
0,0 → 1,59
#ifndef _M68K_FCNTL_H
#define _M68K_FCNTL_H
 
/* open/fcntl - O_SYNC is only implemented on blocks devices and on files
located on an ext2 file system */
#define O_ACCMODE 0003
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
#define O_CREAT 0100 /* not fcntl */
#define O_EXCL 0200 /* not fcntl */
#define O_NOCTTY 0400 /* not fcntl */
#define O_TRUNC 01000 /* not fcntl */
#define O_APPEND 02000
#define O_NONBLOCK 04000
#define O_NDELAY O_NONBLOCK
#define O_SYNC 010000
#define FASYNC 020000 /* fcntl, for BSD compatibility */
 
#define F_DUPFD 0 /* dup */
#define F_GETFD 1 /* get f_flags */
#define F_SETFD 2 /* set f_flags */
#define F_GETFL 3 /* more flags (cloexec) */
#define F_SETFL 4
#define F_GETLK 5
#define F_SETLK 6
#define F_SETLKW 7
 
#define F_SETOWN 8 /* for sockets. */
#define F_GETOWN 9 /* for sockets. */
 
/* for F_[GET|SET]FL */
#define FD_CLOEXEC 1 /* actually anything with low bit set goes */
 
/* for posix fcntl() and lockf() */
#define F_RDLCK 0
#define F_WRLCK 1
#define F_UNLCK 2
 
/* for old implementation of bsd flock () */
#define F_EXLCK 4 /* or 3 */
#define F_SHLCK 8 /* or 4 */
 
/* operations for bsd flock(), also used by the kernel implementation */
#define LOCK_SH 1 /* shared lock */
#define LOCK_EX 2 /* exclusive lock */
#define LOCK_NB 4 /* or'd with one of the above to prevent
blocking */
#define LOCK_UN 8 /* remove lock */
 
struct flock {
short l_type;
short l_whence;
off_t l_start;
off_t l_len;
pid_t l_pid;
};
 
#endif /* _M68K_FCNTL_H */
/string.h
0,0 → 1,358
#ifndef _M68K_STRING_H_
#define _M68K_STRING_H_
 
#define __HAVE_ARCH_STRCPY
extern inline char * strcpy(char * dest,const char *src)
{
char *xdest = dest;
 
__asm__ __volatile__
("1:\tmoveb %1@+,%0@+\n\t"
"jne 1b"
: "=a" (dest), "=a" (src)
: "0" (dest), "1" (src) : "memory");
return xdest;
}
 
#define __HAVE_ARCH_STRNCPY
extern inline char * strncpy(char *dest, const char *src, size_t n)
{
char *xdest = dest;
 
if (n == 0)
return xdest;
 
__asm__ __volatile__
("1:\tmoveb %1@+,%0@+\n\t"
"jeq 2f\n\t"
"subql #1,%2\n\t"
"jne 1b\n\t"
"2:"
: "=a" (dest), "=a" (src), "=d" (n)
: "0" (dest), "1" (src), "2" (n)
: "memory");
return xdest;
}
 
#define __HAVE_ARCH_STRCAT
extern inline char * strcat(char * dest, const char * src)
{
char *tmp = dest;
 
while (*dest)
dest++;
while ((*dest++ = *src++))
;
 
return tmp;
}
 
#define __HAVE_ARCH_STRNCAT
extern inline char * strncat(char *dest, const char *src, size_t count)
{
char *tmp = dest;
 
if (count) {
while (*dest)
dest++;
while ((*dest++ = *src++)) {
if (--count == 0) {
*dest++='\0';
break;
}
}
}
 
return tmp;
}
 
#define __HAVE_ARCH_STRCHR
extern inline char * strchr(const char * s, int c)
{
const char ch = c;
for(; *s != ch; ++s)
if (*s == '\0')
return( NULL );
return( (char *) s);
}
 
#define __HAVE_ARCH_STRPBRK
extern inline char * strpbrk(const char * cs,const char * ct)
{
const char *sc1,*sc2;
for( sc1 = cs; *sc1 != '\0'; ++sc1)
for( sc2 = ct; *sc2 != '\0'; ++sc2)
if (*sc1 == *sc2)
return((char *) sc1);
return( NULL );
}
 
#define __HAVE_ARCH_STRSPN
extern inline size_t strspn(const char *s, const char *accept)
{
const char *p;
const char *a;
size_t count = 0;
 
for (p = s; *p != '\0'; ++p)
{
for (a = accept; *a != '\0'; ++a)
if (*p == *a)
break;
if (*a == '\0')
return count;
else
++count;
}
 
return count;
}
 
#define __HAVE_ARCH_STRTOK
extern inline char * strtok(char * s,const char * ct)
{
char *sbegin, *send;
sbegin = s ? s : ___strtok;
if (!sbegin) {
return NULL;
}
sbegin += strspn(sbegin,ct);
if (*sbegin == '\0') {
___strtok = NULL;
return( NULL );
}
send = strpbrk( sbegin, ct);
if (send && *send != '\0')
*send++ = '\0';
___strtok = send;
return (sbegin);
}
 
/* strstr !! */
 
#define __HAVE_ARCH_STRLEN
extern inline size_t strlen(const char * s)
{
const char *sc;
for (sc = s; *sc != '\0'; ++sc) ;
return(sc - s);
}
 
/* strnlen !! */
 
#define __HAVE_ARCH_STRCMP
extern inline int strcmp(const char * cs,const char * ct)
{
char __res;
 
__asm__
("1:\tmoveb %0@+,%2\n\t" /* get *cs */
"cmpb %1@+,%2\n\t" /* compare a byte */
"jne 2f\n\t" /* not equal, break out */
"tstb %2\n\t" /* at end of cs? */
"jne 1b\n\t" /* no, keep going */
"jra 3f\n\t" /* strings are equal */
"2:\tsubb %1@-,%2\n\t" /* *cs - *ct */
"3:"
: "=a" (cs), "=a" (ct), "=d" (__res)
: "0" (cs), "1" (ct));
return __res;
}
 
#define __HAVE_ARCH_STRNCMP
extern inline int strncmp(const char * cs,const char * ct,size_t count)
{
char __res;
 
if (!count)
return 0;
__asm__
("1:\tmovb %0@+,%3\n\t" /* get *cs */
"cmpb %1@+,%3\n\t" /* compare a byte */
"jne 3f\n\t" /* not equal, break out */
"tstb %3\n\t" /* at end of cs? */
"jeq 4f\n\t" /* yes, all done */
"subql #1,%2\n\t" /* no, adjust count */
"jne 1b\n\t" /* more to do, keep going */
"2:\tmoveq #0,%3\n\t" /* strings are equal */
"jra 4f\n\t"
"3:\tsubb %1@-,%3\n\t" /* *cs - *ct */
"4:"
: "=a" (cs), "=a" (ct), "=d" (count), "=d" (__res)
: "0" (cs), "1" (ct), "2" (count));
return __res;
}
 
#define __HAVE_ARCH_MEMSET
extern inline void * memset(void * s,int c,size_t count)
{
void *xs = s;
size_t temp;
 
if (!count)
return xs;
c &= 0xff;
if ((long) s & 1)
{
char *cs = s;
*cs++ = c;
s = cs;
count--;
}
c |= c << 8;
if (count > 2 && (long) s & 2)
{
short *ss = s;
*ss++ = c;
s = ss;
count -= 2;
}
temp = count >> 2;
if (temp)
{
long *ls = s;
c |= c << 16;
temp--;
do
*ls++ = c;
while (temp--);
s = ls;
}
if (count & 2)
{
short *ss = s;
*ss++ = c;
s = ss;
}
if (count & 1)
{
char *cs = s;
*cs = c;
}
return xs;
}
 
#define __HAVE_ARCH_MEMCPY
#define memcpy(to, from, n) \
(__builtin_constant_p(n) ? \
__builtin_memcpy((to),(from),(n)) : \
memcpy((to),(from),(n)))
 
#define __HAVE_ARCH_MEMMOVE
extern inline void * memmove(void * dest,const void * src, size_t n)
{
void *xdest = dest;
size_t temp;
 
if (!n)
return xdest;
 
if (dest < src)
{
if ((long) dest & 1)
{
char *cdest = dest;
const char *csrc = src;
*cdest++ = *csrc++;
dest = cdest;
src = csrc;
n--;
}
if (n > 2 && (long) dest & 2)
{
short *sdest = dest;
const short *ssrc = src;
*sdest++ = *ssrc++;
dest = sdest;
src = ssrc;
n -= 2;
}
temp = n >> 2;
if (temp)
{
long *ldest = dest;
const long *lsrc = src;
temp--;
do
*ldest++ = *lsrc++;
while (temp--);
dest = ldest;
src = lsrc;
}
if (n & 2)
{
short *sdest = dest;
const short *ssrc = src;
*sdest++ = *ssrc++;
dest = sdest;
src = ssrc;
}
if (n & 1)
{
char *cdest = dest;
const char *csrc = src;
*cdest = *csrc;
}
}
else
{
dest = (char *) dest + n;
src = (const char *) src + n;
if ((long) dest & 1)
{
char *cdest = dest;
const char *csrc = src;
*--cdest = *--csrc;
dest = cdest;
src = csrc;
n--;
}
if (n > 2 && (long) dest & 2)
{
short *sdest = dest;
const short *ssrc = src;
*--sdest = *--ssrc;
dest = sdest;
src = ssrc;
n -= 2;
}
temp = n >> 2;
if (temp)
{
long *ldest = dest;
const long *lsrc = src;
temp--;
do
*--ldest = *--lsrc;
while (temp--);
dest = ldest;
src = lsrc;
}
if (n & 2)
{
short *sdest = dest;
const short *ssrc = src;
*--sdest = *--ssrc;
dest = sdest;
src = ssrc;
}
if (n & 1)
{
char *cdest = dest;
const char *csrc = src;
*--cdest = *--csrc;
}
}
return xdest;
}
 
#define __HAVE_ARCH_MEMCMP
#define memcmp(cs, ct, n) \
(__builtin_constant_p(n) ? \
__builtin_memcmp((cs),(ct),(n)) : \
memcmp((cs),(ct),(n)))
 
#endif /* _M68K_STRING_H_ */
/io.h
0,0 → 1,50
#ifndef _M68K_IO_H
#define _M68K_IO_H
 
static inline unsigned char get_user_byte_io(const char * addr)
{
register unsigned char _v;
 
__asm__ __volatile__ ("moveb %1,%0":"=dm" (_v):"m" (*addr));
return _v;
}
#define inb_p(addr) get_user_byte_io((char *)(addr))
#define inb(addr) get_user_byte_io((char *)(addr))
 
static inline void put_user_byte_io(char val,char *addr)
{
__asm__ __volatile__ ("moveb %0,%1"
: /* no outputs */
:"idm" (val),"m" (*addr)
: "memory");
}
#define outb_p(x,addr) put_user_byte_io((x),(char *)(addr))
#define outb(x,addr) put_user_byte_io((x),(char *)(addr))
 
/*
* Change virtual addresses to physical addresses and vv.
* These are trivial on the 1:1 Linux/i386 mapping (but if we ever
* make the kernel segment mapped at 0, we need to do translation
* on the i386 as well)
*/
extern unsigned long mm_vtop(unsigned long addr);
extern unsigned long mm_ptov(unsigned long addr);
 
extern inline unsigned long virt_to_phys(volatile void * address)
{
return (unsigned long) mm_vtop((unsigned long)address);
}
 
extern inline void * phys_to_virt(unsigned long address)
{
return (void *) mm_ptov(address);
}
 
/*
* IO bus memory addresses are also 1:1 with the physical address
*/
#define virt_to_bus virt_to_phys
#define bus_to_virt phys_to_virt
 
 
#endif /* _M68K_IO_H */
/stat.h
0,0 → 1,41
#ifndef _M68K_STAT_H
#define _M68K_STAT_H
 
struct old_stat {
unsigned short st_dev;
unsigned short st_ino;
unsigned short st_mode;
unsigned short st_nlink;
unsigned short st_uid;
unsigned short st_gid;
unsigned short st_rdev;
unsigned long st_size;
unsigned long st_atime;
unsigned long st_mtime;
unsigned long st_ctime;
};
 
struct new_stat {
unsigned short st_dev;
unsigned short __pad1;
unsigned long st_ino;
unsigned short st_mode;
unsigned short st_nlink;
unsigned short st_uid;
unsigned short st_gid;
unsigned short st_rdev;
unsigned short __pad2;
unsigned long st_size;
unsigned long st_blksize;
unsigned long st_blocks;
unsigned long st_atime;
unsigned long __unused1;
unsigned long st_mtime;
unsigned long __unused2;
unsigned long st_ctime;
unsigned long __unused3;
unsigned long __unused4;
unsigned long __unused5;
};
 
#endif /* _M68K_STAT_H */
/page.h
0,0 → 1,72
#ifndef _M68K_PAGE_H
#define _M68K_PAGE_H
 
/* PAGE_SHIFT determines the page size */
#define PAGE_SHIFT 12
#define PAGE_SIZE (1UL << PAGE_SHIFT)
#define PAGE_MASK (~(PAGE_SIZE-1))
 
#ifdef __KERNEL__
 
#define STRICT_MM_TYPECHECKS
 
#ifdef STRICT_MM_TYPECHECKS
/*
* These are used to make use of C type-checking..
*/
typedef struct { unsigned long pte; } pte_t;
typedef struct { unsigned long pmd[16]; } pmd_t;
typedef struct { unsigned long pgd; } pgd_t;
typedef struct { unsigned long pgprot; } pgprot_t;
 
#define pte_val(x) ((x).pte)
#define pmd_val(x) ((&x)->pmd[0])
#define pgd_val(x) ((x).pgd)
#define pgprot_val(x) ((x).pgprot)
 
#define __pte(x) ((pte_t) { (x) } )
#define __pmd(x) ((pmd_t) { (x) } )
#define __pgd(x) ((pgd_t) { (x) } )
#define __pgprot(x) ((pgprot_t) { (x) } )
 
#else
/*
* .. while these make it easier on the compiler
*/
typedef unsigned long pte_t;
typedef struct { unsigned long pmd[16]; } pmd_t;
typedef unsigned long pgd_t;
typedef unsigned long pgprot_t;
 
#define pte_val(x) (x)
#define pmd_val(x) ((&x)->pmd[0])
#define pgd_val(x) (x)
#define pgprot_val(x) (x)
 
#define __pte(x) (x)
#define __pmd(x) ((pmd_t) { (x) } )
#define __pgd(x) (x)
#define __pgprot(x) (x)
 
#endif
 
/* m68k_is040or060 is != 0 for a '040 or higher; used numbers are 4 for 68040
* and 6 for 68060 */
extern int m68k_is040or060;
 
/* This is the cache mode to be used for pages containing page descriptors for
* processors >= '040. It is in pte_mknocache(), and the variable is defined
* and initialized in head.S */
extern int m68k_pgtable_cachemode;
 
/* to align the pointer to the (next) page boundary */
#define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
 
/* This handles the memory map.. */
#define PAGE_OFFSET 0
#define MAP_NR(addr) (((unsigned long)(addr)) >> PAGE_SHIFT)
#define MAP_PAGE_RESERVED (1<<15)
 
#endif /* __KERNEL__ */
 
#endif /* _M68K_PAGE_H */
/atarikb.h
0,0 → 1,40
/*
** atarikb.h -- This header contains the prototypes of functions of
** the intelligent keyboard of the Atari needed by the
** mouse and joystick drivers.
**
** Copyright 1994 by Robert de Vries
**
** This file is subject to the terms and conditions of the GNU General Public
** License. See the file COPYING in the main directory of this archive
** for more details.
**
** Created: 20 Feb 1994 by Robert de Vries
*/
 
#ifndef _LINUX_ATARIKB_H
#define _LINUX_ATARIKB_H
 
void ikbd_write(const char *, int);
void ikbd_mouse_button_action(int mode);
void ikbd_mouse_rel_pos(void);
void ikbd_mouse_abs_pos(int xmax, int ymax);
void ikbd_mouse_kbd_mode(int dx, int dy);
void ikbd_mouse_thresh(int x, int y);
void ikbd_mouse_scale(int x, int y);
void ikbd_mouse_pos_get(int *x, int *y);
void ikbd_mouse_pos_set(int x, int y);
void ikbd_mouse_y0_bot(void);
void ikbd_mouse_y0_top(void);
void ikbd_mouse_disable(void);
void ikbd_joystick_event_on(void);
void ikbd_joystick_event_off(void);
void ikbd_joystick_get_state(void);
void ikbd_joystick_disable(void);
 
/* Hook for MIDI serial driver */
extern void (*atari_MIDI_interrupt_hook) (void);
/* Hook for mouse driver */
extern void (*atari_mouse_interrupt_hook) (char *);
 
#endif /* _LINUX_ATARIKB_H */
/atafd.h
0,0 → 1,12
#ifndef _ASM_M68K_FD_H
#define _ASM_M68K_FD_H
 
/* Definitions for the Atari Floppy driver */
 
struct atari_format_descr {
int track; /* to be formatted */
int head; /* "" "" */
int sect_offset; /* offset of first sector */
};
 
#endif
/processor.h
0,0 → 1,94
/*
* include/asm-m68k/processor.h
*
* Copyright (C) 1995 Hamish Macdonald
*/
 
#ifndef __ASM_M68K_PROCESSOR_H
#define __ASM_M68K_PROCESSOR_H
 
#include <asm/segment.h>
 
/*
* User space process size: 3.75GB. This is hardcoded into a few places,
* so don't change it unless you know what you are doing.
*/
#define TASK_SIZE (0xF0000000UL)
#define MAX_USER_ADDR TASK_SIZE
#define MMAP_SEARCH_START (TASK_SIZE/3)
 
/*
* Bus types
*/
#define EISA_bus__is_a_macro 1
#define EISA_bus 0
#define MCA_bus__is_a_macro 1
#define MCA_bus 0
 
/*
* The m68k has no problems with write protection
*/
#define wp_works_ok__is_a_macro 1
#define wp_works_ok 1
 
/* MAX floating point unit state size (FSAVE/FRESTORE) */
#define FPSTATESIZE (216/sizeof(unsigned short))
 
/*
* if you change this structure, you must change the code and offsets
* in m68k/machasm.S
*/
struct thread_struct {
unsigned long ksp; /* kernel stack pointer */
unsigned long usp; /* user stack pointer */
unsigned short sr; /* saved status register */
unsigned short fs; /* saved fs (sfc, dfc) */
unsigned long *pagedir_v; /* root page table virtual addr */
unsigned long pagedir_p; /* root page table physaddr */
unsigned long crp[2]; /* cpu root pointer */
unsigned long esp0; /* points to SR of stack frame */
unsigned long fp[8*3];
unsigned long fpcntl[3]; /* fp control regs */
unsigned short fpstate[FPSTATESIZE]; /* floating point state */
};
 
#define INIT_MMAP { &init_mm, 0, 0x40000000, __pgprot(_PAGE_PRESENT|_PAGE_ACCESSED), VM_READ | VM_WRITE | VM_EXEC }
 
#define INIT_TSS { \
sizeof(init_kernel_stack) + (long) init_kernel_stack, 0, \
PS_S, KERNEL_DS, \
NULL, 0, {0, 0}, 0 \
}
 
#define alloc_kernel_stack() get_free_page(GFP_KERNEL)
#define free_kernel_stack(page) free_page((page))
 
/*
* Do necessary setup to start up a newly executed thread.
*/
static inline void start_thread(struct pt_regs * regs, unsigned long pc,
unsigned long usp)
{
unsigned long nilstate = 0;
 
/* clear floating point state */
__asm__ __volatile__ ("frestore %0@" : : "a" (&nilstate));
 
/* reads from user space */
set_fs(USER_DS);
 
regs->pc = pc;
regs->sr &= ~0x2000;
wrusp(usp);
}
 
/*
* Return saved PC of a blocked thread.
*/
extern inline unsigned long thread_saved_pc(struct thread_struct *t)
{
return ((unsigned long *)((struct switch_stack *)t->ksp)->a6)[1];
}
 
#endif
/serial.h
0,0 → 1,380
/*
* include/linux/serial.h
*
* Copyright (C) 1992 by Theodore Ts'o.
*
* Redistribution of this file is permitted under the terms of the GNU
* Public License (GPL)
*/
 
#ifndef _M68K_SERIAL_H
#define _M68K_SERIAL_H
 
 
/* m68k serial port types are numbered from 100 to avoid interference
* with the PC types (1..4)
*/
#define PORT_UNKNOWN 0
#define PORT_8250 1
#define PORT_16450 2
#define PORT_16550 3
#define PORT_16550A 4
#define PORT_CIRRUS 5
#define SER_SCC_NORM 100 /* standard SCC channel */
#define SER_SCC_DMA 101 /* SCC channel with DMA support */
#define SER_MFP_CTRL 102 /* standard MFP port with modem control signals */
#define SER_MFP_BARE 103 /* MFP port without modem controls */
#define SER_MIDI 104 /* Atari MIDI */
#define SER_AMIGA 105 /* Amiga built-in serial port */
#define SER_IOEXT 106 /* Amiga GVP IO-Extender (16c552) */
#define SER_MFC_III 107 /* Amiga BSC Multiface Card III (MC68681) */
 
 
struct serial_struct {
int type;
int line;
int port;
int irq;
int flags;
int xmit_fifo_size;
int custom_divisor;
int baud_base;
unsigned short close_delay;
char reserved_char[2];
int hub6;
unsigned short closing_wait; /* time to wait before closing */
unsigned short closing_wait2; /* no longer used... */
int reserved[4];
};
 
/*
* For the close wait times, 0 means wait forever for serial port to
* flush its output. 65535 means don't wait at all.
*/
#define ASYNC_CLOSING_WAIT_INF 0
#define ASYNC_CLOSING_WAIT_NONE 65535
 
/* This function tables does the abstraction from the underlying
* hardware:
*
* init(): Initialize the port as necessary, set RTS and DTR and
* enable interrupts. It does not need to set the speed and other
* parameters, because change_speed() is called, too.
* deinit(): Stop and shutdown the port (e.g. disable interrupts, ...)
* enab_tx_int(): Enable or disable the Tx Buffer Empty interrupt
* independently from other interrupt sources. If the int is
* enabled, the transmitter should also be restarted, i.e. if there
* are any chars to be sent, they should be put into the Tx
* register. The real en/disabling of the interrupt may be a no-op
* if there is no way to do this or it is too complex. This Tx ints
* are just disabled to save some interrupts if the transmitter is
* stopped anyway. But the restarting must be implemented!
* check_custom_divisor(): Check the given custom divisor for legality
* and return 0 if OK, non-zero otherwise.
* change_speed(): Set port speed, character size, number of stop
* bits and parity from the termios structure. If the user wants
* to set the speed with a custom divisor, he is required to
* check the baud_base first!
* throttle(): Set or clear the RTS line according to 'status'.
* set_break(): Set or clear the 'Send a Break' flag.
* get_serial_info(): Fill in the baud_base and custom_divisor
* fields of a serial_struct. It may also modify other fields, if
* needed.
* get_modem_info(): Return the status of RTS, DTR, DCD, RI, DSR and CTS.
* set_modem_info(): Set the status of RTS and DTR according to
* 'new_dtr' and 'new_rts', resp. 0 = clear, 1 = set, -1 = don't change
* ioctl(): Process any port-specific ioctl's. This pointer may be
* NULL, if the port has no own ioctl's.
* stop_receive(): Turn off the Rx part of the port, so no more characters
* will be received. This is called before shutting the port down.
* trans_empty(): Return !=0 if there are no more characters still to be
* sent out (Tx buffer register and FIFOs empty)
* check_open(): Is called before the port is opened. The driver can check
* if that's ok and return an error code, or keep track of the opening
* even before init() is called. Use deinit() for matching closing of the
* port.
*
*/
 
struct async_struct;
 
typedef struct {
void (*init)( struct async_struct *info );
void (*deinit)( struct async_struct *info, int leave_dtr );
void (*enab_tx_int)( struct async_struct *info, int enab_flag );
int (*check_custom_divisor)( struct async_struct *info, int baud_base,
int divisor );
void (*change_speed)( struct async_struct *info );
void (*throttle)( struct async_struct *info, int status );
void (*set_break)( struct async_struct *info, int break_flag );
void (*get_serial_info)( struct async_struct *info,
struct serial_struct *retinfo );
unsigned int (*get_modem_info)( struct async_struct *info );
int (*set_modem_info)( struct async_struct *info, int new_dtr,
int new_rts );
int (*ioctl)( struct tty_struct *tty, struct file *file,
struct async_struct *info, unsigned int cmd,
unsigned long arg );
void (*stop_receive)( struct async_struct *info );
int (*trans_empty)( struct async_struct *info );
int (*check_open)( struct async_struct *info, struct tty_struct *tty,
struct file *file );
} SERIALSWITCH;
 
/*
* Definitions for async_struct (and serial_struct) flags field
*/
#define ASYNC_HUP_NOTIFY 0x0001 /* Notify getty on hangups and closes
on the callout port */
#define ASYNC_FOURPORT 0x0002 /* Set OU1, OUT2 per AST Fourport settings */
#define ASYNC_SAK 0x0004 /* Secure Attention Key (Orange book) */
#define ASYNC_SPLIT_TERMIOS 0x0008 /* Separate termios for dialin/callout */
 
#define ASYNC_SPD_MASK 0x0030
#define ASYNC_SPD_HI 0x0010 /* Use 56000 instead of 38400 bps */
 
#define ASYNC_SPD_VHI 0x0020 /* Use 115200 instead of 38400 bps */
#define ASYNC_SPD_CUST 0x0030 /* Use user-specified divisor */
 
#define ASYNC_SKIP_TEST 0x0040 /* Skip UART test during autoconfiguration */
#define ASYNC_AUTO_IRQ 0x0080 /* Do automatic IRQ during autoconfiguration */
#define ASYNC_SESSION_LOCKOUT 0x0100 /* Lock out cua opens based on session */
#define ASYNC_PGRP_LOCKOUT 0x0200 /* Lock out cua opens based on pgrp */
#define ASYNC_CALLOUT_NOHUP 0x0400 /* Don't do hangups for cua device */
 
#define ASYNC_FLAGS 0x0FFF /* Possible legal async flags */
#define ASYNC_USR_MASK 0x0430 /* Legal flags that non-privileged
* users can set or reset */
 
/* Internal flags used only by drivers/char/m68kserial.c */
#define ASYNC_INITIALIZED 0x80000000 /* Serial port was initialized */
#define ASYNC_CALLOUT_ACTIVE 0x40000000 /* Call out device is active */
#define ASYNC_NORMAL_ACTIVE 0x20000000 /* Normal device is active */
#define ASYNC_BOOT_AUTOCONF 0x10000000 /* Autoconfigure port on bootup */
#define ASYNC_CLOSING 0x08000000 /* Serial port is closing */
#define ASYNC_CTS_FLOW 0x04000000 /* Do CTS flow control */
#define ASYNC_CHECK_CD 0x02000000 /* i.e., CLOCAL */
 
/*
* Serial input interrupt line counters -- external structure
* Four lines can interrupt: CTS, DSR, RI, DCD
*/
struct serial_icounter_struct {
int cts, dsr, rng, dcd;
int reserved[16];
};
 
 
#ifdef __KERNEL__
/*
* This is our internal structure for each serial port's state.
*
* Many fields are paralleled by the structure used by the serial_struct
* structure.
*
* For definitions of the flags field, see tty.h
*/
 
#include <linux/termios.h>
#include <linux/tqueue.h>
 
/*
* Counters of the input lines (CTS, DSR, RI, CD) interrupts
*/
struct async_icount {
__u32 cts, dsr, rng, dcd;
};
 
struct async_struct {
int magic;
int baud_base;
int port;
int irq;
int flags; /* defined in tty.h */
int hub6; /* HUB6 plus one */
int type;
struct tty_struct *tty;
int read_status_mask;
int ignore_status_mask;
int timeout;
int xmit_fifo_size;
int custom_divisor;
int x_char; /* xon/xoff character */
int close_delay;
unsigned short closing_wait;
unsigned short closing_wait2;
int IER; /* Interrupt Enable Register */
int MCR; /* Modem control register */
int MCR_noint; /* MCR with interrupts off */
unsigned long event;
unsigned long last_active;
int line;
int count; /* # of fd on device */
int blocked_open; /* # of blocked opens */
long session; /* Session of opening process */
long pgrp; /* pgrp of opening process */
unsigned char *xmit_buf;
int xmit_head;
int xmit_tail;
int xmit_cnt;
struct tq_struct tqueue;
struct tq_struct tqueue_hangup;
struct termios normal_termios;
struct termios callout_termios;
struct wait_queue *open_wait;
struct wait_queue *close_wait;
struct wait_queue *delta_msr_wait;
struct async_icount icount; /* kernel counters for the 4 input interrupts */
struct async_struct *next_port; /* For the linked list */
struct async_struct *prev_port;
void *board_base; /* board-base address for use with
boards carrying several UART's,
like some Amiga boards. */
unsigned short nr_uarts; /* UART-counter, that indicates
how many UART's there are on
the board. If the board has a
IRQ-register, this can be used
to check if any of the uarts,
on the board has requested an
interrupt, instead of checking
IRQ-registers on all UART's */
SERIALSWITCH *sw; /* functions to manage this port */
};
 
#define SERIAL_MAGIC 0x5301
 
/*
* The size of the serial xmit buffer is 1 page, or 4096 bytes
*/
#define SERIAL_XMIT_SIZE 4096
 
/*
* Events are used to schedule things to happen at timer-interrupt
* time, instead of at rs interrupt time.
*/
#define RS_EVENT_WRITE_WAKEUP 0
 
/* number of characters left in xmit buffer before we ask for more */
#define WAKEUP_CHARS 256
 
/* Export to allow PCMCIA to use this - Dave Hinds */
extern int register_serial(struct serial_struct *req);
extern void unregister_serial(int line);
extern struct async_struct rs_table[];
extern task_queue tq_serial;
 
 
/*
* This routine is used by the interrupt handler to schedule
* processing in the software interrupt portion of the driver.
*/
static __inline__ void rs_sched_event(struct async_struct *info, int event)
{
info->event |= 1 << event;
queue_task_irq(&info->tqueue, &tq_serial);
mark_bh(SERIAL_BH);
}
 
static __inline__ void rs_receive_char( struct async_struct *info,
int ch, int err )
{
struct tty_struct *tty = info->tty;
if (tty->flip.count >= TTY_FLIPBUF_SIZE)
return;
tty->flip.count++;
if (err == TTY_BREAK) {
if (info->flags & ASYNC_SAK)
do_SAK(tty);
}
*tty->flip.flag_buf_ptr++ = err;
*tty->flip.char_buf_ptr++ = ch;
queue_task_irq(&tty->flip.tqueue, &tq_timer);
}
 
static __inline__ int rs_get_tx_char( struct async_struct *info )
{
unsigned char ch;
if (info->x_char) {
ch = info->x_char;
info->x_char = 0;
return( ch );
}
 
if (info->xmit_cnt <= 0 || info->tty->stopped || info->tty->hw_stopped)
return( -1 );
 
ch = info->xmit_buf[info->xmit_tail++];
info->xmit_tail &= SERIAL_XMIT_SIZE - 1;
if (--info->xmit_cnt < WAKEUP_CHARS)
rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
return( ch );
}
 
static __inline__ int rs_no_more_tx( struct async_struct *info )
{
return( info->xmit_cnt <= 0 ||
info->tty->stopped ||
info->tty->hw_stopped );
}
 
static __inline__ void rs_dcd_changed( struct async_struct *info, int dcd )
 
{
/* update input line counter */
info->icount.dcd++;
wake_up_interruptible(&info->delta_msr_wait);
 
if (info->flags & ASYNC_CHECK_CD) {
#if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
printk("ttyS%d CD now %s...", info->line,
dcd ? "on" : "off");
#endif
if (dcd) {
wake_up_interruptible(&info->open_wait);
} else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
(info->flags & ASYNC_CALLOUT_NOHUP))) {
#ifdef SERIAL_DEBUG_OPEN
printk("scheduling hangup...");
#endif
queue_task_irq(&info->tqueue_hangup,
&tq_scheduler);
}
}
}
 
 
void rs_stop( struct tty_struct *tty );
void rs_start( struct tty_struct *tty );
 
static __inline__ void rs_check_cts( struct async_struct *info, int cts )
{
/* update input line counter */
info->icount.cts++;
wake_up_interruptible(&info->delta_msr_wait);
if ((info->flags & ASYNC_CTS_FLOW) && info->tty)
if (info->tty->hw_stopped) {
if (cts) {
#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
printk("CTS tx start...");
#endif
info->tty->hw_stopped = 0;
rs_start( info->tty );
rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
return;
}
} else {
if (!cts) {
info->tty->hw_stopped = 1;
rs_stop( info->tty );
}
}
}
 
 
#endif /* __KERNEL__ */
 
#endif /* _M68K_SERIAL_H */
/system.h
0,0 → 1,141
#ifndef _M68K_SYSTEM_H
#define _M68K_SYSTEM_H
 
#include <linux/config.h> /* get configuration macros */
#include <linux/linkage.h>
#include <asm/segment.h>
 
extern inline unsigned long rdusp(void) {
unsigned long usp;
 
__asm__ __volatile__("movec %/usp,%0"
: "=d" (usp));
return usp;
}
 
extern inline void wrusp(unsigned long usp) {
__asm__ __volatile__("movec %0,%/usp"
:
: "d" (usp));
}
 
/*
* switch_to(n) should switch tasks to task ptr, first checking that
* ptr isn't the current task, in which case it does nothing. This
* also clears the TS-flag if the task we switched to has used the
* math co-processor latest.
*/
/*
* switch_to() saves the extra registers, that are not saved
* automatically by SAVE_SWITCH_STACK in resume(), ie. d0-d5 and
* a0-a1. Some of these are used by schedule() and its predecessors
* and so we might get see unexpected behaviors when a task returns
* with unexpected register values.
*
* syscall stores these registers itself and none of them are used
* by syscall after the function in the syscall has been called.
*
* Beware that resume now expects *next to be in d1 and the offset of
* tss to be in a1. This saves a few instructions as we no longer have
* to push them onto the stack and read them back right after.
*
* 02/17/96 - Jes Sorensen (jds@kom.auc.dk)
*/
asmlinkage void resume(void);
#define switch_to(prev,next) { \
register int k __asm__ ("a1") = (int)&((struct task_struct *)0)->tss; \
register int n __asm__ ("d1") = (int)next; \
__asm__ __volatile__("jbsr " SYMBOL_NAME_STR(resume) "\n\t" \
: : "a" (k), "d" (n) \
: "d0", "d1", "d2", "d3", "d4", "d5", "a0", "a1"); \
}
 
#define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr))))
#define tas(ptr) (xchg((ptr),1))
 
struct __xchg_dummy { unsigned long a[100]; };
#define __xg(x) ((volatile struct __xchg_dummy *)(x))
 
#if defined(CONFIG_ATARI) && !defined(CONFIG_AMIGA) && !defined(CONFIG_MAC)
/* block out HSYNC on the atari */
#define sti() __asm__ __volatile__ ("andiw #0xfbff,%/sr": : : "memory")
#else /* portable version */
#define sti() __asm__ __volatile__ ("andiw #0xf8ff,%/sr": : : "memory")
#endif /* machine compilation types */
#define cli() __asm__ __volatile__ ("oriw #0x0700,%/sr": : : "memory")
#define nop() __asm__ __volatile__ ("nop"::)
#define mb() __asm__ __volatile__ ("" : : :"memory")
 
#define save_flags(x) \
__asm__ __volatile__("movew %/sr,%0":"=d" (x) : /* no input */ :"memory")
 
#define restore_flags(x) \
__asm__ __volatile__("movew %0,%/sr": /* no outputs */ :"d" (x) : "memory")
 
#define iret() __asm__ __volatile__ ("rte": : :"memory", "sp", "cc")
 
#if 1
static inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
{
unsigned long tmp, flags;
 
save_flags(flags);
cli();
 
switch (size) {
case 1:
__asm__ __volatile__
("moveb %2,%0\n\t"
"moveb %1,%2"
: "=&d" (tmp) : "d" (x), "m" (*__xg(ptr)) : "memory");
break;
case 2:
__asm__ __volatile__
("movew %2,%0\n\t"
"movew %1,%2"
: "=&d" (tmp) : "d" (x), "m" (*__xg(ptr)) : "memory");
break;
case 4:
__asm__ __volatile__
("movel %2,%0\n\t"
"movel %1,%2"
: "=&d" (tmp) : "d" (x), "m" (*__xg(ptr)) : "memory");
break;
}
restore_flags(flags);
return tmp;
}
#else
static inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
{
switch (size) {
case 1:
__asm__ __volatile__
("moveb %2,%0\n\t"
"1:\n\t"
"casb %0,%1,%2\n\t"
"jne 1b"
: "=&d" (x) : "d" (x), "m" (*__xg(ptr)) : "memory");
break;
case 2:
__asm__ __volatile__
("movew %2,%0\n\t"
"1:\n\t"
"casw %0,%1,%2\n\t"
"jne 1b"
: "=&d" (x) : "d" (x), "m" (*__xg(ptr)) : "memory");
break;
case 4:
__asm__ __volatile__
("movel %2,%0\n\t"
"1:\n\t"
"casl %0,%1,%2\n\t"
"jne 1b"
: "=&d" (x) : "d" (x), "m" (*__xg(ptr)) : "memory");
break;
}
return x;
}
#endif
 
#endif /* _M68K_SYSTEM_H */
/resource.h
0,0 → 1,37
#ifndef _M68K_RESOURCE_H
#define _M68K_RESOURCE_H
 
/*
* Resource limits
*/
 
#define RLIMIT_CPU 0 /* CPU time in ms */
#define RLIMIT_FSIZE 1 /* Maximum filesize */
#define RLIMIT_DATA 2 /* max data size */
#define RLIMIT_STACK 3 /* max stack size */
#define RLIMIT_CORE 4 /* max core file size */
#define RLIMIT_RSS 5 /* max resident set size */
#define RLIMIT_NPROC 6 /* max number of processes */
#define RLIMIT_NOFILE 7 /* max number of open files */
#define RLIMIT_MEMLOCK 8 /* max locked-in-memory address space*/
 
#define RLIM_NLIMITS 9
 
#ifdef __KERNEL__
 
#define INIT_RLIMITS \
{ \
{LONG_MAX, LONG_MAX}, \
{LONG_MAX, LONG_MAX}, \
{LONG_MAX, LONG_MAX}, \
{_STK_LIM, _STK_LIM}, \
{ 0, LONG_MAX}, \
{LONG_MAX, LONG_MAX}, \
{MAX_TASKS_PER_USER, MAX_TASKS_PER_USER}, \
{NR_OPEN, NR_OPEN}, \
{LONG_MAX, LONG_MAX} \
}
 
#endif /* __KERNEL__ */
 
#endif /* _M68K_RESOURCE_H */
/shm.h
0,0 → 1,24
#ifndef _M68K_SHM_H
#define _M68K_SHM_H
 
/* format of page table entries that correspond to shared memory pages
currently out in swap space (see also mm/swap.c):
bits 0-1 (PAGE_PRESENT) is = 0
bits 8..2 (SWP_TYPE) are = SHM_SWP_TYPE
bits 31..9 are used like this:
bits 15..9 (SHM_ID) the id of the shared memory segment
bits 30..16 (SHM_IDX) the index of the page within the shared memory segment
(actually only bits 25..16 get used since SHMMAX is so low)
bit 31 (SHM_READ_ONLY) flag whether the page belongs to a read-only attach
*/
/* on the m68k both bits 0 and 1 must be zero */
 
#define SHM_ID_SHIFT 9
#define _SHM_ID_BITS 7
#define SHM_ID_MASK ((1<<_SHM_ID_BITS)-1)
 
#define SHM_IDX_SHIFT (SHM_ID_SHIFT+_SHM_ID_BITS)
#define _SHM_IDX_BITS 15
#define SHM_IDX_MASK ((1<<_SHM_IDX_BITS)-1)
 
#endif /* _M68K_SHM_H */
/atari_SCCserial.h
0,0 → 1,60
#ifndef _ATARI_SCCSERIAL_H
#define _ATARI_SCCSERIAL_H
 
/* Special configuration ioctls for the Atari SCC5380 Serial
* Communications Controller
*/
 
/* ioctl command codes */
 
#define TIOCGATSCC 0x54c0 /* get SCC configuration */
#define TIOCSATSCC 0x54c1 /* set SCC configuration */
#define TIOCDATSCC 0x54c2 /* reset configuration to defaults */
 
/* Clock sources */
 
#define CLK_RTxC 0
#define CLK_TRxC 1
#define CLK_PCLK 2
 
/* baud_bases for the common clocks in the Atari. These are the real
* frequencies divided by 16.
*/
#define SCC_BAUD_BASE_TIMC 19200 /* 0.3072 MHz from TT-MFP, Timer C */
#define SCC_BAUD_BASE_BCLK 153600 /* 2.4576 MHz */
#define SCC_BAUD_BASE_PCLK4 229500 /* 3.6720 MHz */
#define SCC_BAUD_BASE_PCLK 503374 /* 8.0539763 MHz */
#define SCC_BAUD_BASE_NONE 0 /* for not connected or unused
* clock sources */
 
/* The SCC configuration structure */
 
struct atari_SCCserial {
unsigned RTxC_base; /* base_baud of RTxC */
unsigned TRxC_base; /* base_baud of TRxC */
unsigned PCLK_base; /* base_baud of PCLK, for both channels! */
struct {
unsigned clksrc; /* CLK_RTxC, CLK_TRxC or CLK_PCLK */
unsigned divisor; /* divisor for base baud, valid values:
* see below */
} baud_table[17]; /* For 50, 75, 110, 135, 150, 200, 300,
* 600, 1200, 1800, 2400, 4800, 9600,
* 19200, 38400, 57600 and 115200 bps. The
* last two could be replaced by other
* rates > 38400 if they're not possible.
*/
};
 
/* The following divisors are valid:
*
* - CLK_RTxC: 1 or even (1, 2 and 4 are the direct modes, > 4 use
* the BRG)
*
* - CLK_TRxC: 1, 2 or 4 (no BRG, only direct modes possible)
*
* - CLK_PCLK: >= 4 and even (no direct modes, only BRG)
*
*/
 
#endif /* _ATARI_SCCSERIAL_H */
/atari_stdma.h
0,0 → 1,22
 
#ifndef _atari_stdma_h
#define _atari_stdma_h
 
 
#include <asm/irq.h>
 
 
/***************************** Prototypes *****************************/
 
void stdma_lock(isrfunc isr, void *data);
void stdma_release( void );
int stdma_others_waiting( void );
int stdma_islocked( void );
void *stdma_locked_by( void );
void stdma_init( void );
 
/************************* End of Prototypes **************************/
 
 
 
#endif /* _atari_stdma_h */
/atari_rootsec.h
0,0 → 1,34
#ifndef _LINUX_ATARI_ROOTSEC_H
#define _LINUX_ATARI_ROOTSEC_H
 
/*
* linux/include/linux/atari_rootsec.h
* definitions for Atari Rootsector layout
* by Andreas Schwab (schwab@ls5.informatik.uni-dortmund.de)
*
* modified for ICD/Supra partitioning scheme restricted to at most 12
* partitions
* by Guenther Kelleter (guenther@pool.informatik.rwth-aachen.de)
*/
 
struct partition_info
{
u_char flg; /* bit 0: active; bit 7: bootable */
char id[3]; /* "GEM", "BGM", "XGM", or other */
u_long st; /* start of partition */
u_long siz; /* length of partition */
};
 
struct rootsector
{
char unused[0x156]; /* room for boot code */
struct partition_info icdpart[8]; /* info for ICD-partitions 5..12 */
char unused2[0xc];
u_long hd_siz; /* size of disk in blocks */
struct partition_info part[4];
u_long bsl_st; /* start of bad sector list */
u_long bsl_cnt; /* length of bad sector list */
u_short checksum; /* checksum for bootable disks */
};
 
#endif /* _LINUX_ATARI_ROOTSEC_H */
/amigatypes.h
0,0 → 1,59
/*
** linux/amigatypes.h -- Types used in Amiga Linux kernel source
**
** Copyright 1992 by Greg Harp
**
** This file is subject to the terms and conditions of the GNU General Public
** License. See the file COPYING in the main directory of this archive
** for more details.
**
** Created 09/29/92 by Greg Harp
**
** Moved all Zorro definitions to asm/zorro.h which is where they
** really belong - 24/11/95 Jes Sorensen
*/
 
#ifndef _LINUX_AMIGATYPES_H_
#define _LINUX_AMIGATYPES_H_
 
#ifdef __KERNEL__ /* only if compiling the kernel */
#include <linux/types.h>
#endif
 
/*
* Different models of Amiga
*/
#define AMI_UNKNOWN (0)
#define AMI_500 (1)
#define AMI_500PLUS (2)
#define AMI_600 (3)
#define AMI_1000 (4)
#define AMI_1200 (5)
#define AMI_2000 (6)
#define AMI_2500 (7)
#define AMI_3000 (8)
#define AMI_3000T (9)
#define AMI_3000PLUS (10)
#define AMI_4000 (11)
#define AMI_4000T (12)
#define AMI_CDTV (13)
#define AMI_CD32 (14)
#define AMI_DRACO (15)
 
/*
* chipsets
*/
#define CS_STONEAGE (0)
#define CS_OCS (1)
#define CS_ECS (2)
#define CS_AGA (3)
 
/*
* Amiga clocks
*/
 
extern u_long amiga_masterclock; /* 28 MHz */
extern u_long amiga_colorclock; /* 3.5 MHz */
#define amiga_eclock boot_info.bi_amiga.eclock /* 700 kHz */
 
#endif /* asm-m68k/amigatypes.h */
/unistd.h
0,0 → 1,466
#ifndef _ASM_M68K_UNISTD_H_
#define _ASM_M68K_UNISTD_H_
 
/*
* This file contains the system call numbers.
*/
 
#define __NR_setup 0 /* used only by init, to get system going */
#define __NR_exit 1
#define __NR_fork 2
#define __NR_read 3
#define __NR_write 4
#define __NR_open 5
#define __NR_close 6
#define __NR_waitpid 7
#define __NR_creat 8
#define __NR_link 9
#define __NR_unlink 10
#define __NR_execve 11
#define __NR_chdir 12
#define __NR_time 13
#define __NR_mknod 14
#define __NR_chmod 15
#define __NR_chown 16
#define __NR_break 17
#define __NR_oldstat 18
#define __NR_lseek 19
#define __NR_getpid 20
#define __NR_mount 21
#define __NR_umount 22
#define __NR_setuid 23
#define __NR_getuid 24
#define __NR_stime 25
#define __NR_ptrace 26
#define __NR_alarm 27
#define __NR_oldfstat 28
#define __NR_pause 29
#define __NR_utime 30
#define __NR_stty 31
#define __NR_gtty 32
#define __NR_access 33
#define __NR_nice 34
#define __NR_ftime 35
#define __NR_sync 36
#define __NR_kill 37
#define __NR_rename 38
#define __NR_mkdir 39
#define __NR_rmdir 40
#define __NR_dup 41
#define __NR_pipe 42
#define __NR_times 43
#define __NR_prof 44
#define __NR_brk 45
#define __NR_setgid 46
#define __NR_getgid 47
#define __NR_signal 48
#define __NR_geteuid 49
#define __NR_getegid 50
#define __NR_acct 51
#define __NR_phys 52
#define __NR_lock 53
#define __NR_ioctl 54
#define __NR_fcntl 55
#define __NR_mpx 56
#define __NR_setpgid 57
#define __NR_ulimit 58
#define __NR_oldolduname 59
#define __NR_umask 60
#define __NR_chroot 61
#define __NR_ustat 62
#define __NR_dup2 63
#define __NR_getppid 64
#define __NR_getpgrp 65
#define __NR_setsid 66
#define __NR_sigaction 67
#define __NR_sgetmask 68
#define __NR_ssetmask 69
#define __NR_setreuid 70
#define __NR_setregid 71
#define __NR_sigsuspend 72
#define __NR_sigpending 73
#define __NR_sethostname 74
#define __NR_setrlimit 75
#define __NR_getrlimit 76
#define __NR_getrusage 77
#define __NR_gettimeofday 78
#define __NR_settimeofday 79
#define __NR_getgroups 80
#define __NR_setgroups 81
#define __NR_select 82
#define __NR_symlink 83
#define __NR_oldlstat 84
#define __NR_readlink 85
#define __NR_uselib 86
#define __NR_swapon 87
#define __NR_reboot 88
#define __NR_readdir 89
#define __NR_mmap 90
#define __NR_munmap 91
#define __NR_truncate 92
#define __NR_ftruncate 93
#define __NR_fchmod 94
#define __NR_fchown 95
#define __NR_getpriority 96
#define __NR_setpriority 97
#define __NR_profil 98
#define __NR_statfs 99
#define __NR_fstatfs 100
#define __NR_ioperm 101
#define __NR_socketcall 102
#define __NR_syslog 103
#define __NR_setitimer 104
#define __NR_getitimer 105
#define __NR_stat 106
#define __NR_lstat 107
#define __NR_fstat 108
#define __NR_olduname 109
#define __NR_iopl /* 110 */ not supported
#define __NR_vhangup 111
#define __NR_idle 112
#define __NR_vm86 /* 113 */ not supported
#define __NR_wait4 114
#define __NR_swapoff 115
#define __NR_sysinfo 116
#define __NR_ipc 117
#define __NR_fsync 118
#define __NR_sigreturn 119
#define __NR_clone 120
#define __NR_setdomainname 121
#define __NR_uname 122
#define __NR_cacheflush 123
#define __NR_adjtimex 124
#define __NR_mprotect 125
#define __NR_sigprocmask 126
#define __NR_create_module 127
#define __NR_init_module 128
#define __NR_delete_module 129
#define __NR_get_kernel_syms 130
#define __NR_quotactl 131
#define __NR_getpgid 132
#define __NR_fchdir 133
#define __NR_bdflush 134
#define __NR_sysfs 135
#define __NR_personality 136
#define __NR_afs_syscall 137 /* Syscall for Andrew File System */
#define __NR_setfsuid 138
#define __NR_setfsgid 139
#define __NR__llseek 140
#define __NR_getdents 141
#define __NR__newselect 142
#define __NR_flock 143
#define __NR_msync 144
#define __NR_readv 145
#define __NR_writev 146
#define __NR_getsid 147
#define __NR_fdatasync 148
#define __NR__sysctl 149
#define __NR_mlock 150
#define __NR_munlock 151
#define __NR_mlockall 152
#define __NR_munlockall 153
#define __NR_sched_setparam 154
#define __NR_sched_getparam 155
#define __NR_sched_setscheduler 156
#define __NR_sched_getscheduler 157
#define __NR_sched_yield 158
#define __NR_sched_get_priority_max 159
#define __NR_sched_get_priority_min 160
#define __NR_sched_rr_get_interval 161
#define __NR_nanosleep 162
#define __NR_mremap 163
 
#ifdef __ELF__
 
#define _syscall0(type,name) \
type name(void) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
__asm__ __volatile__ ("trap #0" \
: "=g" (__res) \
: "0" (__NR_##name) \
: "%d0"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall1(type,name,atype,a) \
type name(atype a) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,%/d1\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)) \
: "%d0", "%d1"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall2(type,name,atype,a,btype,b) \
type name(atype a,btype b) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,%/d1\n\t" \
"movel %3,%/d2\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)), \
"g" ((long)(b)) \
: "%d0", "%d1", "%d2"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall3(type,name,atype,a,btype,b,ctype,c) \
type name(atype a,btype b,ctype c) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,%/d1\n\t" \
"movel %3,%/d2\n\t" \
"movel %4,%/d3\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)), \
"g" ((long)(b)), \
"g" ((long)(c)) \
: "%d0", "%d1", "%d2", "%d3"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall4(type,name,atype,a,btype,b,ctype,c,dtype,d) \
type name (atype a, btype b, ctype c, dtype d) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,%/d1\n\t" \
"movel %3,%/d2\n\t" \
"movel %4,%/d3\n\t" \
"movel %5,%/d4\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)), \
"g" ((long)(b)), \
"g" ((long)(c)), \
"g" ((long)(d)) \
: "%d0", "%d1", "%d2", "%d3", "%d4"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall5(type,name,atype,a,btype,b,ctype,c,dtype,d,etype,e) \
type name (atype a,btype b,ctype c,dtype d,etype e) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,%/d1\n\t" \
"movel %3,%/d2\n\t" \
"movel %4,%/d3\n\t" \
"movel %5,%/d4\n\t" \
"movel %6,%/d5\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)), \
"g" ((long)(b)), \
"g" ((long)(c)), \
"g" ((long)(d)), \
"g" ((long)(e)) \
: "%d0", "%d1", "%d2", "%d3", "%d4", "%d5"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#else /* not ELF; a.out */
 
/* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
#define _syscall0(type,name) \
type name(void) \
{ \
register long __res __asm__ ("d0") = __NR_##name; \
__asm__ __volatile__ ("trap #0" \
: "=g" (__res) \
: "0" (__NR_##name) \
: "d0"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall1(type,name,atype,a) \
type name(atype a) \
{ \
register long __res __asm__ ("d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,d1\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)) \
: "d0", "d1"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall2(type,name,atype,a,btype,b) \
type name(atype a,btype b) \
{ \
register long __res __asm__ ("d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,d1\n\t" \
"movel %3,d2\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)), \
"g" ((long)(b)) \
: "d0", "d1", "d2"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall3(type,name,atype,a,btype,b,ctype,c) \
type name(atype a,btype b,ctype c) \
{ \
register long __res __asm__ ("d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,d1\n\t" \
"movel %3,d2\n\t" \
"movel %4,d3\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)), \
"g" ((long)(b)), \
"g" ((long)(c)) \
: "d0", "d1", "d2", "d3"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall4(type,name,atype,a,btype,b,ctype,c,dtype,d) \
type name (atype a, btype b, ctype c, dtype d) \
{ \
register long __res __asm__ ("d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,d1\n\t" \
"movel %3,d2\n\t" \
"movel %4,d3\n\t" \
"movel %5,d4\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)), \
"g" ((long)(b)), \
"g" ((long)(c)), \
"g" ((long)(d)) \
: "d0", "d1", "d2", "d3", "d4"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#define _syscall5(type,name,atype,a,btype,b,ctype,c,dtype,d,etype,e) \
type name (atype a,btype b,ctype c,dtype d,etype e) \
{ \
register long __res __asm__ ("d0") = __NR_##name; \
__asm__ __volatile__ ("movel %2,d1\n\t" \
"movel %3,d2\n\t" \
"movel %4,d3\n\t" \
"movel %5,d4\n\t" \
"movel %6,d5\n\t" \
"trap #0" \
: "=g" (__res) \
: "0" (__NR_##name), "g" ((long)(a)), \
"g" ((long)(b)), \
"g" ((long)(c)), \
"g" ((long)(d)), \
"g" ((long)(e)) \
: "d0", "d1", "d2", "d3", "d4", "d5"); \
if (__res >= 0) \
return (type) __res; \
errno = -__res; \
return -1; \
}
 
#endif /* ELF or otherwise */
 
#ifdef __KERNEL_SYSCALLS__
 
/*
* we need this inline - forking from kernel space will result
* in NO COPY ON WRITE (!!!), until an execve is executed. This
* is no problem, but for the stack. This is handled by not letting
* main() use the stack at all after fork(). Thus, no function
* calls - which means inline code for fork too, as otherwise we
* would use the stack upon exit from 'fork()'.
*
* Actually only pause and fork are needed inline, so that there
* won't be any messing with the stack from main(), but we define
* some others too.
*/
#define __NR__exit __NR_exit
static inline _syscall0(int,idle)
static inline _syscall0(int,fork)
static inline _syscall2(int,clone,unsigned long,flags,char *,usp)
static inline _syscall0(int,pause)
static inline _syscall0(int,setup)
static inline _syscall0(int,sync)
static inline _syscall0(pid_t,setsid)
static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
static inline _syscall1(int,dup,int,fd)
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
static inline _syscall1(int,close,int,fd)
static inline _syscall1(int,_exit,int,exitcode)
static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
 
/*
* This is the mechanism for creating a new kernel thread.
*
* NOTE! Only a kernel-only process(ie the swapper or direct descendants
* who haven't done an "execve()") should use this: it will work within
* a system call from a "real" process, but the process memory space will
* not be free'd until both the parent and the child have exited.
*/
static inline pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
{
register long retval __asm__ ("d0") = __NR_clone;
register long clone_arg __asm__ ("d1") = flags | CLONE_VM;
 
__asm__ __volatile__
("movel %%sp,%%d2\n\t"
"trap #0\n\t" /* Linux/m68k system call */
"cmpl %%sp,%%d2\n\t" /* child or parent */
"jeq 1f\n\t" /* parent - jump */
"movel %3,%%sp@-\n\t" /* push argument */
"jsr %4@\n\t" /* call fn */
"movel %2,%0\n\t" /* exit */
"trap #0\n"
"1:"
: "=d" (retval)
: "0" (__NR_clone), "i" (__NR_exit),
"r" (arg), "a" (fn), "d" (clone_arg)
: "d0", "d2");
 
return retval;
}
 
static inline pid_t wait(int * wait_stat)
{
return waitpid(-1,wait_stat,0);
}
 
#endif
 
#endif /* _ASM_M68K_UNISTD_H_ */
/amigardb.h
0,0 → 1,126
#ifndef _LINUX_AMIGARDB_H
#define _LINUX_AMIGARDB_H 1
 
#define ULONG u_long
#define LONG long
#define UBYTE u_char
 
/* definitions for the Amiga RigidDiskBlock layout, which always starts in
cylinder 0 of a medium. Taken from page 254f of the RKM: Devices */
 
struct RigidDiskBlock {
ULONG rdb_ID; /* 4 character identifier */
ULONG rdb_SummedLongs; /* size of this checksummed structure */
LONG rdb_ChkSum; /* block checksum (longword sum to zero) */
ULONG rdb_HostID; /* SCSI Target ID of host */
ULONG rdb_BlockBytes; /* size of disk blocks */
ULONG rdb_Flags; /* see below for defines */
/* block list heads */
ULONG rdb_BadBlockList; /* optional bad block list */
ULONG rdb_PartitionList; /* optional first partition block */
ULONG rdb_FileSysHeaderList; /* optional file system header block */
ULONG rdb_DriveInit; /* optional drive-specific init code */
/* DriveInit(lun,rdb,ior): "C" stk & d0/a0/a1 */
ULONG rdb_Reserved1[6]; /* set to $ffffffff */
/* physical drive characteristics */
ULONG rdb_Cylinders; /* number of drive cylinders */
ULONG rdb_Sectors; /* sectors per track */
ULONG rdb_Heads; /* number of drive heads */
ULONG rdb_Interleave; /* interleave */
ULONG rdb_Park; /* landing zone cylinder */
ULONG rdb_Reserved2[3];
ULONG rdb_WritePreComp; /* starting cylinder: write precompensation */
ULONG rdb_ReducedWrite; /* starting cylinder: reduced write current */
ULONG rdb_StepRate; /* drive step rate */
ULONG rdb_Reserved3[5];
/* logical drive characteristics */
ULONG rdb_RDBBlocksLo; /* low block of range reserved for hardblocks */
ULONG rdb_RDBBlocksHi; /* high block of range for these hardblocks */
ULONG rdb_LoCylinder; /* low cylinder of partitionable disk area */
ULONG rdb_HiCylinder; /* high cylinder of partitionable data area */
ULONG rdb_CylBlocks; /* number of blocks available per cylinder */
ULONG rdb_AutoParkSeconds; /* zero for no auto park */
ULONG rdb_HighRDSKBlock; /* highest block used by RDSK */
/* (not including replacement bad blocks) */
ULONG rdb_Reserved4;
/* drive identification */
char rdb_DiskVendor[8];
char rdb_DiskProduct[16];
char rdb_DiskRevision[4];
char rdb_ControllerVendor[8];
char rdb_ControllerProduct[16];
char rdb_ControllerRevision[4];
ULONG rdb_Reserved5[10];
};
 
#define IDNAME_RIGIDDISK 0x5244534B /* 'RDSK' */
 
#define RDB_LOCATION_LIMIT 16
 
#define RDBFB_LAST 0 /* no disks exist to be configured after */
#define RDBFF_LAST 0x01L /* this one on this controller */
#define RDBFB_LASTLUN 1 /* no LUNs exist to be configured greater */
#define RDBFF_LASTLUN 0x02L /* than this one at this SCSI Target ID */
#define RDBFB_LASTTID 2 /* no Target IDs exist to be configured */
#define RDBFF_LASTTID 0x04L /* greater than this one on this SCSI bus */
#define RDBFB_NORESELECT 3 /* don't bother trying to perform reselection */
#define RDBFF_NORESELECT 0x08L /* when talking to this drive */
#define RDBFB_DISKID 4 /* rdb_Disk... identification valid */
#define RDBFF_DISKID 0x10L
#define RDBFB_CTRLRID 5 /* rdb_Controller... identification valid */
#define RDBFF_CTRLRID 0x20L
/* added 7/20/89 by commodore: */
#define RDBFB_SYNCH 6 /* drive supports scsi synchronous mode */
#define RDBFF_SYNCH 0x40L /* CAN BE DANGEROUS TO USE IF IT DOESN'T! */
 
struct PartitionBlock {
ULONG pb_ID; /* 4 character identifier */
ULONG pb_SummedLongs; /* size of this checksummed structure */
LONG pb_ChkSum; /* block checksum (longword sum to zero) */
ULONG pb_HostID; /* SCSI Target ID of host */
ULONG pb_Next; /* block number of the next PartitionBlock */
ULONG pb_Flags; /* see below for defines */
ULONG pb_Reserved1[2];
ULONG pb_DevFlags; /* preferred flags for OpenDevice */
UBYTE pb_DriveName[32]; /* preferred DOS device name: BSTR form */
/* (not used if this name is in use) */
ULONG pb_Reserved2[15]; /* filler to 32 longwords */
ULONG pb_Environment[17]; /* environment vector for this partition */
ULONG pb_EReserved[15]; /* reserved for future environment vector */
};
 
#define IDNAME_PARTITION 0x50415254 /* 'PART' */
 
#define PBFB_BOOTABLE 0 /* this partition is intended to be bootable */
#define PBFF_BOOTABLE 1L /* (expected directories and files exist) */
#define PBFB_NOMOUNT 1 /* do not mount this partition (e.g. manually */
#define PBFF_NOMOUNT 2L /* mounted, but space reserved here) */
 
/* this is from <dos/filehandler.h> */
 
#define DE_TABLESIZE 0 /* minimum value is 11 (includes NumBuffers) */
#define DE_SIZEBLOCK 1 /* in longwords: standard value is 128 */
#define DE_SECORG 2 /* not used; must be 0 */
#define DE_NUMHEADS 3 /* # of heads (surfaces). drive specific */
#define DE_SECSPERBLK 4 /* not used; must be 1 */
#define DE_BLKSPERTRACK 5 /* blocks per track. drive specific */
#define DE_RESERVEDBLKS 6 /* unavailable blocks at start. usually 2 */
#define DE_PREFAC 7 /* not used; must be 0 */
#define DE_INTERLEAVE 8 /* usually 0 */
#define DE_LOWCYL 9 /* starting cylinder. typically 0 */
#define DE_UPPERCYL 10 /* max cylinder. drive specific */
#define DE_NUMBUFFERS 11 /* starting # of buffers. typically 5 */
#define DE_MEMBUFTYPE 12 /* type of mem to allocate for buffers. */
#define DE_BUFMEMTYPE 12 /* same as above, better name
* 1 is public, 3 is chip, 5 is fast */
#define DE_MAXTRANSFER 13 /* Max number bytes to transfer at a time */
#define DE_MASK 14 /* Address Mask to block out certain memory */
#define DE_BOOTPRI 15 /* Boot priority for autoboot */
#define DE_DOSTYPE 16 /* ASCII (HEX) string showing filesystem type;
* 0X444F5300 is old filesystem,
* 0X444F5301 is fast file system */
#define DE_BAUD 17 /* Baud rate for serial handler */
#define DE_CONTROL 18 /* Control word for handler/filesystem */
#define DE_BOOTBLOCKS 19 /* Number of blocks containing boot code */
 
#endif /* _LINUX_AMIGARDB_H */
/atarihdreg.h
0,0 → 1,24
#ifndef _LINUX_ATAHDREG_H
#define _LINUX_ATAHDREG_H
 
/*
* This file contains some defines for the Falcon IDE hd controller.
* Various sources. Check out some definitions (see comments with
* a ques).
*/
 
#define ATA_HD_BASE 0xfff00000
 
#define ATA_HD_DATA 0x00 /* _CTL when writing */
#define ATA_HD_ERROR 0x05 /* see err-bits */
#define ATA_HD_NSECTOR 0x09 /* nr of sectors to read/write */
#define ATA_HD_SECTOR 0x0d /* starting sector */
#define ATA_HD_LCYL 0x11 /* starting cylinder */
#define ATA_HD_HCYL 0x15 /* high byte of starting cyl */
#define ATA_HD_CURRENT 0x19 /* 101dhhhh , d=drive, hhhh=head */
#define ATA_HD_STATUS 0x1d /* see status-bits */
 
#define ATA_HD_CMD 0x39
#define ATA_HD_ALTSTATUS 0x39 /* same as HD_STATUS but doesn't clear irq */
 
#endif /* _LINUX_ATAHDREG_H */
/sockios.h
0,0 → 1,12
#ifndef __ARCH_M68K_SOCKIOS__
#define __ARCH_M68K_SOCKIOS__
 
/* Socket-level I/O control calls. */
#define FIOSETOWN 0x8901
#define SIOCSPGRP 0x8902
#define FIOGETOWN 0x8903
#define SIOCGPGRP 0x8904
#define SIOCATMARK 0x8905
#define SIOCGSTAMP 0x8906 /* Get stamp */
 
#endif /* __ARCH_M68K_SOCKIOS__ */
/zorro.h
0,0 → 1,392
/*
* asm-m68k/zorro.h -- Amiga AutoConfig (Zorro) Expansion Device Definitions
*
* Copyright (C) 1995 Geert Uytterhoeven
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of this archive
* for more details.
*/
 
#ifndef _ASM_M68K_ZORRO_H_
#define _ASM_M68K_ZORRO_H_
 
#ifndef __ASSEMBLY__
 
#include <linux/config.h>
#include <asm/amigatypes.h>
 
 
/*
* Defined Board Manufacturers
*
* Please update arch/m68k/amiga/zorro.c if you make changes here
 
* and by looking at the NetBSD-Amiga kernel source
*/
 
#define MANUF_MEMPHIS (0x0100) /* Memphis */
#define PROD_STORMBRINGER (0x00) /* Stormbringer */
 
#define MANUF_COMMODORE2 (0x0201) /* Commodore Germany */
#define PROD_A2088 (0x01) /* CBM A2088 Bridgeboard */
#define PROD_A2386SX (0x67) /* CBM A2386-SX Bridgeboard */
 
#define MANUF_COMMODORE (0x0202) /* Commodore USA */
#define PROD_A2090A (0x01) /* CBM A2090/A2090A HD Controller */
#define PROD_A590 (0x02) /* CBM A590 SCSI Controller */
#define PROD_A2091 (0x03) /* CBM A2091 SCSI Controller */
#define PROD_A2090B (0x04) /* CBM A2090B 2090 Autoboot Card */
#define PROD_ARCNET (0x09) /* CBM A2060 Arcnet Card */
#define PROD_CBMRAM (0x0A) /* CBM A2052/58.RAM | 590/2091.RAM */
#define PROD_A560RAM (0x20) /* CBM A560 Memory Module */
#define PROD_A2232PROTO (0x45) /* CBM A2232 Serial Prototype */
#define PROD_A2232 (0x46) /* CBM A2232 Serial Production */
#define PROD_A2620 (0x50) /* CBM A2620 68020/RAM Card */
#define PROD_A2630 (0x51) /* CBM A2630 68030/RAM Card */
#define PROD_A4091 (0x54) /* CBM A4091 SCSI Controller */
#define PROD_ROMULATOR (0x60) /* CBM Romulator Card */
#define PROD_A3000TESTFIX (0x61) /* CBM A3000 Test Fixture */
#define PROD_A2065 (0x70) /* CBM A2065 Ethernet Card */
 
#define MANUF_CARDCO (0x03EC) /* Cardco */
#define PROD_CC_A2410 (0xF5) /* Cardco A2410 Hires Graphics Card */
 
#define MANUF_MICROBOTICS (0x03F2) /* MicroBotics */
#define PROD_VXL_30 (0x45) /* VXL-30 Turbo Board */
 
#define MANUF_ASDG (0x03FF) /* ASDG */
#define PROD_LAN_ROVER (0xFE) /* Lan Rover Ethernet */
#define PROD_ASDG_DUAL_SERIAL (0xFF) /* Dual Serial Card */
 
#define MANUF_UNIV_OF_LOWELL (0x0406) /* University of Lowell */
#define PROD_A2410 (0x00) /* CBM A2410 Hires Graphics Card */
 
#define MANUF_AMERISTAR (0x041D) /* Ameristar */
#define PROD_AMERISTAR2065 (0x01) /* A2065 Ethernet Card */
#define PROD_A560 (0x09) /* Arcnet Card */
#define PROD_A4066 (0x0A) /* A4066 Ethernet Card */
 
#define MANUF_SUPRA (0x0420) /* Supra */
#define PROD_WORDSYNC (0x0C) /* Supra Wordsync SCSI Controller */
#define PROD_WORDSYNC_II (0x0D) /* Supra Wordsync II SCSI Controller */
#define PROD_SUPRA_2400MODEM (0x10) /* Supra 2400 Modem */
 
#define MANUF_CSA (0x0422) /* CSA */
#define PROD_MAGNUM (0x11) /* Magnum 40 SCSI Controller */
#define PROD_12GAUGE (0x15) /* 12 Gauge SCSI Controller */
 
#define MANUF_HACKER (0x07DB) /* Test only: no product definitions */
 
#define MANUF_POWER_COMPUTING (0x07DC) /* Power Computing */
#define PROD_DKB_1240 (0x12) /* Viper II Turbo Board (DKB 1240) */
 
#define MANUF_GVP (0x07E1) /* Great Valley Products */
#define PROD_GVPIISCSI (0x0B) /* GVP Series II SCSI Controller */
#define PROD_GVPIISCSI_2 (0x09) /* evidence that the driver works
for this product code also */
#define PROD_GVPIIRAM (0x0A) /* GVP Series II RAM */
#define PROD_GVP (0x0B) /* This code is used by a wide range of
GVP products - use the epc to
identify it correctly */
#define PROD_GVP_A2000_030 (0x0D) /* GVP A2000 68030 Turbo Board */
#define PROD_GFORCE_040_SCSI (0x16) /* GForce 040 with SCSI (new) */
#define PROD_GVPIV_24 (0x20) /* GVP IV-24 Graphics Board */
/* #define PROD_GVPIO_EXT (0xFF)*/ /* GVP I/O Extender */
 
#define MANUF_PPI (0x07EA) /* Progressive Peripherals Inc. */
#define PROD_MERCURY (0x00) /* Mercury Turbo Board */
#define PROD_PPS_A3000_040 (0x01) /* PP&S A3000 68040 Turbo Board */
#define PROD_PPS_A2000_040 (0x69) /* PP&S A2000 68040 Turbo Board */
#define PROD_ZEUS (0x96) /* Zeus SCSI Controller */
#define PROD_PPS_A500_040 (0xBB) /* PP&S A500 68040 Turbo Board */
 
#define MANUF_BSC (0x07FE) /* BSC */
#define PROD_ALF_3_SCSI (0x03) /* BSC ALF 3 SCSI Controller */
 
#define MANUF_C_LTD (0x0802) /* C Ltd. */
#define PROD_KRONOS_SCSI (0x04) /* Kronos SCSI Controller */
 
#define MANUF_JOCHHEIM (0x0804) /* Jochheim */
#define PROD_JOCHHEIM_RAM (0x01) /* Jochheim RAM */
 
#define MANUF_CHECKPOINT (0x0807) /* Checkpoint Technologies */
#define PROD_SERIAL_SOLUTION (0x00) /* Serial Solution */
 
#define MANUF_GOLEM (0x0819) /* Golem */
#define PROD_GOLEM_SCSI_II (0x02) /* Golem SCSI-II Controller */
 
#define MANUF_HARDITAL_SYNTHES (0x0817) /* Hardital Synthesis */
#define PROD_HARDITAL_SCSI (0x01) /* Hardital Synthesis SCSI Controller */
 
#define MANUF_HARDITAL2 (0x0820) /* Hardital Synthesis */
#define PROD_TQM (0x14) /* TQM 68030+68882 Turbo Board */
 
#define MANUF_BSC2 (0x082C) /* BSC */
#define PROD_OKTAGON_SCSI (0x05) /* BSC Oktagon 2008 SCSI Controller */
#define PROD_TANDEM (0x06) /* BSC Tandem */
#define PROD_OKTAGON_RAM (0x08) /* BSC Oktagon 2008 RAM */
#define PROD_MULTIFACE_I (0x10) /* Alfa Data MultiFace I */
#define PROD_MULTIFACE_II (0x11) /* Alfa Data MultiFace II */
#define PROD_MULTIFACE_III (0x12) /* Alfa Data MultiFace III */
#define PROD_ISDN_MASTER (0x40) /* BSC ISDN Master */
 
#define MANUF_ADV_SYS_SOFT (0x0836) /* Advanced Systems & Software */
#define PROD_NEXUS_SCSI (0x01) /* Nexus SCSI Controller */
#define PROD_NEXUS_RAM (0x08) /* Nexus RAM */
 
#define MANUF_IVS (0x0840) /* IVS */
#define PROD_TRUMPCARD_500 (0x30) /* Trumpcard 500 SCSI Controller */
#define PROD_TRUMPCARD (0x34) /* Trumpcard SCSI Controller */
#define PROD_VECTOR (0xF3) /* Vector SCSI Controller */
 
#define MANUF_XPERT_PRODEV (0x0845) /* XPert/ProDev */
#define PROD_MERLIN_RAM (0x03) /* Merlin Graphics Board */
#define PROD_MERLIN_REG (0x04)
 
#define MANUF_HYDRA_SYSTEMS (0x0849) /* Hydra Systems */
#define PROD_AMIGANET (0x01) /* Amiganet Board */
 
#define MANUF_DIG_MICRONICS (0x0851) /* Digital Micronics Inc */
#define PROD_DMI_RESOLVER (0x01) /* DMI Resolver Graphics Board */
 
#define MANUF_HELFRICH1 (0x0861) /* Helfrich */
#define PROD_RAINBOW3 (0x21) /* Rainbow3 Graphics Board */
 
#define MANUF_SW_RESULT_ENTS (0x0866) /* Software Result Enterprises */
#define PROD_GG2PLUS (0x01) /* GG2+ Bus Converter */
 
#define MANUF_VILLAGE_TRONIC (0x0877) /* Village Tronic */
#define PROD_PICASSO_II_RAM (0x0B) /* Picasso II Graphics Board */
#define PROD_PICASSO_II_REG (0x0C)
#define PROD_ARIADNE (0xC9) /* Ariadne Ethernet */
 
#define MANUF_UTILITIES_ULTD (0x087B) /* Utilities Unlimited */
#define PROD_EMPLANT_DELUXE (0x15) /* Emplant Deluxe SCSI Controller */
#define PROD_EMPLANT_DELUXE2 (0x20) /* Emplant Deluxe SCSI Controller */
 
#define MANUF_MTEC (0x0890) /* MTEC Germany */
#define PROD_MTEC_68030 (0x03) /* 68030 Turbo Board */
#define PROD_MTEC_T1230 (0x20) /* MTEC T1230/28 Turbo Board */
 
#define MANUF_GVP2 (0x0891) /* Great Valley Products */
#define PROD_SPECTRUM_RAM (0x01) /* GVP Spectrum Graphics Board */
#define PROD_SPECTRUM_REG (0x02)
 
#define MANUF_HELFRICH2 (0x0893) /* Helfrich */
#define PROD_PICCOLO_RAM (0x05) /* Piccolo Graphics Board */
#define PROD_PICCOLO_REG (0x06)
#define PROD_PEGGY_PLUS (0x07) /* PeggyPlus MPEG Decoder Board */
#define PROD_SD64_RAM (0x0A) /* SD64 Graphics Board */
#define PROD_SD64_REG (0x0B)
 
#define MANUF_MACROSYSTEMS (0x089B) /* MacroSystems USA */
#define PROD_WARP_ENGINE (0x13) /* Warp Engine SCSI Controller */
 
#define MANUF_HARMS_PROF (0x0A00) /* Harms Professional */
#define PROD_3500_TURBO (0xD0) /* 3500 Turbo board */
 
#define MANUF_VORTEX (0x2017) /* Vortex */
#define PROD_GOLDEN_GATE_386 (0x07) /* Golden Gate 80386 Board */
#define PROD_GOLDEN_GATE_RAM (0x08) /* Golden Gate RAM */
#define PROD_GOLDEN_GATE_486 (0x09) /* Golden Gate 80486 Board */
 
#define MANUF_DATAFLYER (0x2062) /* DataFlyer */
#define PROD_DATAFLYER_4000SX (0x01) /* DataFlyer 4000SX SCSI Controller */
 
#define MANUF_PHASE5 (0x2140) /* Phase5 */
#define PROD_FASTLANE_RAM (0x0A) /* FastLane RAM */
#define PROD_FASTLANE_SCSI (0x0B) /* FastLane/Blizzard 1230-II SCSI */
#define PROD_CYBERSTORM_SCSI (0x0C) /* CyberStorm Fast SCSI-II Controller */
#define PROD_BLIZZARD_1230_III (0x0D) /* Blizzard 1230-III Turbo Board */
#define PROD_BLIZZARD_1230_IV (0x11) /* Blizzard 1230-IV Turbo Board */
#define PROD_CYBERVISION (0x22) /* CyberVision64 Graphics Board */
 
#define MANUF_APOLLO (0x2222) /* Apollo */
#define PROD_AT_APOLLO (0x22) /* AT-Apollo */
#define PROD_APOLLO_TURBO (0x23) /* Apollo Turbo Board */
 
#define MANUF_UWE_GERLACH (0x3FF7) /* Uwe Gerlach */
#define PROD_UG_RAM_ROM (0xd4) /* RAM/ROM */
 
#define MANUF_MACROSYSTEMS2 (0x4754) /* MacroSystems Germany */
#define PROD_MAESTRO (0x03) /* Maestro */
#define PROD_VLAB (0x04) /* VLab */
#define PROD_MAESTRO_PRO (0x05) /* Maestro Pro */
#define PROD_RETINA_Z2 (0x06) /* Retina Z2 Graphics Board */
#define PROD_MULTI_EVOLUTION (0x08) /* MultiEvolution */
#define PROD_RETINA_Z3 (0x10) /* Retina Z3 Graphics Board */
#define PROD_FALCON_040 (0xFD) /* Falcon '040 Turbo Board */
 
 
/* Illegal Manufacturer IDs. These do NOT appear in amiga/zorro.c! */
 
#define MANUF_HACKER_INC (0x07DB) /* Hacker Inc. */
#define PROD_HACKER_SCSI (0x01) /* Hacker Inc. SCSI Controller */
 
#define MANUF_RES_MNGT_FORCE (0x07DB) /* Resource Management Force */
#define PROD_QUICKNET (0x02) /* QuickNet Ethernet */
 
 
/*
* GVP's identifies most of their product through the 'extended
* product code' (epc). The epc has to be and'ed with the GVPEPCMASK
* before the identification.
*/
 
#define GVP_EPCMASK (0xf8)
 
enum GVP_ident {
GVP_GFORCE_040 = 0x20,
GVP_GFORCE_040_SCSI = 0x30,
GVP_A1291_SCSI = 0x40,
GVP_COMBO_R4 = 0x60,
GVP_COMBO_R4_SCSI = 0x70,
GVP_PHONEPAK = 0x78,
GVP_IOEXT = 0x98,
GVP_GFORCE_030 = 0xa0,
GVP_GFORCE_030_SCSI = 0xb0,
GVP_A530 = 0xc0,
GVP_A530_SCSI = 0xd0,
GVP_COMBO_R3 = 0xe0,
GVP_COMBO_R3_SCSI = 0xf0,
GVP_SERIESII = 0xf8,
};
 
enum GVP_flags {
GVP_IO = 0x01,
GVP_ACCEL = 0x02,
GVP_SCSI = 0x04,
GVP_24BITDMA = 0x08,
GVP_25BITDMA = 0x10,
GVP_NOBANK = 0x20,
GVP_14MHZ = 0x40,
};
 
 
struct Node {
struct Node *ln_Succ; /* Pointer to next (successor) */
struct Node *ln_Pred; /* Pointer to previous (predecessor) */
u_char ln_Type;
char ln_Pri; /* Priority, for sorting */
char *ln_Name; /* ID string, null terminated */
};
 
struct ExpansionRom {
/* -First 16 bytes of the expansion ROM */
u_char er_Type; /* Board type, size and flags */
u_char er_Product; /* Product number, assigned by manufacturer */
u_char er_Flags; /* Flags */
u_char er_Reserved03; /* Must be zero ($ff inverted) */
u_short er_Manufacturer; /* Unique ID,ASSIGNED BY COMMODORE-AMIGA! */
u_long er_SerialNumber; /* Available for use by manufacturer */
u_short er_InitDiagVec; /* Offset to optional "DiagArea" structure */
u_char er_Reserved0c;
u_char er_Reserved0d;
u_char er_Reserved0e;
u_char er_Reserved0f;
};
 
/* er_Type board type bits */
#define ERT_TYPEMASK 0xc0
#define ERT_ZORROII 0xc0
#define ERT_ZORROIII 0x80
 
/* other bits defined in er_Type */
#define ERTB_MEMLIST 5 /* Link RAM into free memory list */
#define ERTF_MEMLIST (1<<5)
 
struct ConfigDev {
struct Node cd_Node;
u_char cd_Flags; /* (read/write) */
u_char cd_Pad; /* reserved */
struct ExpansionRom cd_Rom; /* copy of board's expansion ROM */
void *cd_BoardAddr; /* where in memory the board was placed */
u_long cd_BoardSize; /* size of board in bytes */
u_short cd_SlotAddr; /* which slot number (PRIVATE) */
u_short cd_SlotSize; /* number of slots (PRIVATE) */
void *cd_Driver; /* pointer to node of driver */
struct ConfigDev *cd_NextCD; /* linked list of drivers to config */
u_long cd_Unused[4]; /* for whatever the driver wants */
};
 
#else /* __ASSEMBLY__ */
 
LN_Succ = 0
LN_Pred = LN_Succ+4
LN_Type = LN_Pred+4
LN_Pri = LN_Type+1
LN_Name = LN_Pri+1
LN_sizeof = LN_Name+4
 
ER_Type = 0
ER_Product = ER_Type+1
ER_Flags = ER_Product+1
ER_Reserved03 = ER_Flags+1
ER_Manufacturer = ER_Reserved03+1
ER_SerialNumber = ER_Manufacturer+2
ER_InitDiagVec = ER_SerialNumber+4
ER_Reserved0c = ER_InitDiagVec+2
ER_Reserved0d = ER_Reserved0c+1
ER_Reserved0e = ER_Reserved0d+1
ER_Reserved0f = ER_Reserved0e+1
ER_sizeof = ER_Reserved0f+1
 
CD_Node = 0
CD_Flags = CD_Node+LN_sizeof
CD_Pad = CD_Flags+1
CD_Rom = CD_Pad+1
CD_BoardAddr = CD_Rom+ER_sizeof
CD_BoardSize = CD_BoardAddr+4
CD_SlotAddr = CD_BoardSize+4
CD_SlotSize = CD_SlotAddr+2
CD_Driver = CD_SlotSize+2
CD_NextCD = CD_Driver+4
CD_Unused = CD_NextCD+4
CD_sizeof = CD_Unused+(4*4)
 
#endif /* __ASSEMBLY__ */
 
#ifndef __ASSEMBLY__
 
/*
* Zorro Functions
*/
 
extern int zorro_find(int manuf, int prod, int part, int index);
extern struct ConfigDev *zorro_get_board(int key);
extern void zorro_config_board(int key, int part);
extern void zorro_unconfig_board(int key, int part);
 
 
/*
* Bitmask indicating portions of available Zorro II RAM that are unused
* by the system. Every bit represents a 64K chunk, for a maximum of 8MB
* (128 chunks, physical 0x00200000-0x009fffff).
*
* If you want to use (= allocate) portions of this RAM, you should clear
* the corresponding bits.
*/
 
extern u_long zorro_unused_z2ram[4];
 
#define Z2RAM_START (0x00200000)
#define Z2RAM_END (0x00a00000)
#define Z2RAM_SIZE (0x00800000)
#define Z2RAM_CHUNKSIZE (0x00010000)
#define Z2RAM_CHUNKMASK (0x0000ffff)
#define Z2RAM_CHUNKSHIFT (16)
 
 
/*
* Verbose Board Identification
*/
 
#ifdef CONFIG_ZORRO
extern void zorro_identify(void);
extern int zorro_get_list(char *buffer);
#endif CONFIG_ZORRO
 
#endif /* __ASSEMBLY__ */
 
#endif /* _ASM_M68K_ZORRO_H_ */
/amigahw.h
0,0 → 1,246
/*
** asm-m68k/amigahw.h -- This header defines some macros and pointers for
** the various Amiga custom hardware registers.
** The naming conventions used here conform to those
** used in the Amiga Hardware Reference Manual, 3rd Edition
**
** Copyright 1992 by Greg Harp
**
** This file is subject to the terms and conditions of the GNU General Public
** License. See the file COPYING in the main directory of this archive
** for more details.
**
** Created: 9/24/92 by Greg Harp
*/
 
#ifndef _ASMm68k_AMIGAHW_H_
#define _ASMm68k_AMIGAHW_H_
 
struct CUSTOM {
u_short bltddat;
u_short dmaconr;
u_short vposr;
u_short vhposr;
u_short dskdatr;
u_short joy0dat;
u_short joy1dat;
u_short clxdat;
u_short adkconr;
u_short pot0dat;
u_short pot1dat;
u_short potgor;
u_short serdatr;
u_short dskbytr;
u_short intenar;
u_short intreqr;
u_char *dskptr;
u_short dsklen;
u_short dskdat;
u_short refptr;
u_short vposw;
u_short vhposw;
u_short copcon;
u_short serdat;
u_short serper;
u_short potgo;
u_short joytest;
u_short strequ;
u_short strvbl;
u_short strhor;
u_short strlong;
u_short bltcon0;
u_short bltcon1;
u_short bltafwm;
u_short bltalwm;
u_char *bltcpt;
u_char *bltbpt;
u_char *bltapt;
u_char *bltdpt;
u_short bltsize;
u_char pad2d;
u_char bltcon0l;
u_short bltsizv;
u_short bltsizh;
u_short bltcmod;
u_short bltbmod;
u_short bltamod;
u_short bltdmod;
u_short spare2[4];
u_short bltcdat;
u_short bltbdat;
u_short bltadat;
u_short spare3[3];
u_short deniseid;
u_short dsksync;
u_short *cop1lc;
u_short *cop2lc;
u_short copjmp1;
u_short copjmp2;
u_short copins;
u_short diwstrt;
u_short diwstop;
u_short ddfstrt;
u_short ddfstop;
u_short dmacon;
u_short clxcon;
u_short intena;
u_short intreq;
u_short adkcon;
struct {
u_short *audlc;
u_short audlen;
u_short audper;
u_short audvol;
u_short auddat;
u_short audspare[2];
} aud[4];
u_char *bplpt[8];
u_short bplcon0;
u_short bplcon1;
u_short bplcon2;
u_short bplcon3;
u_short bpl1mod;
u_short bpl2mod;
u_short bplcon4;
u_short clxcon2;
u_short bpldat[8];
u_char *sprpt[8];
struct {
u_short pos;
u_short ctl;
u_short dataa;
u_short datab;
} spr[8];
u_short color[32];
u_short htotal;
u_short hsstop;
u_short hbstrt;
u_short hbstop;
u_short vtotal;
u_short vsstop;
u_short vbstrt;
u_short vbstop;
u_short sprhstrt;
u_short sprhstop;
u_short bplhstrt;
u_short bplhstop;
u_short hhposw;
u_short hhposr;
u_short beamcon0;
u_short hsstrt;
u_short vsstrt;
u_short hcenter;
u_short diwhigh;
u_short spare4[11];
u_short fmode;
};
 
/*
* DMA register bits
*/
#define DMAF_SETCLR (0x8000)
#define DMAF_AUD0 (0x0001)
#define DMAF_AUD1 (0x0002)
#define DMAF_AUD2 (0x0004)
#define DMAF_AUD3 (0x0008)
#define DMAF_DISK (0x0010)
#define DMAF_SPRITE (0x0020)
#define DMAF_BLITTER (0x0040)
#define DMAF_COPPER (0x0080)
#define DMAF_RASTER (0x0100)
#define DMAF_MASTER (0x0200)
#define DMAF_BLITHOG (0x0400)
#define DMAF_BLTNZERO (0x2000)
#define DMAF_BLTDONE (0x4000)
#define DMAF_ALL (0x01FF)
 
struct CIA {
u_char pra; char pad0[0xff];
u_char prb; char pad1[0xff];
u_char ddra; char pad2[0xff];
u_char ddrb; char pad3[0xff];
u_char talo; char pad4[0xff];
u_char tahi; char pad5[0xff];
u_char tblo; char pad6[0xff];
u_char tbhi; char pad7[0xff];
u_char todlo; char pad8[0xff];
u_char todmid; char pad9[0xff];
u_char todhi; char pada[0x1ff];
u_char sdr; char padb[0xff];
u_char icr; char padc[0xff];
u_char cra; char padd[0xff];
u_char crb; char pade[0xff];
};
 
#if 1
#define zTwoBase (0x80000000)
#define ZTWO_PADDR(x) (((unsigned long)(x))-zTwoBase)
#define ZTWO_VADDR(x) (((unsigned long)(x))+zTwoBase)
#else
#define zTwoBase 0
#define ZTWO_PADDR(x) (x)
#define ZTWO_VADDR(x) (x)
#endif
 
#define CUSTOM_PHYSADDR (0xdff000)
#define custom ((*(volatile struct CUSTOM *)(zTwoBase+CUSTOM_PHYSADDR)))
 
#define CIAA_PHYSADDR (0xbfe001)
#define CIAB_PHYSADDR (0xbfd000)
#define ciaa ((*(volatile struct CIA *)(zTwoBase + CIAA_PHYSADDR)))
#define ciab ((*(volatile struct CIA *)(zTwoBase + CIAB_PHYSADDR)))
 
#define CHIP_PHYSADDR (0x000000)
#define chipaddr ((unsigned long)(zTwoBase + CHIP_PHYSADDR))
void amiga_chip_init (void);
void *amiga_chip_alloc (long size);
void amiga_chip_free (void *);
 
struct tod3000 {
unsigned int :28, second2:4; /* lower digit */
unsigned int :28, second1:4; /* upper digit */
unsigned int :28, minute2:4; /* lower digit */
unsigned int :28, minute1:4; /* upper digit */
unsigned int :28, hour2:4; /* lower digit */
unsigned int :28, hour1:4; /* upper digit */
unsigned int :28, weekday:4;
unsigned int :28, day2:4; /* lower digit */
unsigned int :28, day1:4; /* upper digit */
unsigned int :28, month2:4; /* lower digit */
unsigned int :28, month1:4; /* upper digit */
unsigned int :28, year2:4; /* lower digit */
unsigned int :28, year1:4; /* upper digit */
unsigned int :28, cntrl1:4; /* control-byte 1 */
unsigned int :28, cntrl2:4; /* control-byte 2 */
unsigned int :28, cntrl3:4; /* control-byte 3 */
};
#define TOD3000_CNTRL1_HOLD 0
#define TOD3000_CNTRL1_FREE 9
#define TOD_3000 ((struct tod3000 *)(zTwoBase+0xDC0000))
 
struct tod2000 {
unsigned int :28, second2:4; /* lower digit */
unsigned int :28, second1:4; /* upper digit */
unsigned int :28, minute2:4; /* lower digit */
unsigned int :28, minute1:4; /* upper digit */
unsigned int :28, hour2:4; /* lower digit */
unsigned int :28, hour1:4; /* upper digit */
unsigned int :28, day2:4; /* lower digit */
unsigned int :28, day1:4; /* upper digit */
unsigned int :28, month2:4; /* lower digit */
unsigned int :28, month1:4; /* upper digit */
unsigned int :28, year2:4; /* lower digit */
unsigned int :28, year1:4; /* upper digit */
unsigned int :28, weekday:4;
unsigned int :28, cntrl1:4; /* control-byte 1 */
unsigned int :28, cntrl2:4; /* control-byte 2 */
unsigned int :28, cntrl3:4; /* control-byte 3 */
};
 
#define TOD2000_CNTRL1_HOLD (1<<0)
#define TOD2000_CNTRL1_BUSY (1<<1)
#define TOD2000_CNTRL3_24HMODE (1<<2)
#define TOD2000_HOUR1_PM (1<<2)
#define TOD_2000 ((struct tod2000 *)(zTwoBase+0xDC0000))
 
#endif /* asm-m68k/amigahw.h */
/signal.h
0,0 → 1,96
#ifndef _M68K_SIGNAL_H
#define _M68K_SIGNAL_H
 
typedef unsigned long sigset_t; /* at least 32 bits */
 
#define _NSIG 32
#define NSIG _NSIG
 
#define SIGHUP 1
#define SIGINT 2
#define SIGQUIT 3
#define SIGILL 4
#define SIGTRAP 5
#define SIGABRT 6
#define SIGIOT 6
#define SIGBUS 7
#define SIGFPE 8
#define SIGKILL 9
#define SIGUSR1 10
#define SIGSEGV 11
#define SIGUSR2 12
#define SIGPIPE 13
#define SIGALRM 14
#define SIGTERM 15
#define SIGSTKFLT 16
#define SIGCHLD 17
#define SIGCONT 18
#define SIGSTOP 19
#define SIGTSTP 20
#define SIGTTIN 21
#define SIGTTOU 22
#define SIGURG 23
#define SIGXCPU 24
#define SIGXFSZ 25
#define SIGVTALRM 26
#define SIGPROF 27
#define SIGWINCH 28
#define SIGIO 29
#define SIGPOLL SIGIO
/*
#define SIGLOST 29
*/
#define SIGPWR 30
#define SIGUNUSED 31
 
/*
* sa_flags values: SA_STACK is not currently supported, but will allow the
* usage of signal stacks by using the (now obsolete) sa_restorer field in
* the sigaction structure as a stack pointer. This is now possible due to
* the changes in signal handling. LBT 010493.
* SA_INTERRUPT is a no-op, but left due to historical reasons. Use the
* SA_RESTART flag to get restarting signals (which were the default long ago)
* SA_SHIRQ flag is for shared interrupt support on PCI and EISA.
*/
#define SA_NOCLDSTOP 1
#define SA_SHIRQ 0x04000000
#define SA_STACK 0x08000000
#define SA_RESTART 0x10000000
#define SA_INTERRUPT 0x20000000
#define SA_NOMASK 0x40000000
#define SA_ONESHOT 0x80000000
 
#ifdef __KERNEL__
/*
* These values of sa_flags are used only by the kernel as part of the
* irq handling routines.
*
* SA_INTERRUPT is also used by the irq handling routines.
*/
#define SA_PROBE SA_ONESHOT
#define SA_SAMPLE_RANDOM SA_RESTART
#endif
 
#define SIG_BLOCK 0 /* for blocking signals */
#define SIG_UNBLOCK 1 /* for unblocking signals */
#define SIG_SETMASK 2 /* for setting the signal mask */
 
/* Type of a signal handler. */
typedef void (*__sighandler_t)(int);
 
#define SIG_DFL ((__sighandler_t)0) /* default signal handling */
#define SIG_IGN ((__sighandler_t)1) /* ignore signal */
#define SIG_ERR ((__sighandler_t)-1) /* error return from signal */
 
struct sigaction {
__sighandler_t sa_handler;
sigset_t sa_mask;
unsigned long sa_flags;
void (*sa_restorer)(void);
};
 
#ifdef __KERNEL__
#include <asm/sigcontext.h>
#endif
 
#endif /* _M68K_SIGNAL_H */
/ptrace.h
0,0 → 1,73
#ifndef _M68K_PTRACE_H
#define _M68K_PTRACE_H
 
#define PT_D1 0
#define PT_D2 1
#define PT_D3 2
#define PT_D4 3
#define PT_D5 4
#define PT_D6 5
#define PT_D7 6
#define PT_A0 7
#define PT_A1 8
#define PT_A2 9
#define PT_A3 10
#define PT_A4 11
#define PT_A5 12
#define PT_A6 13
#define PT_D0 14
#define PT_USP 15
#define PT_ORIG_D0 16
#define PT_SR 17
#define PT_PC 18
 
#ifndef __ASSEMBLY__
 
/* this struct defines the way the registers are stored on the
stack during a system call. */
 
struct pt_regs {
long d1;
long d2;
long d3;
long d4;
long d5;
long a0;
long a1;
long d0;
long orig_d0;
long stkadj;
unsigned short sr;
unsigned long pc;
unsigned format : 4; /* frame format specifier */
unsigned vector : 12; /* vector offset */
};
 
/*
* This is the extended stack used by signal handlers and the context
* switcher: it's pushed after the normal "struct pt_regs".
*/
struct switch_stack {
unsigned long d6;
unsigned long d7;
unsigned long a2;
unsigned long a3;
unsigned long a4;
unsigned long a5;
unsigned long a6;
unsigned long retpc;
};
 
#ifdef __KERNEL__
 
#ifndef PS_S
#define PS_S (0x2000)
#define PS_M (0x1000)
#endif
 
#define user_mode(regs) (!((regs)->sr & PS_S))
#define instruction_pointer(regs) ((regs)->pc)
extern void show_regs(struct pt_regs *);
#endif /* __KERNEL__ */
#endif /* __ASSEMBLY__ */
#endif /* _M68K_PTRACE_H */
/amifd.h
0,0 → 1,57
#ifndef _ASM_M68K_AMIFD_H
#define _ASM_M68K_AMIFD_H
 
/* Definitions for the Amiga floppy driver */
 
#include <linux/fd.h>
 
#define FD_MAX_UNITS 4
 
struct fd_data_type {
char *name; /* description of data type */
int sects; /* sectors per track */
#ifdef __STDC__
int (*read_fkt)(int, unsigned char *, unsigned long, int);
void (*write_fkt)(int, unsigned long, unsigned char *, int);
#else
int (*read_fkt)(); /* read whole track */
void (*write_fkt)(); /* write whole track */
#endif
};
 
#ifndef ASSEMBLER
/*
** Floppy type descriptions
*/
 
struct fd_drive_type {
unsigned long code; /* code returned from drive */
char *name; /* description of drive */
unsigned int tracks; /* number of tracks */
unsigned int heads; /* number of heads */
unsigned int read_size; /* raw read size for one track */
unsigned int write_size; /* raw write size for one track */
unsigned int sect_mult; /* sectors and gap multiplier (HD = 2) */
unsigned int precomp1; /* start track for precomp 1 */
unsigned int precomp2; /* start track for precomp 2 */
unsigned int step_delay; /* time (in ms) for delay after step */
unsigned int settle_time; /* time to settle after dir change */
unsigned int side_time; /* time needed to change sides */
};
 
struct amiga_floppy_struct {
struct fd_drive_type *type; /* type of floppy for this unit */
struct fd_data_type *dtype; /* type of floppy for this unit */
int track; /* current track (-1 == unknown) */
 
int blocks; /* total # blocks on disk */
int sects; /* number of sectors per track */
 
int disk; /* disk in drive (-1 == unknown) */
int motor; /* true when motor is at speed */
int busy; /* true when drive is active */
int status; /* current error code for unit */
};
#endif
 
#endif
/errno.h
0,0 → 1,130
#ifndef _M68K_ERRNO_H
#define _M68K_ERRNO_H
 
#define EPERM 1 /* Operation not permitted */
#define ENOENT 2 /* No such file or directory */
#define ESRCH 3 /* No such process */
#define EINTR 4 /* Interrupted system call */
#define EIO 5 /* I/O error */
#define ENXIO 6 /* No such device or address */
#define E2BIG 7 /* Arg list too long */
#define ENOEXEC 8 /* Exec format error */
#define EBADF 9 /* Bad file number */
#define ECHILD 10 /* No child processes */
#define EAGAIN 11 /* Try again */
#define ENOMEM 12 /* Out of memory */
#define EACCES 13 /* Permission denied */
#define EFAULT 14 /* Bad address */
#define ENOTBLK 15 /* Block device required */
#define EBUSY 16 /* Device or resource busy */
#define EEXIST 17 /* File exists */
#define EXDEV 18 /* Cross-device link */
#define ENODEV 19 /* No such device */
#define ENOTDIR 20 /* Not a directory */
#define EISDIR 21 /* Is a directory */
#define EINVAL 22 /* Invalid argument */
#define ENFILE 23 /* File table overflow */
#define EMFILE 24 /* Too many open files */
#define ENOTTY 25 /* Not a typewriter */
#define ETXTBSY 26 /* Text file busy */
#define EFBIG 27 /* File too large */
#define ENOSPC 28 /* No space left on device */
#define ESPIPE 29 /* Illegal seek */
#define EROFS 30 /* Read-only file system */
#define EMLINK 31 /* Too many links */
#define EPIPE 32 /* Broken pipe */
#define EDOM 33 /* Math argument out of domain of func */
#define ERANGE 34 /* Math result not representable */
#define EDEADLK 35 /* Resource deadlock would occur */
#define ENAMETOOLONG 36 /* File name too long */
#define ENOLCK 37 /* No record locks available */
#define ENOSYS 38 /* Function not implemented */
#define ENOTEMPTY 39 /* Directory not empty */
#define ELOOP 40 /* Too many symbolic links encountered */
#define EWOULDBLOCK EAGAIN /* Operation would block */
#define ENOMSG 42 /* No message of desired type */
#define EIDRM 43 /* Identifier removed */
#define ECHRNG 44 /* Channel number out of range */
#define EL2NSYNC 45 /* Level 2 not synchronized */
#define EL3HLT 46 /* Level 3 halted */
#define EL3RST 47 /* Level 3 reset */
#define ELNRNG 48 /* Link number out of range */
#define EUNATCH 49 /* Protocol driver not attached */
#define ENOCSI 50 /* No CSI structure available */
#define EL2HLT 51 /* Level 2 halted */
#define EBADE 52 /* Invalid exchange */
#define EBADR 53 /* Invalid request descriptor */
#define EXFULL 54 /* Exchange full */
#define ENOANO 55 /* No anode */
#define EBADRQC 56 /* Invalid request code */
#define EBADSLT 57 /* Invalid slot */
#define EDEADLOCK 58 /* File locking deadlock error */
#define EBFONT 59 /* Bad font file format */
#define ENOSTR 60 /* Device not a stream */
#define ENODATA 61 /* No data available */
#define ETIME 62 /* Timer expired */
#define ENOSR 63 /* Out of streams resources */
#define ENONET 64 /* Machine is not on the network */
#define ENOPKG 65 /* Package not installed */
#define EREMOTE 66 /* Object is remote */
#define ENOLINK 67 /* Link has been severed */
#define EADV 68 /* Advertise error */
#define ESRMNT 69 /* Srmount error */
#define ECOMM 70 /* Communication error on send */
#define EPROTO 71 /* Protocol error */
#define EMULTIHOP 72 /* Multihop attempted */
#define EDOTDOT 73 /* RFS specific error */
#define EBADMSG 74 /* Not a data message */
#define EOVERFLOW 75 /* Value too large for defined data type */
#define ENOTUNIQ 76 /* Name not unique on network */
#define EBADFD 77 /* File descriptor in bad state */
#define EREMCHG 78 /* Remote address changed */
#define ELIBACC 79 /* Can not access a needed shared library */
#define ELIBBAD 80 /* Accessing a corrupted shared library */
#define ELIBSCN 81 /* .lib section in a.out corrupted */
#define ELIBMAX 82 /* Attempting to link in too many shared libraries */
#define ELIBEXEC 83 /* Cannot exec a shared library directly */
#define EILSEQ 84 /* Illegal byte sequence */
#define ERESTART 85 /* Interrupted system call should be restarted */
#define ESTRPIPE 86 /* Streams pipe error */
#define EUSERS 87 /* Too many users */
#define ENOTSOCK 88 /* Socket operation on non-socket */
#define EDESTADDRREQ 89 /* Destination address required */
#define EMSGSIZE 90 /* Message too long */
#define EPROTOTYPE 91 /* Protocol wrong type for socket */
#define ENOPROTOOPT 92 /* Protocol not available */
#define EPROTONOSUPPORT 93 /* Protocol not supported */
#define ESOCKTNOSUPPORT 94 /* Socket type not supported */
#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
#define EPFNOSUPPORT 96 /* Protocol family not supported */
#define EAFNOSUPPORT 97 /* Address family not supported by protocol */
#define EADDRINUSE 98 /* Address already in use */
#define EADDRNOTAVAIL 99 /* Cannot assign requested address */
#define ENETDOWN 100 /* Network is down */
#define ENETUNREACH 101 /* Network is unreachable */
#define ENETRESET 102 /* Network dropped connection because of reset */
#define ECONNABORTED 103 /* Software caused connection abort */
#define ECONNRESET 104 /* Connection reset by peer */
#define ENOBUFS 105 /* No buffer space available */
#define EISCONN 106 /* Transport endpoint is already connected */
#define ENOTCONN 107 /* Transport endpoint is not connected */
#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */
#define ETOOMANYREFS 109 /* Too many references: cannot splice */
#define ETIMEDOUT 110 /* Connection timed out */
#define ECONNREFUSED 111 /* Connection refused */
#define EHOSTDOWN 112 /* Host is down */
#define EHOSTUNREACH 113 /* No route to host */
#define EALREADY 114 /* Operation already in progress */
#define EINPROGRESS 115 /* Operation now in progress */
#define ESTALE 116 /* Stale NFS file handle */
#define EUCLEAN 117 /* Structure needs cleaning */
#define ENOTNAM 118 /* Not a XENIX named type file */
#define ENAVAIL 119 /* No XENIX semaphores available */
#define EISNAM 120 /* Is a named type file */
#define EREMOTEIO 121 /* Remote I/O error */
#define EDQUOT 122 /* Quota exceeded */
 
#define ENOMEDIUM 123 /* No medium found */
#define EMEDIUMTYPE 124 /* Wrong medium type */
 
#endif /* _M68K_ERRNO_H */
/posix_types.h
0,0 → 1,46
#ifndef __ARCH_I386_POSIX_TYPES_H
#define __ARCH_I386_POSIX_TYPES_H
 
/*
* This file is generally used by user-level software, so you need to
* be a little careful about namespace pollution etc. Also, we cannot
* assume GCC is being used.
*/
 
typedef unsigned short __kernel_dev_t;
typedef unsigned long __kernel_ino_t;
typedef unsigned short __kernel_mode_t;
typedef unsigned short __kernel_nlink_t;
typedef long __kernel_off_t;
typedef int __kernel_pid_t;
typedef unsigned short __kernel_uid_t;
typedef unsigned short __kernel_gid_t;
typedef unsigned int __kernel_size_t;
typedef int __kernel_ssize_t;
typedef int __kernel_ptrdiff_t;
typedef long __kernel_time_t;
typedef long __kernel_clock_t;
typedef int __kernel_daddr_t;
typedef char * __kernel_caddr_t;
 
#ifdef __GNUC__
typedef long long __kernel_loff_t;
#endif
 
typedef struct {
int val[2];
} __kernel_fsid_t;
 
#undef __FD_SET
#define __FD_SET(d, set) ((set)->fds_bits[__FDELT(d)] |= __FDMASK(d))
 
#undef __FD_CLR
#define __FD_CLR(d, set) ((set)->fds_bits[__FDELT(d)] &= ~__FDMASK(d))
 
#undef __FD_ISSET
#define __FD_ISSET(d, set) ((set)->fds_bits[__FDELT(d)] & __FDMASK(d))
 
#undef __FD_ZERO
#define __FD_ZERO(fdsetp) (memset (fdsetp, 0, sizeof(*(fd_set *)fdsetp)))
 
#endif
/sigcontext.h
0,0 → 1,19
#ifndef _ASMm68k_SIGCONTEXT_H
#define _ASMm68k_SIGCONTEXT_H
 
struct sigcontext_struct {
unsigned long sc_mask; /* old sigmask */
unsigned long sc_usp; /* old user stack pointer */
unsigned long sc_d0;
unsigned long sc_d1;
unsigned long sc_a0;
unsigned long sc_a1;
unsigned short sc_sr;
unsigned long sc_pc;
unsigned short sc_formatvec;
unsigned long sc_fpregs[2*3]; /* room for two fp registers */
unsigned long sc_fpcntl[3];
unsigned char sc_fpstate[216];
};
 
#endif
/socket.h
0,0 → 1,25
#ifndef _ASM_SOCKET_H
#define _ASM_SOCKET_H
 
#include <asm/sockios.h>
 
/* For setsockoptions(2) */
#define SOL_SOCKET 1
 
#define SO_DEBUG 1
#define SO_REUSEADDR 2
#define SO_TYPE 3
#define SO_ERROR 4
#define SO_DONTROUTE 5
#define SO_BROADCAST 6
#define SO_SNDBUF 7
#define SO_RCVBUF 8
#define SO_KEEPALIVE 9
#define SO_OOBINLINE 10
#define SO_NO_CHECK 11
#define SO_PRIORITY 12
#define SO_LINGER 13
#define SO_BSDCOMPAT 14
/* To add :#define SO_REUSEPORT 15 */
 
#endif /* _ASM_SOCKET_H */
/mman.h
0,0 → 1,31
#ifndef __M68K_MMAN_H__
#define __M68K_MMAN_H__
 
#define PROT_READ 0x1 /* page can be read */
#define PROT_WRITE 0x2 /* page can be written */
#define PROT_EXEC 0x4 /* page can be executed */
#define PROT_NONE 0x0 /* page can not be accessed */
 
#define MAP_SHARED 0x01 /* Share changes */
#define MAP_PRIVATE 0x02 /* Changes are private */
#define MAP_TYPE 0x0f /* Mask for type of mapping */
#define MAP_FIXED 0x10 /* Interpret addr exactly */
#define MAP_ANONYMOUS 0x20 /* don't use a file */
 
#define MAP_GROWSDOWN 0x0100 /* stack-like segment */
#define MAP_DENYWRITE 0x0800 /* ETXTBSY */
#define MAP_EXECUTABLE 0x1000 /* mark it as a executable */
#define MAP_LOCKED 0x2000 /* pages are locked */
 
#define MS_ASYNC 1 /* sync memory asynchronously */
#define MS_INVALIDATE 2 /* invalidate the caches */
#define MS_SYNC 4 /* synchronous memory sync */
 
#define MCL_CURRENT 1 /* lock all current mappings */
#define MCL_FUTURE 2 /* lock all future mappings */
 
/* compatibility flags */
#define MAP_ANON MAP_ANONYMOUS
#define MAP_FILE 0
 
#endif /* __M68K_MMAN_H__ */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.