pdata
PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
*pdata = data;
int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
if (pdata >= 0) {
close(pdata);
pdata = -1;
if (pdata >= 0) {
close(pdata);
pdata = -1;
extern int pdata;
int pdata = -1; /* for passive mode */
pdata = -1;
pdata = -1;
if (pdata >= 0) {
FD_SET(pdata, &set);
if ((flags = fcntl(pdata, F_GETFL, 0)) == -1 ||
fcntl(pdata, F_SETFL, flags | O_NONBLOCK) == -1)
if (select(pdata+1, &set, NULL, NULL, &timeout) <= 0 ||
(s = accept(pdata, (struct sockaddr *) &from, &fromlen)) < 0)
close(pdata);
pdata = s;
if ((flags = fcntl(pdata, F_GETFL, 0)) == -1 ||
fcntl(pdata, F_SETFL, flags & ~O_NONBLOCK) == -1)
return (fdopen(pdata, mode));
close(pdata);
pdata = -1;
else if (pdata != -1) {
if (pdata >= 0) /* close old port if one set */
close(pdata);
pdata = socket(ctrl_addr.su_family, SOCK_STREAM, 0);
if (pdata < 0) {
if (setsockopt(pdata, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
if (setsockopt(pdata, IPPROTO_IP, IP_PORTRANGE,
if (setsockopt(pdata, IPPROTO_IPV6, IPV6_PORTRANGE,
if (bind(pdata, (struct sockaddr *)&pasv_addr, pasv_addr.su_len) < 0)
if (getsockname(pdata, (struct sockaddr *) &pasv_addr, &len) < 0)
if (listen(pdata, 1) < 0)
close(pdata);
pdata = -1;
if (pdata >= 0) /* close old port if one set */
close(pdata);
pdata = socket(ctrl_addr.su_family, SOCK_STREAM, 0);
if (pdata < 0) {
if (setsockopt(pdata, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
if (setsockopt(pdata, IPPROTO_IP, IP_PORTRANGE,
if (setsockopt(pdata, IPPROTO_IPV6, IPV6_PORTRANGE,
if (bind(pdata, (struct sockaddr *)&pasv_addr, len) < 0)
if (getsockname(pdata, (struct sockaddr *) &pasv_addr, &len) < 0)
if (listen(pdata, 1) < 0)
close(pdata);
pdata = -1;
pdata = -1;
uint8_t *pdata;
pdata = m->cur_data_ptr;
pdata = m->cur_data_ptr + m->cur_data_len;
io_len, pdata);
err = usb_fifo_uiomove(f, pdata, io_len, uio);
lwbuf_cache_ctor(void *obj, void *pdata, int ocflags)
struct amdgpu_backlight_privdata *pdata = bl_get_data(bd);
struct amdgpu_encoder *amdgpu_encoder = pdata->encoder;
struct amdgpu_backlight_privdata *pdata = bl_get_data(bd);
struct amdgpu_encoder *amdgpu_encoder = pdata->encoder;
struct amdgpu_backlight_privdata *pdata;
pdata = kmalloc(sizeof(struct amdgpu_backlight_privdata), M_DRM, GFP_KERNEL);
if (!pdata) {
pdata, &amdgpu_atombios_encoder_backlight_ops, &props);
pdata->encoder = amdgpu_encoder;
kfree(pdata);
struct amdgpu_legacy_backlight_privdata *pdata;
pdata = bl_get_data(bd);
kfree(pdata);
uint32_t *pdata = (uint32_t *)&data_byte;
*pdata = PP_SMC_TO_HOST_UL(data);
pinfo.data = pdata;
pinfo.size_data = sizeof(*pdata);
pdata->num_pipes = INTEL_INFO(dev_priv)->num_pipes;
pdata->num_ports = IS_CHERRYVIEW(dev_priv) ? 3 : 2; /* B,C,D or B,C */
pdata->port[0].pipe = -1;
pdata->port[1].pipe = -1;
pdata->port[2].pipe = -1;
spin_lock_init(&pdata->lpe_audio_slock);
kfree(pdata);
struct intel_hdmi_lpe_audio_pdata *pdata;
pdata = dev_get_platdata(&dev_priv->lpe_audio.platdev->dev);
ppdata = &pdata->port[port - PORT_B];
spin_lock_irqsave(&pdata->lpe_audio_slock, irqflags);
if (pdata->notify_audio_lpe)
pdata->notify_audio_lpe(dev_priv->lpe_audio.platdev, port - PORT_B);
spin_unlock_irqrestore(&pdata->lpe_audio_slock, irqflags);
struct intel_hdmi_lpe_audio_pdata *pdata;
pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
if (!pdata)
kfree(pdata);
struct radeon_backlight_privdata *pdata = bl_get_data(bd);
struct radeon_encoder *radeon_encoder = pdata->encoder;
struct radeon_backlight_privdata *pdata = bl_get_data(bd);
struct radeon_encoder *radeon_encoder = pdata->encoder;
struct radeon_backlight_privdata *pdata;
pdata = kmalloc(sizeof(struct radeon_backlight_privdata), M_DRM,
if (!pdata) {
pdata, &radeon_atom_backlight_ops, &props);
pdata->encoder = radeon_encoder;
kfree(pdata);
struct radeon_legacy_backlight_privdata *pdata;
pdata = bl_get_data(bd);
kfree(pdata);
struct radeon_backlight_privdata *pdata = bl_get_data(bd);
if (pdata->negative)
struct radeon_backlight_privdata *pdata = bl_get_data(bd);
struct radeon_encoder *radeon_encoder = pdata->encoder;
struct radeon_backlight_privdata *pdata = bl_get_data(bd);
struct radeon_encoder *radeon_encoder = pdata->encoder;
return pdata->negative ? RADEON_MAX_BL_LEVEL - backlight_level : backlight_level;
struct radeon_backlight_privdata *pdata;
pdata = kmalloc(sizeof(struct radeon_backlight_privdata),
if (!pdata) {
pdata, &radeon_backlight_ops, &props);
pdata->encoder = radeon_encoder;
pdata->negative = true;
pdata->negative = false;
pdata->negative = (rdev->family != CHIP_RV200 &&
pdata->negative = (pdata->negative ||
kfree(pdata);
struct radeon_backlight_privdata *pdata;
pdata = bl_get_data(bd);
kfree(pdata);
if ((error = copyout(req->data, user_buf->pdata,
if ((error = copyin((TW_VOID *)(user_buf->pdata),
TW_VOID *pdata; /* points to data_buf */
error = copyin(ubuf->pdata, req->data, req->length);
error = copyout(req->data, ubuf->pdata, req->length);
void *pdata; /* points to data_buf */
int *pdata; /* and parity block data */
pdata = (int *) (&prqe->b.b_data[(prqe->groupoffset) << DEV_BSHIFT]); /* parity data pointer */
bzero(pdata, prqe->grouplen << DEV_BSHIFT); /* start with nothing in the parity block */
pdata[count] ^= sdata[count];
pdata = (int *) (&prqe->b.b_data[rqoffset << DEV_BSHIFT]); /* parity data pointer */
if ((pdata < ((int *) prqe->b.b_data))
|| (&pdata[length] > ((int *) (prqe->b.b_data + prqe->b.b_bcount)))
pdata[count] ^= sdata[count];
pdata[count] ^= sdata[count];
#define FEEDER_DECLARE(feeder, pdata) \
.data = pdata, \
struct lwbuf **plwb, const char **pdata)
*pdata = (void *)lwbuf_kva(*plwb);
sf_buf_cache_ctor(void *obj, void *pdata, int ocflags)
pdata += i;
pdata->lotime = 0x7FFFFFFFFFFFFFFFLL;
if (pdata->reset) {
pdata->counter = 0;
pdata->tsc_total1 = 0;
pdata->tsc_total2 = 0;
pdata->lotime = 0x7FFFFFFFFFFFFFFFLL;
pdata->hitime = 0;
pdata->reset = 0;
++pdata->counter;
pdata->tsc_total1 += delta;
pdata->tsc_total2 += delta * delta;
if (pdata->lotime > delta)
pdata->lotime = delta;
if (pdata->hitime < delta)
pdata->hitime = delta;
lotime = pdata[0].lotime;
hitime = pdata[0].hitime;
count += pdata[i].counter;
total1 += pdata[i].tsc_total1;
total2 += pdata[i].tsc_total2;
if (lotime > pdata[i].lotime)
lotime = pdata[i].lotime;
if (hitime < pdata[i].hitime)
hitime = pdata[i].hitime;
pdata[i].reset = 1;
volatile pdata_t *pdata;
pdata = mmap(NULL, nprocs * sizeof(*pdata), PROT_READ|PROT_WRITE,
do_msc_cmd(uint8_t *pcmd, uint8_t cmdlen, void *pdata, uint32_t datalen,
pdata, datalen, &actlen, TIMEOUT_FILTER(timeout)))) {