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; }