static irqreturn_t pj_irq(int irq, void *dev_id)
{
struct pj_data *touch = dev_id;
struct i2c_client *client = touch->client;
union pj_buff event;
unsigned short x, y;
int offs;
int ret;
ret = i2c_smbus_read_i2c_block_data(client, X1_H,
sizeof(event.buff), event.buff);
if (WARN_ON(ret < 0)) {
dev_err(&client->dev, "error %d reading event data\n", ret);
return IRQ_NONE;
}
ret = i2c_smbus_write_byte_data(client, C_FLAG, 0);
if (WARN_ON(ret < 0)) {
dev_err(&client->dev, "error %d clearing interrupt\n", ret);
return IRQ_NONE;
}
input_report_key(touch->input_dev, BTN_TOUCH,
(event.data.fingers == 1 || event.data.fingers == 2));
input_report_key(touch->input_dev, BTN_2, (event.data.fingers == 2));
if (!event.data.fingers || (event.data.fingers > 2))
goto out;
offs = (event.data.fingers == 2) ? ABS_HAT0X : ABS_X;
x = __be16_to_cpu(event.data.x0);
y = __be16_to_cpu(event.data.y0);
dev_dbg(&client->dev, "f[0] x=%u, y=%u\n", x, y);
input_report_abs(touch->input_dev, offs, x);
input_report_abs(touch->input_dev, offs + 1, y);
if (event.data.fingers == 1)
goto out;
x = __be16_to_cpu(event.data.x1);
y = __be16_to_cpu(event.data.y1);
dev_dbg(&client->dev, "f[1] x=%u, y=%u\n", x, y);
input_report_abs(touch->input_dev, ABS_HAT1X, x);
input_report_abs(touch->input_dev, ABS_HAT1Y, y);
out:
input_sync(touch->input_dev);
return IRQ_HANDLED;
}
void hostap_dump_tx_header(const char *name, const struct hfa384x_tx_frame *tx)
{
u16 fc;
printk(KERN_DEBUG "%s: TX status=0x%04x retry_count=%d tx_rate=%d "
"tx_control=0x%04x; jiffies=%ld\n",
name, __le16_to_cpu(tx->status), tx->retry_count, tx->tx_rate,
__le16_to_cpu(tx->tx_control), jiffies);
fc = __le16_to_cpu(tx->frame_control);
printk(KERN_DEBUG " FC=0x%04x (type=%d:%d) dur=0x%04x seq=0x%04x "
"data_len=%d%s%s\n",
fc, WLAN_FC_GET_TYPE(fc), WLAN_FC_GET_STYPE(fc),
__le16_to_cpu(tx->duration_id), __le16_to_cpu(tx->seq_ctrl),
__le16_to_cpu(tx->data_len),
fc & WLAN_FC_TODS ? " [ToDS]" : "",
fc & WLAN_FC_FROMDS ? " [FromDS]" : "");
printk(KERN_DEBUG " A1=" MACSTR " A2=" MACSTR " A3=" MACSTR " A4="
MACSTR "\n",
MAC2STR(tx->addr1), MAC2STR(tx->addr2), MAC2STR(tx->addr3),
MAC2STR(tx->addr4));
printk(KERN_DEBUG " dst=" MACSTR " src=" MACSTR " len=%d\n",
MAC2STR(tx->dst_addr), MAC2STR(tx->src_addr),
__be16_to_cpu(tx->len));
}
void hostap_dump_rx_header(const char *name, const struct hfa384x_rx_frame *rx)
{
u16 status, fc;
status = __le16_to_cpu(rx->status);
printk(KERN_DEBUG "%s: RX status=0x%04x (port=%d, type=%d, "
"fcserr=%d) silence=%d signal=%d rate=%d rxflow=%d; "
"jiffies=%ld\n",
name, status, (status >> 8) & 0x07, status >> 13, status & 1,
rx->silence, rx->signal, rx->rate, rx->rxflow, jiffies);
fc = __le16_to_cpu(rx->frame_control);
printk(KERN_DEBUG " FC=0x%04x (type=%d:%d) dur=0x%04x seq=0x%04x "
"data_len=%d%s%s\n",
fc, WLAN_FC_GET_TYPE(fc), WLAN_FC_GET_STYPE(fc),
__le16_to_cpu(rx->duration_id), __le16_to_cpu(rx->seq_ctrl),
__le16_to_cpu(rx->data_len),
fc & WLAN_FC_TODS ? " [ToDS]" : "",
fc & WLAN_FC_FROMDS ? " [FromDS]" : "");
printk(KERN_DEBUG " A1=" MACSTR " A2=" MACSTR " A3=" MACSTR " A4="
MACSTR "\n",
MAC2STR(rx->addr1), MAC2STR(rx->addr2), MAC2STR(rx->addr3),
MAC2STR(rx->addr4));
printk(KERN_DEBUG " dst=" MACSTR " src=" MACSTR " len=%d\n",
MAC2STR(rx->dst_addr), MAC2STR(rx->src_addr),
__be16_to_cpu(rx->len));
}
static int fts_get_rawdata(struct fts_info *ts, u16 *rawdata)
{
int i, k, ret = 0;
u8 addr = REG_RAWDATA;
u16 *buffer;
//#ifdef FT5606
u16 *p;
int counter;
//#endif
buffer = kzalloc((max_rx*2), GFP_KERNEL);
if(!buffer){
fts_msg("%d ERROR: Alloc memory Fail !\n", __LINE__);
return -1;
}
ret = fts_enter_mode(ts, FTS_MODE_TEST);
if(ret)
goto exit;
fts_scan_ts(ts);
for(i = 0; i < max_tx; i++){
fts_writeb(ts, REG_RAWDATA_ROW, i);
//#ifdef FT5606
if(ts->chip_id == FT5606_ID && max_rx > 20){
counter = max_rx;
p = buffer;
fts_readsb(ts, &addr, (u8 *)p, (min(20, counter) << 1));
p += min(20, counter);
counter -= 20;
fts_enter_mode(ts, FTS_MODE_TEST1);
fts_readsb(ts, &addr, (u8 *)p, (min(20, counter) << 1));
p += min(20, counter);
counter -= min(20, counter);
if(counter > 0){
fts_enter_mode(ts, FTS_MODE_TEST2);
fts_readsb(ts, &addr, (u8 *)p, (min(20, counter) << 1));
}
fts_enter_mode(ts, FTS_MODE_TEST);
}
else
//#endif
fts_readsb(ts, &addr, (u8 *)buffer, (max_rx << 1));
for(k = 0; k < max_rx; k++)
*rawdata++ = __be16_to_cpu(buffer[k]);
}
fts_enter_mode(ts, FTS_MODE_NORMAL);
exit:
kfree(buffer);
return 0;
}
static void ath_debug_send_fft_sample(struct ath_softc *sc,
struct fft_sample_tlv *fft_sample_tlv)
{
int length;
if (!sc->rfs_chan_spec_scan)
return;
length = __be16_to_cpu(fft_sample_tlv->length) +
sizeof(*fft_sample_tlv);
relay_write(sc->rfs_chan_spec_scan, fft_sample_tlv, length);
}
static irqreturn_t pj_irq(int irq, void *dev_id)
{
struct pj_data *touch = dev_id;
struct i2c_client *client = touch->client;
union pj_buff event;
int ret, i;
ret = i2c_smbus_read_i2c_block_data(client, X1_H,
sizeof(event.buff), event.buff);
if (WARN_ON(ret < 0)) {
dev_err(&client->dev, "error %d reading event data\n", ret);
return IRQ_NONE;
}
ret = i2c_smbus_write_byte_data(client, C_FLAG, 0);
if (WARN_ON(ret < 0)) {
dev_err(&client->dev, "error %d clearing interrupt\n", ret);
return IRQ_NONE;
}
input_report_key(touch->input_dev, BTN_TOUCH,
(event.data.fingers == 1 || event.data.fingers == 2));
input_report_key(touch->input_dev, BTN_2, (event.data.fingers == 2));
if (!event.data.fingers || (event.data.fingers > 2))
goto out;
for (i = 0; i < event.data.fingers; i++) {
input_report_abs(touch->input_dev, ABS_MT_POSITION_X,
__be16_to_cpu(event.data.coord[i][0]));
input_report_abs(touch->input_dev, ABS_MT_POSITION_Y,
__be16_to_cpu(event.data.coord[i][1]));
input_report_abs(touch->input_dev, ABS_MT_TRACKING_ID, i + 1);
input_mt_sync(touch->input_dev);
}
out:
input_sync(touch->input_dev);
return IRQ_HANDLED;
}
/*
* si470x_get_register - read register
*/
int si470x_get_register(struct si470x_device *radio, int regnr)
{
u16 buf[READ_REG_NUM];
struct i2c_msg msgs[1] = {
{ radio->client->addr, I2C_M_RD, sizeof(u16) * READ_REG_NUM,
(void *)buf },
};
if (i2c_transfer(radio->client->adapter, msgs, 1) != 1)
return -EIO;
radio->registers[regnr] = __be16_to_cpu(buf[READ_INDEX(regnr)]);
return 0;
}
/* I2C code related */
int tea5764_i2c_read(struct tea5764_device *radio)
{
int i;
u16 *p = (u16 *) &radio->regs;
struct i2c_msg msgs[1] = {
{ radio->i2c_client->addr, I2C_M_RD, sizeof(radio->regs),
(void *)&radio->regs },
};
if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
return -EIO;
for (i = 0; i < sizeof(struct tea5764_regs) / sizeof(u16); i++)
p[i] = __be16_to_cpu(p[i]);
return 0;
}
/*
* si470x_get_all_registers - read entire registers
*/
static int si470x_get_all_registers(struct si470x_device *radio)
{
int i;
u16 buf[READ_REG_NUM];
struct i2c_msg msgs[1] = {
{ radio->client->addr, I2C_M_RD, sizeof(u16) * READ_REG_NUM,
(void *)buf },
};
if (i2c_transfer(radio->client->adapter, msgs, 1) != 1)
return -EIO;
for (i = 0; i < READ_REG_NUM; i++)
radio->registers[i] = __be16_to_cpu(buf[READ_INDEX(i)]);
return 0;
}
static uint16_t read_val16(uint16_t *adr)
{
uint16_t val;
switch(endian) {
case ENDIAN_HOST:
val = *adr;
break;
case ENDIAN_LITTLE:
val = __le16_to_cpu(*adr);
break;
case ENDIAN_BIG:
val = __be16_to_cpu(*adr);
break;
}
return val;
}
static __u16 read_val16(__u16 *adr)
{
__u16 val;
switch(endian) {
case ENDIAN_HOST:
val = *adr;
break;
case ENDIAN_LITTLE:
val = __le16_to_cpu(*adr);
break;
case ENDIAN_BIG:
val = __be16_to_cpu(*adr);
break;
}
return val;
}
int asymmetric_verify(struct key *keyring, const char *sig,
int siglen, const char *data, int datalen)
{
struct public_key_signature pks;
struct signature_v2_hdr *hdr = (struct signature_v2_hdr *)sig;
struct key *key;
int ret = -ENOMEM;
if (siglen <= sizeof(*hdr))
return -EBADMSG;
siglen -= sizeof(*hdr);
if (siglen != __be16_to_cpu(hdr->sig_size))
return -EBADMSG;
if (hdr->hash_algo >= PKEY_HASH__LAST)
return -ENOPKG;
key = request_asymmetric_key(keyring, __be32_to_cpu(hdr->keyid));
if (IS_ERR(key))
return PTR_ERR(key);
memset(&pks, 0, sizeof(pks));
pks.pkey_hash_algo = hdr->hash_algo;
pks.digest = (u8 *)data;
pks.digest_size = datalen;
pks.nr_mpi = 1;
pks.rsa.s = mpi_read_raw_data(hdr->sig, siglen);
if (pks.rsa.s)
ret = verify_signature(key, &pks);
mpi_free(pks.rsa.s);
key_put(key);
pr_debug("%s() = %d\n", __func__, ret);
return ret;
}
static int pohmelfs_trans_iter(struct netfs_trans *t, struct pohmelfs_crypto_engine *e,
int (*iterator) (struct pohmelfs_crypto_engine *e,
struct scatterlist *dst,
struct scatterlist *src))
{
void *data = t->iovec.iov_base + sizeof(struct netfs_cmd) + t->psb->crypto_attached_size;
unsigned int size = t->iovec.iov_len - sizeof(struct netfs_cmd) - t->psb->crypto_attached_size;
struct netfs_cmd *cmd = data;
unsigned int sz, pages = t->attached_pages, i, csize, cmd_cmd, dpage_idx;
struct scatterlist sg_src, sg_dst;
int err;
while (size) {
cmd = data;
cmd_cmd = __be16_to_cpu(cmd->cmd);
csize = __be32_to_cpu(cmd->size);
cmd->iv = __cpu_to_be64(e->iv);
if (cmd_cmd == NETFS_READ_PAGES || cmd_cmd == NETFS_READ_PAGE)
csize = __be16_to_cpu(cmd->ext);
sz = csize + __be16_to_cpu(cmd->cpad) + sizeof(struct netfs_cmd);
dprintk("%s: size: %u, sz: %u, cmd_size: %u, cmd_cpad: %u.\n",
__func__, size, sz, __be32_to_cpu(cmd->size), __be16_to_cpu(cmd->cpad));
data += sz;
size -= sz;
sg_init_one(&sg_src, cmd->data, sz - sizeof(struct netfs_cmd));
sg_init_one(&sg_dst, cmd->data, sz - sizeof(struct netfs_cmd));
err = iterator(e, &sg_dst, &sg_src);
if (err)
return err;
}
if (!pages)
return 0;
dpage_idx = 0;
for (i = 0; i < t->page_num; ++i) {
struct page *page = t->pages[i];
struct page *dpage = e->pages[dpage_idx];
if (!page)
continue;
sg_init_table(&sg_src, 1);
sg_init_table(&sg_dst, 1);
sg_set_page(&sg_src, page, page_private(page), 0);
sg_set_page(&sg_dst, dpage, page_private(page), 0);
err = iterator(e, &sg_dst, &sg_src);
if (err)
return err;
pages--;
if (!pages)
break;
dpage_idx++;
}
return 0;
}
/* ( open -- flag ) */
static void
macparts_open( macparts_info_t *di )
{
char *str = my_args_copy();
char *parstr = NULL, *argstr = NULL;
char *tmpstr;
int bs, parnum=-1, apple_parnum=-1;
int parlist[2], parlist_size = 0;
desc_map_t dmap;
part_entry_t par;
int ret = 0, i = 0, j = 0;
int want_bootcode = 0;
phandle_t ph;
ducell offs = 0, size = -1;
DPRINTF("macparts_open '%s'\n", str );
/*
Arguments that we accept:
id: [0-7]
[(id)][,][filespec]
*/
if ( str && strlen(str) ) {
/* Detect the arguments */
if ((*str >= '0' && *str <= '9') || (*str == ',')) {
push_str(str);
PUSH(',');
fword("left-parse-string");
parstr = pop_fstr_copy();
argstr = pop_fstr_copy();
} else {
argstr = str;
}
/* Make sure argstr is not null */
if (argstr == NULL)
argstr = strdup("");
/* Convert the id to a partition number */
if (parstr && strlen(parstr))
parnum = atol(parstr);
/* Detect if we are looking for the bootcode */
if (strcmp(argstr, "%BOOT") == 0) {
want_bootcode = 1;
}
}
DPRINTF("parstr: %s argstr: %s parnum: %d\n", parstr, argstr, parnum);
DPRINTF("want_bootcode %d\n", want_bootcode);
DPRINTF("macparts_open %d\n", parnum);
di->filesystem_ph = 0;
di->read_xt = find_parent_method("read");
di->seek_xt = find_parent_method("seek");
SEEK( 0 );
if( READ(&dmap, sizeof(dmap)) != sizeof(dmap) )
goto out;
/* partition maps might support multiple block sizes; in this case,
* pmPyPartStart is typically given in terms of 512 byte blocks.
*/
bs = __be16_to_cpu(dmap.sbBlockSize);
if( bs != 512 ) {
SEEK( 512 );
READ( &par, sizeof(par) );
if( __be16_to_cpu(par.pmSig) == DESC_PART_SIGNATURE )
bs = 512;
}
SEEK( bs );
if( READ(&par, sizeof(par)) != sizeof(par) )
goto out;
if (__be16_to_cpu(par.pmSig) != DESC_PART_SIGNATURE)
goto out;
/*
* Implement partition selection as per the PowerPC Microprocessor CHRP bindings
*/
if (argstr == NULL || parnum == 0) {
/* According to the spec, partition 0 as well as no arguments means the whole disk */
offs = (long long)0;
size = (long long)__be32_to_cpu(dmap.sbBlkCount) * bs;
di->blocksize = (unsigned int)bs;
di->offs_hi = offs >> BITS;
di->offs_lo = offs & (ucell) -1;
di->size_hi = size >> BITS;
di->size_lo = size & (ucell) -1;
ret = -1;
goto out;
} else if (parnum == -1) {
/* peak handler */
static void compute_max_peak(u_char *data, size_t count)
{
signed int val, max, perc[2], max_peak[2];
static int run = 0;
size_t ocount = count;
int format_little_endian = snd_pcm_format_little_endian(hwparams.format);
int ichans, c;
if (vumeter == VUMETER_STEREO)
ichans = 2;
else
ichans = 1;
memset(max_peak, 0, sizeof(max_peak));
switch (bits_per_sample) {
case 8: {
signed char *valp = (signed char *)data;
signed char mask = snd_pcm_format_silence(hwparams.format);
c = 0;
while (count-- > 0) {
val = *valp++ ^ mask;
val = abs(val);
if (max_peak[c] < val)
max_peak[c] = val;
if (vumeter == VUMETER_STEREO)
c = !c;
}
break;
}
case 16: {
signed short *valp = (signed short *)data;
signed short mask = snd_pcm_format_silence_16(hwparams.format);
signed short sval;
count /= 2;
c = 0;
while (count-- > 0) {
if (format_little_endian)
sval = __le16_to_cpu(*valp);
else
sval = __be16_to_cpu(*valp);
sval = abs(sval) ^ mask;
if (max_peak[c] < sval)
max_peak[c] = sval;
valp++;
if (vumeter == VUMETER_STEREO)
c = !c;
}
break;
}
case 24: {
unsigned char *valp = data;
signed int mask = snd_pcm_format_silence_32(hwparams.format);
count /= 3;
c = 0;
while (count-- > 0) {
if (format_little_endian) {
val = valp[0] | (valp[1]<<8) | (valp[2]<<16);
} else {
val = (valp[0]<<16) | (valp[1]<<8) | valp[2];
}
/* Correct signed bit in 32-bit value */
if (val & (1<<(bits_per_sample-1))) {
val |= 0xff<<24; /* Negate upper bits too */
}
val = abs(val) ^ mask;
if (max_peak[c] < val)
max_peak[c] = val;
valp += 3;
if (vumeter == VUMETER_STEREO)
c = !c;
}
break;
}
case 32: {
signed int *valp = (signed int *)data;
signed int mask = snd_pcm_format_silence_32(hwparams.format);
count /= 4;
c = 0;
while (count-- > 0) {
if (format_little_endian)
val = __le32_to_cpu(*valp);
else
val = __be32_to_cpu(*valp);
val = abs(val) ^ mask;
if (max_peak[c] < val)
max_peak[c] = val;
valp++;
if (vumeter == VUMETER_STEREO)
c = !c;
}
break;
}
default:
if (run == 0) {
fprintf(stderr, _("Unsupported bit size %d.\n"), (int)bits_per_sample);
run = 1;
}
return;
}
max = 1 << (bits_per_sample-1);
if (max <= 0)
max = 0x7fffffff;
for (c = 0; c < ichans; c++) {
if (bits_per_sample > 16)
perc[c] = max_peak[c] / (max / 100);
else
perc[c] = max_peak[c] * 100 / max;
}
if (interleaved && verbose <= 2) {
static int maxperc[2];
static time_t t=0;
const time_t tt=time(NULL);
if(tt>t) {
t=tt;
maxperc[0] = 0;
maxperc[1] = 0;
}
for (c = 0; c < ichans; c++)
if (perc[c] > maxperc[c])
maxperc[c] = perc[c];
putchar('\r');
print_vu_meter(perc, maxperc);
fflush(stdout);
}
else if(verbose==3) {
printf(_("Max peak (%li samples): 0x%08x "), (long)ocount, max_peak[0]);
for (val = 0; val < 20; val++)
if (val <= perc[0] / 5)
putchar('#');
else
putchar(' ');
printf(" %i%%\n", perc[0]);
fflush(stdout);
}
}
u16 ntohs(u16 netshort)
{
return __be16_to_cpu(netshort);
}
