void EVENT_CHANGE_LED_state (void) {
// NUM LOCK
if (current_LED_state & _BV(HIDKEYBOARD_LEDBIT_NUM_LOCK)) SET_HIGH(LED_NUMLOCK);
else SET_LOW(LED_NUMLOCK);
// CAPS LOCK
if (current_LED_state & _BV(HIDKEYBOARD_LEDBIT_CAPS_LOCK)) SET_HIGH(LED_CAPSLOCK);
else SET_LOW(LED_CAPSLOCK);
// SCROLL LOCK
if (current_LED_state & _BV(HIDKEYBOARD_LEDBIT_SCROLL_LOCK)) SET_HIGH(LED_SCROLLLOCK);
else SET_LOW(LED_SCROLLLOCK);
}
int main(void){
// The following four lines are due to my laziness about breadboard.
SET_OUTPUT(DDRD,3); // +5v
SET_HIGH(PORTD,3); // +5V
SET_OUTPUT(DDRD,4); // GND
SET_LOW(PORTD,4); // GND
// Initial values of channels.
channels[0]=25;
channels[1]=75;
channels[2]=125;
channels[3]=175;
channels[4]=225;
// Set to taste. Start with 0 initially.
pulse_fine_tune=30;
// Start.
init_transmission();
while(1){
// Changing channels
channels[0]++;
_delay_ms(100);
}
return 0;
}
// ElTorito - Terminate disk emu
void
cdemu_134b(struct bregs *regs)
{
// FIXME ElTorito Hardcoded
SET_INT13ET(regs, size, 0x13);
SET_INT13ET(regs, media, GET_LOW(CDEmu.media));
SET_INT13ET(regs, emulated_drive, GET_LOW(CDEmu.emulated_extdrive));
struct drive_s *drive_gf = GET_LOW(CDEmu.emulated_drive_gf);
u8 cntl_id = 0;
if (drive_gf)
cntl_id = GET_GLOBALFLAT(drive_gf->cntl_id);
SET_INT13ET(regs, controller_index, cntl_id / 2);
SET_INT13ET(regs, device_spec, cntl_id % 2);
SET_INT13ET(regs, ilba, GET_LOW(CDEmu.ilba));
SET_INT13ET(regs, buffer_segment, GET_LOW(CDEmu.buffer_segment));
SET_INT13ET(regs, load_segment, GET_LOW(CDEmu.load_segment));
SET_INT13ET(regs, sector_count, GET_LOW(CDEmu.sector_count));
SET_INT13ET(regs, cylinders, GET_LOW(CDEmu.lchs.cylinders));
SET_INT13ET(regs, sectors, GET_LOW(CDEmu.lchs.spt));
SET_INT13ET(regs, heads, GET_LOW(CDEmu.lchs.heads));
// If we have to terminate emulation
if (regs->al == 0x00) {
// FIXME ElTorito Various. Should be handled accordingly to spec
SET_LOW(CDEmu.active, 0x00); // bye bye
// XXX - update floppy/hd count.
}
disk_ret(regs, DISK_RET_SUCCESS);
}
void ds18b20_write_bit(uint8_t bit){
// synchronize
SET_OUTPUT(DS18B20_DDR, DS18B20_DQ);
SET_LOW(DS18B20_PORT, DS18B20_DQ);
DS18B20_PRECISE_DELAY(2);
// put bit
if(bit){
SET_HIGH(DS18B20_PORT, DS18B20_DQ);
}
DS18B20_PRECISE_DELAY(60);
// release line
SET_INPUT(DS18B20_DDR, DS18B20_DQ);
SET_LOW(DS18B20_PORT, DS18B20_DQ);
DS18B20_PRECISE_DELAY(2);
}
void set_led (uint8_t ebene)
{
uint8_t offset = ebene*9;
uint8_t i =0;
for (i =0; i<255;i++)
{
if (led_values[0+offset]>i)
{SET_HIGH(LED1);}
else{SET_LOW(LED1);}
if (led_values[1+offset]>i)
{SET_HIGH(LED2);}
else{SET_LOW(LED2);}
if (led_values[2+offset]>i)
{SET_HIGH(LED3);}
else{SET_LOW(LED3);}
if (led_values[3+offset]>i)
{SET_HIGH(LED4);}
else{SET_LOW(LED4);}
if (led_values[4+offset]>i)
{SET_HIGH(LED5);}
else{SET_LOW(LED5);}
if (led_values[5+offset]>i)
{SET_HIGH(LED6);}
else{SET_LOW(LED6);}
if (led_values[6+offset]>i)
{SET_HIGH(LED7);}
else{SET_LOW(LED7);}
if (led_values[7+offset]>i)
{SET_HIGH(LED8);}
else{SET_LOW(LED8);}
if (led_values[8+offset]>i)
{SET_HIGH(LED9);}
else{SET_LOW(LED9);}
// __asm("nop");__asm("nop");__asm("nop");
// __asm("nop");__asm("nop");__asm("nop");
}
}
// lock
static void
disk_134500(struct bregs *regs, struct drive_s *drive_gf)
{
int cdid = regs->dl - EXTSTART_CD;
u8 locks = GET_LOW(CDRom_locks[cdid]);
if (locks == 0xff) {
regs->al = 1;
disk_ret(regs, DISK_RET_ETOOMANYLOCKS);
return;
}
SET_LOW(CDRom_locks[cdid], locks + 1);
regs->al = 1;
disk_ret(regs, DISK_RET_SUCCESS);
}
// ElTorito - Terminate disk emu
static void
cdemu_134b(struct bregs *regs)
{
memcpy_far(regs->ds, (void*)(regs->si+0), SEG_LOW, &CDEmu, sizeof(CDEmu));
// If we have to terminate emulation
if (regs->al == 0x00) {
// FIXME ElTorito Various. Should be handled accordingly to spec
SET_LOW(CDEmu.media, 0x00); // bye bye
// XXX - update floppy/hd count.
}
disk_ret(regs, DISK_RET_SUCCESS);
}
// unlock
static void
disk_134501(struct bregs *regs, struct drive_s *drive_gf)
{
int cdid = regs->dl - EXTSTART_CD;
u8 locks = GET_LOW(CDRom_locks[cdid]);
if (locks == 0x00) {
regs->al = 0;
disk_ret(regs, DISK_RET_ENOTLOCKED);
return;
}
locks--;
SET_LOW(CDRom_locks[cdid], locks);
regs->al = (locks ? 1 : 0);
disk_ret(regs, DISK_RET_SUCCESS);
}
uint8_t ds18b20_read_bit(){
// synchronize
SET_LOW(DS18B20_PORT, DS18B20_DQ);
SET_OUTPUT(DS18B20_DDR, DS18B20_DQ);
DS18B20_PRECISE_DELAY(2);
// wait until thermometer puts bit
SET_INPUT(DS18B20_DDR, DS18B20_DQ);
DS18B20_PRECISE_DELAY(5);
// read it
uint8_t ret=IS_HIGH(DS18B20_PIN, DS18B20_DQ);
DS18B20_PRECISE_DELAY(60);
return ret;
}
uint8_t ds18b20_reset(){
// reset pulse
SET_LOW(DS18B20_PORT, DS18B20_DQ);
SET_OUTPUT(DS18B20_DDR,DS18B20_DQ);
DS18B20_PRECISE_DELAY(480);
// presence pulse
SET_INPUT(DS18B20_DDR, DS18B20_DQ);
DS18B20_PRECISE_DELAY(100);
if(IS_HIGH(DS18B20_PIN, DS18B20_DQ)){
return 0; // not present
}
DS18B20_PRECISE_DELAY(380);
if(IS_LOW(DS18B20_PIN, DS18B20_DQ)){
return 0; // not present
}
return 1;
}
void main(void)
{
WD_STOP();
CAL_CLOCK();
// TimerAInit();
HardwareInit();
I2cInit(0x02, 0x00);
_EINT();
while (1)
{
//LPM0;
//_NOP();
if (GetWriteEndpoint(0))
SET_LOW(RED_LED);
else
SET_HIGH(RED_LED);
SetReadEndpoint(0, READ_IN(LP_SWITCH));
}
}
void write_cube(uint8_t ebene)
{
switch (ebene)
{
case 0:
SET_LOW(TOP);SET_LOW(MIDDLE);SET_HIGH(LOW);
break;
case 1:
SET_LOW(TOP);SET_HIGH(MIDDLE);SET_LOW(LOW);
break;
case 2:
SET_HIGH(TOP);SET_LOW(MIDDLE);SET_LOW(LOW);
break;
default:return;
}
set_led(ebene);
//sleep_us(4);
//SET_LOW(TOP);SET_LOW(MIDDLE);SET_LOW(LOW);
}
// Process USB keyboard data.
static void
handle_key(struct keyevent *data)
{
dprintf(9, "Got key %x %x\n", data->modifiers, data->keys[0]);
// Load old keys.
struct usbkeyinfo old;
old.data = GET_LOW(LastUSBkey.data);
// Check for keys no longer pressed.
int addpos = 0;
int i;
for (i=0; i<ARRAY_SIZE(old.keys); i++) {
u8 key = old.keys[i];
if (!key)
break;
int j;
for (j=0;; j++) {
if (j>=ARRAY_SIZE(data->keys)) {
// Key released.
procscankey(key, RELEASEBIT, data->modifiers);
if (i+1 >= ARRAY_SIZE(old.keys) || !old.keys[i+1])
// Last pressed key released - disable repeat.
old.repeatcount = 0xff;
break;
}
if (data->keys[j] == key) {
// Key still pressed.
data->keys[j] = 0;
old.keys[addpos++] = key;
break;
}
}
}
procmodkey(old.modifiers & ~data->modifiers, RELEASEBIT);
// Process new keys
procmodkey(data->modifiers & ~old.modifiers, 0);
old.modifiers = data->modifiers;
for (i=0; i<ARRAY_SIZE(data->keys); i++) {
u8 key = data->keys[i];
if (!key)
continue;
// New key pressed.
procscankey(key, 0, data->modifiers);
old.keys[addpos++] = key;
old.repeatcount = KEYREPEATWAITMS / KEYREPEATMS + 1;
}
if (addpos < ARRAY_SIZE(old.keys))
old.keys[addpos] = 0;
// Check for key repeat event.
if (addpos) {
if (!old.repeatcount)
procscankey(old.keys[addpos-1], 0, data->modifiers);
else if (old.repeatcount != 0xff)
old.repeatcount--;
}
// Update old keys
SET_LOW(LastUSBkey.data, old.data);
}
static void smc91c111_writeb(void *opaque, hwaddr offset,
uint32_t value)
{
smc91c111_state *s = (smc91c111_state *)opaque;
if (offset == 14) {
s->bank = value;
return;
}
if (offset == 15)
return;
switch (s->bank) {
case 0:
switch (offset) {
case 0: /* TCR */
SET_LOW(tcr, value);
return;
case 1:
SET_HIGH(tcr, value);
return;
case 4: /* RCR */
SET_LOW(rcr, value);
return;
case 5:
SET_HIGH(rcr, value);
if (s->rcr & RCR_SOFT_RST)
smc91c111_reset(s);
return;
case 10: case 11: /* RPCR */
/* Ignored */
return;
}
break;
case 1:
switch (offset) {
case 0: /* CONFIG */
SET_LOW(cr, value);
return;
case 1:
SET_HIGH(cr,value);
return;
case 2: case 3: /* BASE */
case 4: case 5: case 6: case 7: case 8: case 9: /* IA */
/* Not implemented. */
return;
case 10: /* Genral Purpose */
SET_LOW(gpr, value);
return;
case 11:
SET_HIGH(gpr, value);
return;
case 12: /* Control */
if (value & 1)
fprintf(stderr, "smc91c111:EEPROM store not implemented\n");
if (value & 2)
fprintf(stderr, "smc91c111:EEPROM reload not implemented\n");
value &= ~3;
SET_LOW(ctr, value);
return;
case 13:
SET_HIGH(ctr, value);
return;
}
break;
case 2:
switch (offset) {
case 0: /* MMU Command */
switch (value >> 5) {
case 0: /* no-op */
break;
case 1: /* Allocate for TX. */
s->tx_alloc = 0x80;
s->int_level &= ~INT_ALLOC;
smc91c111_update(s);
smc91c111_tx_alloc(s);
break;
case 2: /* Reset MMU. */
s->allocated = 0;
s->tx_fifo_len = 0;
s->tx_fifo_done_len = 0;
s->rx_fifo_len = 0;
s->tx_alloc = 0;
break;
case 3: /* Remove from RX FIFO. */
smc91c111_pop_rx_fifo(s);
break;
case 4: /* Remove from RX FIFO and release. */
if (s->rx_fifo_len > 0) {
smc91c111_release_packet(s, s->rx_fifo[0]);
}
smc91c111_pop_rx_fifo(s);
break;
case 5: /* Release. */
smc91c111_release_packet(s, s->packet_num);
break;
case 6: /* Add to TX FIFO. */
smc91c111_queue_tx(s, s->packet_num);
break;
case 7: /* Reset TX FIFO. */
s->tx_fifo_len = 0;
s->tx_fifo_done_len = 0;
break;
}
return;
case 1:
/* Ignore. */
return;
case 2: /* Packet Number Register */
s->packet_num = value;
return;
case 3: case 4: case 5:
/* Should be readonly, but linux writes to them anyway. Ignore. */
return;
case 6: /* Pointer */
SET_LOW(ptr, value);
return;
case 7:
SET_HIGH(ptr, value);
return;
case 8: case 9: case 10: case 11: /* Data */
{
int p;
int n;
if (s->ptr & 0x8000)
n = s->rx_fifo[0];
else
n = s->packet_num;
p = s->ptr & 0x07ff;
if (s->ptr & 0x4000) {
s->ptr = (s->ptr & 0xf800) | ((s->ptr + 1) & 0x7ff);
} else {
p += (offset & 3);
}
s->data[n][p] = value;
}
return;
case 12: /* Interrupt ACK. */
s->int_level &= ~(value & 0xd6);
if (value & INT_TX)
smc91c111_pop_tx_fifo_done(s);
smc91c111_update(s);
return;
case 13: /* Interrupt mask. */
s->int_mask = value;
smc91c111_update(s);
return;
}
break;;
case 3:
switch (offset) {
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
/* Multicast table. */
/* Not implemented. */
return;
case 8: case 9: /* Management Interface. */
/* Not implemented. */
return;
case 12: /* Early receive. */
s->ercv = value & 0x1f;
case 13:
/* Ignore. */
return;
}
break;
}
hw_error("smc91c111_write: Bad reg %d:%x\n", s->bank, (int)offset);
}
/* Effects marked with 'special' are handled specifically in itrender.c */
void _dumb_it_xm_convert_effect(int effect, int value, IT_ENTRY *entry)
{
const int log = 0;
if ((!effect && !value) || (effect >= XM_N_EFFECTS))
return;
if (log) printf("%c%02X", (effect<10)?('0'+effect):('A'+effect-10), value);
/* Linearisation of the effect number... */
if (effect == XM_E) {
effect = EBASE + HIGH(value);
value = LOW(value);
} else if (effect == XM_X) {
effect = XBASE + HIGH(value);
value = LOW(value);
}
if (log) printf(" - %2d %02X", effect, value);
#if 0 // This should be handled in itrender.c!
/* update effect memory */
switch (xm_has_memory[effect]) {
case 1:
if (!value)
value = memory[entry->channel][effect];
else
memory[entry->channel][effect] = value;
break;
case 2:
if (!HIGH(value))
SET_HIGH(value, HIGH(memory[entry->channel][effect]));
else
SET_HIGH(memory[entry->channel][effect], HIGH(value));
if (!LOW(value))
SET_LOW(value, LOW(memory[entry->channel][effect]));
else
SET_LOW(memory[entry->channel][effect], LOW(value));
break;
}
#endif
/* convert effect */
entry->mask |= IT_ENTRY_EFFECT;
switch (effect) {
case XM_APPREGIO: effect = IT_ARPEGGIO; break;
case XM_VIBRATO: effect = IT_VIBRATO; break;
case XM_TONE_PORTAMENTO: effect = IT_TONE_PORTAMENTO; break; /** TODO: glissando control */
case XM_TREMOLO: effect = IT_TREMOLO; break;
case XM_SET_PANNING: effect = IT_SET_PANNING; break;
case XM_SAMPLE_OFFSET: effect = IT_SET_SAMPLE_OFFSET; break;
case XM_POSITION_JUMP: effect = IT_JUMP_TO_ORDER; break;
case XM_MULTI_RETRIG: effect = IT_RETRIGGER_NOTE; break;
case XM_TREMOR: effect = IT_TREMOR; break;
case XM_PORTAMENTO_UP: effect = IT_XM_PORTAMENTO_UP; break;
case XM_PORTAMENTO_DOWN: effect = IT_XM_PORTAMENTO_DOWN; break;
case XM_SET_CHANNEL_VOLUME: effect = IT_SET_CHANNEL_VOLUME; break; /* special */
case XM_VOLSLIDE_TONEPORTA: effect = IT_VOLSLIDE_TONEPORTA; break; /* special */
case XM_VOLSLIDE_VIBRATO: effect = IT_VOLSLIDE_VIBRATO; break; /* special */
case XM_PATTERN_BREAK:
effect = IT_BREAK_TO_ROW;
value = BCD_TO_NORMAL(value);
break;
case XM_VOLUME_SLIDE: /* special */
effect = IT_VOLUME_SLIDE;
value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));
break;
case XM_PANNING_SLIDE:
effect = IT_PANNING_SLIDE;
value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));
//value = HIGH(value) ? EFFECT_VALUE(0, HIGH(value)) : EFFECT_VALUE(LOW(value), 0);
break;
case XM_GLOBAL_VOLUME_SLIDE: /* special */
effect = IT_GLOBAL_VOLUME_SLIDE;
value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));
break;
case XM_SET_TEMPO_BPM:
effect = (value < 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO);
break;
case XM_SET_GLOBAL_VOLUME:
effect = IT_SET_GLOBAL_VOLUME;
value *= 2;
break;
case XM_KEY_OFF:
effect = IT_XM_KEY_OFF;
break;
case XM_SET_ENVELOPE_POSITION:
effect = IT_XM_SET_ENVELOPE_POSITION;
break;
case EBASE+XM_E_SET_FILTER: effect = SBASE+IT_S_SET_FILTER; break;
case EBASE+XM_E_SET_GLISSANDO_CONTROL: effect = SBASE+IT_S_SET_GLISSANDO_CONTROL; break; /** TODO */
case EBASE+XM_E_SET_FINETUNE: effect = SBASE+IT_S_FINETUNE; break; /** TODO */
case EBASE+XM_E_SET_LOOP: effect = SBASE+IT_S_PATTERN_LOOP; break;
case EBASE+XM_E_NOTE_CUT: effect = SBASE+IT_S_DELAYED_NOTE_CUT; break;
case EBASE+XM_E_NOTE_DELAY: effect = SBASE+IT_S_NOTE_DELAY; break;
case EBASE+XM_E_PATTERN_DELAY: effect = SBASE+IT_S_PATTERN_DELAY; break;
case EBASE+XM_E_FINE_VOLSLIDE_UP: effect = IT_XM_FINE_VOLSLIDE_UP; break;
case EBASE+XM_E_FINE_VOLSLIDE_DOWN: effect = IT_XM_FINE_VOLSLIDE_DOWN; break;
case EBASE + XM_E_FINE_PORTA_UP:
effect = IT_PORTAMENTO_UP;
value = EFFECT_VALUE(0xF, value);
break;
case EBASE + XM_E_FINE_PORTA_DOWN:
effect = IT_PORTAMENTO_DOWN;
value = EFFECT_VALUE(0xF, value);
break;
case EBASE + XM_E_RETRIG_NOTE:
effect = IT_XM_RETRIGGER_NOTE;
value = EFFECT_VALUE(0, value);
break;
case EBASE + XM_E_SET_VIBRATO_CONTROL:
effect = SBASE+IT_S_SET_VIBRATO_WAVEFORM;
value &= ~4; /** TODO: value&4 -> don't retrig wave */
break;
case EBASE + XM_E_SET_TREMOLO_CONTROL:
effect = SBASE+IT_S_SET_TREMOLO_WAVEFORM;
value &= ~4; /** TODO: value&4 -> don't retrig wave */
break;
case XBASE + XM_X_EXTRAFINE_PORTA_UP:
effect = IT_PORTAMENTO_UP;
value = EFFECT_VALUE(0xE, value);
break;
case XBASE + XM_X_EXTRAFINE_PORTA_DOWN:
effect = IT_PORTAMENTO_DOWN;
value = EFFECT_VALUE(0xE, value);
break;
default:
/* user effect (often used in demos for synchronisation) */
entry->mask &= ~IT_ENTRY_EFFECT;
}
if (log) printf(" - %2d %02X", effect, value);
/* Inverse linearisation... */
if (effect >= SBASE && effect < SBASE+16) {
value = EFFECT_VALUE(effect-SBASE, value);
effect = IT_S;
}
if (log) printf(" - %c%02X\n", 'A'+effect-1, value);
entry->effect = effect;
entry->effectvalue = value;
}
static void smc91c111_writeb(void *opaque, target_phys_addr_t offset,
uint32_t value)
{
smc91c111_state *s = (smc91c111_state *)opaque;
if (offset == 14) {
s->bank = value;
return;
}
if (offset == 15)
return;
switch (s->bank) {
case 0:
switch (offset) {
case 0:
SET_LOW(tcr, value);
return;
case 1:
SET_HIGH(tcr, value);
return;
case 4:
SET_LOW(rcr, value);
return;
case 5:
SET_HIGH(rcr, value);
if (s->rcr & RCR_SOFT_RST)
smc91c111_reset(s);
return;
case 10: case 11:
return;
}
break;
case 1:
switch (offset) {
case 0:
SET_LOW(cr, value);
return;
case 1:
SET_HIGH(cr,value);
return;
case 2: case 3:
case 4: case 5: case 6: case 7: case 8: case 9:
return;
case 10:
SET_LOW(gpr, value);
return;
case 11:
SET_HIGH(gpr, value);
return;
case 12:
if (value & 1)
fprintf(stderr, "smc91c111:EEPROM store not implemented\n");
if (value & 2)
fprintf(stderr, "smc91c111:EEPROM reload not implemented\n");
value &= ~3;
SET_LOW(ctr, value);
return;
case 13:
SET_HIGH(ctr, value);
return;
}
break;
case 2:
switch (offset) {
case 0:
switch (value >> 5) {
case 0:
break;
case 1:
s->tx_alloc = 0x80;
s->int_level &= ~INT_ALLOC;
smc91c111_update(s);
smc91c111_tx_alloc(s);
break;
case 2:
s->allocated = 0;
s->tx_fifo_len = 0;
s->tx_fifo_done_len = 0;
s->rx_fifo_len = 0;
s->tx_alloc = 0;
break;
case 3:
smc91c111_pop_rx_fifo(s);
break;
case 4:
if (s->rx_fifo_len > 0) {
smc91c111_release_packet(s, s->rx_fifo[0]);
}
smc91c111_pop_rx_fifo(s);
break;
case 5:
smc91c111_release_packet(s, s->packet_num);
break;
case 6:
smc91c111_queue_tx(s, s->packet_num);
break;
case 7:
s->tx_fifo_len = 0;
s->tx_fifo_done_len = 0;
break;
}
return;
case 1:
return;
case 2:
s->packet_num = value;
return;
case 3: case 4: case 5:
return;
case 6:
SET_LOW(ptr, value);
return;
case 7:
SET_HIGH(ptr, value);
return;
case 8: case 9: case 10: case 11:
{
int p;
int n;
if (s->ptr & 0x8000)
n = s->rx_fifo[0];
else
n = s->packet_num;
p = s->ptr & 0x07ff;
if (s->ptr & 0x4000) {
s->ptr = (s->ptr & 0xf800) | ((s->ptr + 1) & 0x7ff);
} else {
p += (offset & 3);
}
s->data[n][p] = value;
}
return;
case 12:
s->int_level &= ~(value & 0xd6);
if (value & INT_TX)
smc91c111_pop_tx_fifo_done(s);
smc91c111_update(s);
return;
case 13:
s->int_mask = value;
smc91c111_update(s);
return;
}
break;;
case 3:
switch (offset) {
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
return;
case 8: case 9:
return;
case 12:
s->ercv = value & 0x1f;
case 13:
return;
}
break;
}
hw_error("smc91c111_write: Bad reg %d:%x\n", s->bank, (int)offset);
}
// IBM/MS get drive parameters
static void noinline
disk_1348(struct bregs *regs, struct drive_s *drive_gf)
{
u16 seg = regs->ds;
struct int13dpt_s *param_far = (struct int13dpt_s*)(regs->si+0);
u16 size = GET_FARVAR(seg, param_far->size);
u16 t13 = size == 74;
// Buffer is too small
if (size < 26) {
disk_ret(regs, DISK_RET_EPARAM);
return;
}
// EDD 1.x
u8 type = GET_GLOBALFLAT(drive_gf->type);
u16 npc = GET_GLOBALFLAT(drive_gf->pchs.cylinder);
u16 nph = GET_GLOBALFLAT(drive_gf->pchs.head);
u16 nps = GET_GLOBALFLAT(drive_gf->pchs.sector);
u64 lba = GET_GLOBALFLAT(drive_gf->sectors);
u16 blksize = GET_GLOBALFLAT(drive_gf->blksize);
dprintf(DEBUG_HDL_13, "disk_1348 size=%d t=%d chs=%d,%d,%d lba=%d bs=%d\n"
, size, type, npc, nph, nps, (u32)lba, blksize);
SET_FARVAR(seg, param_far->size, 26);
if (type == DTYPE_ATA_ATAPI) {
// 0x74 = removable, media change, lockable, max values
SET_FARVAR(seg, param_far->infos, 0x74);
SET_FARVAR(seg, param_far->cylinders, 0xffffffff);
SET_FARVAR(seg, param_far->heads, 0xffffffff);
SET_FARVAR(seg, param_far->spt, 0xffffffff);
SET_FARVAR(seg, param_far->sector_count, (u64)-1);
} else {
if (lba > (u64)nps*nph*0x3fff) {
SET_FARVAR(seg, param_far->infos, 0x00); // geometry is invalid
SET_FARVAR(seg, param_far->cylinders, 0x3fff);
} else {
SET_FARVAR(seg, param_far->infos, 0x02); // geometry is valid
SET_FARVAR(seg, param_far->cylinders, (u32)npc);
}
SET_FARVAR(seg, param_far->heads, (u32)nph);
SET_FARVAR(seg, param_far->spt, (u32)nps);
SET_FARVAR(seg, param_far->sector_count, lba);
}
SET_FARVAR(seg, param_far->blksize, blksize);
if (size < 30 ||
(type != DTYPE_ATA && type != DTYPE_ATA_ATAPI &&
type != DTYPE_VIRTIO_BLK && type != DTYPE_VIRTIO_SCSI)) {
disk_ret(regs, DISK_RET_SUCCESS);
return;
}
// EDD 2.x
int bdf;
u16 iobase1 = 0;
u64 device_path = 0;
u8 channel = 0;
SET_FARVAR(seg, param_far->size, 30);
if (type == DTYPE_ATA || type == DTYPE_ATA_ATAPI) {
SET_FARVAR(seg, param_far->dpte, SEGOFF(SEG_LOW, (u32)&DefaultDPTE));
// Fill in dpte
struct atadrive_s *adrive_gf = container_of(
drive_gf, struct atadrive_s, drive);
struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf);
u8 slave = GET_GLOBALFLAT(adrive_gf->slave);
u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2);
u8 irq = GET_GLOBALFLAT(chan_gf->irq);
iobase1 = GET_GLOBALFLAT(chan_gf->iobase1);
bdf = GET_GLOBALFLAT(chan_gf->pci_bdf);
device_path = slave;
channel = GET_GLOBALFLAT(chan_gf->chanid);
u16 options = 0;
if (type == DTYPE_ATA) {
u8 translation = GET_GLOBALFLAT(drive_gf->translation);
if (translation != TRANSLATION_NONE) {
options |= 1<<3; // CHS translation
if (translation == TRANSLATION_LBA)
options |= 1<<9;
if (translation == TRANSLATION_RECHS)
options |= 3<<9;
}
} else {
// ATAPI
options |= 1<<5; // removable device
options |= 1<<6; // atapi device
}
options |= 1<<4; // lba translation
if (CONFIG_ATA_PIO32)
options |= 1<<7;
SET_LOW(DefaultDPTE.iobase1, iobase1);
SET_LOW(DefaultDPTE.iobase2, iobase2 + ATA_CB_DC);
SET_LOW(DefaultDPTE.prefix, ((slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0)
| ATA_CB_DH_LBA));
SET_LOW(DefaultDPTE.unused, 0xcb);
SET_LOW(DefaultDPTE.irq, irq);
SET_LOW(DefaultDPTE.blkcount, 1);
SET_LOW(DefaultDPTE.dma, 0);
SET_LOW(DefaultDPTE.pio, 0);
SET_LOW(DefaultDPTE.options, options);
SET_LOW(DefaultDPTE.reserved, 0);
SET_LOW(DefaultDPTE.revision, 0x11);
u8 sum = checksum_far(SEG_LOW, &DefaultDPTE, 15);
SET_LOW(DefaultDPTE.checksum, -sum);
} else {
void init_io(void)
{
SET_OUTPUT(TOP);
SET_OUTPUT(MIDDLE);
SET_OUTPUT(LOW);
SET_LOW(TOP);
SET_LOW(MIDDLE);
SET_LOW(LOW);
SET_OUTPUT(LED1);
SET_OUTPUT(LED2);
SET_OUTPUT(LED3);
SET_OUTPUT(LED4);
SET_OUTPUT(LED5);
SET_OUTPUT(LED6);
SET_OUTPUT(LED7);
SET_OUTPUT(LED8);
SET_OUTPUT(LED9);
SET_LOW(LED1);
SET_LOW(LED2);
SET_LOW(LED3);
SET_LOW(LED4);
SET_LOW(LED5);
SET_LOW(LED6);
SET_LOW(LED7);
SET_LOW(LED8);
SET_LOW(LED9);
led_values[0]=0;
led_values[1]=0;
led_values[2]=0;
led_values[3]=0;
led_values[4]=0;
led_values[5]=0;
led_values[6]=0;
led_values[7]=0;
led_values[8]=0;
led_values[9]=85;
led_values[10]=85;
led_values[11]=85;
led_values[12]=85;
led_values[13]=85;
led_values[14]=85;
led_values[15]=85;
led_values[16]=85;
led_values[17]=85;
led_values[18]=170;
led_values[19]=170;
led_values[20]=170;
led_values[21]=85;
led_values[22]=0;
led_values[23]=85;
led_values[24]=170;
led_values[25]=170;
led_values[26]=170;
}
