void
nuse_vif_pipe_delete(struct nuse_vif *vif)
{
int sock = vif->sock;
free(vif);
host_close(sock);
}
static void set_control(struct sscape_info *devc, int ctrl, int value)
{
host_open(devc);
host_command3(devc, CMD_SET_CONTROL, ctrl, value);
if (host_read(devc) != CMD_ACK)
{
/* printk( "SNDSCAPE: Setting control (%d) failed\n", ctrl); */
}
host_close(devc);
}
static void set_mt32(struct sscape_info *devc, int value)
{
host_open(devc);
host_command2(devc, CMD_SET_MT32, value ? 1 : 0);
if (host_read(devc) != CMD_ACK)
{
/* printk( "SNDSCAPE: Setting MT32 mode failed\n"); */
}
host_close(devc);
}
//Copy file operation
int copy_file() {
int in_fd;
FILE* out_fd;
int fsize = 0;
char file_name[MAX_BUFFER_SIZE];
/* Get the file name to copy to
* This will activate our hook on the invalid opcode in the python script.
*/
host_get_file_name(agent_buffer, sizeof(agent_buffer));
strncpy(file_name,agent_buffer,sizeof(file_name));
/* Open file on the host. */
if ((in_fd = host_open(file_name)) == -1){
fprintf(stderr, "Error opening file on host\n");
return 2;
}
/* Read file from the host and output it on stdout. */
if ((out_fd = fopen(file_name, "wb")) == NULL){
fprintf(stderr, "Error opening file %s on guest for writing\n", file_name);
return 3;
}
/* Data read loop */
while (1) {
int ret = host_read(in_fd, agent_buffer, sizeof(agent_buffer));
if (ret == -1) {
fprintf(stderr, "Error reading from host file\n");
return 4;
}
else if (ret == 0) {
break;
}
if (fwrite(agent_buffer, 1, ret, out_fd) != ret) {
fprintf(stderr, "Error writing to file on guest\n");
return 5;
}
fsize += ret;
}
/* Don't forget to close the file on the host. */
host_close(in_fd);
fclose(out_fd);
fprintf(stderr, "File %s of size %d was successfully transferred\n", file_name, fsize);
return 0;
}
void
nuse_vif_pipe_read(struct nuse_vif *vif, struct SimDevice *dev)
{
int sock = vif->sock;
char buf[8192];
ssize_t size;
while (1) {
size = host_read(sock, buf, sizeof(buf));
if (size < 0) {
perror("read");
host_close(sock);
return;
} else if (size == 0) {
host_close(sock);
return;
}
nuse_dev_rx(dev, buf, size);
}
}
static int
get_board_type (struct sscape_info *devc)
{
int tmp;
host_open (devc);
if (!host_command1 (devc, CMD_GET_BOARD_TYPE))
tmp = -1;
else
tmp = host_read (devc);
host_close (devc);
return tmp;
}
static void __init sscape_pnp_init_hw(sscape_info* devc)
{
unsigned char midi_irq = 0, sb_irq = 0;
unsigned i;
static char code_file_name[23] = "/sndscape/sndscape.cox";
int sscape_sb_enable = 0;
int sscape_joystic_enable = 0x7f;
int sscape_mic_enable = 0;
int sscape_ext_midi = 0;
if ( !sscape_pnp_alloc_dma(devc) ) {
printk(KERN_ERR "sscape: faild to allocate dma\n");
return;
}
for (i = 0; i < 4; i++) {
if ( devc -> irq == valid_interrupts[i] )
midi_irq = i;
if ( devc -> codec_irq == valid_interrupts[i] )
sb_irq = i;
}
sscape_write( devc, 5, 0x50);
sscape_write( devc, 7, 0x2e);
sscape_write( devc, 8, 0x00);
sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
sscape_write( devc, 3, ( devc -> dma << 4) | 0x80);
if ( sscape_sb_enable )
sscape_write (devc, 4, 0xF0 | (sb_irq << 2) | midi_irq);
else
sscape_write (devc, 4, 0xF0 | (midi_irq<<2) | midi_irq);
i = 0x10; //sscape_read(devc, 9) & (devc->ic_type == IC_ODIE ? 0xf0 : 0xc0);
if ( sscape_sb_enable )
i |= devc->ic_type == IC_ODIE ? 0x05 : 0x07;
if (sscape_joystic_enable) i |= 8;
sscape_write (devc, 9, i);
sscape_write (devc, 6, 0x80);
sscape_write (devc, 1, 0x80);
if (devc -> codec_type == 2) {
sscape_pnp_write_codec( devc, 0x0C, 0x50);
sscape_pnp_write_codec( devc, 0x10, sscape_pnp_read_codec( devc, 0x10) & 0x3F);
sscape_pnp_write_codec( devc, 0x11, sscape_pnp_read_codec( devc, 0x11) | 0xC0);
sscape_pnp_write_codec( devc, 29, 0x20);
}
if (sscape_pnp_upload_file(devc, "/sndscape/scope.cod") == 0 ) {
printk(KERN_ERR "sscape: faild to upload file /sndscape/scope.cod\n");
sscape_pnp_free_dma(devc);
return;
}
i = sscape_read_host_ctrl( devc );
if ( (i & 0x0F) > 7 ) {
printk(KERN_ERR "sscape: scope.cod faild\n");
sscape_pnp_free_dma(devc);
return;
}
if ( i & 0x10 ) sscape_write( devc, 7, 0x2F);
code_file_name[21] = (char) ( i & 0x0F) + 0x30;
if (sscape_pnp_upload_file( devc, code_file_name) == 0) {
printk(KERN_ERR "sscape: faild to upload file %s\n", code_file_name);
sscape_pnp_free_dma(devc);
return;
}
if (devc->ic_type != IC_ODIE) {
sscape_pnp_write_codec( devc, 10, (sscape_pnp_read_codec(devc, 10) & 0x7f) |
( sscape_mic_enable == 0 ? 0x00 : 0x80) );
}
sscape_write_host_ctrl2( devc, 0x84, 0x64 ); /* MIDI volume */
sscape_write_host_ctrl2( devc, 0x86, 0x64 ); /* MIDI volume?? */
sscape_write_host_ctrl2( devc, 0x8A, sscape_ext_midi);
sscape_pnp_write_codec ( devc, 6, 0x3f ); //WAV_VOL
sscape_pnp_write_codec ( devc, 7, 0x3f ); //WAV_VOL
sscape_pnp_write_codec ( devc, 2, 0x1F ); //WD_CDXVOLL
sscape_pnp_write_codec ( devc, 3, 0x1F ); //WD_CDXVOLR
if (devc -> codec_type == 1) {
sscape_pnp_write_codec ( devc, 4, 0x1F );
sscape_pnp_write_codec ( devc, 5, 0x1F );
sscape_write_host_ctrl2( devc, 0x88, sscape_mic_enable);
} else {
int t;
sscape_pnp_write_codec ( devc, 0x10, 0x1F << 1);
sscape_pnp_write_codec ( devc, 0x11, 0xC0 | (0x1F << 1));
t = sscape_pnp_read_codec( devc, 0x00) & 0xDF;
if ( (sscape_mic_enable == 0)) t |= 0;
else t |= 0x20;
sscape_pnp_write_codec ( devc, 0x00, t);
t = sscape_pnp_read_codec( devc, 0x01) & 0xDF;
if ( (sscape_mic_enable == 0) ) t |= 0;
else t |= 0x20;
sscape_pnp_write_codec ( devc, 0x01, t);
sscape_pnp_write_codec ( devc, 0x40 | 29 , 0x20);
outb(0, devc -> codec);
}
if (devc -> ic_type == IC_OPUS ) {
int i = sscape_read( devc, 9 );
sscape_write( devc, 9, i | 3 );
sscape_write( devc, 3, 0x40);
if (check_region(0x228, 1)) {
outb(0, 0x228);
release_region(0x228,1);
}
sscape_write( devc, 3, (devc -> dma << 4) | 0x80);
sscape_write( devc, 9, i );
}
host_close ( devc );
sscape_pnp_free_dma(devc);
}
