void main_loop(void)
{
const char *s[] = {
"001.jpg",
"002.jpg", 0,
"003.jpg",
"004.jpg",
"005.jpg",
"006.jpg",
"007.jpg",
"008.jpg",
"009.jpg",
"010.jpg",
"011.jpg",
"012.jpg",
0
};
char **p = (char**)s;
unsigned short fseq = 1;
while (*p) {
unsigned short seq;
unsigned short client_fseq;
load_buff_pool(p_bp, *p);
p_bp->f.fseq = fseq;
/* send filename, send chunks, send EOF */
do {
push_fileinfo(p_bp);
} while (CPAPP_IOF != wait_ack(10, &client_fseq));
for (unsigned int i = 0; i <= p_bp->f.filesize / CPAPP_MAX_CHUNKSIZE; i++) {
push_chunk(p_bp, i);
}
push_eof(p_bp);
while (((seq = wait_ack(10, &client_fseq)) != CPAPP_EOF) || (client_fseq != fseq)) {
// printf("ACK LOOP: ack, cliseq, seq = %04x, %04x, %04x\n", seq, client_fseq, fseq);
switch (seq) {
case CPAPP_TMO:
push_eof(p_bp);
break;
case CPAPP_IGN:
break;
case CPAPP_EOF:
break;
case CPAPP_IOF:
break;
default:
push_chunk(p_bp, seq);
break;
}
}
printf("Step to next file. (%d finished)\n", client_fseq);
p++;
fseq++;
}
}
static int
i2c_write(struct i2c_au1550_data *adap, unsigned char *buf,
unsigned int len)
{
int i;
u32 data;
volatile psc_smb_t *sp;
if (len == 0)
return 0;
sp = (volatile psc_smb_t *)(adap->psc_base);
i = 0;
while (i < (len-1)) {
data = buf[i];
sp->psc_smbtxrx = data;
au_sync();
if (wait_ack(adap))
return -EIO;
i++;
}
data = buf[i];
data |= PSC_SMBTXRX_STP;
sp->psc_smbtxrx = data;
au_sync();
if (wait_master_done(adap))
return -EIO;
return 0;
}
static int
do_address(struct i2c_au1550_data *adap, unsigned int addr, int rd, int q)
{
unsigned long stat;
/* Reset the FIFOs, clear events. */
stat = RD(adap, PSC_SMBSTAT);
WR(adap, PSC_SMBEVNT, PSC_SMBEVNT_ALLCLR);
if (!(stat & PSC_SMBSTAT_TE) || !(stat & PSC_SMBSTAT_RE)) {
WR(adap, PSC_SMBPCR, PSC_SMBPCR_DC);
while ((RD(adap, PSC_SMBPCR) & PSC_SMBPCR_DC) != 0)
cpu_relax();
udelay(50);
}
/* Write out the i2c chip address and specify operation */
addr <<= 1;
if (rd)
addr |= 1;
/* zero-byte xfers stop immediately */
if (q)
addr |= PSC_SMBTXRX_STP;
/* Put byte into fifo, start up master. */
WR(adap, PSC_SMBTXRX, addr);
WR(adap, PSC_SMBPCR, PSC_SMBPCR_MS);
if (wait_ack(adap))
return -EIO;
return (q) ? wait_master_done(adap) : 0;
}
static int i2c_write(struct i2c_au1550_data *adap, unsigned char *buf,
unsigned int len)
{
int i;
unsigned long data;
if (len == 0)
return 0;
i = 0;
while (i < (len-1)) {
data = buf[i];
WR(adap, PSC_SMBTXRX, data);
if (wait_ack(adap))
return -EIO;
i++;
}
/* The last byte has to indicate transfer done. */
data = buf[i];
data |= PSC_SMBTXRX_STP;
WR(adap, PSC_SMBTXRX, data);
if (wait_master_done(adap))
return -EIO;
return 0;
}
void send_data_packets() {
int i;
struct sockaddr_in* from;
int retsize, chunk_size;
int * upload_id_list = get_upload_list(&retsize);
int * upload_chunk_id_list = get_upload_chunk_list(&chunk_size);
int peer_id;
unsigned seq_number;
int canSend;
int timeout;
for(i = 0; i < retsize; i++) {
peer_id = upload_id_list[i];
canSend = 1;
/* if timeout send timeout packet first */
if ((seq_number = get_timeout_seq(peer_id)) == 0) {
/* if not timout, check window size */
if(get_queue_size(peer_id) < get_cwnd_size(peer_id)) {
seq_number = get_tail_seq_number(peer_id);
/* transmit */
timeout = 0;
}
else{
canSend = 0;
}
}
else {
/* retransmit */
printf("retransmit\n");
window_timeout(peer_id);
seq_number -= 1; /* offset by 1 */
timeout = 1;
}
//printf("seq: %d, canSend: %d, queue: %d, cwnd: %d\n", seq_number, canSend, get_queue_size(peer_id), get_cwnd_size(peer_id));
/* send one packet one time to ensure fairness */
if(canSend && seq_number < MAX_PACKET_PER_CHUNK) {
char data[MAX_PAYLOAD_SIZE];
struct packet* packet;
if(seq_number==MAX_PACKET_PER_CHUNK-1){
int last_packet_size = BT_CHUNK_SIZE-MAX_PAYLOAD_SIZE*(MAX_PACKET_PER_CHUNK-1);
read_file(master_data_file_name, data, last_packet_size,
upload_chunk_id_list[i] * BT_CHUNK_SIZE + seq_number * MAX_PAYLOAD_SIZE);
packet = make_packet(DATA, NULL, data, last_packet_size, seq_number + 1, 0, NULL, NULL, NULL);
}else{
read_file(master_data_file_name, data, MAX_PAYLOAD_SIZE,
upload_chunk_id_list[i] * BT_CHUNK_SIZE + seq_number * MAX_PAYLOAD_SIZE);
packet = make_packet(DATA, NULL, data, MAX_PAYLOAD_SIZE, seq_number + 1, 0, NULL, NULL, NULL);
}
/* Send DATA */
from = find_addr(peer_id);
send_packet(*packet, sock, (struct sockaddr*)from);
wait_ack(peer_id, seq_number + 1, timeout);
free(packet->header);
free(packet);
}
}
free(upload_id_list);
free(upload_chunk_id_list);
}
static int i2c_write(struct i2c_algo_sgi_data *adap, unsigned char *buf,
unsigned int len)
{
int i;
/* We are already in write state */
for (i = 0; i < len; i++) {
write_data(buf[i]);
if (wait_ack(adap))
return -EIO;
}
return 0;
}
void control_sender(int* data_parity,int frame_no,int isFile,int dataSize){
unsigned char* frame;
int send_unsuccess;
// Send All-1 Frame
while(frame_number_current<frame_number_last){
// CREATE frame from << data_parity
frame=iframe_new_frame(isFile,0,frame_number_current%2,dataSize-frame_number_current*8 /*size*/,data_parity+frame_number_current);
printf("Frane Data size : %d\n",dataSize-frame_number_current*8);
while(send_unsuccess){
// Send 1 frame + Start counter
frame_sender(frame);
printf("Sent Frame : %d\n",frame_number_current);
startTimer(sender_timer);
send_unsuccess=wait_ack(frame_number_current%2); // frame_number_current%2 == 0,1 << ACK
// EXIT PROGRAM
}
frame_number_current++; // Next frame
}
// LAST FRAME;
frame=iframe_new_frame(isFile,1,frame_number_current%2,dataSize-frame_number_current*8,data_parity+frame_number_current);// text lastframe put 1
while(send_unsuccess){
// Send 1 frame + Start counter
frame_sender(frame);
printf("Sent Frame : %d\n",frame_number_current);
startTimer(sender_timer);
send_unsuccess=wait_ack(frame_number_current%2); // frame_number_current%2 == 0,1 << ACK
// EXIT PROGRAM
}
}
void send_file(int conn_fd) {
strip_newline(buf);
/* Client sends file name to recieve */
FILE* f = fopen(buf, "r");
if(f == NULL) {
send(conn_fd, OP_DIE, strlen(OP_DIE), NO_FLAGS);
return;
}
wait_ack(conn_fd, cmd_buf, sizeof(cmd_buf));
while(fgets(buf, sizeof(buf), f) != NULL)
send(conn_fd, buf, strlen(buf), NO_FLAGS);
send(conn_fd, OP_EOF, strlen(OP_EOF), NO_FLAGS);
fclose(f);
}
SANE_Status
sane_start (SANE_Handle h)
{
struct device_s *dev = (struct device_s *) h;
int status;
size_t size;
dev->read_offset = 0;
dev->write_offset_r = 0;
dev->write_offset_g = 1;
dev->write_offset_b = 2;
free (dev->buffer);
dev->buffer = NULL;
send_pkt (PKT_RESET, 0, dev);
send_pkt (PKT_READ_STATUS, 0, dev);
wait_ack (dev, &status);
if (status)
return SANE_STATUS_IO_ERROR;
send_pkt (PKT_READCONF, 0, dev);
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
send_pkt (PKT_SETCONF, 100, dev);
send_conf (dev);
wait_ack (dev, NULL);
send_pkt (PKT_START_SCAN, 0, dev);
wait_ack (dev, NULL);
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
dev->status = STATUS_SCANNING;
/* Get the first data */
return get_data (dev);
}
int stable_send(int fudp, const void *sndbuf, socklen_t len, u_short ackno, int *pcancel)
{
const char *psndbuf = (const char *)sndbuf;
int result = send(fudp, psndbuf, len, 0);
for (int i = 0; i < 5 && result == len && *pcancel == 0; i++) {
if (wait_ack(fudp, ackno, pcancel))
return 1;
result = send(fudp, psndbuf, len, 0);
}
if (result != len)
pcancel[0] = 1;
return 0;
}
static bool ast_write_data(struct drm_device *dev, u8 data)
{
struct ast_private *ast = dev->dev_private;
if (wait_nack(ast)) {
send_nack(ast);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x9a, 0x00, data);
send_ack(ast);
if (wait_ack(ast)) {
send_nack(ast);
return true;
}
}
send_nack(ast);
return false;
}
int8_t SOFTI2C::send_byte(uint8_t byte)
{
int8_t ret = 0;
uint8_t ii = 8;
sda_pin->mode(OUTPUT_PP);
while( ii-- )
{
scl_pin->reset();
sda_pin->write(byte & 0x80);delay_us(delay_times);
byte += byte;//<<1
scl_pin->set();delay_us(delay_times);
scl_pin->reset();delay_us(delay_times);
}
ret = wait_ack();
return ret;
}
static int
at_command (grub_uint8_t data)
{
unsigned i;
for (i = 0; i < GRUB_AT_TRIES; i++)
{
grub_uint8_t ack;
keyboard_controller_wait_until_ready ();
grub_outb (data, KEYBOARD_REG_STATUS);
ack = wait_ack ();
if (ack == GRUB_AT_NACK)
continue;
if (ack == GRUB_AT_ACK)
break;
return 0;
}
return (i != GRUB_AT_TRIES);
}
static int do_address(struct i2c_algo_sgi_data *adap, unsigned int addr,
int rd)
{
if (rd)
set_control(SGI_I2C_NOT_IDLE);
/* Check if bus is idle, eventually force it to do so */
if (get_control() & SGI_I2C_NOT_IDLE)
if (force_idle(adap))
return -EIO;
/* Write out the i2c chip address and specify operation */
set_control(SGI_I2C_HOLD_BUS | SGI_I2C_WRITE | SGI_I2C_NOT_IDLE);
if (rd)
addr |= 1;
write_data(addr);
if (wait_ack(adap))
return -EIO;
return 0;
}
static bool ast_read_data(struct drm_device *dev, u8 *data)
{
struct ast_private *ast = dev->dev_private;
u8 tmp;
*data = 0;
if (wait_ack(ast) == false)
return false;
tmp = ast_get_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xd3, 0xff);
*data = tmp;
if (wait_nack(ast) == false) {
send_nack(ast);
return false;
}
send_nack(ast);
return true;
}
static int
do_address(struct i2c_au1550_data *adap, unsigned int addr, int rd, int q)
{
volatile psc_smb_t *sp;
u32 stat;
sp = (volatile psc_smb_t *)(adap->psc_base);
/* Reset the FIFOs, clear events.
*/
stat = sp->psc_smbstat;
sp->psc_smbevnt = PSC_SMBEVNT_ALLCLR;
au_sync();
if (!(stat & PSC_SMBSTAT_TE) || !(stat & PSC_SMBSTAT_RE)) {
sp->psc_smbpcr = PSC_SMBPCR_DC;
au_sync();
do {
stat = sp->psc_smbpcr;
au_sync();
} while ((stat & PSC_SMBPCR_DC) != 0);
udelay(50);
}
/* Write out the i2c chip address and specify operation
*/
addr <<= 1;
if (rd)
addr |= 1;
/* zero-byte xfers stop immediately */
if (q)
addr |= PSC_SMBTXRX_STP;
/* Put byte into fifo, start up master.
*/
sp->psc_smbtxrx = addr;
au_sync();
sp->psc_smbpcr = PSC_SMBPCR_MS;
au_sync();
if (wait_ack(adap))
return -EIO;
return (q) ? wait_master_done(adap) : 0;
}
static int
do_address(struct i2c_au1550_data *adap, unsigned int addr, int rd, int q)
{
volatile psc_smb_t *sp;
u32 stat;
sp = (volatile psc_smb_t *)(adap->psc_base);
stat = sp->psc_smbstat;
sp->psc_smbevnt = PSC_SMBEVNT_ALLCLR;
au_sync();
if (!(stat & PSC_SMBSTAT_TE) || !(stat & PSC_SMBSTAT_RE)) {
sp->psc_smbpcr = PSC_SMBPCR_DC;
au_sync();
do {
stat = sp->psc_smbpcr;
au_sync();
} while ((stat & PSC_SMBPCR_DC) != 0);
udelay(50);
}
addr <<= 1;
if (rd)
addr |= 1;
if (q)
addr |= PSC_SMBTXRX_STP;
sp->psc_smbtxrx = addr;
au_sync();
sp->psc_smbpcr = PSC_SMBPCR_MS;
au_sync();
if (wait_ack(adap))
return -EIO;
return (q) ? wait_master_done(adap) : 0;
}
static bool ast_write_cmd(struct drm_device *dev, u8 data)
{
struct ast_private *ast = dev->dev_private;
int retry = 0;
if (wait_nack(ast)) {
send_nack(ast);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x9a, 0x00, data);
send_ack(ast);
set_cmd_trigger(ast);
do {
if (wait_ack(ast)) {
clear_cmd_trigger(ast);
send_nack(ast);
return true;
}
} while (retry++ < 100);
}
clear_cmd_trigger(ast);
send_nack(ast);
return false;
}
static int
write_mode (int mode)
{
unsigned i;
for (i = 0; i < GRUB_AT_TRIES; i++)
{
grub_uint8_t ack;
keyboard_controller_wait_until_ready ();
grub_outb (0xf0, KEYBOARD_REG_DATA);
keyboard_controller_wait_until_ready ();
grub_outb (mode, KEYBOARD_REG_DATA);
keyboard_controller_wait_until_ready ();
ack = wait_ack ();
if (ack == GRUB_AT_NACK)
continue;
if (ack == GRUB_AT_ACK)
break;
return 0;
}
return (i != GRUB_AT_TRIES);
}
int8_t SOFTI2C::write_byte(uint8_t slave_address,uint8_t reg_address,uint8_t* data,uint16_t num_to_write)
{
int8_t ret = 0;
start();
if (send_7bits_address(slave_address) == -1)
ret = -1;
if (send_byte(reg_address) == -1)
ret = -2;
while(num_to_write--)
{
send_byte(*data++);
if (wait_ack() == -1)
ret = -3;
}
stop();
delay_us(10);
return ret;
}
void text_sender(unsigned char* send_data){
int* data_parity;
int send_unsuccess;
char s_frame=sframe_new(0,1,0);
send_unsuccess=1;
//----------SSSSSSSS----------
// Create S_FRAME;
while(send_unsuccess){
// Send 1 frame + Start counter
frame_sender(s_frame);
printf("Sent S-Frame\n");
startTimer(sender_timer);
send_unsuccess=wait_ack(0); // frame_number_current%2 == 0,1 << ACK
}
//----------IIIIIIII----------
send_unsuccess=1;
dataSize=strlen(send_data);
printf("SIZE : %d\n",dataSize);
data8bit=Cut8Char(send_data,dataSize);
// Add 2D-Parity (send_data,dataSize)
// Use new pointer from parity to Send >> data_parity
data_parity=parityGenerator(send_data,dataSize);
frame_number_current=0;
frame_number_last=dataSize/8;
printf("Frame Number : %d\n",frame_number_last);
if(dataSize%8!=0)
frame_number_last++;
control_sender(data_parity,frame_number_last,0,dataSize);
}
static SANE_Status
get_data (struct device_s *dev)
{
int color;
size_t size;
int packet_size;
unsigned char *buffer = (unsigned char *) dev->packet_data;
if (dev->status == STATUS_IDLE)
return SANE_STATUS_IO_ERROR;
/* first wait a standard data pkt */
do
{
size = 32;
sanei_usb_read_bulk (dev->dn, buffer, &size);
if (size)
{
if (ntohl (dev->packet_data[0]) == MAGIC_NUMBER)
{
if (ntohl (dev->packet_data[1]) == PKT_DATA)
break;
if (ntohl (dev->packet_data[1]) == PKT_END_DATA)
{
dev->status = STATUS_IDLE;
DBG(100,"End of scan encountered on device %s\n",dev->devname);
send_pkt (PKT_GO_IDLE, 0, dev);
wait_ack (dev, NULL);
wait_ack (dev, NULL);
send_pkt (PKT_UNKNOW_1, 0, dev);
wait_ack (dev, NULL);
send_pkt (PKT_RESET, 0, dev);
sleep (2); /* Time for the scanning head to go back home */
return SANE_STATUS_EOF;
}
}
}
}
while (1);
packet_size = ntohl (dev->packet_data[5]);
if (!dev->buffer)
{
dev->bufs = packet_size - 24 /* size of header */ ;
if (dev->optionw[COLOR_OFFSET] == RGB)
dev->bufs *= 3;
dev->buffer = malloc (dev->bufs);
if (!dev->buffer)
return SANE_STATUS_NO_MEM;
dev->write_offset_r = 0;
dev->write_offset_g = 1;
dev->write_offset_b = 2;
}
/* Get the "data header" */
do
{
size = 24;
sanei_usb_read_bulk (dev->dn, buffer, &size);
}
while (!size);
color = ntohl (dev->packet_data[0]);
packet_size -= size;
dev->width = ntohl (dev->packet_data[5]);
DBG(100,"Got data size %d on device %s. Scan width: %d\n",packet_size, dev->devname, dev->width);
/* Now, read the data */
do
{
int j;
int i;
int ret;
do
{
size = packet_size > 512 ? 512 : packet_size;
ret = sanei_usb_read_bulk (dev->dn, buffer, &size);
}
while (!size || ret != SANE_STATUS_GOOD);
packet_size -= size;
switch (color)
{
case RED_LAYER:
DBG(101,"Got red layer data on device %s\n",dev->devname);
i = dev->write_offset_r + 3 * size;
if (i > dev->bufs)
i = dev->bufs;
for (j = 0; dev->write_offset_r < i; dev->write_offset_r += 3)
dev->buffer[dev->write_offset_r] = buffer[j++];
break;
case GREEN_LAYER:
DBG(101,"Got green layer data on device %s\n",dev->devname);
i = dev->write_offset_g + 3 * size;
if (i > dev->bufs)
i = dev->bufs;
for (j = 0; dev->write_offset_g < i; dev->write_offset_g += 3)
dev->buffer[dev->write_offset_g] = buffer[j++];
break;
case BLUE_LAYER:
DBG(101,"Got blue layer data on device %s\n",dev->devname);
i = dev->write_offset_b + 3 * size;
if (i > dev->bufs)
i = dev->bufs;
for (j = 0; dev->write_offset_b < i; dev->write_offset_b += 3)
dev->buffer[dev->write_offset_b] = buffer[j++];
break;
case GRAY_LAYER:
DBG(101,"Got gray layer data on device %s\n",dev->devname);
if (dev->write_offset_r + (int)size >= dev->bufs)
size = dev->bufs - dev->write_offset_r;
memcpy (dev->buffer + dev->write_offset_r, buffer, size);
dev->write_offset_r += size;
break;
}
}
while (packet_size > 0);
return SANE_STATUS_GOOD;
}
