static int uni_player_stop(struct uniperif *player)
{
int ret;
/* The player should not be in stopped state */
if (player->state == UNIPERIF_STATE_STOPPED) {
dev_err(player->dev, "%s: invalid player state", __func__);
return -EINVAL;
}
/* Turn the player off */
SET_UNIPERIF_CTRL_OPERATION_OFF(player);
/* Soft reset the player */
SET_UNIPERIF_SOFT_RST_SOFT_RST(player);
ret = reset_player(player);
if (ret < 0)
return ret;
/* Disable interrupts */
SET_UNIPERIF_ITM_BCLR(player, GET_UNIPERIF_ITM(player));
/* Disable clock */
clk_disable_unprepare(player->clk);
/* Update state to stopped and return */
player->state = UNIPERIF_STATE_STOPPED;
return 0;
}
void enter_contest(struct player *j, Track *track)
{
reset_player(j->p_no);
track->t_flags |= PU_CONTEST;
if (track->t_pos < 0) get_dog_stats(j,track);
}
/*
Remove a playera from whatever arena currently in,
place them in the new arena.
Also heals, switches the player's team, and declares war.
*/
void go_arena(int ano, int pno, int position)
{
Arena *old_a = NULL;
Track *track;
struct player *j;
checkBadPlayerNo(pno,"in go_arena");
j = &players[pno];
smileon(j);
track = &tracks[j->p_no];
if (badArenaNo(track->t_arena))
{
ERROR(2,("Bad old arena number %d for %d. Resetting player\n",
old_a ? (int)(old_a->a_no) : -1, pno));
reset_player(pno);
return;
}
old_a = &arenas[(int) track->t_arena];
checkBadArenaNo(ano,"in teleport\n");
if (ano == 0)
{
j->p_team = ROM;
}
else
{
switch (ano % 3)
{
case 0:
j->p_team = FED;
break;
case 1:
j->p_team = KLI;
break;
default:
j->p_team = ORI;
break;
}
}
/* Rule 1) Love your enemies, hate your friends */
declare_selfhate(j);
do_teleport_arena(ano, j, position);
check_arena_free(old_a->a_no);
}
void reset_all_players(void)
{
register int i;
register struct player *j;
for (i = 0, j = &players[i];
i < MAXPLAYER; i++, j++) {
if ((j->p_status != PFREE) && !(j->p_flags & PFROBOT)) {
reset_player(j->p_no);
}
}
}
void join_game(Track *track)
{
/*If you are already sitting out, do nothing*/
track->t_flags = 0;
reset_player(track->t_no);
if (inprogress == 2)
track->t_flags |= PU_CONTEST;
if (track->t_pos < 0) get_dog_stats(&players[track->t_no],track);
/* reset preferred ship; not initialized elsewhere, funny things happened */
track->t_preferred = BATTLESHIP;
}
void reset_world(world* game_world) {
reset_player(game_world->width / 2, game_world->height / 2,
game_world->game_player);
game_world->num_walls = 0;
for (int i = 0; i < game_world->width; i++) {
add_wall(i, 0, game_world);
add_wall(i, game_world->height - 1, game_world);
}
for (int i = 0; i < game_world->height; i++) {
add_wall(0, i, game_world);
add_wall(game_world->width - 1, i, game_world);
}
random_inbounds_pos(game_world, game_world->pellet->pos);
}
/* ARGSUSED */
void do_sitout(char *comm, struct message *mess)
{
int who;
struct player *j;
Track *track;
who = mess->m_from;
j = &players[who];
track = &tracks[who];
/*If you are already sitting out, do nothing*/
if (track->t_flags & PU_NOTCONTEST)
{
messOne(255,roboname,who,"You are already sitting out");
return;
}
if (inprogress == 2)
{
#ifdef ALLOWQUIT
reset_player(who);
dont_score(who);
#else
messOne(255,roboname,who,"What, you chicken! Go fight!");
return;
#endif
}
messAll(255,roboname,"%s (%c) has decided to watch, what a twink.",
players[who].p_name, shipnos[who]);
do_teleport_home(who);
track->t_flags |= PU_SITOUT ;
j->p_speed = 0; /*So you don't move */
j->p_desspeed = 0;
j->p_subspeed = 0;
j->p_flags = PFSHIELD;
j->p_fuel = 0; /*Hah, you're hosed anyway */
j->p_damage = j->p_ship.s_maxdamage - 5;
j->p_shield = j->p_ship.s_maxshield; /*OK, a potential help */
}
int humanvspsp(Player *p1, Player *p2)
{
BITMAP* buffer_field_game = create_bitmap(MAX_WIDTH, MAX_HEIGTH);
BITMAP* buffer_border_and_info = create_bitmap(SCREEN_WIDTH, SCREEN_HEIGTH);
int koniec = -1;
reset_player(p1, 136, 230, 2);
reset_player(p2, 136, 245, 3);
clear_to_color(buffer_field_game, makecol(0, 0, 0));
rysuj_obramowanie(buffer_border_and_info, p1, p2);
blit(buffer_border_and_info, screen, 0, 0, 0, 0, buffer_border_and_info->w, buffer_border_and_info->h);
clear_keybuf();
odliczanie();
blit(buffer_border_and_info, screen, 0, 0, 0, 0, buffer_border_and_info->w, buffer_border_and_info->h);
clear_key();
blit(buffer_field_game, buffer_border_and_info, 0, 0, 1, 1, buffer_field_game->w, buffer_field_game->h);
blit(buffer_border_and_info, screen, 0, 0, 0, 0, buffer_border_and_info->w, buffer_border_and_info->h);
p1_speed = 0;
p2_speed = 0;
speed = 25;
install_int_ex(p1_speed_func, MSEC_TO_TIMER(speed));
install_int_ex(p2_speed_func, MSEC_TO_TIMER(speed));
install_int_ex(speed_func, SECS_TO_TIMER(1));
while(TRUE)
{
ai_run(p2, buffer_field_game);
if((p1->x == p2->x) && (p1->y == p2->y))
{
koniec = 0;
break;
}
switch(p1->direction)
{
case UP:
if(getpixel(buffer_field_game, p1->y, p1->x-1) != makecol(0, 0, 0))
{
koniec = 1;
}
break;
case DOWN:
if(getpixel(buffer_field_game, p1->y, p1->x+1) != makecol(0, 0, 0))
{
koniec = 1;
}
break;
case LEFT:
if(getpixel(buffer_field_game, p1->y-1, p1->x) != makecol(0, 0, 0))
{
koniec = 1;
}
break;
case RIGHT:
if(getpixel(buffer_field_game, p1->y+1, p1->x) != makecol(0, 0, 0))
{
koniec = 1;
}
break;
}
switch(p2->direction)
{
case UP:
if(getpixel(buffer_field_game, p2->y, p2->x-1) != makecol(0, 0, 0))
{
if(koniec == 1)
{
koniec = 0;
break;
}
else
{
koniec = 2;
}
}
break;
case DOWN:
if(getpixel(buffer_field_game, p2->y, p2->x+1) != makecol(0, 0, 0))
{
if(koniec == 1)
{
koniec = 0;
break;
}
else
{
koniec = 2;
}
}
break;
case LEFT:
if(getpixel(buffer_field_game, p2->y-1, p2->x) != makecol(0, 0, 0))
{
if(koniec == 1)
{
koniec = 0;
break;
}
else
{
koniec = 2;
}
}
break;
case RIGHT:
if(getpixel(buffer_field_game, p2->y+1, p2->x) != makecol(0, 0, 0))
{
if(koniec == 1)
{
koniec = 0;
break;
}
else
{
koniec = 2;
}
}
break;
}
putpixel(buffer_field_game, p1->y, p1->x, makecol(255, 255, 255));
putpixel(buffer_field_game, p2->y, p2->x, makecol(86, 160, 222));
if(p1->x < MIN_HEIGTH || p1->x > MAX_HEIGTH-1 || p1->y < MIN_WIDTH || p1->y > MAX_WIDTH-1)
{
koniec = 1;
}
if(p2->x < MIN_HEIGTH || p2->x > MAX_HEIGTH-1 || p2->y < MIN_WIDTH || p2->y > MAX_WIDTH-1)
{
if(koniec == 1)
{
koniec = 0;
break;
}
else
{
koniec = 2;
}
}
blit(buffer_field_game, screen, 0, 0, 1, 1, buffer_field_game->w, buffer_field_game->h);
if(koniec != -1)
break;
if(key[KEY_ESC])
break;
if(key[KEY_ENTER])
{
pause_game(0, p1, p2);
odliczanie();
}
#ifdef PSP
if(key[KEY_RSHIFT])
{
thid = sceKernelCreateThread("Screenshotpsp", screenshotpsp,
0x11, 256 * 1024, PSP_THREAD_ATTR_USER, NULL);
sceKernelStartThread(thid, 0, NULL);
}
#else
if(key[KEY_M])
{
screenshot();
}
#endif
#if PSP
if(key[KEY_UP])
#else
if(key[KEY_W])
#endif
{
if(p1->direction != DOWN)
p1->direction = UP;
}
#if PSP
else if(key[KEY_DOWN])
#else
else if(key[KEY_S])
#endif
{
if(p1->direction != UP)
p1->direction = DOWN;
}
#if PSP
else if(key[KEY_LEFT])
#else
else if(key[KEY_A])
#endif
{
if(p1->direction != RIGHT)
p1->direction = LEFT;
}
#if PSP
else if(key[KEY_RIGHT])
#else
else if(key[KEY_D])
#endif
{
if(p1->direction != LEFT)
p1->direction = RIGHT;
}
clear_keybuf();
keypressed();
while(p1_speed > 0)
{
switch(p1->direction)
{
case UP:
p1->x--;
break;
case DOWN:
p1->x++;
break;
case LEFT:
p1->y--;
break;
case RIGHT:
p1->y++;
break;
}
p1_speed--;
}
while(p2_speed > 0)
{
switch(p2->direction)
{
case UP:
p2->x--;
break;
case DOWN:
p2->x++;
break;
case LEFT:
p2->y--;
break;
case RIGHT:
p2->y++;
break;
}
p2_speed--;
}
}
remove_int(p1_speed_func);
remove_int(p2_speed_func);
remove_int(speed_func);
destroy_bitmap(buffer_field_game);
destroy_bitmap(buffer_border_and_info);
return koniec;
}
static int uni_player_start(struct uniperif *player)
{
int ret;
/* The player should be stopped */
if (player->state != UNIPERIF_STATE_STOPPED) {
dev_err(player->dev, "%s: invalid player state", __func__);
return -EINVAL;
}
ret = clk_prepare_enable(player->clk);
if (ret) {
dev_err(player->dev, "%s: Failed to enable clock", __func__);
return ret;
}
/* Clear any pending interrupts */
SET_UNIPERIF_ITS_BCLR(player, GET_UNIPERIF_ITS(player));
/* Set the interrupt mask */
SET_UNIPERIF_ITM_BSET_DMA_ERROR(player);
SET_UNIPERIF_ITM_BSET_FIFO_ERROR(player);
/* Enable underflow recovery interrupts */
if (player->info->underflow_enabled) {
SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_DONE(player);
SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_FAILED(player);
}
/* Reset uniperipheral player */
SET_UNIPERIF_SOFT_RST_SOFT_RST(player);
ret = reset_player(player);
if (ret < 0)
return ret;
/*
* Does not use IEC61937 features of the uniperipheral hardware.
* Instead it performs IEC61937 in software and inserts it directly
* into the audio data stream. As such, when encoded mode is selected,
* linear pcm mode is still used, but with the differences of the
* channel status bits set for encoded mode and the validity bits set.
*/
SET_UNIPERIF_CTRL_OPERATION_PCM_DATA(player);
/*
* If iec958 formatting is required for hdmi or spdif, then it must be
* enabled after the operation mode is set. If set prior to this, it
* will not take affect and hang the player.
*/
if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
if (UNIPERIF_TYPE_IS_IEC958(player))
SET_UNIPERIF_CTRL_SPDIF_FMT_ON(player);
/* Force channel status update (no update if clk disable) */
if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
SET_UNIPERIF_CONFIG_CHL_STS_UPDATE(player);
else
SET_UNIPERIF_BIT_CONTROL_CHL_STS_UPDATE(player);
/* Update state to started */
player->state = UNIPERIF_STATE_STARTED;
return 0;
}
static int uni_player_prepare(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
struct uniperif *player = priv->dai_data.uni;
struct snd_pcm_runtime *runtime = substream->runtime;
int transfer_size, trigger_limit;
int ret;
/* The player should be stopped */
if (player->state != UNIPERIF_STATE_STOPPED) {
dev_err(player->dev, "%s: invalid player state %d", __func__,
player->state);
return -EINVAL;
}
/* Calculate transfer size (in fifo cells and bytes) for frame count */
if (player->info->type == SND_ST_UNIPERIF_TYPE_TDM) {
/* transfer size = user frame size (in 32 bits FIFO cell) */
transfer_size =
sti_uniperiph_get_user_frame_size(runtime) / 4;
} else {
transfer_size = runtime->channels * UNIPERIF_FIFO_FRAMES;
}
/* Calculate number of empty cells available before asserting DREQ */
if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) {
trigger_limit = UNIPERIF_FIFO_SIZE - transfer_size;
} else {
/*
* Since SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0
* FDMA_TRIGGER_LIMIT also controls when the state switches
* from OFF or STANDBY to AUDIO DATA.
*/
trigger_limit = transfer_size;
}
/* Trigger limit must be an even number */
if ((!trigger_limit % 2) || (trigger_limit != 1 && transfer_size % 2) ||
(trigger_limit > UNIPERIF_CONFIG_DMA_TRIG_LIMIT_MASK(player))) {
dev_err(player->dev, "invalid trigger limit %d", trigger_limit);
return -EINVAL;
}
SET_UNIPERIF_CONFIG_DMA_TRIG_LIMIT(player, trigger_limit);
/* Uniperipheral setup depends on player type */
switch (player->info->type) {
case SND_ST_UNIPERIF_TYPE_HDMI:
ret = uni_player_prepare_iec958(player, runtime);
break;
case SND_ST_UNIPERIF_TYPE_PCM:
ret = uni_player_prepare_pcm(player, runtime);
break;
case SND_ST_UNIPERIF_TYPE_SPDIF:
ret = uni_player_prepare_iec958(player, runtime);
break;
case SND_ST_UNIPERIF_TYPE_TDM:
ret = uni_player_prepare_tdm(player, runtime);
break;
default:
dev_err(player->dev, "invalid player type");
return -EINVAL;
}
if (ret)
return ret;
switch (player->daifmt & SND_SOC_DAIFMT_INV_MASK) {
case SND_SOC_DAIFMT_NB_NF:
SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player);
SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player);
break;
case SND_SOC_DAIFMT_NB_IF:
SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player);
SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player);
break;
case SND_SOC_DAIFMT_IB_NF:
SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player);
SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player);
break;
case SND_SOC_DAIFMT_IB_IF:
SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player);
SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player);
break;
}
switch (player->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) {
case SND_SOC_DAIFMT_I2S:
SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player);
SET_UNIPERIF_I2S_FMT_PADDING_I2S_MODE(player);
break;
case SND_SOC_DAIFMT_LEFT_J:
SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player);
SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player);
break;
case SND_SOC_DAIFMT_RIGHT_J:
SET_UNIPERIF_I2S_FMT_ALIGN_RIGHT(player);
SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player);
break;
default:
dev_err(player->dev, "format not supported");
return -EINVAL;
}
SET_UNIPERIF_I2S_FMT_NO_OF_SAMPLES_TO_READ(player, 0);
/* Reset uniperipheral player */
SET_UNIPERIF_SOFT_RST_SOFT_RST(player);
return reset_player(player);
}
