Exemple #1
0
void ADS1299::updateChannelData(){
	byte inByte;
  int byteCounter = 0;
	csLow();				//  open SPI
    for(int i=0; i<3; i++){
	     inByte = xfer(0x00);		        //  read status register (1100 + LOFF_STATP + LOFF_STATN + GPIO[7:4])
	     stat = (stat << 8) | inByte;
    }
    for(int i = 0; i<8; i++){
  	  for(int j=0; j<3; j++){		//  read 24 bits of channel data in 8 3 byte chunks
  	    inByte = xfer(0x00);
        rawChannelData[byteCounter] = inByte;
        byteCounter++;
  	    channelData[i] = (channelData[i]<<8) | inByte;
  	  }
	  }
	csHigh();				//  close SPI
	
	for(int i=0; i<8; i++){			// convert 3 byte 2's compliment to 4 byte 2's compliment	
		if(bitRead(channelData[i],23) == 1){	
			channelData[i] |= 0xFF000000;
		}else{
			channelData[i] &= 0x00FFFFFF;
		}
	}

}
Exemple #2
0
// Read more than one register starting at _address
void ADS1299::RREGS(byte _address, byte _numRegistersMinusOne) {
//	for(byte i = 0; i < 0x17; i++){
//		regData[i] = 0;					//  reset the regData array
//	}
    byte opcode1 = _address + 0x20; 	//  RREG expects 001rrrrr where rrrrr = _address
    csLow(); 				//  open SPI
    xfer(opcode1); 					//  opcode1
    xfer(_numRegistersMinusOne);	//  opcode2
    for(int i = 0; i <= _numRegistersMinusOne; i++){
        regData[_address + i] = xfer(0x00); 	//  add register byte to mirror array
		}
    csHigh(); 			//  close SPI
	if(verbosity){						//  verbosity output
		for(int i = 0; i<= _numRegistersMinusOne; i++){
			printRegisterName(_address + i);
			printHex(_address + i);
			Serial.print(", ");
			printHex(regData[_address + i]);
			Serial.print(", ");
			for(int j = 0; j<8; j++){
				Serial.print(bitRead(regData[_address + i], 7-j));
				if(j!=7) Serial.print(", ");
			}
			Serial.println();
			delay(30);
		}
    }
}
Exemple #3
0
static void goodfet_destroy(device_t dev_base)
{
	struct goodfet *gc = (struct goodfet *)dev_base;
	struct packet pkt;

	xfer(gc->serial_fd, APP_JTAG430, JTAG430_RELEASECPU, 0, NULL, &pkt);
	xfer(gc->serial_fd, APP_JTAG430, GLOBAL_STOP, 0, NULL, &pkt);
	sport_close(gc->serial_fd);
	free(gc);
}
Exemple #4
0
void ADS1299::WREG(byte _address, byte _value) {	//  Write ONE register at _address
    byte opcode1 = _address + 0x40; 	//  WREG expects 010rrrrr where rrrrr = _address
    csLow(); 				//  open SPI
    xfer(opcode1);					//  Send WREG command & address
    xfer(0x00);						//	Send number of registers to read -1
    xfer(_value);					//  Write the value to the register
    csHigh(); 			//  close SPI
	regData[_address] = _value;			//  update the mirror array
	if(verbosity){						//  verbosity output
		Serial.print("Register ");
		printHex(_address);
		Serial.println(" modified.");
	}
}
int main(void) {
    CPU_PRESCALE(0);

    GBA_DDR &= ~(1<<MISO_BIT);
    GBA_DDR |= (1<<MOSI_BIT) | (1<<CLK_BIT);
    CLK_HIGH();

    usb_init();
    while (!usb_configured());
    _delay_ms(1000);

    INIT_TIMER();

    while (1) {
        if (usb_serial_available() >= 4) {
            uint32_t data = 0;
            data |= (uint32_t)usb_serial_getchar()<<24;
            data |= (uint32_t)usb_serial_getchar()<<16;
            data |= (uint32_t)usb_serial_getchar()<<8;
            data |= (uint32_t)usb_serial_getchar();
            xfer(&data);
            usb_serial_putchar((data>>24) & 0xff);
            usb_serial_putchar((data>>16) & 0xff);
            usb_serial_putchar((data>>8) & 0xff);
            usb_serial_putchar(data & 0xff);
            usb_serial_flush_output();
        }
    }
Exemple #6
0
    void onDraw(SkCanvas* canvas) override {
        SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kDstOver_Mode));

        // gradient should appear over color bitmap
        SkAutoTUnref<SkShader> shader0(new SkComposeShader(fLinearGradientShader,
                                                           fColorBitmapShader,
                                                           xfer));
        // gradient should appear over alpha8 bitmap colorized by the paint color
        SkAutoTUnref<SkShader> shader1(new SkComposeShader(fLinearGradientShader,
                                                           fAlpha8BitmapShader,
                                                           xfer));

        SkShader* shaders[] = { shader0.get(), shader1.get() };

        SkPaint paint;
        paint.setColor(SK_ColorYELLOW);

        const SkRect r = SkRect::MakeXYWH(0, 0, SkIntToScalar(squareLength),
                                          SkIntToScalar(squareLength));

        for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
            SkShader* shader = shaders[y];
            canvas->save();
            for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
                paint.setAlpha(alpha);
                paint.setShader(shader);
                canvas->drawRect(r, paint);

                canvas->translate(r.width() + 5, 0);
            }
            canvas->restore();
            canvas->translate(0, r.height() + 5);
        }
    }
Exemple #7
0
void ADS1299::WREGS(byte _address, byte _numRegistersMinusOne) {
    byte opcode1 = _address + 0x40;		//  WREG expects 010rrrrr where rrrrr = _address
    csLow(); 				//  open SPI
    xfer(opcode1);					//  Send WREG command & address
    xfer(_numRegistersMinusOne);	//	Send number of registers to read -1	
	for (int i=_address; i <=(_address + _numRegistersMinusOne); i++){
		xfer(regData[i]);			//  Write to the registers
	}	
	digitalWrite(CS,HIGH);				//  close SPI
	if(verbosity){
		Serial.print("Registers ");
		printHex(_address); Serial.print(" to ");
		printHex(_address + _numRegistersMinusOne);
		Serial.println(" modified");
	}
}
Exemple #8
0
    LinearPipelineContext(const SkShader& shader, const SkShader::ContextRec& rec,
                          SkBitmapProcInfo* info)
        : INHERITED(shader, rec, info)
    {
        // Save things off in case we need to build a blitter pipeline.
        fSrcPixmap = info->fPixmap;
        fAlpha = SkColorGetA(info->fPaintColor) / 255.0f;
        fXMode = info->fTileModeX;
        fYMode = info->fTileModeY;
        fFilterQuality = info->fFilterQuality;
        fMatrixTypeMask = info->fRealInvMatrix.getType();

        // Need to ensure that our pipeline is created at a 16byte aligned address
        fShaderPipeline = (SkLinearBitmapPipeline*)SkAlign16((intptr_t)fShaderStorage);
        new (fShaderPipeline) SkLinearBitmapPipeline(info->fRealInvMatrix, info->fFilterQuality,
                                               info->fTileModeX, info->fTileModeY,
                                               fAlpha,
                                               info->fPixmap);

        // To implement the old shadeSpan entry-point, we need to efficiently convert our native
        // floats into SkPMColor. The SkXfermode::D32Procs do exactly that.
        //
        sk_sp<SkXfermode> xfer(SkXfermode::Make(SkXfermode::kSrc_Mode));
        fXferProc = SkXfermode::GetD32Proc(xfer.get(), 0);
    }
Exemple #9
0
/* Read a word-aligned block from any kind of memory.
 * returns the number of bytes read or -1 on failure
 */
static int read_words(device_t dev, const struct chipinfo_memory *m,
		address_t addr, address_t len, uint8_t *data)
{
	struct goodfet *gc = (struct goodfet *)dev;
	sport_t fd = gc->serial_fd;
	struct packet pkt;
	uint8_t req[6];

	if (len > MAX_MEM_BLOCK)
		len = MAX_MEM_BLOCK;

	req[0] = addr;
	req[1] = addr >> 8;
	req[2] = addr >> 16;
	req[3] = addr >> 24;
	req[4] = len;
	req[5] = len >> 8;

	if (xfer(fd, APP_JTAG430, GLOBAL_PEEK, sizeof(req), req, &pkt) < 0) {
		printc_err("goodfet: read %d bytes from 0x%x failed\n",
			   len, addr);
		return -1;
	}

	if (pkt.len != len) {
		printc_err("goodfet: short memory read (got %d, "
			   "expected %d)\n", pkt.len, len);
		return -1;
	}

	memcpy(data, pkt.data, pkt.len);
	return len;
}
Exemple #10
0
static void xfer_for_each_size(void (*xfer)(int len), int slen, int elen)
{
	int i;

	for (i = slen; i <= elen; i *= 2)
		xfer(i);
}
Exemple #11
0
DEF_TEST(FlatData, reporter) {
    // Test flattening SkShader
    SkPoint points[2];
    points[0].set(0, 0);
    points[1].set(SkIntToScalar(20), SkIntToScalar(20));
    SkColor colors[2];
    colors[0] = SK_ColorRED;
    colors[1] = SK_ColorBLUE;

    SkAutoTUnref<SkShader> shader(SkGradientShader::CreateLinear(points, colors, NULL, 2,
                                                                 SkShader::kRepeat_TileMode));
    testCreate<SkFlattenableTraits>(reporter, *shader);

    // Test SkBitmap
    {
        SkBitmap bm;
        bm.allocN32Pixels(50, 50);
        SkCanvas canvas(bm);
        SkPaint paint;
        paint.setShader(shader);
        canvas.drawPaint(paint);
        testCreate<SkBitmapTraits>(reporter, bm);
    }

    // Test SkColorFilter
    SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateLightingFilter(SK_ColorBLUE, SK_ColorRED));
    testCreate<SkFlattenableTraits>(reporter, *cf);

    // Test SkXfermode
    SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kDstOver_Mode));
    testCreate<SkFlattenableTraits>(reporter, *xfer);
}
Exemple #12
0
    void onDrawContent(SkCanvas* canvas) override {
        if (!canvas->getTotalMatrix().invert(&fInvMatrix)) {
            return;
        }

        SkPaint paint;
        
        SkScalar texWidth = fTexScale * TexWidth;
        SkScalar texHeight = fTexScale * TexHeight;
        const SkPoint texCoords[SkPatchUtils::kNumCorners] = {
            { fTexX - texWidth, fTexY - texHeight},
            { fTexX + texWidth, fTexY - texHeight},
            { fTexX + texWidth, fTexY + texHeight},
            { fTexX - texWidth, fTexY + texHeight}}
        ;
        
        SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kSrc_Mode));

        SkScalar scaleFreq = 2.0;
        fShader1 = SkPerlinNoiseShader2::CreateImprovedNoise(fXFreq/scaleFreq, fYFreq/scaleFreq, 4,
                                                             fSeed);
        fShaderCompose = SkShader::CreateComposeShader(fShader0, fShader1, nullptr);

        paint.setShader(fShaderCompose);
        canvas->drawPatch(fPts, nullptr, texCoords, xfer, paint);

        draw_control_points(canvas, fPts);
        SkSafeUnref(fShader1);
        SkSafeUnref(fShaderCompose);
    }
Exemple #13
0
void rdm_str_addr_sr_xfer_for_each_size(void (*xfer)(int len), int slen, int elen)
{
	int i;

	for (i = slen; i <= elen; i *= 2) {
		xfer(i);
	}
}
Exemple #14
0
 //Reads/Writes next byte. Call 'n' times to read/write 'n' number of bytes. Should be called after _beginSPI()
 uint8_t SPIFlash::_nextByte(char IOType, uint8_t data) {
 #if defined (ARDUINO_ARCH_SAMD)
   #ifdef ENABLEZERODMA
     union {
       uint8_t dataBuf[1];
       uint8_t val;
     } rxData, txData;
     txData.val = data;
     spi_transfer(txData.dataBuf, rxData.dataBuf, 1);
     return rxData.val;
   #else
     return xfer(data);
   #endif
 #else
   return xfer(data);
 #endif
 }
Exemple #15
0
 //Reads/Writes next data buffer. Should be called after _beginSPI()
 void SPIFlash::_nextBuf(uint8_t opcode, uint8_t *data_buffer, uint32_t size) {
   uint8_t *_dataAddr = &(*data_buffer);
   switch (opcode) {
     case READDATA:
     #if defined (ARDUINO_ARCH_SAM)
       due.SPIRecByte(&(*data_buffer), size);
     #elif defined (ARDUINO_ARCH_SAMD)
       #ifdef ENABLEZERODMA
         spi_read(&(*data_buffer), size);
       #else
         _spi->transfer(&data_buffer[0], size);
       #endif
     #elif defined (ARDUINO_ARCH_AVR)
       SPI.transfer(&(*data_buffer), size);
     #else
       for (uint16_t i = 0; i < size; i++) {
         *_dataAddr = xfer(NULLBYTE);
         _dataAddr++;
       }
     #endif
     break;

     case PAGEPROG:
     #if defined (ARDUINO_ARCH_SAM)
       due.SPISendByte(&(*data_buffer), size);
     #elif defined (ARDUINO_ARCH_SAMD)
       #ifdef ENABLEZERODMA
         spi_write(&(*data_buffer), size);
       #else
         _spi->transfer(&data_buffer[0], size);
       #endif
     #elif defined (ARDUINO_ARCH_AVR)
       SPI.transfer(&(*data_buffer), size);
     #else
       for (uint16_t i = 0; i < size; i++) {
         xfer(*_dataAddr);
         _dataAddr++;
       }
     #endif
     break;
   }
 }
Exemple #16
0
void ADS1299::RDATA() {					//  use in Stop Read Continuous mode when DRDY goes low
	byte inByte;						//  to read in one sample of the channels
    csLow();				//  open SPI
    xfer(_RDATA);					//  send the RDATA command
	stat = xfer(0x00);				//  read status register (1100 + LOFF_STATP + LOFF_STATN + GPIO[7:4])
	for(int i = 0; i<8; i++){
		for(int j=0; j<3; j++){		//  read in the status register and new channel data
			inByte = xfer(0x00);
			channelData[i] = (channelData[i]<<8) | inByte;
		}
	}
	csHigh();				//  close SPI
	
	for(int i=0; i<8; i++){
		if(bitRead(channelData[i],23) == 1){	// convert 3 byte 2's compliment to 4 byte 2's compliment
			channelData[i] |= 0xFF000000;
		}else{
			channelData[i] &= 0x00FFFFFF;
		}
	}
}
Exemple #17
0
static int goodfet_halt(struct goodfet *gc)
{
	struct packet pkt;

	if (xfer(gc->serial_fd, APP_JTAG430, JTAG430_HALTCPU,
		 0, NULL, &pkt) < 0) {
		printc_err("goodfet: failed to release CPU\n");
		return -1;
	}

	return 0;
}
Exemple #18
0
byte ADS1299::RREG(byte _address) {		//  reads ONE register at _address
    byte opcode1 = _address + 0x20; 	//  RREG expects 001rrrrr where rrrrr = _address
    csLow(); 				//  open SPI
    xfer(opcode1); 					//  opcode1
    xfer(0x00); 					//  opcode2
    regData[_address] = xfer(0x00);//  update mirror location with returned byte
    csHigh(); 			//  close SPI	
	if (verbosity){						//  verbosity output
		printRegisterName(_address);
		printHex(_address);
		Serial.print(", ");
		printHex(regData[_address]);
		Serial.print(", ");
		for(byte j = 0; j<8; j++){
			Serial.print(bitRead(regData[_address], 7-j));
			if(j!=7) Serial.print(", ");
		}
		
		Serial.println();
	}
	return regData[_address];			// return requested register value
}
Exemple #19
0
void unmap_tags(
    Mesh* old_mesh, Mesh* new_mesh, Int ent_dim, LOs new_ents2old_ents) {
  for (Int i = 0; i < old_mesh->ntags(ent_dim); ++i) {
    auto tag = old_mesh->get_tag(ent_dim, i);
    if (is<I8>(tag)) {
      new_mesh->add_tag<I8>(ent_dim, tag->name(), tag->ncomps(), tag->xfer(),
          tag->outflags(),
          unmap(new_ents2old_ents, to<I8>(tag)->array(), tag->ncomps()));
    } else if (is<I32>(tag)) {
      new_mesh->add_tag<I32>(ent_dim, tag->name(), tag->ncomps(), tag->xfer(),
          tag->outflags(),
          unmap(new_ents2old_ents, to<I32>(tag)->array(), tag->ncomps()));
    } else if (is<I64>(tag)) {
      new_mesh->add_tag<I64>(ent_dim, tag->name(), tag->ncomps(), tag->xfer(),
          tag->outflags(),
          unmap(new_ents2old_ents, to<I64>(tag)->array(), tag->ncomps()));
    } else if (is<Real>(tag)) {
      new_mesh->add_tag<Real>(ent_dim, tag->name(), tag->ncomps(), tag->xfer(),
          tag->outflags(),
          unmap(new_ents2old_ents, to<Real>(tag)->array(), tag->ncomps()));
    }
  }
}
Exemple #20
0
static int spi_gpio_transfer(struct spi_t * spi, struct spi_msg_t * msg)
{
	struct spi_gpio_pdata_t * pdat = (struct spi_gpio_pdata_t *)spi->priv;
	int (*xfer)(struct spi_gpio_pdata_t * pdat,
		u32_t (*txrx)(struct spi_gpio_pdata_t * pdat, u32_t val, int bits, int ns),
		int ns, struct spi_msg_t * msg);
	int ns;

	if(msg->bits <= 8)
		xfer = spi_gpio_bitbang_xfer_8;
	else if(msg->bits <= 16)
		xfer = spi_gpio_bitbang_xfer_16;
	else if(msg->bits <= 32)
		xfer = spi_gpio_bitbang_xfer_32;
	else
		return 0;

	if(msg->speed > 0)
		ns = (1000000000 / 2) / msg->speed;
	else
		ns = 10;

	switch(msg->mode & 0x3)
	{
	case 0:
		return xfer(pdat, spi_gpio_bitbang_txrx_mode0, ns, msg);
	case 1:
		return xfer(pdat, spi_gpio_bitbang_txrx_mode1, ns, msg);
	case 2:
		return xfer(pdat, spi_gpio_bitbang_txrx_mode2, ns, msg);
	case 3:
		return xfer(pdat, spi_gpio_bitbang_txrx_mode3, ns, msg);
	default:
		break;
	}
	return 0;
}
Exemple #21
0
void work(void){

    uint32_t xdata;
    uint32_t cmd,data;
    mmio_write(FUC_NEWSCRATCH_SET2, 8);
    if (q2get != q2put) {
	struct qe *ptr = &q2[q2get & 7];
	cmd = ptr->cmd & ~0x7800;
	data = ptr->data;
	if (++q2get == 0x10)
	    q2get = 0;
    } else if (qget != qput) {
	struct qe *ptr = &queue[qget & 7];
	cmd = ptr->cmd & ~0x7800;
	data = ptr->data;
	if (++qget == 0x10)
	    qget = 0;
    } else {
	mmio_write(FUC_NEWSCRATCH_CLEAR2, 8);
	return;
    }

    in_temp_cmd = cmd;
    in_temp_data = data;


    set4160();
    waitdone_12();


    mmio_write(0xa24, 0);
    mmio_write(FUC_MEM_CHAN, 0); /* type=nv50_channnel????? */
    mmio_write(FUC_MEM_CMD, 7);
    while (mmio_read(FUC_MEM_CMD)&0x1f);

    setxferbase(10);
    extr(xdata,0x08020495,28,29);
    // base, 
    //xfer(0x80020494<<4,0,1,0,xdata,1,1,2);
    xfer(0x20495<<4,0,5,&temp[0],0,2,1,2);

    clear4160();
    mmio_write(0x808, 0xb0000000 | temp[0]);
    mmio_write(0x804, 0xb0000000 | temp[1]);
    mmio_write(0x80c, 0x12345678);


}
Exemple #22
0
/* Write a word to RAM. */
static int write_ram_word(sport_t fd, address_t addr, uint16_t value)
{
	uint8_t req[6];
	struct packet pkt;

	req[0] = addr;
	req[1] = addr >> 8;
	req[2] = 0;
	req[3] = 0;
	req[4] = value;
	req[5] = value >> 8;

	if (xfer(fd, APP_JTAG430, GLOBAL_POKE, sizeof(req), req, &pkt) < 0) {
		printc_err("goodfet: failed to write word at 0x%x\n", addr);
		return -1;
	}

	return 0;
}
Exemple #23
0
static int goodfet_erase(device_t dev_base, device_erase_type_t type,
			 address_t addr)
{
	struct goodfet *gc = (struct goodfet *)dev_base;
	struct packet pkt;

	if (type != DEVICE_ERASE_MAIN) {
		printc_err("goodfet: only main memory erase is supported\n");
		return -1;
	}

	if (xfer(gc->serial_fd, APP_JTAG430, JTAG430_ERASEFLASH,
		 0, NULL, &pkt) < 0) {
		printc_err("goodfet: erase failed\n");
		return -1;
	}

	return 0;
}
Exemple #24
0
static int init_device(sport_t fd)
{
	struct packet pkt;

	printc_dbg("Initializing...\n");

	if (xfer(fd, APP_JTAG430, GLOBAL_NOK, 0, NULL, &pkt) < 0) {
		printc_err("goodfet: comms test failed\n");
		return -1;
	}

	printc_dbg("Setting up JTAG pins\n");

	if (xfer(fd, APP_JTAG430, GLOBAL_SETUP, 0, NULL, &pkt) < 0) {
		printc_err("goodfet: SETUP command failed\n");
		return -1;
	}

	printc_dbg("Starting JTAG\n");

	if (xfer(fd, APP_JTAG430, GLOBAL_START, 0, NULL, &pkt) < 0) {
		printc_err("goodfet: START command failed\n");
		return -1;
	}

	if (pkt.len < 1) {
		printc_err("goodfet: bad response to JTAG START\n");
		return -1;
	}

	printc("JTAG ID: 0x%02x\n", pkt.data[0]);
	if (pkt.data[0] != 0x89 && pkt.data[0] != 0x91) {
		printc_err("goodfet: unexpected JTAG ID: 0x%02x\n",
			   pkt.data[0]);
		xfer(fd, APP_JTAG430, GLOBAL_STOP, 0, NULL, &pkt);
		return -1;
	}

	printc_dbg("Halting CPU\n");

	if (xfer(fd, APP_JTAG430, JTAG430_HALTCPU, 0, NULL, &pkt) < 0) {
		printc_err("goodfet: HALTCPU command failed\n");
		xfer(fd, APP_JTAG430, GLOBAL_STOP, 0, NULL, &pkt);
		return -1;
	}

	return 0;
}
Exemple #25
0
/* Write a word-aligned flash block. The starting address must be within
 * the flash memory range.
 */
static int write_flash_block(sport_t fd, address_t addr,
			     address_t len, const uint8_t *data)
{
	uint8_t req[MAX_MEM_BLOCK + 4];
	struct packet pkt;

	req[0] = addr >> 0;
	req[1] = addr >> 8;
	req[2] = addr >> 16;
	req[3] = addr >> 24;
	memcpy(req + 4, data, len);

	if (xfer(fd, APP_JTAG430, JTAG430_WRITEFLASH,
		 len + 4, req, &pkt) < 0) {
		printc_err("goodfet: failed to write "
			   "flash block of size %d at 0x%x\n",
			   len, addr);
		return -1;
	}

	return 0;
}
Exemple #26
0
static SkShader* make_shader(SkXfermode::Mode mode) {
    SkPoint pts[2];
    SkColor colors[2];

    pts[0].set(0, 0);
    pts[1].set(SkIntToScalar(100), 0);
    colors[0] = SK_ColorRED;
    colors[1] = SK_ColorBLUE;
    SkAutoTUnref<SkShader> shaderA(SkGradientShader::CreateLinear(pts, colors, nullptr, 2,
                                                                  SkShader::kClamp_TileMode));

    pts[0].set(0, 0);
    pts[1].set(0, SkIntToScalar(100));
    colors[0] = SK_ColorBLACK;
    colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
    SkAutoTUnref<SkShader> shaderB(SkGradientShader::CreateLinear(pts, colors, nullptr, 2,
                                                                  SkShader::kClamp_TileMode));

    SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(mode));

    return new SkComposeShader(shaderA, shaderB, xfer);
}
Exemple #27
0
/*
 * Cu-like take command
 */
void
cu_take(char cc)
{
	int fd, argc;
	char line[BUFSIZ], *expand(), *cp;

	if (prompt("[take] ", copyname, sizeof(copyname)))
		return;
	if ((argc = args(copyname, argv, sizeof(argv)/sizeof(argv[0]))) < 1 || argc > 2) {
		printf("usage: <take> from [to]\r\n");
		return;
	}
	if (argc == 1)
		argv[1] = argv[0];
	cp = expand(argv[1]);
	if ((fd = creat(cp, 0666)) < 0) {
		printf("\r\n%s: cannot create\r\n", argv[1]);
		return;
	}
	(void)snprintf(line, sizeof(line), "cat %s ; echo \"\" ; echo ___tip_end_of_file_marker___", argv[0]);
	xfer(line, fd, "\n___tip_end_of_file_marker___\n");
}
Exemple #28
0
static int goodfet_reset(struct goodfet *gc)
{
	static const uint8_t cmd_seq[] = {
		JTAG430_RELEASECPU,
		GLOBAL_STOP,
		GLOBAL_START,
		JTAG430_HALTCPU
	};
	int i;

	/* We don't have a POR request, so just restart JTAG */
	for (i = 0; i < 4; i++) {
		struct packet pkt;

		if (xfer(gc->serial_fd, APP_JTAG430, cmd_seq[i],
			 0, NULL, &pkt) < 0) {
			printc_err("goodfet: reset: command 0x%02x failed\n",
				   cmd_seq[i]);
			return -1;
		}
	}

	return 0;
}
Exemple #29
0
void
main(int argc, char **argv)
{
	int conn, ctlfd, fd, n;
	char buf[128], *base, *mtpt, *post, *url;

	mtpt = "/mnt/web";
	post = nil;
	base = nil;
	ARGBEGIN{
	default:
		usage();
	case 'b':
		base = EARGF(usage());
		break;
	case 'm':
		mtpt = EARGF(usage());
		break;
	case 'p':
		post = EARGF(usage());
		break;
	}ARGEND;

	if (argc != 1) 
		usage();

	url = argv[0];
 
	snprint(buf, sizeof buf, "%s/clone", mtpt);
	if((ctlfd = open(buf, ORDWR)) < 0)
		sysfatal("couldn't open %s: %r", buf);
	if((n = read(ctlfd, buf, sizeof buf-1)) < 0)
		sysfatal("reading clone: %r");
	if(n == 0)
		sysfatal("short read on clone");
	buf[n] = '\0';
	conn = atoi(buf);

	if(base)
		if(fprint(ctlfd, "baseurl %s", base) < 0)
			sysfatal("baseurl ctl write: %r");

	if(fprint(ctlfd, "url %s", url) <= 0)
		sysfatal("get ctl write: %r");

	if(post){
		snprint(buf, sizeof buf, "%s/%d/postbody", mtpt, conn);
		if((fd = open(buf, OWRITE)) < 0)
			sysfatal("open %s: %r", buf);
		if(write(fd, post, strlen(post)) < 0)
			sysfatal("post write failed: %r");
		close(fd);
	}

	snprint(buf, sizeof buf, "%s/%d/body", mtpt, conn);
	if((fd = open(buf, OREAD)) < 0)
		sysfatal("open %s: %r", buf);

	xfer(fd, 1);
	exits(nil);
}
Exemple #30
0
void ADS1299::SDATAC() {
    csLow();
    xfer(_SDATAC);
    csHigh();
	delayMicroseconds(3);   //must wait 4 tCLK cycles after executing this command (Datasheet, pg. 37)
}