BranchesTags

Latest commit

History

111 Commits

Folders and files

NameName
Last commit message
Last commit date
doc
doc
fpga
fpga
progs
progs
src
src
tests
tests
.gitignore
.gitignore
Makefile
Makefile
README.md
README.md

Repository files navigation

Overview

This is a collection of utilities and source to work with assembly for the AX211 SD processor. It consists of an assembler, a utility to kick the processor into code-load mode, and a source file to upload once it's in code-load mode.

Assembler

The assembler originally comes from https://www.pjrc.com/tech/8051/. It is a beta test release. The parser.y file is pre-processed due to Bison not functioning on the current Novena OpenEmbedded distribution.

Utility

The ax211-utility is used for testing the chip. It is also used to load and execute code, and for working with the EIM interface.

For more information, run "./ax211 -h"

ROM File

The ROM file expects to be loaded at offset 0x2900. You're limited to 512 bytes, and you shouldn't assume anything is set up such as a stack.

Using the Interactive Debugger

The ax211 binary now includes an interactive debugger. To run it, you must supply an executable binary. Commands on the host will get transmitted to the card, and the responses will get read back.

The wire protocol is simply a re-purposed SD interface running over two wires. Commands go out the CMD line, and responses come back on the CMD line. You must know how many bytes the response will take, and stop wiggling the clock line once you have reached that many bytes. Be sure to add two bytes, one for the start byte and one for the CRC7.

For information on available commands, run "help".

Debugger Internals

When the debugger starts up, it dumps a small portion of the AX211's RAM and searches for some magical fixup sequences. These three-byte sequences begin with the preamble "0xa5", and are used to overcome some limitations of the 8051, namely with respect to reading from internal RAM.

After it performs fixups, the debugger enters into its main loop. It acts as a shell, and gets its commands from the debug_commands[] array. Each element of the debug_commands array is made up of a struct debug_command:

struct debug_command {
char *name; // Name of the command
char *desc; // Brief, one-line description
char *help; // Multi-line "help" description
int (*func)(struct dbg *dbg, int argc, char **argv);
};

The func() gets called with a C-style argc and argv, with argv[0] set to the command name. You can call getopt() to process arguments.

Return a negative value upon error. If possible, return a negative errno value, for example -EINVAL or -ENOSPC.

About

Some code for the AX211 or AX215 8051-based CPU

Resources

Readme
Activity

Stars

1 star

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Latest commit
History
111 Commits
Folders and files
NameName
Last commit message
Last commit date
doc
doc
fpga
fpga
progs
progs
src
src
tests
tests
.gitignore
.gitignore
Makefile
Makefile
README.md
README.md
Repository files navigation
Overview
This is a collection of utilities and source to work with assembly for the
AX211 SD processor. It consists of an assembler, a utility to kick the
processor into code-load mode, and a source file to upload once it's in
code-load mode.
Assembler
The assembler originally comes from https://www.pjrc.com/tech/8051/. It is
a beta test release. The parser.y file is pre-processed due to Bison not
functioning on the current Novena OpenEmbedded distribution.
Utility
The ax211-utility is used for testing the chip. It is also used to load and
execute code, and for working with the EIM interface.
For more information, run "./ax211 -h"
ROM File
The ROM file expects to be loaded at offset 0x2900. You're limited to 512
bytes, and you shouldn't assume anything is set up such as a stack.
Using the Interactive Debugger
The ax211 binary now includes an interactive debugger. To run it, you must
supply an executable binary. Commands on the host will get transmitted to
the card, and the responses will get read back.
The wire protocol is simply a re-purposed SD interface running over two
wires. Commands go out the CMD line, and responses come back on the CMD
line. You must know how many bytes the response will take, and stop
wiggling the clock line once you have reached that many bytes. Be sure to
add two bytes, one for the start byte and one for the CRC7.
For information on available commands, run "help".
Debugger Internals
When the debugger starts up, it dumps a small portion of the AX211's RAM
and searches for some magical fixup sequences. These three-byte sequences
begin with the preamble "0xa5", and are used to overcome some limitations
of the 8051, namely with respect to reading from internal RAM.
After it performs fixups, the debugger enters into its main loop. It acts
as a shell, and gets its commands from the debug_commands[] array. Each
element of the debug_commands array is made up of a struct debug_command:
struct debug_command {
char *name; // Name of the command
char *desc; // Brief, one-line description
char *help; // Multi-line "help" description
int (*func)(struct dbg *dbg, int argc, char **argv);
};

The func() gets called with a C-style argc and argv, with argv[0] set to
the command name. You can call getopt() to process arguments.
Return a negative value upon error. If possible, return a negative errno
value, for example -EINVAL or -ENOSPC.
About
Some code for the AX211 or AX215 8051-based CPU
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Latest commit
History
111 Commits
Folders and files
NameName
Last commit message
Last commit date
doc
doc
fpga
fpga
progs
progs
src
src
tests
tests
.gitignore
.gitignore
Makefile
Makefile
README.md
README.md
Repository files navigation
Overview
This is a collection of utilities and source to work with assembly for the
AX211 SD processor. It consists of an assembler, a utility to kick the
processor into code-load mode, and a source file to upload once it's in
code-load mode.
Assembler
The assembler originally comes from https://www.pjrc.com/tech/8051/. It is
a beta test release. The parser.y file is pre-processed due to Bison not
functioning on the current Novena OpenEmbedded distribution.
Utility
The ax211-utility is used for testing the chip. It is also used to load and
execute code, and for working with the EIM interface.
For more information, run "./ax211 -h"
ROM File
The ROM file expects to be loaded at offset 0x2900. You're limited to 512
bytes, and you shouldn't assume anything is set up such as a stack.
Using the Interactive Debugger
The ax211 binary now includes an interactive debugger. To run it, you must
supply an executable binary. Commands on the host will get transmitted to
the card, and the responses will get read back.
The wire protocol is simply a re-purposed SD interface running over two
wires. Commands go out the CMD line, and responses come back on the CMD
line. You must know how many bytes the response will take, and stop
wiggling the clock line once you have reached that many bytes. Be sure to
add two bytes, one for the start byte and one for the CRC7.
For information on available commands, run "help".
Debugger Internals
When the debugger starts up, it dumps a small portion of the AX211's RAM
and searches for some magical fixup sequences. These three-byte sequences
begin with the preamble "0xa5", and are used to overcome some limitations
of the 8051, namely with respect to reading from internal RAM.
After it performs fixups, the debugger enters into its main loop. It acts
as a shell, and gets its commands from the debug_commands[] array. Each
element of the debug_commands array is made up of a struct debug_command:
struct debug_command {
char *name; // Name of the command
char *desc; // Brief, one-line description
char *help; // Multi-line "help" description
int (*func)(struct dbg *dbg, int argc, char **argv);
};

The func() gets called with a C-style argc and argv, with argv[0] set to
the command name. You can call getopt() to process arguments.
Return a negative value upon error. If possible, return a negative errno
value, for example -EINVAL or -ENOSPC.
About
Some code for the AX211 or AX215 8051-based CPU
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Latest commit
History
111 Commits
Folders and files
NameName
Last commit message
Last commit date
doc
doc
fpga
fpga
progs
progs
src
src
tests
tests
.gitignore
.gitignore
Makefile
Makefile
README.md
README.md
Repository files navigation
Overview
This is a collection of utilities and source to work with assembly for the
AX211 SD processor. It consists of an assembler, a utility to kick the
processor into code-load mode, and a source file to upload once it's in
code-load mode.
Assembler
The assembler originally comes from https://www.pjrc.com/tech/8051/. It is
a beta test release. The parser.y file is pre-processed due to Bison not
functioning on the current Novena OpenEmbedded distribution.
Utility
The ax211-utility is used for testing the chip. It is also used to load and
execute code, and for working with the EIM interface.
For more information, run "./ax211 -h"
ROM File
The ROM file expects to be loaded at offset 0x2900. You're limited to 512
bytes, and you shouldn't assume anything is set up such as a stack.
Using the Interactive Debugger
The ax211 binary now includes an interactive debugger. To run it, you must
supply an executable binary. Commands on the host will get transmitted to
the card, and the responses will get read back.
The wire protocol is simply a re-purposed SD interface running over two
wires. Commands go out the CMD line, and responses come back on the CMD
line. You must know how many bytes the response will take, and stop
wiggling the clock line once you have reached that many bytes. Be sure to
add two bytes, one for the start byte and one for the CRC7.
For information on available commands, run "help".
Debugger Internals
When the debugger starts up, it dumps a small portion of the AX211's RAM
and searches for some magical fixup sequences. These three-byte sequences
begin with the preamble "0xa5", and are used to overcome some limitations
of the 8051, namely with respect to reading from internal RAM.
After it performs fixups, the debugger enters into its main loop. It acts
as a shell, and gets its commands from the debug_commands[] array. Each
element of the debug_commands array is made up of a struct debug_command:
struct debug_command {
char *name; // Name of the command
char *desc; // Brief, one-line description
char *help; // Multi-line "help" description
int (*func)(struct dbg *dbg, int argc, char **argv);
};

The func() gets called with a C-style argc and argv, with argv[0] set to
the command name. You can call getopt() to process arguments.
Return a negative value upon error. If possible, return a negative errno
value, for example -EINVAL or -ENOSPC.
About
Some code for the AX211 or AX215 8051-based CPU
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Latest commit
History
111 Commits
Folders and files
NameName
Last commit message
Last commit date
doc
doc
fpga
fpga
progs
progs
src
src
tests
tests
.gitignore
.gitignore
Makefile
Makefile
README.md
README.md
Repository files navigation
Overview
This is a collection of utilities and source to work with assembly for the
AX211 SD processor. It consists of an assembler, a utility to kick the
processor into code-load mode, and a source file to upload once it's in
code-load mode.
Assembler
The assembler originally comes from https://www.pjrc.com/tech/8051/. It is
a beta test release. The parser.y file is pre-processed due to Bison not
functioning on the current Novena OpenEmbedded distribution.
Utility
The ax211-utility is used for testing the chip. It is also used to load and
execute code, and for working with the EIM interface.
For more information, run "./ax211 -h"
ROM File
The ROM file expects to be loaded at offset 0x2900. You're limited to 512
bytes, and you shouldn't assume anything is set up such as a stack.
Using the Interactive Debugger
The ax211 binary now includes an interactive debugger. To run it, you must
supply an executable binary. Commands on the host will get transmitted to
the card, and the responses will get read back.
The wire protocol is simply a re-purposed SD interface running over two
wires. Commands go out the CMD line, and responses come back on the CMD
line. You must know how many bytes the response will take, and stop
wiggling the clock line once you have reached that many bytes. Be sure to
add two bytes, one for the start byte and one for the CRC7.
For information on available commands, run "help".
Debugger Internals
When the debugger starts up, it dumps a small portion of the AX211's RAM
and searches for some magical fixup sequences. These three-byte sequences
begin with the preamble "0xa5", and are used to overcome some limitations
of the 8051, namely with respect to reading from internal RAM.
After it performs fixups, the debugger enters into its main loop. It acts
as a shell, and gets its commands from the debug_commands[] array. Each
element of the debug_commands array is made up of a struct debug_command:
struct debug_command {
char *name; // Name of the command
char *desc; // Brief, one-line description
char *help; // Multi-line "help" description
int (*func)(struct dbg *dbg, int argc, char **argv);
};

The func() gets called with a C-style argc and argv, with argv[0] set to
the command name. You can call getopt() to process arguments.
Return a negative value upon error. If possible, return a negative errno
value, for example -EINVAL or -ENOSPC.
About
Some code for the AX211 or AX215 8051-based CPU
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Latest commit
History
111 Commits
Folders and files
NameName
Last commit message
Last commit date
doc
doc
fpga
fpga
progs
progs
src
src
tests
tests
.gitignore
.gitignore
Makefile
Makefile
README.md
README.md
Repository files navigation
Overview
This is a collection of utilities and source to work with assembly for the
AX211 SD processor. It consists of an assembler, a utility to kick the
processor into code-load mode, and a source file to upload once it's in
code-load mode.
Assembler
The assembler originally comes from https://www.pjrc.com/tech/8051/. It is
a beta test release. The parser.y file is pre-processed due to Bison not
functioning on the current Novena OpenEmbedded distribution.
Utility
The ax211-utility is used for testing the chip. It is also used to load and
execute code, and for working with the EIM interface.
For more information, run "./ax211 -h"
ROM File
The ROM file expects to be loaded at offset 0x2900. You're limited to 512
bytes, and you shouldn't assume anything is set up such as a stack.
Using the Interactive Debugger
The ax211 binary now includes an interactive debugger. To run it, you must
supply an executable binary. Commands on the host will get transmitted to
the card, and the responses will get read back.
The wire protocol is simply a re-purposed SD interface running over two
wires. Commands go out the CMD line, and responses come back on the CMD
line. You must know how many bytes the response will take, and stop
wiggling the clock line once you have reached that many bytes. Be sure to
add two bytes, one for the start byte and one for the CRC7.
For information on available commands, run "help".
Debugger Internals
When the debugger starts up, it dumps a small portion of the AX211's RAM
and searches for some magical fixup sequences. These three-byte sequences
begin with the preamble "0xa5", and are used to overcome some limitations
of the 8051, namely with respect to reading from internal RAM.
After it performs fixups, the debugger enters into its main loop. It acts
as a shell, and gets its commands from the debug_commands[] array. Each
element of the debug_commands array is made up of a struct debug_command:
struct debug_command {
char *name; // Name of the command
char *desc; // Brief, one-line description
char *help; // Multi-line "help" description
int (*func)(struct dbg *dbg, int argc, char **argv);
};

The func() gets called with a C-style argc and argv, with argv[0] set to
the command name. You can call getopt() to process arguments.
Return a negative value upon error. If possible, return a negative errno
value, for example -EINVAL or -ENOSPC.
About
Some code for the AX211 or AX215 8051-based CPU
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Latest commit
History
111 Commits
Folders and files
NameName
Last commit message
Last commit date
doc
doc
fpga
fpga
progs
progs
src
src
tests
tests
.gitignore
.gitignore
Makefile
Makefile
README.md
README.md
Repository files navigation
Overview
This is a collection of utilities and source to work with assembly for the
AX211 SD processor. It consists of an assembler, a utility to kick the
processor into code-load mode, and a source file to upload once it's in
code-load mode.
Assembler
The assembler originally comes from https://www.pjrc.com/tech/8051/. It is
a beta test release. The parser.y file is pre-processed due to Bison not
functioning on the current Novena OpenEmbedded distribution.
Utility
The ax211-utility is used for testing the chip. It is also used to load and
execute code, and for working with the EIM interface.
For more information, run "./ax211 -h"
ROM File
The ROM file expects to be loaded at offset 0x2900. You're limited to 512
bytes, and you shouldn't assume anything is set up such as a stack.
Using the Interactive Debugger
The ax211 binary now includes an interactive debugger. To run it, you must
supply an executable binary. Commands on the host will get transmitted to
the card, and the responses will get read back.
The wire protocol is simply a re-purposed SD interface running over two
wires. Commands go out the CMD line, and responses come back on the CMD
line. You must know how many bytes the response will take, and stop
wiggling the clock line once you have reached that many bytes. Be sure to
add two bytes, one for the start byte and one for the CRC7.
For information on available commands, run "help".
Debugger Internals
When the debugger starts up, it dumps a small portion of the AX211's RAM
and searches for some magical fixup sequences. These three-byte sequences
begin with the preamble "0xa5", and are used to overcome some limitations
of the 8051, namely with respect to reading from internal RAM.
After it performs fixups, the debugger enters into its main loop. It acts
as a shell, and gets its commands from the debug_commands[] array. Each
element of the debug_commands array is made up of a struct debug_command:
struct debug_command {
char *name; // Name of the command
char *desc; // Brief, one-line description
char *help; // Multi-line "help" description
int (*func)(struct dbg *dbg, int argc, char **argv);
};

The func() gets called with a C-style argc and argv, with argv[0] set to
the command name. You can call getopt() to process arguments.
Return a negative value upon error. If possible, return a negative errno
value, for example -EINVAL or -ENOSPC.
About
Some code for the AX211 or AX215 8051-based CPU
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Latest commit
History
111 Commits
Folders and files
NameName
Last commit message
Last commit date
doc
doc
fpga
fpga
progs
progs
src
src
tests
tests
.gitignore
.gitignore
Makefile
Makefile
README.md
README.md
Repository files navigation
Overview
This is a collection of utilities and source to work with assembly for the
AX211 SD processor. It consists of an assembler, a utility to kick the
processor into code-load mode, and a source file to upload once it's in
code-load mode.
Assembler
The assembler originally comes from https://www.pjrc.com/tech/8051/. It is
a beta test release. The parser.y file is pre-processed due to Bison not
functioning on the current Novena OpenEmbedded distribution.
Utility
The ax211-utility is used for testing the chip. It is also used to load and
execute code, and for working with the EIM interface.
For more information, run "./ax211 -h"
ROM File
The ROM file expects to be loaded at offset 0x2900. You're limited to 512
bytes, and you shouldn't assume anything is set up such as a stack.
Using the Interactive Debugger
The ax211 binary now includes an interactive debugger. To run it, you must
supply an executable binary. Commands on the host will get transmitted to
the card, and the responses will get read back.
The wire protocol is simply a re-purposed SD interface running over two
wires. Commands go out the CMD line, and responses come back on the CMD
line. You must know how many bytes the response will take, and stop
wiggling the clock line once you have reached that many bytes. Be sure to
add two bytes, one for the start byte and one for the CRC7.
For information on available commands, run "help".
Debugger Internals
When the debugger starts up, it dumps a small portion of the AX211's RAM
and searches for some magical fixup sequences. These three-byte sequences
begin with the preamble "0xa5", and are used to overcome some limitations
of the 8051, namely with respect to reading from internal RAM.
After it performs fixups, the debugger enters into its main loop. It acts
as a shell, and gets its commands from the debug_commands[] array. Each
element of the debug_commands array is made up of a struct debug_command:
struct debug_command {
char *name; // Name of the command
char *desc; // Brief, one-line description
char *help; // Multi-line "help" description
int (*func)(struct dbg *dbg, int argc, char **argv);
};

The func() gets called with a C-style argc and argv, with argv[0] set to
the command name. You can call getopt() to process arguments.
Return a negative value upon error. If possible, return a negative errno
value, for example -EINVAL or -ENOSPC.
About
Some code for the AX211 or AX215 8051-based CPU
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages