Free 6502 chip software for linux

dis6502 is a flow-tracing disassembler for the 6502, originally written by Robert Bond and supporting Atari binary files. Robert posted dis6502 to the Usenet newsgroup net.sources on 9-Oct-1986, and to comp.sources.unix 7-Jun-1988.

Udi Finkelstein ported dis6502 to the Amiga, added support for Commodore 64 object files, and posted it to comp.sources.amiga on 4-Nov-1988.

This version of dis6502 has been modified in several ways:

* Can read raw binary files.

* Option to specify alternate reset and interrupt vector addresses.

* Line numbers are no longer necessary with equates in definition files.

* If a data reference is made to an address that does not have an
assigned name, but address-1 does, the reference will be disassembled
as name+1. This is convenient for two-byte variables, particularly in
zero page.

* New definition file directives:

< name > .equ < addr > same as .eq

.jtab2 < addr >,< addr >,< count > table of code pointers, split into high and low byte tables
.rtstab < addr >,< addr >,< count > like jtab2, but each entry contains the target address
minus one, for use with RTS

* Rather than using recursive calls to trace every instruction, there is now a trace queue.

* Added a "-7" option to mask off MSB of character data.

* Updated to use ANSI C function prototypes and include files.

* Amiga/Manx changes have been removed.

dis6502 has been tested on Red Hat Linux 9, but should work on other Linux, BSD, and Unix systems.

dis6502 is distributed under the terms of the Free Software Foundations General Public License, Version 2. See the file COPYING for details.

The original release notes from Robert Bond and Udi Finkelstein are in the files README.Bond and README.Finkelstein.

cc65 is a complete cross development package for 6502 systems, including a powerful macro assembler, a C compiler, linker, librarian and several other tools. cc65 is based on a C compiler that was originally adapted for the Atari 8bit computers by John R. Dunning.
The original C compiler is a Small C descendant but has several extensions, and some of the limits of the original Small C compiler are gone. The original copyright allows free redistribution including sources, even if it would not qualify as Open Source Software according to the Open Source Definition.
The original Atari compiler is available from http://www.umich.edu/~archive/atari/8bit/Languages/Cc65/. The complete package consists of the compiler, an assembler, a librarian, a linker, and a C library for the Atari. There are some packages on the net that claim to be adapted as a crosscompiler for DOS or Unix, but was not able to get them working correctly.
Because I wanted a C compiler for my CBM machines, I took the Atari compiler and started a rewrite. Until today, I have rewritten large parts of the compiler, all of the library, completely replaced the assembler, the linker and the librarian, and added a frontend to simplify use. All changes have been done with portability in mind, so porting to new 6502 architectures should be quite easy.
The compiler is almost ISO C compatible, so you should be able to translate many sources from other systems.
Main features:
- The compiler allows single line comments that start with //. This feature is disabled in strict ANSI mode.
- The compiler allows unnamed parameters in parameter lists. The compiler will not issue warnings about unused parameters that dont have a name. This feature is disabled in strict ANSI mode.
- The compiler has some additional keywords that are needed for special features. In strict ANSI mode, the additional keywords start with two underscores.
- The volatile modifier has no effect.
- The datatypes float and double are not available.
- The compiler does not support bit fields.
- C functions may not return structs and structs may not be passed as parameters by value. Struct assignment is possible.
- There are some limitation on the size of local variables. Not all operations are available if the size of local variables exceeds 256 bytes.
- Part of the C library is available only with fastcall calling conventions (see below). This means, that you may not mix pointers to those functions with pointers to user written functions.
There may be other target system dependent limitations. One example is file I/O, which is not implemented on all platforms. This is no technical limitation (as with the stuff mentioned above) but does just mean that no one cared enough to write the actual code.
The compiler is only one of the tools available in this package. The assembler suite (assembler, linker, archiver) is a complete development environment for itself, that may be used to write programs for any 6502 machine. C code and assembler code may be used together and may call each other.
The assembler is a one pass macroassembler and is able to output code for the 6502, the 65SC02 and 65SC816. It has a lot of nifty features like include files, conditional assembly, macros, nested lexical levels (that is, local symbols), and more. The assembler creates object files containing relocatable code. These files must be run through a linker to create the final program.
The linker has a flexible output format and is able to support ROMable code (different load and run addresses for data), banked systems (segments may share the same run address), systems with multiple ROMs, unlimited segments, more than one BSS segment and lots of other things.
The archiver is used to create libraries containing objects files. This simplifies code management. The linker will extract only those modules from a library that are actually needed.
To simplifiy use, there is also a frontend to the tools contained in the cc65 package. The frontend is named cl65. It knows how to build binaries from a list of C files, assembler files, object files and libraries. For smaller projects, just one invocation of the cl65 utility is needed to build a binary from several source files and libraries.

X10 is an experimental new language currently under development at IBM in collaboration with academic partners. The X10 effort is part of the IBM PERCS project (Productive Easy-to-use Reliable Computer Systems) in the DARPA program on High Productivity Computer Systems. The PERCS project is focused on a hardware-software co-design methodology to integrate advances in chip technology, architecture, operating systems, compilers, programming language and programming tools to deliver new adaptable, scalable systems that will provide an order-of-magnitude improvement in development productivity for parallel applications by 2010.

X10 aims to contribute to this productivity improvement by developing a new programming model, combined with a new set of tools integrated into Eclipse and new implementation techniques for delivering optimized scalable parallelism in a managed runtime environment. X10 is a type-safe, modern, parallel, distributed object-oriented language intended to be very easily accessible to Java programmers.

It is targeted to future low-end and high-end systems with nodes that are built out of multi-core SMP chips with non-uniform memory hierarchies, and interconnected in scalable cluster configurations. A member of the Partitioned Global Address Space (PGAS) family of languages, X10 highlights the explicit reification of locality in the form of places; lightweight activities embodied in async, future, foreach, and ateach constructs; constructs for termination detection (finish) and phased computation (clocks); the use of lock-free synchronization (atomic blocks); and the manipulation of global arrays and data structures.

An Eclipse-based Integrated Development Environment (IDE) has been developed at IBM for X10 to help further increase programmer productivity by providing state-of-the-art functionality for viewing, editing, navigating, executing, and manipulating X10 programs. The X10 Development Toolkit (X10DT) is intended to be a full-featured IDE for X10 offering the features Java programmers have come to love and depend upon in Eclipse: a source editor with various coding assists, lightweight information pop-ups, high-level and low-level navigation views, powerful search capabilities, application launch configuration management, refactoring, and debugging support. In addition, the X10DT will include tools, views and refactorings that specifically address the development of highly concurrent software in X10.

The P65 assemblers are assemblers for the 6502 microprocessor (such as is used in the Commodore 64, Apple II, and Nintendo Entertainment System).
They are designed to be able to support a wide variety of output formats, both to support multiple target platforms and to produce code for emulators.
The eventual goal of P65 is to be as expressive as the more powerful assemblers of the late 80s, such as DASM. Its not there yet, but its getting there.
Main features:
- Highly portable - All versions of P65 are written in portable scripting languages. The original releases were done in Perl. While P65-Perl 1.1 is stable and reasonably powerful, it lacks some major features, such as modules and macros. P65-Ophis, the Python port, will run on slightly fewer architectures, but will still run on all current major systems.
- Flexible output format - P65 allows for very flexible control over data and assemble points. Output file formats are completely independent of the final memory maps.
- Multiple file support - libraries may be kept as seperate files and included seperately, facilitating code reuse.
- Temporary label support - source may contain "anonymous labels" that help decrease namespace pollution. P65-Ophis also supports named temporary labels that only exist within a well-defined scope.
- Assemble-time expressions - P65-Ophis supports High-byte/low-byte computations along with bitmasking and traditional arithmetic operations in code and data statements. Access to the current PC is also supported. P65-Perls expressions are more limited but are generally sufficient.
- Symbol table management - Allows for creating labels and data constants outside of the code, and for allocating RAM symbolically. This includes full support for segments.
- Optimal instruction selection - Compresses as many instructions as possible into zero page format. If this compression permits other instructions to become zero page instructions, it will compress those as well.

ThinTUX is a small Linux distribution for thin clients. It has support for all major remote access protocols like ICA, RDP, XDM, telnet, ssh, and more.
The distribution can be booted from the network using a network card with PXE-support or from standard media storage devices like floppy, CD, hard disk, or disk-on-chip.
The configuration is stored on a DHCP server to simplify terminal management.
Main features:
- Automatic hardware discovery and centralized configuration using DHCP
- Single point of administration
- Small footprint
- Fully self-contained
- No NFS mounted root filesystem
- Web based configuration tool
- One boot image fits all computers
- No previous Linux knowledge required
Enhancements:
- Reduced startup time.
- Reduced RAM footprint.
- Added support for glibc programs.
- Updated kernel
- Updated to rdesktop 1.4.1
- Updated the configuration tool(ThinTUX web tool).
- Renamed configuration variables

Libchipcard is a library for easy access to chip cards via chip card readers (terminals). Libchipcard2 currently works under Linux, FreeBSD, NetBSD, OpenBSD and (partially) Windows.
A graphical setup tool (using KDE), man pages and German translations to all KDE programs and all console tools are provided.
This library is used by OpenHBCI and thus by AqMoney, GOpenHBCI, KOpenHBCI, LxBank and GnuCash to provide support for German Homebanking cards. Recently, AqBanking joined the family of programs using Libchipcard2.
Whats New in 3.9.1 Beta Release:
- This release adds support for the latest Cyberjack device.
- All references to Libchipcard3 have been renamed to simply Libchipcard (without a number).
- This also affects the configuration files and paths, so you will have to move your configuration files.
Whats New in 3.0.3 Stable Release:
- This version includes several new features that have been back-ported from the (soon to become) libchipcard4 branch.
- In particular, newly supported readers are CardMedic 2, SCR 331, SCM 3320, Omnikey Cardman 4040, and also for the card type eGK.
- For the Celetronic CardStar2 the second slot of this readers is supported now as well.
- Some build problems have been fixed.

openflash is an open source utility to (re)program flash BIOS chips. Initial support will be for the i-opener network appliance under Qnx since there is an immediate need.
Usage: qnxflash [-r < file >] [-w < file >] [-v < file >] [-iadlcV]
-r Read bios image from chip.
-w Write bios image to chip.
-v Verify chip data against image file.
-i display bios chips device Id.
-a report All verify errors.
-d Disable verify while programming.
-l List supported devices.
-c disable device id Check.
-V Verbose messages
Enhancements:
- Modifications to correct failures to exit Device ID mode on V4 Iopeners using RISE CPU. This problem was reported as an erase failure in 1.01.
- Changed the method used to exit Device mode from the one step method to the three step.
- Added code to check that Device ID mode was exited successfully. If the first attempt fails an additional 9 attempts will be made before giving up.
- Corrected a bug in WaitFlashComplete() which prevented timeout errors from being detected.
- Doubled the loop count in WaitFlashComplete().
- Added the -V switch to enable verbose error and status messages.
- Added -c switch to allow Device ID checks to be disabled.