void
h8_start_new_cmd(void)
{
unsigned long flags;
h8_cmd_q_t *qp;
save_flags(flags); cli();
if (h8_state != H8_IDLE) {
if (h8_debug & 0x1)
Dprintk("h8_start_new_cmd: not idle\n");
restore_flags(flags);
return;
}
if (!list_empty(&h8_actq)) {
Dprintk("h8_start_new_cmd: inconsistency: IDLE with non-empty active queue!\n");
restore_flags(flags);
return;
}
if (list_empty(&h8_cmdq)) {
Dprintk("h8_start_new_cmd: no command to dequeue\n");
restore_flags(flags);
return;
}
/*
* Take first command off of the command queue and put
* it on the active queue.
*/
qp = list_entry(h8_cmdq.next, h8_cmd_q_t, link);
list_del(&qp->link);
/* XXX should this go to the end of the active queue? */
list_add(&qp->link, &h8_actq);
h8_state = H8_XMIT;
if (h8_debug & 0x1)
Dprintk("h8_start_new_cmd: Starting a command\n");
qp->cnt = 1;
WRITE_CMD(qp->cmdbuf[0]); /* Kick it off */
restore_flags(flags);
return;
}
void
h8_send_next_cmd_byte(void)
{
h8_cmd_q_t *qp = list_entry(h8_actq.next, h8_cmd_q_t, link);
int cnt;
cnt = qp->cnt;
qp->cnt++;
if (h8_debug & 0x1)
Dprintk("h8 sending next cmd byte 0x%x (0x%x)\n",
cnt, qp->cmdbuf[cnt]);
if (cnt) {
WRITE_DATA(qp->cmdbuf[cnt]);
} else {
WRITE_CMD(qp->cmdbuf[cnt]);
}
return;
}
/* Still keeping this around because it demonstrates page flipping and
* automatic z-clear. */
static void savage_BCI_clear(struct gl_context *ctx, drm_savage_clear_t *pclear)
{
savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
int nbox = imesa->sarea->nbox;
drm_clip_rect_t *pbox = imesa->sarea->boxes;
int i;
if (nbox > SAVAGE_NR_SAREA_CLIPRECTS)
nbox = SAVAGE_NR_SAREA_CLIPRECTS;
for (i = 0 ; i < nbox ; i++, pbox++) {
unsigned int x = pbox->x1;
unsigned int y = pbox->y1;
unsigned int width = pbox->x2 - x;
unsigned int height = pbox->y2 - y;
uint32_t *bciptr;
if (pbox->x1 > pbox->x2 ||
pbox->y1 > pbox->y2 ||
pbox->x2 > imesa->savageScreen->width ||
pbox->y2 > imesa->savageScreen->height)
continue;
if ( pclear->flags & SAVAGE_FRONT ) {
bciptr = savageDMAAlloc (imesa, 8);
WRITE_CMD((bciptr) , 0x4BCC8C00,uint32_t);
WRITE_CMD((bciptr) , imesa->savageScreen->frontOffset,uint32_t);
WRITE_CMD((bciptr) , imesa->savageScreen->frontBitmapDesc,uint32_t);
WRITE_CMD((bciptr) , pclear->clear_color,uint32_t);
WRITE_CMD((bciptr) , (y <<16) | x,uint32_t);
WRITE_CMD((bciptr) , (height << 16) | width,uint32_t);
savageDMACommit (imesa, bciptr);
}
if ( pclear->flags & SAVAGE_BACK ) {
bciptr = savageDMAAlloc (imesa, 8);
WRITE_CMD((bciptr) , 0x4BCC8C00,uint32_t);
WRITE_CMD((bciptr) , imesa->savageScreen->backOffset,uint32_t);
WRITE_CMD((bciptr) , imesa->savageScreen->backBitmapDesc,uint32_t);
WRITE_CMD((bciptr) , pclear->clear_color,uint32_t);
WRITE_CMD((bciptr) , (y <<16) | x,uint32_t);
WRITE_CMD((bciptr) , (height << 16) | width,uint32_t);
savageDMACommit (imesa, bciptr);
}
if ( pclear->flags & (SAVAGE_DEPTH |SAVAGE_STENCIL) ) {
uint32_t writeMask = 0x0;
if(imesa->hw_stencil)
{
if(pclear->flags & SAVAGE_STENCIL)
{
writeMask |= 0xFF000000;
}
if(pclear->flags & SAVAGE_DEPTH)
{
writeMask |= 0x00FFFFFF;
}
}
if(imesa->IsFullScreen && imesa->NotFirstFrame &&
imesa->savageScreen->chipset >= S3_SAVAGE4)
{
imesa->regs.s4.zBufCtrl.ni.autoZEnable = GL_TRUE;
imesa->regs.s4.zBufCtrl.ni.frameID =
~imesa->regs.s4.zBufCtrl.ni.frameID;
imesa->dirty |= SAVAGE_UPLOAD_GLOBAL;
}
else
{
if(imesa->IsFullScreen)
imesa->NotFirstFrame = GL_TRUE;
if(imesa->hw_stencil)
{
bciptr = savageDMAAlloc (imesa, 10);
if(writeMask != 0xFFFFFFFF)
{
WRITE_CMD((bciptr) , 0x960100D7,uint32_t);
WRITE_CMD((bciptr) , writeMask,uint32_t);
}
}
else
{
bciptr = savageDMAAlloc (imesa, 6);
}
WRITE_CMD((bciptr) , 0x4BCC8C00,uint32_t);
WRITE_CMD((bciptr) , imesa->savageScreen->depthOffset,uint32_t);
WRITE_CMD((bciptr) , imesa->savageScreen->depthBitmapDesc,uint32_t);
WRITE_CMD((bciptr) , pclear->clear_depth,uint32_t);
WRITE_CMD((bciptr) , (y <<16) | x,uint32_t);
WRITE_CMD((bciptr) , (height << 16) | width,uint32_t);
if(imesa->hw_stencil)
{
if(writeMask != 0xFFFFFFFF)
{
WRITE_CMD((bciptr) , 0x960100D7,uint32_t);
WRITE_CMD((bciptr) , 0xFFFFFFFF,uint32_t);
}
}
savageDMACommit (imesa, bciptr);
}
}
}
/* FK: Make sure that the clear stuff is emitted. Otherwise a
software fallback may get overwritten by a delayed clear. */
savageDMAFlush (imesa);
}
/********************************************************************
* FlashROMの消去、または書き込みを RAM上で実行する.
********************************************************************
この関数はFlashROM上のコードを直接呼んではいけません。
RAM上にコピーしたものを呼び出してください。
*/
int FM3_FlashEraseWrite(int cmd,int adrs,short *buf,int size)
{
int i,d0,d1,d2,d7,data;
int err = 0;
int bank = adrs & FM3_ROM_MASK;
FM3_FLASH_IF_TypeDef *flash_if=FM3_FLASH_IF;
__disable_irq();
__disable_fault_irq();
rom_cmd1 = (ushort *) (FM3_ROM_CMD1); // =0x1550
rom_cmd2 = (ushort *) (FM3_ROM_CMD2); // =0x0aa8
rom_cmdp = (ushort *) (bank);
flash_if->FASZR = 0x01; // '01' Flash ROM 16bitアクセス
dummy_val = flash_if->FASZR; // ダミーリード.
(void) dummy_val;
if( cmd == FM3_ERASE_CMD) {
{
ERASE_CMD(); //消去シーケンスコマンド発行.
ROMCMDP(0x30); //消去アドレスに0x30を書き込む.
d0 = *rom_cmdp; //ダミーリード.
(void) d0;
#if 1 // FlashROMの構成が32bit + 32bit構成なので、
// 奇数ワードのエリア(xxxxxxx4など) も一緒に消す.
{
rom_cmdp[2] = 0x30;
d7 = *rom_cmdp & TOGG; //１回目読み出し実行.
d1 = *rom_cmdp; //２回目読み出し実行.
// d1のSETIビット監視(35uS超過チェック)はここでは省略
}
#endif
//消去完了?
while(1) {
d7 = *rom_cmdp & TOGG; //１回目読み出し実行.
d1 = *rom_cmdp; //２回目読み出し実行.
if((d1 & TOGG)==d7) break; //反転データでなければ抜ける.
if((d1 & TLOV)) { //TLOV==1なら、タイミングリミット超過.
d7 = *rom_cmdp & TOGG; //１回目読み出し実行.
d1 = *rom_cmdp; //２回目読み出し実行.
if((d1 & TOGG)==d7) break; //反転データでなければ抜ける.
//書き込みエラー発生.
err=1;break;
}
//TLOV==0ならwhileループの頭へ.
}
}
}
if( cmd == FM3_WRITE_CMD) {
size = (size+1) >> 1;
rom_cmdp = (ushort *) (adrs);
for(i=0;i<size;i++) {
data = *buf++;
d7 = data & DPOL; //書き込みデータのbit7.
WRITE_CMD(); //書き込みシーケンスコマンド発行.
ROMCMDP(data); //ハーフワード書き込み.
d0 = *rom_cmdp; //ダミーリード.
(void) d0;
//書き込み完了?
while(1) {
d1 = *rom_cmdp; //読み出し実行.
if((d1 & DPOL)==d7) break; //反転データでなければ抜ける.
if((d1 & TLOV)) { //TLOV==1なら、タイミングリミット超過.
d2 = *rom_cmdp; //さらに読み出し実行.
if((d2 & DPOL)==d7) break; //反転データでなければ抜ける.
//書き込みエラー発生.
err=1;break;
}
//TLOV==0ならwhileループの頭へ.
}
if(err) break; //書き込みエラー発生.
//次のアドレス.
rom_cmdp++;
}
}
dk_session_t *
smtp_connect (char * host1, caddr_t * err_ret, caddr_t sender, caddr_t recipient, caddr_t msg_body)
{
volatile int rc, inx, len, addr, at;
dk_session_t * volatile ses = dk_session_allocate (SESCLASS_TCPIP);
caddr_t cmd = NULL;
char resp [1024];
char tmp [1024], *ptmp;
char c;
caddr_t volatile hf = NULL, host;
if (!strchr (host1, ':'))
{
host = dk_alloc_box (strlen (host1) + 4, DV_SHORT_STRING);
strcpy_box_ck (host, host1);
strcat_box_ck (host, ":25");
}
else
{
host = box_dv_short_string (host1);
}
rc = session_set_address (ses->dks_session, host);
dk_free_box (host); host = NULL;
if (SER_SUCC != rc)
{
PrpcSessionFree (ses);
*err_ret = srv_make_new_error ("2E000", "SM002", "Cannot resolve host in smtp_send");
return NULL;
}
rc = session_connect (ses->dks_session);
if (SER_SUCC != rc)
{
if (rc != SER_NOREC)
session_disconnect (ses->dks_session);
PrpcSessionFree (ses);
*err_ret = srv_make_new_error ("08001", "SM003", "Cannot connect in smtp_send");
return NULL;
}
cmd = dk_alloc_box (MAX (MAX (box_length(sender), box_length(recipient)), 1000) + 24, DV_LONG_STRING);
/* get initial line */
IS_OK_GO (ses, resp, rc, RESP_OK)
/* send HELO */
if (gethostname (tmp, sizeof (tmp)))
strcpy_ck (tmp, "localhost");
snprintf (cmd, box_length (cmd), "HELO %s\r\n", tmp);
/*WRITE_CMD (ses, rc, "HELO virtuoso.mail\r\n");*/
WRITE_CMD (ses, rc, cmd);
IS_OK_GO (ses, resp, rc, RESP_OK)
/* send SENDER */
len = box_length (sender);
ptmp = tmp;
addr = -1;
at = 0;
for (inx = 0; inx < len; inx++)
{
c = sender [inx];
if (c == '<')
addr = 1;
else if (c == '>' && addr == 1)
addr = 2;
else if (c == '>' && addr == -1)
{
strcpy_ck (resp, "Unbalanced <...> in sender e-mail address.");
goto error_end;
}
else if (c == '@')
at = 1;
if (((ptmp - tmp) < sizeof(tmp)) && (addr == 1 || addr == 2))
*ptmp++ = c;
else if ((ptmp - tmp) >= sizeof(tmp))
{
strcpy_ck (resp, "Sender\'s e-mail address is too long.");
goto error_end;
}
if (addr == 2)
{
*ptmp = 0;
snprintf (cmd, box_length (cmd), "MAIL FROM: %s\r\n", tmp);
WRITE_CMD (ses, rc, cmd);
IS_OK_GO (ses, resp, rc, RESP_OK)
break;
}
}
/*
* H8 interrupt handler
*/
static void h8_intr(int irq, void *dev_id, struct pt_regs *regs)
{
u_char stat_reg, data_reg;
h8_cmd_q_t *qp = list_entry(h8_actq.next, h8_cmd_q_t, link);
stat_reg = H8_GET_STATUS;
data_reg = H8_READ_DATA;
XDprintk("h8_intr: state %d status 0x%x data 0x%x\n", h8_state, stat_reg, data_reg);
switch (h8_state) {
/* Response to an asynchronous event. */
case H8_IDLE: { /* H8_IDLE */
if (stat_reg & H8_OFULL) {
if (data_reg == H8_INTR) {
h8_state = H8_INTR_MODE;
/* Executing a command to determine what happened. */
WRITE_CMD(H8_RD_EVENT_STATUS);
intr_buf_ptr = 1;
WRITE_CMD(H8_RD_EVENT_STATUS);
} else {
Dprintk("h8_intr: idle stat 0x%x data 0x%x\n",
stat_reg, data_reg);
}
} else {
Dprintk("h8_intr: bogus interrupt\n");
}
break;
}
case H8_INTR_MODE: { /* H8_INTR_MODE */
XDprintk("H8 intr/intr_mode\n");
if (data_reg == H8_BYTE_LEVEL_ACK) {
return;
} else if (data_reg == H8_CMD_ACK) {
return;
} else {
intrbuf.byte[intr_buf_ptr] = data_reg;
if(!intr_buf_ptr) {
h8_state = H8_IDLE;
h8_read_event_status();
}
intr_buf_ptr--;
}
break;
}
/* Placed in this state by h8_start_new_cmd(). */
case H8_XMIT: { /* H8_XMIT */
XDprintk("H8 intr/xmit\n");
/* If a byte level acknowledgement has been received */
if (data_reg == H8_BYTE_LEVEL_ACK) {
XDprintk("H8 intr/xmit BYTE ACK\n");
qp->nacks++;
if (qp->nacks > qp->ncmd)
if(h8_debug & 0x1)
Dprintk("h8intr: bogus # of acks!\n");
/*
* If the number of bytes sent is less than the total
* number of bytes in the command.
*/
if (qp->cnt < qp->ncmd) {
h8_send_next_cmd_byte();
}
return;
/* If the complete command has produced an acknowledgement. */
} else if (data_reg == H8_CMD_ACK) {
XDprintk("H8 intr/xmit CMD ACK\n");
/* If there are response bytes */
if (qp->nrsp)
h8_state = H8_RCV;
else
h8_state = H8_IDLE;
qp->cnt = 0;
return;
/* Error, need to start over with a clean slate. */
} else if (data_reg == H8_NACK) {
XDprintk("h8_intr: NACK received restarting command\n");
qp->nacks = 0;
qp->cnt = 0;
h8_state = H8_IDLE;
WRITE_CMD(H8_SYNC);
return;
} else {
Dprintk ("h8intr: xmit unknown data 0x%x \n", data_reg);
return;
}
break;
}
case H8_RESYNC: { /* H8_RESYNC */
XDprintk("H8 intr/resync\n");
if (data_reg == H8_BYTE_LEVEL_ACK) {
return;
} else if (data_reg == H8_SYNC_BYTE) {
h8_state = H8_IDLE;
if (!list_empty(&h8_actq))
h8_send_next_cmd_byte();
} else {
Dprintk ("h8_intr: resync unknown data 0x%x \n", data_reg);
return;
}
break;
}
case H8_RCV: { /* H8_RCV */
XDprintk("H8 intr/rcv\n");
if (qp->cnt < qp->nrsp) {
qp->rcvbuf[qp->cnt] = data_reg;
qp->cnt++;
/* If command reception finished. */
if (qp->cnt == qp->nrsp) {
h8_state = H8_IDLE;
list_del(&qp->link);
h8_cmd_done (qp);
/* More commands to send over? */
if (!list_empty(&h8_cmdq))
h8_start_new_cmd();
}
return;
} else {
Dprintk ("h8intr: rcv overflow cmd 0x%x\n", qp->cmdbuf[0]);
}
break;
}
default: /* default */
Dprintk("H8 intr/unknown\n");
break;
}
return;
}
