static int __devinit galaxy_init(struct snd_galaxy *galaxy, u8 *type)
{
u8 major;
u8 minor;
int err;
err = dsp_reset(galaxy->port);
if (err < 0)
return err;
err = dsp_get_version(galaxy->port, &major, &minor);
if (err < 0)
return err;
if (major != GALAXY_DSP_MAJOR || minor != GALAXY_DSP_MINOR)
return -ENODEV;
err = dsp_command(galaxy->port, DSP_COMMAND_GALAXY_8);
if (err < 0)
return err;
err = dsp_command(galaxy->port, GALAXY_COMMAND_GET_TYPE);
if (err < 0)
return err;
err = dsp_get_byte(galaxy->port, type);
if (err < 0)
return err;
return 0;
}
int YARPMEIDeviceDriver::open(void *d)
{
// temporarily removed
int16 rc = 0;
MEIOpenParameters *p = (MEIOpenParameters *)d;
_njoints = p->nj;
rc = dsp_init(p->meiPortAddr); // init
rc = dsp_reset(); // reset
_ref_speeds = new double [_njoints];
ACE_ASSERT (_ref_speeds != NULL);
_ref_accs = new double [_njoints];
ACE_ASSERT (_ref_accs != NULL);
_ref_positions = new double [_njoints];
ACE_ASSERT (_ref_positions != NULL);
_all_axes = new int16[_njoints];
ACE_ASSERT (_all_axes != NULL);
int i;
for(i = 0; i < _njoints; i++)
_all_axes[i] = i;
_filter_coeffs = new int16* [_njoints];
ACE_ASSERT (_filter_coeffs != NULL);
for(i = 0; i < _njoints; i++)
{
_filter_coeffs[i] = new int16 [COEFFICIENTS];
ACE_ASSERT (_filter_coeffs[i] != NULL);
}
_dsp_rate = dsp_sample_rate();
_winding = new int16[_njoints];
ACE_ASSERT (_winding != NULL);
memset (_winding, 0, sizeof(int16) * _njoints);
_16bit_oldpos = new double[_njoints];
ACE_ASSERT (_16bit_oldpos != NULL);
memset (_16bit_oldpos, 0, sizeof(double) * _njoints);
_position_zero = new double[_njoints];
ACE_ASSERT (_position_zero != NULL);
memset (_position_zero, 0, sizeof(double) * _njoints);
int mask = p->ioPorts;
for (i = 0; i < MAX_PORTS; i++)
{
if (mask & 0x1)
init_io (i, IO_OUTPUT);
else
init_io (i, IO_INPUT);
mask >>= 1;
}
return rc;
}
void pcm_play_dma_init(void)
{
IO_INTC_IRQ0 = 1 << 11;
IO_INTC_EINT0 |= 1 << 11;
IO_DSPC_HPIB_CONTROL = 1 << 10 | 1 << 9 | 1 << 8 | 1 << 7 | 1 << 3 | 1 << 0;
dsp_reset();
dsp_load(dsp_image);
dsp_wake();
}
static struct file *dsp_alloc()
{
struct dsp_file *f = (struct dsp_file *)kmalloc(sizeof(struct dsp_file));
file_init(&f->custom_file.base_file, &dsp_ops, O_LARGEFILE | O_RDWR);
virtualfs_init_custom(f, &dsp_desc);
f->waveout = NULL;
SECURITY_ATTRIBUTES attr;
attr.nLength = sizeof(SECURITY_ATTRIBUTES);
attr.bInheritHandle = FALSE;
attr.lpSecurityDescriptor = NULL;
for (int i = 0; i < DSP_BUFFER_COUNT; i++)
f->buffer[i].event = CreateEventW(&attr, FALSE, TRUE, NULL);
dsp_reset(f);
return (struct file *)f;
}
static int dsp_close(struct file *f)
{
struct dsp_file *dsp = (struct dsp_file *)f;
/* Send remaining buffer */
if (dsp->buffer[dsp->current_buffer].buffer_pos < dsp->buffer_size)
{
dsp->buffer[dsp->current_buffer].hdr.dwBufferLength = dsp->buffer[dsp->current_buffer].buffer_pos;
dsp_send_buffer(dsp->waveout, &dsp->buffer[dsp->current_buffer]);
/* Wait for playback */
WaitForSingleObject(dsp->buffer[dsp->current_buffer].event, INFINITE);
}
dsp_reset(dsp);
kfree(dsp, sizeof(struct dsp_file));
return 0;
}
static int __devinit galaxy_set_mode(struct snd_galaxy *galaxy, u8 mode)
{
int err;
err = dsp_command(galaxy->port, DSP_COMMAND_GALAXY_9);
if (err < 0)
return err;
err = dsp_command(galaxy->port, mode);
if (err < 0)
return err;
#ifdef AZT1605
err = dsp_reset(galaxy->port);
if (err < 0)
return err;
#endif
return 0;
}
void pcm_play_dma_init(void)
{
IO_INTC_IRQ0 = INTR_IRQ0_IMGBUF;
bitset16(&IO_INTC_EINT0, INTR_EINT0_IMGBUF);
/* Set this as a FIQ */
bitset16(&IO_INTC_FISEL0, INTR_EINT0_IMGBUF);
/* Enable the HPIB clock */
bitset16(&IO_CLK_MOD0, (CLK_MOD0_HPIB | CLK_MOD0_DSP));
IO_SDRAM_SDDMASEL = 0x24;
IO_DSPC_HPIB_CONTROL = 1 << 10 | 1 << 9 | 1 << 8 | 1 << 7 | 1 << 3 | 1 << 0;
dsp_reset();
dsp_load(dsp_image);
DSP_(_dma0_stopped)=1;
dsp_wake();
}
int dsp_open(struct inode *inode, struct file *file)
{
if (dsp_iopage) return 0;
/* if (GPLR & GPIO_GPIO(1)) { OLD */
if (GPLR(0) & GPIO_bit(1)) {
printk("btweb: no DSP device found, continuing anyways\n");
return -ENODEV;
}
dsp_iopage = (unsigned short *)ioremap(0x20000000, PAGE_SIZE);
if (!dsp_iopage) {
printk("btweb: ioremap failed\n");
return -ENODEV;
}
/* first open, force a reset */
dsp_reset(inode, file, 0, 0);
return 0;
}
static int __devinit galaxy_set_mode(struct snd_galaxy *galaxy, u8 mode)
{
int err;
err = dsp_command(galaxy->port, DSP_COMMAND_GALAXY_9);
if (err < 0)
return err;
err = dsp_command(galaxy->port, mode);
if (err < 0)
return err;
#ifdef AZT1605
/*
* Needed for MPU IRQ on AZT1605, but AZT2316 loses WSS again
*/
err = dsp_reset(galaxy->port);
if (err < 0)
return err;
#endif
return 0;
}
int main(void)
{
int vmode = -1;
exception_init();
dsp_reset();
irq_initialize();
irq_bw_enable(BW_PI_IRQ_RESET);
irq_bw_enable(BW_PI_IRQ_HW); //hollywood pic
/* external ohci */
irq_hw_enable(IRQ_OHCI0);
/* internal ohci */
//irq_hw_enable(IRQ_OHCI1);
ipc_initialize();
ipc_slowping();
gecko_init();
input_init();
init_fb(vmode);
VIDEO_Init(vmode);
VIDEO_SetFrameBuffer(get_xfb());
VISetupEncoder();
u32 version = ipc_getvers();
u16 mini_version_major = version >> 16 & 0xFFFF;
u16 mini_version_minor = version & 0xFFFF;
printf("Mini version: %d.%0d\n", mini_version_major, mini_version_minor);
if (version < MINIMUM_MINI_VERSION) {
printf("Sorry, this version of MINI (armboot.bin)\n"
"is too old, please update to at least %d.%0d.\n",
(MINIMUM_MINI_VERSION >> 16), (MINIMUM_MINI_VERSION & 0xFFFF));
for (;;)
; // better ideas welcome!
}
int main(void)
{
// slot LED
write32(0xcd8000c0, 0x20);
dsp_reset();
exception_init();
// Install trampoline at 80001800; some payloads like to jump
// there to restart. Sometimes this can even work.
//memcpy(trampoline_buffer, reboot_trampoline, sizeof(reboot_trampoline));
// Clear interrupt mask.
write32(0x0c003004, 0);
// Unlock EXI.
write32(0x0d00643c, 0);
video_init();
usbgecko_init();
printf("savezelda\n%s\n", version);
printf("\n");
printf("Copyright 2008,2009 Segher Boessenkool\n");
printf("Copyright 2008 Haxx Enterprises\n");
printf("Copyright 2008 Hector Martin (\"marcan\")\n");
printf("Copyright 2003,2004 Felix Domke\n");
printf("\n");
printf("This code is licensed to you under the terms of the\n");
printf("GNU GPL, version 2; see the file COPYING\n");
printf("\n");
printf("Font and graphics by Freddy Leitner\n");
printf("\n");
printf("\n");
printf("Cleaning up environment... ");
reset_ios();
printf("OK.\n");
int err;
restart:
err = try_sd_load();
if (err) {
err = try_usbgecko_load();
if (err) {
printf("No code found to load, hanging.\n");
for (;;)
;
}
}
if (valid_elf_image(code_buffer)) {
printf("Valid ELF image detected.\n");
void (*entry)() = load_elf_image(code_buffer);
entry();
printf("Program returned to loader, reloading.\n");
} else
printf("No valid ELF image detected, retrying.\n");
goto restart;
}
static int dsp_regwrite(unsigned short cmd_l, unsigned short adr,
unsigned short val)
{
struct mbcmd mb;
struct mb_exarg arg = {
.tid = OMAP_DSP_TID_ANON,
.argc = 1,
.argv = &val,
};
mbcmd_set(mb, MBCMD(REGRW), cmd_l, adr);
dsp_mbsend_exarg(&mb, &arg);
return 0;
}
static int dsp_getvar(unsigned char varid, unsigned short *val, int sz)
{
struct mbcmd mb;
int ret = 0;
if (down_interruptible(&ioctl_sem))
return -ERESTARTSYS;
ioctl_wait_cmd = MBCMD(GETVAR);
mbcmd_set(mb, MBCMD(GETVAR), varid, 0);
dsp_mbsend_and_wait(&mb, &ioctl_wait_q);
if (ioctl_wait_cmd != 0) {
printk(KERN_ERR "omapdsp: variable read error!\n");
ret = -EINVAL;
goto up_out;
}
memcpy(val, varread_val, sz * sizeof(short));
up_out:
up(&ioctl_sem);
return ret;
}
static int dsp_setvar(unsigned char varid, unsigned short val)
{
struct mbcmd mb;
mbcmd_set(mb, MBCMD(SETVAR), varid, val);
dsp_mbsend(&mb);
return 0;
}
static int dspcfg(void)
{
struct mbcmd mb;
int ret = 0;
if (down_interruptible(&ioctl_sem))
return -ERESTARTSYS;
if (cfgstat != CFG_ERR) {
printk(KERN_ERR
"omapdsp: DSP has been already configured. "
"do unconfig!\n");
ret = -EBUSY;
goto up_out;
}
dsp_mb_start();
dsp_twch_start();
dsp_mem_start();
dsp_err_start();
mbx_revision = -1;
ioctl_wait_cmd = MBCMD(DSPCFG);
mbcmd_set(mb, MBCMD(DSPCFG), OMAP_DSP_MBCMD_DSPCFG_REQ, 0);
dsp_mbsend_and_wait(&mb, &ioctl_wait_q);
if (ioctl_wait_cmd != 0) {
printk(KERN_ERR "omapdsp: configuration error!\n");
ret = -EINVAL;
cfgstat = CFG_ERR;
goto up_out;
}
if ((ret = dsp_task_config_all(n_stask)) < 0) {
up(&ioctl_sem);
dspuncfg();
return -EINVAL;
}
cfgstat = CFG_READY;
/* send parameter */
if ((ret = dsp_setvar(OMAP_DSP_MBCMD_VARID_ICRMASK, dsp_icrmask)) < 0)
goto up_out;
#ifdef CONFIG_PROC_FS
dsp_create_runtime_procs();
#endif
up_out:
up(&ioctl_sem);
return ret;
}
int dspuncfg(void)
{
if (dsp_taskmod_busy()) {
printk(KERN_WARNING "omapdsp: tasks are busy.\n");
return -EBUSY;
}
if (down_interruptible(&ioctl_sem))
return -ERESTARTSYS;
/* FIXME: lock task module */
#ifdef CONFIG_PROC_FS
dsp_remove_runtime_procs();
#endif
dsp_mb_stop();
dsp_twch_stop();
dsp_err_stop();
dsp_task_unconfig_all();
ipbuf_stop();
cfgstat = CFG_ERR;
up(&ioctl_sem);
return 0;
}
int dsp_is_ready(void)
{
return (cfgstat == CFG_READY) ? 1 : 0;
}
void dsp_runlevel(unsigned char level)
{
struct mbcmd mb;
mbcmd_set(mb, MBCMD(RUNLEVEL), level, 0);
if (level == OMAP_DSP_MBCMD_RUNLEVEL_RECOVERY)
dsp_mbsend_recovery(&mb);
else
dsp_mbsend(&mb);
}
int dsp_suspend(void)
{
struct mbcmd mb;
int ret = 0;
if (down_interruptible(&ioctl_sem))
return -ERESTARTSYS;
if (!dsp_is_ready()) {
printk(KERN_WARNING
"omapdsp: DSP is not ready. suspend failed.\n");
ret = -EINVAL;
goto up_out;
}
ioctl_wait_cmd = MBCMD(SUSPEND);
mbcmd_set(mb, MBCMD(SUSPEND), 0, 0);
dsp_mbsend_and_wait(&mb, &ioctl_wait_q);
if (ioctl_wait_cmd != 0) {
printk(KERN_ERR "omapdsp: DSP suspend error!\n");
ret = -EINVAL;
goto up_out;
}
udelay(100);
dsp_reset();
cfgstat = CFG_SUSPEND;
up_out:
up(&ioctl_sem);
return ret;
}
int dsp_resume(void)
{
if (cfgstat != CFG_SUSPEND)
return 0;
cfgstat = CFG_READY;
dsp_run();
return 0;
}
/*
* DSP control device file operations
*/
static int dsp_ctl_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
/*
* command level 1: commands which don't need lock
*/
case OMAP_DSP_IOCTL_RUN:
dsp_run();
break;
case OMAP_DSP_IOCTL_RESET:
dsp_reset();
break;
case OMAP_DSP_IOCTL_SETRSTVECT:
ret = dsp_set_rstvect((unsigned long)arg);
break;
case OMAP_DSP_IOCTL_IDLE:
dsp_idle();
break;
case OMAP_DSP_IOCTL_MPUI_WORDSWAP_ON:
mpui_wordswap_on();
break;
case OMAP_DSP_IOCTL_MPUI_WORDSWAP_OFF:
mpui_wordswap_off();
break;
case OMAP_DSP_IOCTL_MPUI_BYTESWAP_ON:
mpui_byteswap_on();
break;
case OMAP_DSP_IOCTL_MPUI_BYTESWAP_OFF:
mpui_byteswap_off();
break;
case OMAP_DSP_IOCTL_MBSEND:
{
struct omap_dsp_mailbox_cmd u_cmd;
struct mbcmd_hw mb;
if (copy_from_user(&u_cmd, (void *)arg, sizeof(u_cmd)))
return -EFAULT;
mb.cmd = u_cmd.cmd;
mb.data = u_cmd.data;
ret = dsp_mbsend((struct mbcmd *)&mb);
break;
}
case OMAP_DSP_IOCTL_SETVAR:
{
struct omap_dsp_varinfo var;
if (copy_from_user(&var, (void *)arg, sizeof(var)))
return -EFAULT;
ret = dsp_setvar(var.varid, var.val[0]);
break;
}
case OMAP_DSP_IOCTL_RUNLEVEL:
dsp_runlevel(arg);
break;
/*
* command level 2: commands which need lock
*/
case OMAP_DSP_IOCTL_DSPCFG:
ret = dspcfg();
break;
case OMAP_DSP_IOCTL_DSPUNCFG:
ret = dspuncfg();
break;
case OMAP_DSP_IOCTL_TASKCNT:
ret = dsp_task_count();
break;
case OMAP_DSP_IOCTL_SUSPEND:
ret = dsp_suspend();
break;
case OMAP_DSP_IOCTL_RESUME:
ret = dsp_resume();
break;
case OMAP_DSP_IOCTL_REGMEMR:
{
struct omap_dsp_reginfo *u_reg = (void *)arg;
unsigned short adr, val;
if (copy_from_user(&adr, &u_reg->adr, sizeof(short)))
return -EFAULT;
if ((ret = dsp_regread(OMAP_DSP_MBCMD_REGRW_MEMR,
adr, &val)) < 0)
return ret;
if (copy_to_user(&u_reg->val, &val, sizeof(short)))
return -EFAULT;
break;
}
case OMAP_DSP_IOCTL_REGMEMW:
{
struct omap_dsp_reginfo reg;
if (copy_from_user(®, (void *)arg, sizeof(reg)))
return -EFAULT;
ret = dsp_regwrite(OMAP_DSP_MBCMD_REGRW_MEMW,
reg.adr, reg.val);
break;
}
case OMAP_DSP_IOCTL_REGIOR:
{
struct omap_dsp_reginfo *u_reg = (void *)arg;
unsigned short adr, val;
if (copy_from_user(&adr, &u_reg->adr, sizeof(short)))
return -EFAULT;
if ((ret = dsp_regread(OMAP_DSP_MBCMD_REGRW_IOR,
adr, &val)) < 0)
return ret;
if (copy_to_user(&u_reg->val, &val, sizeof(short)))
return -EFAULT;
break;
}
case OMAP_DSP_IOCTL_REGIOW:
{
struct omap_dsp_reginfo reg;
if (copy_from_user(®, (void *)arg, sizeof(reg)))
return -EFAULT;
ret = dsp_regwrite(OMAP_DSP_MBCMD_REGRW_IOW,
reg.adr, reg.val);
break;
}
case OMAP_DSP_IOCTL_GETVAR:
{
struct omap_dsp_varinfo *u_var = (void *)arg;
unsigned char varid;
unsigned short val[5]; /* maximum */
int argc;
if (copy_from_user(&varid, &u_var->varid, sizeof(char)))
return -EFAULT;
switch (varid) {
case OMAP_DSP_MBCMD_VARID_ICRMASK:
argc = 1;
break;
case OMAP_DSP_MBCMD_VARID_LOADINFO:
argc = 5;
break;
default:
return -EINVAL;
}
if ((ret = dsp_getvar(varid, val, argc)) < 0)
return ret;
if (copy_to_user(&u_var->val, val, sizeof(short) * argc))
return -EFAULT;
break;
}
default:
return -ENOIOCTLCMD;
}
return ret;
}
static int dsp_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{
AcquireSRWLockExclusive(&f->rw_lock);
int r = 0;
struct dsp_file *dsp = (struct dsp_file *)f;
switch (cmd)
{
case SNDCTL_DSP_RESET:
{
log_info("SNDCTL_DSP_RESET.");
dsp_reset(dsp);
break;
}
case SNDCTL_DSP_SPEED:
{
if (!mm_check_read((int *)arg, sizeof(int)))
{
r = -L_EFAULT;
break;
}
int speed = *(int *)arg;
log_info("SNDCTL_DSP_SPEED: %d", speed);
DWORD old_speed = dsp->format.nSamplesPerSec;
dsp->format.nSamplesPerSec = speed;
if (!dsp_test_format(&dsp->format))
{
log_warning("Speed not supported.");
dsp->format.nSamplesPerSec = old_speed;
r = -L_EINVAL;
}
break;
}
case SNDCTL_DSP_STEREO:
{
if (!mm_check_read((int *)arg, sizeof(int)))
{
r = -L_EFAULT;
break;
}
int c = *(int *)arg;
log_info("SNDCTL_DSP_STEREO: %d", c);
if (c == 0)
dsp->format.nChannels = 1;
else if (c == 1)
dsp->format.nChannels = 2;
else
{
log_warning("Invalid argument (can only be 0 or 1).");
r = -L_EINVAL;
}
break;
}
case SNDCTL_DSP_SETFMT:
{
if (!mm_check_read((int *)arg, sizeof(int)))
{
r = -L_EFAULT;
break;
}
int fmt = *(int *)arg;
log_info("SNDCTL_DSP_SETFMT: 0x%x", fmt);
if (fmt == AFMT_S16_LE)
dsp->format.wBitsPerSample = 16;
else if (fmt == AFMT_U8)
dsp->format.wBitsPerSample = 8;
else
{
log_warning("Invalid argument (can only be AFMT_S16_LE or AFMT_U8).");
r = -L_EINVAL;
}
break;
}
case SNDCTL_DSP_GETFMTS:
{
if (!mm_check_write((int *)arg, sizeof(int)))
{
r = -L_EFAULT;
break;
}
log_info("SNDCTL_DSP_GETFMTS");
*(int *)arg = AFMT_U8 | AFMT_S16_LE;
break;
}
}
ReleaseSRWLockExclusive(&f->rw_lock);
return r;
}
