devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

Nuke the never-functional iriver ifp-7xx port

Browse source 
It never worked, and hasn't compiled in something like a decade, Given
the HW capabilities (limited onboard flash, no expandability) there's
really no point in trying to fix/complete it.

Change-Id: I7d175089840396f8891645bd10010d730dd5bfdc
This commit is contained in:
Solomon Peachy 2021-04-23 11:31:58 -04:00
parent 3ba2f6e5c7
commit 7d0d32dbc6
58 changed files with 3 additions and 4087 deletions
Download patch file Download diff file Expand all files Collapse all files

144
firmware/target/arm/pnx0101/app.lds
View file

@ -1,144 +0,0 @@
#include "config.h"
ENTRY(start)
OUTPUT_FORMAT(elf32-littlearm)
OUTPUT_ARCH(arm)
STARTUP(target/arm/pnx0101/crt0-pnx0101.o)
#define PLUGINSIZE PLUGIN_BUFFER_SIZE
#define CODECSIZE CODEC_SIZE
#ifdef DEBUG
#define STUBOFFSET 0x10000
#else
#define STUBOFFSET 0
#endif
#define DRAMSIZE (MEMORYSIZE * 0x100000) - PLUGINSIZE - STUBOFFSET - CODECSIZE
#define DRAMORIG 0xc00000 + STUBOFFSET
#define IRAM0ORIG 0x000000
#define IRAM0SIZE 0x7000
#define IRAMORIG 0x400000
#define IRAMSIZE 0x7000
/* End of the audio buffer, where the codec buffer starts */
#define ENDAUDIOADDR (DRAMORIG + DRAMSIZE)
/* Where the codec buffer ends, and the plugin buffer starts */
#define ENDADDR (ENDAUDIOADDR + CODECSIZE)
MEMORY
{
DRAM : ORIGIN = DRAMORIG, LENGTH = DRAMSIZE
IRAM : ORIGIN = IRAMORIG, LENGTH = IRAMSIZE
IRAM0 : ORIGIN = IRAM0ORIG, LENGTH = IRAM0SIZE
}
SECTIONS
{
.text :
{
loadaddress = .;
_loadaddress = .;
. = ALIGN(0x200);
*(.init.text)
*(.text*)
*(.glue_7)
*(.glue_7t)
. = ALIGN(0x4);
} > DRAM
.rodata :
{
*(.rodata) /* problems without this, dunno why */
*(.rodata*)
*(.rodata.str1.1)
*(.rodata.str1.4)
. = ALIGN(0x4);
} > DRAM
.data :
{
*(.data*)
. = ALIGN(0x4);
} > DRAM
/DISCARD/ :
{
*(.eh_frame)
}
.vectors 0x0 :
{
_vectorsstart = .;
KEEP(*(.vectors));
_vectorsend = .;
*(.dmabuf)
} >IRAM0 AT> DRAM
_vectorscopy = LOADADDR(.vectors);
.iram IRAMORIG + SIZEOF(.vectors) :
{
_iramstart = .;
*(.icode)
*(.irodata)
*(.idata)
. = ALIGN(0x4);
_iramend = .;
} > IRAM AT> DRAM
_iramcopy = LOADADDR(.iram);
.ibss (NOLOAD) :
{
_iedata = .;
*(.ibss)
. = ALIGN(0x4);
_iend = .;
} > IRAM
.stack :
{
*(.stack)
stackbegin = .;
. += 0x2000;
stackend = .;
} > IRAM
.bss ADDR(.data) + SIZEOF(.data) + SIZEOF(.iram) + SIZEOF(.vectors):
{
_edata = .;
*(.bss*)
*(COMMON)
. = ALIGN(0x4);
_end = .;
} > DRAM
.audiobuf ALIGN(4) :
{
_audiobuffer = .;
audiobuffer = .;
} > DRAM
.audiobufend ENDAUDIOADDR:
{
audiobufend = .;
_audiobufend = .;
} > DRAM
.codec ENDAUDIOADDR:
{
codecbuf = .;
_codecbuf = .;
}
.plugin ENDADDR:
{
_pluginbuf = .;
pluginbuf = .;
}
}

28
firmware/target/arm/pnx0101/backlight-target.h
View file

@ -1,28 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id: backlight-target.h 13136 2007-04-12 22:12:13Z amiconn $
*
* Copyright (C) 2006 by Barry Wardell
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef BACKLIGHT_TARGET_H
#define BACKLIGHT_TARGET_H
#define backlight_hw_init() true
void backlight_hw_on(void);
void backlight_hw_off(void);
#endif

225
firmware/target/arm/pnx0101/crt0-pnx0101.S
View file

@ -1,225 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id: crt0.S 11850 2006-12-29 02:49:12Z markun $
*
* Copyright (C) 2002 by Linus Nielsen Feltzing
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#define ASM /* do not include structure definitions from pnx0101.h */
#include "config.h"
#include "cpu.h"
.section .init.text,"ax",%progbits
.global start
start:
/* Arm bootloader and startup code based on startup.s from the iPodLinux loader
*
* Copyright (c) 2003, Daniel Palffy (dpalffy (at) rainstorm.org)
* Copyright (c) 2005, Bernard Leach <leachbj@bouncycastle.org>
*
*/
msr cpsr_c, #0xd3 /* enter supervisor mode, disable IRQ */
#ifndef BOOTLOADER
#ifndef DEBUG
ldr r0, =0x80105000
mov r1, #1
str r1, [r0, #4]
mov r1, #0
str r1, [r0, #4]
1: ldr r1, [r0]
cmp r1, #0
bne 1b
mov r1, #0x74
str r1, [r0, #8]
mov r1, #2
str r1, [r0, #0x18]
mov r1, #2
str r1, [r0, #0x20]
mov r1, #82
str r1, [r0, #0x28]
mov r1, #100
str r1, [r0, #0x2c]
mov r1, #0x120
str r1, [r0, #0x30]
mov r1, #6
str r1, [r0, #4]
ldr r0, =1f
mov r15, r0
1:
#endif /* !DEBUG */
#ifndef DEBUG
/* Copy exception handler code to address 0 */
ldr r2, =_vectorsstart
ldr r3, =_vectorsend
ldr r4, =_vectorscopy
1:
cmp r3, r2
ldrhi r5, [r4], #4
strhi r5, [r2], #4
bhi 1b
#else
ldr r1, =vectors
ldr r0, =irq_handler
str r0, [r1, #24]
ldr r0, =fiq_handler
str r0, [r1, #28]
#endif
#ifndef STUB
/* Zero out IBSS */
ldr r2, =_iedata
ldr r3, =_iend
mov r4, #0
1:
cmp r3, r2
strhi r4, [r2], #4
bhi 1b
/* Copy the IRAM */
ldr r2, =_iramcopy
ldr r3, =_iramstart
ldr r4, =_iramend
1:
cmp r4, r3
ldrhi r5, [r2], #4
strhi r5, [r3], #4
bhi 1b
#endif /* !STUB */
#endif /* !BOOTLOADER */
/* Initialise bss section to zero */
ldr r2, =_edata
ldr r3, =_end
mov r4, #0
1:
cmp r3, r2
strhi r4, [r2], #4
bhi 1b
/* Set up stack for IRQ mode */
msr cpsr_c, #0xd2
ldr sp, =irq_stack
/* Set up stack for FIQ mode */
msr cpsr_c, #0xd1
ldr sp, =fiq_stack
/* Let svc, abort and undefined modes use irq stack */
msr cpsr_c, #0xd3
ldr sp =irq_stack
msr cpsr_c, #0xd7
ldr sp, =irq_stack
msr cpsr_c, #0xdb
ldr sp, =irq_stack
/* Switch to sys mode */
msr cpsr_c, #0xdf
/* Set up some stack and munge it with 0xdeadbeef */
ldr sp, =stackend
mov r3, sp
ldr r2, =stackbegin
ldr r4, =0xdeadbeef
1:
cmp r3, r2
strhi r4, [r2], #4
bhi 1b
bl main
/* main() should never return */
/* Exception handlers. Will be copied to address 0 after memory remapping */
.section .vectors,"aw"
ldr pc, [pc, #24]
ldr pc, [pc, #24]
ldr pc, [pc, #24]
ldr pc, [pc, #24]
ldr pc, [pc, #24]
ldr pc, [pc, #24]
ldr pc, [pc, #24]
ldr pc, [pc, #24]
/* Exception vectors */
.global vectors
vectors:
.word start
.word undef_instr_handler
.word software_int_handler
.word prefetch_abort_handler
.word data_abort_handler
.word reserved_handler
.word irq_handler
.word fiq_handler
.text
/* All illegal exceptions call into UIE with exception address as first
parameter. This is calculated differently depending on which exception
we're in. Second parameter is exception number, used for a string lookup
in UIE.
*/
undef_instr_handler:
sub r0, lr, #4
mov r1, #0
b UIE
/* We run sys mode most of the time, and should never see a software
exception being thrown. Make it illegal and call UIE.
*/
software_int_handler:
reserved_handler:
sub r0, lr, #4
mov r1, #4
b UIE
prefetch_abort_handler:
sub r0, lr, #4
mov r1, #1
b UIE
fiq_handler:
@ Branch straight to FIQ handler in pcm_playback.c. This also handles the
@ the correct return sequence.
stmfd sp!, {r0-r7, r12, lr}
bl fiq
ldmfd sp!, {r0-r7, r12, lr}
subs pc, lr, #4
irq_handler:
#ifndef STUB
stmfd sp!, {r0-r11, r12, lr}
bl irq
ldmfd sp!, {r0-r11, r12, lr}
#endif
subs pc, lr, #4
#ifdef STUB
UIE:
b UIE
#endif
/* 256 words of IRQ stack */
.space 256*4
irq_stack:
/* 256 words of FIQ stack */
.space 256*4
fiq_stack:

5
firmware/target/arm/pnx0101/debug-pnx0101.c
View file

@ -1,5 +0,0 @@
#include <stdbool.h>
bool dbg_ports()
{
return false;
}

24
firmware/target/arm/pnx0101/i2c-pnx0101.c
View file

@ -1,24 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 by Tomasz Malesinski
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
void i2c_init(void)
{
}

59
firmware/target/arm/pnx0101/iriver-ifp7xx/adc-ifp7xx.c
View file

@ -1,59 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 by Barry Wardell
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "cpu.h"
#include "system.h"
#include "kernel.h"
#include "thread.h"
#include "adc.h"
static unsigned short adcdata[NUM_ADC_CHANNELS];
unsigned short adc_read(int channel)
{
return adcdata[channel];
}
static void adc_tick(void)
{
if (ADCST & 0x10) {
adcdata[0] = ADCCH0 & 0x3ff;
adcdata[1] = ADCCH1 & 0x3ff;
adcdata[2] = ADCCH2 & 0x3ff;
adcdata[3] = ADCCH3 & 0x3ff;
adcdata[4] = ADCCH4 & 0x3ff;
ADCST = 0xa;
}
}
void adc_init(void)
{
ADCR24 = 0xaaaaa;
ADCR28 = 0;
ADCST = 2;
ADCST = 0xa;
while (!(ADCST & 0x10));
adc_tick();
tick_add_task(adc_tick);
}

31
firmware/target/arm/pnx0101/iriver-ifp7xx/adc-target.h
View file

@ -1,31 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 by Barry Wardell
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef _ADC_TARGET_H_
#define _ADC_TARGET_H_
#define NUM_ADC_CHANNELS 5
#define ADC_BUTTONS 0
#define ADC_BATTERY 1
#define ADC_BUTTON_PLAY 2
#define ADC_UNREG_POWER ADC_BATTERY /* For compatibility */
#endif

35
firmware/target/arm/pnx0101/iriver-ifp7xx/backlight-ifp7xx.c
View file

@ -1,35 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 by Barry Wardell
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "cpu.h"
#include "system.h"
#include "backlight.h"
#include "lcd.h"
void backlight_hw_on(void)
{
GPIO3_SET = 1;
}
void backlight_hw_off(void)
{
GPIO3_CLR = 1;
}

90
firmware/target/arm/pnx0101/iriver-ifp7xx/button-ifp7xx.c
View file

@ -1,90 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 by Barry Wardell
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdlib.h>
#include "config.h"
#include "cpu.h"
#include "system.h"
#include "button.h"
#include "kernel.h"
#include "backlight.h"
#include "adc.h"
void button_init_device(void)
{
}
bool button_hold(void)
{
return (GPIO5_READ & 4) ? false : true;
}
/*
* Get button pressed from hardware
*/
int button_read_device(void)
{
int btn = BUTTON_NONE;
int data;
static bool hold_button = false;
bool hold_button_old;
/* normal buttons */
hold_button_old = hold_button;
hold_button = button_hold();
if (hold_button != hold_button_old)
backlight_hold_changed(hold_button);
if (!button_hold())
{
data = adc_read(ADC_BUTTONS);
if (data < 0x35c)
{
if (data < 0x151)
if (data < 0xc7)
if (data < 0x41)
btn = BUTTON_LEFT;
else
btn = BUTTON_RIGHT;
else
btn = BUTTON_SELECT;
else
if (data < 0x268)
if (data < 0x1d7)
btn = BUTTON_UP;
else
btn = BUTTON_DOWN;
else
if (data < 0x2f9)
btn = BUTTON_EQ;
else
btn = BUTTON_MODE;
}
if (adc_read(ADC_BUTTON_PLAY) < 0x64)
btn |= BUTTON_PLAY;
}
return btn;
}

49
firmware/target/arm/pnx0101/iriver-ifp7xx/button-target.h
View file

@ -1,49 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 by Barry Wardell
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
/* Custom written for the ifp7xx */
#ifndef _BUTTON_TARGET_H_
#define _BUTTON_TARGET_H_
#define HAS_BUTTON_HOLD
/* iriver IFP7XX specific button codes */
#define BUTTON_PLAY 0x00000001
#define BUTTON_SELECT 0x00000002
#define BUTTON_LEFT 0x00000004
#define BUTTON_RIGHT 0x00000008
#define BUTTON_UP 0x00000010
#define BUTTON_DOWN 0x00000020
#define BUTTON_MODE 0x00000040
#define BUTTON_EQ 0x00000080
#define BUTTON_MAIN (BUTTON_PLAY|BUTTON_SELECT\
|BUTTON_LEFT|BUTTON_RIGHT|BUTTON_UP|BUTTON_DOWN\
|BUTTON_MODE|BUTTON_EQ)
#define POWEROFF_BUTTON BUTTON_PLAY
#define POWEROFF_COUNT 40
#endif /* _BUTTON_TARGET_H_ */

224
firmware/target/arm/pnx0101/iriver-ifp7xx/lcd-ifp7xx.c
View file

@ -1,224 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Alan Korr
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "kernel.h"
#include "lcd.h"
#include "system.h"
/*** definitions ***/
#define LCD_SET_LOWER_COLUMN_ADDRESS ((char)0x00)
#define LCD_SET_HIGHER_COLUMN_ADDRESS ((char)0x10)
#define LCD_SET_INTERNAL_REGULATOR_RESISTOR_RATIO ((char)0x20)
#define LCD_SET_POWER_CONTROL_REGISTER ((char)0x28)
#define LCD_SET_DISPLAY_START_LINE ((char)0x40)
#define LCD_SET_CONTRAST_CONTROL_REGISTER ((char)0x81)
#define LCD_SET_SEGMENT_REMAP ((char)0xA0)
#define LCD_SET_LCD_BIAS ((char)0xA2)
#define LCD_SET_ENTIRE_DISPLAY_OFF ((char)0xA4)
#define LCD_SET_ENTIRE_DISPLAY_ON ((char)0xA5)
#define LCD_SET_NORMAL_DISPLAY ((char)0xA6)
#define LCD_SET_REVERSE_DISPLAY ((char)0xA7)
#define LCD_SET_MULTIPLEX_RATIO ((char)0xA8)
#define LCD_SET_BIAS_TC_OSC ((char)0xA9)
#define LCD_SET_1OVER4_BIAS_RATIO ((char)0xAA)
#define LCD_SET_INDICATOR_OFF ((char)0xAC)
#define LCD_SET_INDICATOR_ON ((char)0xAD)
#define LCD_SET_DISPLAY_OFF ((char)0xAE)
#define LCD_SET_DISPLAY_ON ((char)0xAF)
#define LCD_SET_PAGE_ADDRESS ((char)0xB0)
#define LCD_SET_COM_OUTPUT_SCAN_DIRECTION ((char)0xC0)
#define LCD_SET_TOTAL_FRAME_PHASES ((char)0xD2)
#define LCD_SET_DISPLAY_OFFSET ((char)0xD3)
#define LCD_SET_READ_MODIFY_WRITE_MODE ((char)0xE0)
#define LCD_SOFTWARE_RESET ((char)0xE2)
#define LCD_NOP ((char)0xE3)
#define LCD_SET_END_OF_READ_MODIFY_WRITE_MODE ((char)0xEE)
/* LCD command codes */
#define LCD_CNTL_RESET 0xe2 /* Software reset */
#define LCD_CNTL_POWER 0x2f /* Power control */
#define LCD_CNTL_CONTRAST 0x81 /* Contrast */
#define LCD_CNTL_OUTSCAN 0xc8 /* Output scan direction */
#define LCD_CNTL_SEGREMAP 0xa1 /* Segment remap */
#define LCD_CNTL_DISPON 0xaf /* Display on */
#define LCD_CNTL_PAGE 0xb0 /* Page address */
#define LCD_CNTL_HIGHCOL 0x10 /* Upper column address */
#define LCD_CNTL_LOWCOL 0x00 /* Lower column address */
/*** driver routines ***/
void lcd_write_command(int cmd)
{
while ((LCDSTAT & 3) != 3);
LCDCMD = cmd;
}
void lcd_write_data( const unsigned char* data, int count )
{
int i;
for (i=0; i < count; i++) {
while ((LCDSTAT & 3) != 3);
LCDDATA = data[i];
}
}
/*** hardware configuration ***/
int lcd_default_contrast(void)
{
return 45;
}
void lcd_set_contrast(int val)
{
lcd_write_command(LCD_CNTL_CONTRAST);
lcd_write_command(val);
}
void lcd_set_invert_display(bool yesno)
{
if (yesno)
lcd_write_command(LCD_SET_REVERSE_DISPLAY);
else
lcd_write_command(LCD_SET_NORMAL_DISPLAY);
}
/* turn the display upside down (call lcd_update() afterwards) */
void lcd_set_flip(bool yesno)
{
if (yesno)
{
lcd_write_command(LCD_SET_SEGMENT_REMAP);
lcd_write_command(LCD_SET_COM_OUTPUT_SCAN_DIRECTION);
}
else
{
lcd_write_command(LCD_SET_SEGMENT_REMAP | 0x01);
lcd_write_command(LCD_SET_COM_OUTPUT_SCAN_DIRECTION | 0x08);
}
}
void lcd_init_device(void)
{
LCDREG10 = 0xf;
LCDREG04 = 0x4084;
/* inits like the original firmware */
lcd_write_command(LCD_SOFTWARE_RESET);
lcd_write_command(LCD_SET_INTERNAL_REGULATOR_RESISTOR_RATIO + 4);
lcd_write_command(LCD_SET_LCD_BIAS);
lcd_write_command(LCD_SET_POWER_CONTROL_REGISTER + 7);
/* power control register: op-amp=1, regulator=1, booster=1 */
lcd_write_command(LCD_SET_DISPLAY_ON);
lcd_write_command(LCD_SET_NORMAL_DISPLAY);
lcd_set_flip(false);
lcd_write_command(LCD_SET_DISPLAY_START_LINE + 0);
lcd_set_contrast(lcd_default_contrast());
lcd_write_command(LCD_SET_PAGE_ADDRESS);
lcd_write_command(LCD_SET_LOWER_COLUMN_ADDRESS + 0);
lcd_write_command(LCD_SET_HIGHER_COLUMN_ADDRESS + 0);
lcd_clear_display();
lcd_update();
}
/*** Update functions ***/
/* Performance function that works with an external buffer
note that by and bheight are in 8-pixel units! */
void lcd_blit_mono(const unsigned char *data, int x, int by, int width,
int bheight, int stride)
{
/* Copy display bitmap to hardware */
while (bheight--)
{
lcd_write_command (LCD_CNTL_PAGE | (by++ & 0xf));
lcd_write_command (LCD_CNTL_HIGHCOL | (((x+4)>>4) & 0xf));
lcd_write_command (LCD_CNTL_LOWCOL | ((x+4) & 0xf));
lcd_write_data(data, width);
data += stride;
}
}
/* Performance function that works with an external buffer
note that by and bheight are in 8-pixel units! */
void lcd_blit_grey_phase(unsigned char *values, unsigned char *phases,
int x, int by, int width, int bheight, int stride)
{
(void)values;
(void)phases;
(void)x;
(void)by;
(void)width;
(void)bheight;
(void)stride;
}
/* Update the display.
This must be called after all other LCD functions that change the display. */
void lcd_update(void) ICODE_ATTR;
void lcd_update(void)
{
int y;
/* Copy display bitmap to hardware */
for (y = 0; y < LCD_FBHEIGHT; y++)
{
lcd_write_command (LCD_CNTL_PAGE | (y & 0xf));
lcd_write_command (LCD_CNTL_HIGHCOL);
lcd_write_command (LCD_CNTL_LOWCOL | 4);
lcd_write_data (FBADDR(0, y), LCD_WIDTH);
}
}
/* Update a fraction of the display. */
void lcd_update_rect(int, int, int, int) ICODE_ATTR;
void lcd_update_rect(int x, int y, int width, int height)
{
int ymax;
/* The Y coordinates have to work on even 8 pixel rows */
ymax = (y + height-1) >> 3;
y >>= 3;
if(x + width > LCD_WIDTH)
width = LCD_WIDTH - x;
if (width <= 0)
return; /* nothing left to do, 0 is harmful to lcd_write_data() */
if(ymax >= LCD_FBHEIGHT)
ymax = LCD_FBHEIGHT-1;
/* Copy specified rectange bitmap to hardware */
for (; y <= ymax; y++)
{
lcd_write_command (LCD_CNTL_PAGE | (y & 0xf));
lcd_write_command (LCD_CNTL_HIGHCOL | (((x+4) >> 4) & 0xf));
lcd_write_command (LCD_CNTL_LOWCOL | ((x+4) & 0xf));
lcd_write_data (FBADDR(x,y), width);
}
}

76
firmware/target/arm/pnx0101/iriver-ifp7xx/power-ifp7xx.c
View file

@ -1,76 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Linus Nielsen Feltzing
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "cpu.h"
#include <stdbool.h>
#include "kernel.h"
#include "system.h"
#include "power.h"
#include "logf.h"
#include "usb.h"
#if CONFIG_TUNER
bool tuner_power(bool status)
{
(void)status;
return true;
}
#endif /* #if CONFIG_TUNER */
#ifndef SIMULATOR
void power_init(void)
{
}
void ide_power_enable(bool on)
{
(void)on;
/* no ide controller */
}
bool ide_powered(void)
{
return true; /* pretend always powered if not controlable */
}
void power_off(void)
{
disable_interrupt(IRQ_FIQ_STATUS);
GPIO1_CLR = 1 << 16;
GPIO2_SET = 1;
while(1);
}
#else
void power_off(void)
{
}
void ide_power_enable(bool on)
{
(void)on;
}
#endif /* SIMULATOR */

55
firmware/target/arm/pnx0101/iriver-ifp7xx/powermgmt-ifp7xx.c
View file

@ -1,55 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Heikki Hannikainen, Uwe Freese
* Revisions copyright (C) 2005 by Gerald Van Baren
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "adc.h"
#include "powermgmt.h"
const unsigned short battery_level_dangerous[BATTERY_TYPES_COUNT] =
{
1050, 1150
};
const unsigned short battery_level_shutoff[BATTERY_TYPES_COUNT] =
{
1050, 1150 /* FIXME: just copied from above, was missing in powermgmt.c */
};
/* voltages (millivolt) of 0%, 10%, ... 100% when charging disabled */
const unsigned short percent_to_volt_discharge[BATTERY_TYPES_COUNT][11] =
{
/* These values are the same as for Ondio divided by 3. */
/* May need recalibration. */
{ 930, 1080, 1140, 1180, 1210, 1250, 1280, 1320, 1360, 1420, 1580 }, /* alkaline */
{ 1030, 1180, 1210, 1230, 1240, 1250, 1260, 1270, 1280, 1290, 1350 } /* NiMH */
};
/* TODO: only roughly correct */
#define BATTERY_SCALE_FACTOR 3072
/* full-scale ADC readout (2^10) in millivolt */
/* Returns battery voltage from ADC [millivolts] */
int _battery_voltage(void)
{
return (adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR) >> 10;
}

36
firmware/target/arm/pnx0101/iriver-ifp7xx/system-target.h
View file

@ -1,36 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Alan Korr
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef SYSTEM_TARGET_H
#define SYSTEM_TARGET_H
#include "system-arm.h"
#define CPUFREQ_DEFAULT 12000000
#define CPUFREQ_NORMAL 48000000
#define CPUFREQ_MAX 60000000
typedef void (*interrupt_handler_t)(void);
void irq_set_int_handler(int n, interrupt_handler_t handler);
void irq_enable_int(int n);
void irq_disable_int(int n);
#endif /* SYSTEM_TARGET_H */

49
firmware/target/arm/pnx0101/iriver-ifp7xx/usb-ifp7xx.c
View file

@ -1,49 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 by Barry Wardell
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "cpu.h"
#include "kernel.h"
#include "thread.h"
#include "system.h"
#include "debug.h"
#include "ata.h"
#include "disk.h"
#include "panic.h"
#include "lcd.h"
#include "usb.h"
#include "button.h"
#include "string.h"
void usb_init_device(void)
{
}
int usb_detect(void)
{
/* TODO: Implement USB_ISP1582 */
return USB_EXTRACTED;
}
void usb_enable(bool on)
{
/* TODO: Implement USB_ISP1582 */
(void)on;
}

45
firmware/target/arm/pnx0101/kernel-pnx0101.c
View file

@ -1,45 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 by Tomasz Malesinski
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "system.h"
#include "kernel.h"
void timer_handler(void)
{
/* Run through the list of tick tasks */
call_tick_tasks();
TIMER0.clr = 0;
}
void tick_start(unsigned int interval_in_ms)
{
TIMER0.ctrl &= ~0x80; /* Disable the counter */
TIMER0.ctrl |= 0x40; /* Reload after counting down to zero */
TIMER0.load = 3000000 * interval_in_ms / 1000;
TIMER0.ctrl &= ~0xc; /* No prescaler */
TIMER0.clr = 1; /* Clear the interrupt request */
irq_set_int_handler(IRQ_TIMER0, timer_handler);
irq_enable_int(IRQ_TIMER0);
TIMER0.ctrl |= 0x80; /* Enable the counter */
}

207
firmware/target/arm/pnx0101/pcm-pnx0101.c
View file

@ -1,207 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 by Tomek Malesinski
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "system.h"
#include "audio.h"
#include "string.h"
#include "pcm-internal.h"
#define DMA_BUF_SAMPLES 0x100
short __attribute__((section(".dmabuf"))) dma_buf_left[DMA_BUF_SAMPLES];
short __attribute__((section(".dmabuf"))) dma_buf_right[DMA_BUF_SAMPLES];
const int16_t* p IBSS_ATTR;
size_t p_size IBSS_ATTR;
void pcm_play_lock(void)
{
}
void pcm_play_unlock(void)
{
}
void pcm_play_dma_start(const void *addr, size_t size)
{
p = addr;
p_size = size;
}
void pcm_play_dma_stop(void)
{
}
static inline void fill_dma_buf(int offset)
{
short *l, *r, *lend;
l = dma_buf_left + offset;
lend = l + DMA_BUF_SAMPLES / 2;
r = dma_buf_right + offset;
if (pcm_playing)
{
bool new_buffer =false;
do
{
int count;
const int16_t *tmp_p;
count = MIN(p_size / 4, (size_t)(lend - l));
tmp_p = p;
p_size -= count * 4;
if ((int)l & 3)
{
*l++ = *tmp_p++;
*r++ = *tmp_p++;
count--;
}
while (count >= 4)
{
asm("ldmia %0!, {r0, r1, r2, r3}\n\t"
"and r4, r0, %3\n\t"
"orr r4, r4, r1, lsl #16\n\t"
"and r5, r2, %3\n\t"
"orr r5, r5, r3, lsl #16\n\t"
"stmia %1!, {r4, r5}\n\t"
"bic r4, r1, %3\n\t"
"orr r4, r4, r0, lsr #16\n\t"
"bic r5, r3, %3\n\t"
"orr r5, r5, r2, lsr #16\n\t"
"stmia %2!, {r4, r5}"
: "+r" (tmp_p), "+r" (l), "+r" (r)
: "r" (0xffff)
: "r0", "r1", "r2", "r3", "r4", "r5", "memory");
count -= 4;
}
while (count > 0)
{
*l++ = *tmp_p++;
*r++ = *tmp_p++;
count--;
}
p = tmp_p;
if (new_buffer)
{
new_buffer = false;
pcm_play_dma_status_callback(PCM_DMAST_STARTED);
}
if (l >= lend)
return;
new_buffer = pcm_play_dma_complete_callback(PCM_DMAST_OK,
&p, &p_size);
}
while (p_size);
}
if (l < lend)
{
memset(l, 0, sizeof(short) * (lend - l));
memset(r, 0, sizeof(short) * (lend - l));
}
}
static void audio_irq(void)
{
unsigned long st = DMAINTSTAT & ~DMAINTEN;
int i;
for (i = 0; i < 2; i++)
if (st & (1 << i))
{
fill_dma_buf((i == 1) ? 0 : DMA_BUF_SAMPLES / 2);
DMAINTSTAT = 1 << i;
}
}
unsigned long physical_address(void *p)
{
unsigned long adr = (unsigned long)p;
return (MMUBLOCK((adr >> 21) & 0xf) << 21) | (adr & ((1 << 21) - 1));
}
void pcm_init(void)
{
int i;
memset(dma_buf_left, 0, sizeof(dma_buf_left));
memset(dma_buf_right, 0, sizeof(dma_buf_right));
for (i = 0; i < 8; i++)
{
DMASRC(i) = 0;
DMADEST(i) = 0;
DMALEN(i) = 0x1ffff;
DMAR0C(i) = 0;
DMAR10(i) = 0;
DMAR1C(i) = 0;
}
DMAINTSTAT = 0xc000ffff;
DMAINTEN = 0xc000ffff;
DMASRC(0) = physical_address(dma_buf_left);
DMADEST(0) = 0x80200280;
DMALEN(0) = 0xff;
DMAR1C(0) = 0;
DMAR0C(0) = 0x40408;
DMASRC(1) = physical_address(dma_buf_right);
DMADEST(1) = 0x80200284;
DMALEN(1) = 0xff;
DMAR1C(1) = 0;
DMAR0C(1) = 0x40409;
irq_set_int_handler(0x1b, audio_irq);
irq_enable_int(0x1b);
DMAINTSTAT = 1;
DMAINTSTAT = 2;
DMAINTEN &= ~3;
DMAR10(0) |= 1;
DMAR10(1) |= 1;
}
void pcm_play_dma_postinit(void)
{
audiohw_postinit();
}
void pcm_dma_apply_settings(void)
{
}
const void * pcm_play_dma_get_peak_buffer(int *count)
{
unsigned long addr = (unsigned long)p;
size_t cnt = p_size;
*count = cnt >> 2;
return (void *)((addr + 2) & ~3);
}
void audiohw_set_volume(int value)
{
int tmp = (60 - value * 4) & 0xff;
CODECVOL = tmp | (tmp << 8);
}

317
firmware/target/arm/pnx0101/system-pnx0101.c
View file

@ -1,317 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id: $
*
* Copyright (C) 2007 by Tomasz Malesinski
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdlib.h>
#include "pnx0101.h"
#include "system.h"
static struct
{
unsigned char freq;
unsigned char sys_mult;
unsigned char sys_div;
}
perf_modes[3] ICONST_ATTR =
{
{12, 4, 4},
{48, 4, 1},
{60, 5, 1}
};
static int performance_mode, bus_divider;
static void cgu_set_sel_stage_input(int clock, int input)
{
int s = CGU.base_ssr[clock];
if (s & 1)
CGU.base_fs2[clock] = input;
else
CGU.base_fs1[clock] = input;
CGU.base_scr[clock] = (s & 3) ^ 3;
}
static void cgu_reset_sel_stage_clocks(int first_esr, int n_esr,
int first_div, int n_div)
{
int i;
for (i = 0; i < n_esr; i++)
CGU.clk_esr[first_esr + i] = 0;
for (i = 0; i < n_div; i++)
CGU.base_fdc[first_div + i] = 0;
}
static void cgu_configure_div(int div, int n, int m)
{
int msub, madd, div_size, max_n;
unsigned long cfg;
if (n == m)
{
CGU.base_fdc[div] = CGU.base_fdc[div] & ~1;
return;
}
msub = -n;
madd = m - n;
div_size = (div == PNX0101_HIPREC_FDC) ? 10 : 8;
max_n = 1 << div_size;
while ((madd << 1) < max_n && (msub << 1) >= -max_n)
{
madd <<= 1;
msub <<= 1;
}
cfg = (((msub << div_size) | madd) << 3) | 4;
CGU.base_fdc[div] = CGU.base_fdc[div] & ~1;
CGU.base_fdc[div] = cfg | 2;
CGU.base_fdc[div] = cfg;
CGU.base_fdc[div] = cfg | 1;
}
static void cgu_connect_div_to_clock(int rel_div, int esr)
{
CGU.clk_esr[esr] = (rel_div << 1) | 1;
}
static void cgu_enable_clock(int clock)
{
CGU.clk_pcr[clock] |= 1;
}
static void cgu_start_sel_stage_dividers(int bcr)
{
CGU.base_bcr[bcr] = 1;
}
/* Convert a pointer that points to IRAM (0x4xxxx) to a pointer that
points to the uncached page (0x0xxxx) that is also mapped to IRAM. */
static inline void *noncached(void *p)
{
return (void *)(((unsigned long)p) & 0xffff);
}
/* To avoid SRAM accesses while changing memory controller settings we
run this routine from uncached copy of IRAM. All times are in CPU
cycles. At CPU frequencies lower than 60 MHz we could use faster
settings, but since DMA may access SRAM at any time, changing
memory timings together with CPU frequency would be tricky. */
static void do_set_mem_timings(void) ICODE_ATTR;
static void do_set_mem_timings(void)
{
int old_irq = disable_irq_save();
while ((EMC.status & 3) != 0);
EMC.control = 5;
EMCSTATIC0.waitrd = 6;
EMCSTATIC0.waitwr = 5;
EMCSTATIC1.waitrd = 5;
EMCSTATIC1.waitwr = 4; /* OF uses 5 here */
EMCSTATIC2.waitrd = 4;
EMCSTATIC2.waitwr = 3;
EMCSTATIC0.waitoen = 1;
EMCSTATIC1.waitoen = 1;
EMCSTATIC2.waitoen = 1;
/* Enable write buffers for SRAM. */
#ifndef DEBUG
EMCSTATIC1.config = 0x80081;
#endif
EMC.control = 1;
restore_irq(old_irq);
}
static void emc_set_mem_timings(void)
{
void (*f)(void) = noncached(do_set_mem_timings);
(*f)();
}
static void cgu_set_sys_mult(int i)
{
cgu_set_sel_stage_input(PNX0101_SEL_STAGE_SYS, PNX0101_MAIN_CLOCK_FAST);
cgu_set_sel_stage_input(PNX0101_SEL_STAGE_APB3, PNX0101_MAIN_CLOCK_FAST);
PLL.lppdn = 1;
PLL.lpfin = 1;
PLL.lpmbyp = 0;
PLL.lpdbyp = 0;
PLL.lppsel = 1;
PLL.lpmsel = i - 1;
PLL.lppdn = 0;
while (!PLL.lplock);
cgu_configure_div(PNX0101_FIRST_DIV_SYS + 1, 1, (i == 5) ? 15 : 12);
cgu_connect_div_to_clock(1, 0x11);
cgu_enable_clock(0x11);
cgu_start_sel_stage_dividers(PNX0101_BCR_SYS);
cgu_set_sel_stage_input(PNX0101_SEL_STAGE_SYS,
PNX0101_MAIN_CLOCK_MAIN_PLL);
cgu_set_sel_stage_input(PNX0101_SEL_STAGE_APB3,
PNX0101_MAIN_CLOCK_MAIN_PLL);
}
static void pnx0101_set_performance_mode(int mode)
{
int old = performance_mode;
if (perf_modes[old].sys_mult != perf_modes[mode].sys_mult)
cgu_set_sys_mult(perf_modes[mode].sys_mult);
if (perf_modes[old].sys_div != perf_modes[mode].sys_div)
cgu_configure_div(bus_divider, 1, perf_modes[mode].sys_div);
performance_mode = mode;
}
static void pnx0101_init_clocks(void)
{
bus_divider = PNX0101_FIRST_DIV_SYS + (CGU.clk_esr[0] >> 1);
performance_mode = 0;
emc_set_mem_timings();
pnx0101_set_performance_mode(2);
cgu_set_sel_stage_input(PNX0101_SEL_STAGE_APB1,
PNX0101_MAIN_CLOCK_FAST);
cgu_reset_sel_stage_clocks(PNX0101_FIRST_ESR_APB1, PNX0101_N_ESR_APB1,
PNX0101_FIRST_DIV_APB1, PNX0101_N_DIV_APB1);
cgu_configure_div(PNX0101_FIRST_DIV_APB1, 1, 4);
cgu_connect_div_to_clock(0, PNX0101_ESR_APB1);
cgu_connect_div_to_clock(0, PNX0101_ESR_T0);
cgu_connect_div_to_clock(0, PNX0101_ESR_T1);
cgu_connect_div_to_clock(0, PNX0101_ESR_I2C);
cgu_enable_clock(PNX0101_CLOCK_APB1);
cgu_enable_clock(PNX0101_CLOCK_T0);
cgu_enable_clock(PNX0101_CLOCK_T1);
cgu_enable_clock(PNX0101_CLOCK_I2C);
}
#ifdef HAVE_ADJUSTABLE_CPU_FREQ
void set_cpu_frequency(long frequency)
{
switch (frequency)
{
case CPUFREQ_MAX:
pnx0101_set_performance_mode(2);
cpu_frequency = CPUFREQ_MAX;
break;
case CPUFREQ_NORMAL:
pnx0101_set_performance_mode(1);
cpu_frequency = CPUFREQ_NORMAL;
break;
case CPUFREQ_DEFAULT:
default:
pnx0101_set_performance_mode(0);
cpu_frequency = CPUFREQ_DEFAULT;
break;
}
}
#endif
interrupt_handler_t interrupt_vector[0x1d] __attribute__ ((section(".idata")));
#define IRQ_READ(reg, dest) \
do { unsigned long v2; \
do { \
dest = (reg); \
v2 = (reg); \
} while ((dest != v2)); \
} while (0);
#define IRQ_WRITE_WAIT(reg, val, cond) \
do { unsigned long v, v2; \
do { \
(reg) = (val); \
v = (reg); \
v2 = (reg); \
} while ((v != v2) || !(cond)); \
} while (0);
static void undefined_int(void)
{
}
void irq(void)
{
unsigned long n;
IRQ_READ(INTVECTOR[0], n)
(*(interrupt_vector[n >> 3]))();
}
void fiq(void)
{
}
void irq_enable_int(int n)
{
IRQ_WRITE_WAIT(INTREQ[n], INTREQ_WEENABLE | INTREQ_ENABLE, v & 0x10000);
}
void irq_disable_int(int n)
{
IRQ_WRITE_WAIT(INTREQ[n], INTREQ_WEENABLE, (v & 0x10000) == 0);
}
void irq_set_int_handler(int n, interrupt_handler_t handler)
{
interrupt_vector[n] = handler;
}
void system_init(void)
{
int i;
/* turn off watchdog */
(*(volatile unsigned long *)0x80002804) = 0;
/*
IRQ_WRITE_WAIT(INTVECTOR[0], 0, v == 0);
IRQ_WRITE_WAIT(INTVECTOR[1], 0, v == 0);
IRQ_WRITE_WAIT(INTPRIOMASK[0], 0, v == 0);
IRQ_WRITE_WAIT(INTPRIOMASK[1], 0, v == 0);
*/
for (i = 1; i <= 0x1c; i++)
{
IRQ_WRITE_WAIT(INTREQ[i],
INTREQ_WEPRIO | INTREQ_WETARGET |
INTREQ_WEENABLE | INTREQ_WEACTVLO | 1,
(v & 0x3010f) == 1);
IRQ_WRITE_WAIT(INTREQ[i], INTREQ_WEENABLE, (v & 0x10000) == 0);
IRQ_WRITE_WAIT(INTREQ[i], INTREQ_WEPRIO | 1, (v & 0xf) == 1);
interrupt_vector[i] = undefined_int;
}
interrupt_vector[0] = undefined_int;
pnx0101_init_clocks();
}
void system_reboot(void)
{
(*(volatile unsigned long *)0x80002804) = 1;
while (1);
}
void system_exception_wait(void)
{
while (1);
}
int system_memory_guard(int newmode)
{
(void)newmode;
return 0;
}

81
firmware/target/arm/pnx0101/timer-pnx0101.c
View file

@ -1,81 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 Tomasz Malesinski
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "system.h"
#include "timer.h"
static long cycles_new = 0;
void TIMER1_ISR(void)
{
if (cycles_new > 0)
{
TIMER1.load = cycles_new - 1;
cycles_new = 0;
}
if (pfn_timer != NULL)
{
cycles_new = -1;
/* "lock" the variable, in case timer_set_period()
* is called within pfn_timer() */
pfn_timer();
cycles_new = 0;
}
TIMER1.clr = 1; /* clear the interrupt */
}
bool timer_set(long cycles, bool start)
{
if (start)
{
if (pfn_unregister != NULL)
{
pfn_unregister();
pfn_unregister = NULL;
}
TIMER1.ctrl &= ~0x80; /* disable the counter */
TIMER1.ctrl |= 0x40; /* reload after counting down to zero */
TIMER1.ctrl &= ~0xc; /* no prescaler */
TIMER1.clr = 1; /* clear an interrupt event */
}
if (start || (cycles_new == -1)) /* within isr, cycles_new is "locked" */
{ /* enable timer */
TIMER1.load = cycles - 1;
TIMER1.ctrl |= 0x80; /* enable the counter */
}
else
cycles_new = cycles;
return true;
}
bool timer_start(void)
{
irq_set_int_handler(IRQ_TIMER1, TIMER1_ISR);
irq_enable_int(IRQ_TIMER1);
return true;
}
void timer_stop(void)
{
TIMER1.ctrl &= ~0x80; /* disable timer 1 */
irq_disable_int(IRQ_TIMER1);
}

7
firmware/target/hosted/sdl/sim-ui-defines.h
View file

@ -203,13 +203,6 @@
#define UI_LCD_POSX 42 /* x position of lcd */
#define UI_LCD_POSY 35 /* y position of lcd */
#elif defined(IRIVER_IFP7XX)
#define UI_TITLE "iriver iFP7xx"
#define UI_WIDTH 425 /* width of GUI window */
#define UI_HEIGHT 183 /* height of GUI window */
#define UI_LCD_POSX 115 /* x position of lcd */
#define UI_LCD_POSY 54 /* y position of lcd */
#elif defined(MROBE_100)
#define UI_TITLE "Olympus M:Robe 100"
#define UI_WIDTH 247 /* width of GUI window */