ia
int clkdm_register_autodeps(struct clkdm_autodep *ia)
if (!ia)
autodeps = ia;
int clkdm_register_autodeps(struct clkdm_autodep *ia);
uint64_t ia:5;
uint64_t ia:5;
uint64_t ia:8;
uint64_t ia:8;
unsigned int ia;
ia = (ea >> 2) & 0x1;
if (ia) {
unsigned long long ia; /* Instruction Address */
u64 ia : 1; /* 23 psw instruction address validity */
unsigned long ia : 64; /* Instruction Address */
if (!mci.ms || !mci.pm || !mci.ia)
psw_bits(regs.psw).ia = basic->ia;
unsigned int *ia = (unsigned int *)(unsigned long)*start;
ia[0] = (ia[0] & ~0x3fffff) | (high_bits >> 10);
__asm__ __volatile__("flush %0" : : "r" (ia));
ia[1] = (ia[1] & ~0x3fffff) | (low_bits >> 10);
__asm__ __volatile__("flush %0" : : "r" (ia + 1));
ia[2] = (ia[2] & ~0x1fff) | (high_bits & 0x3ff);
__asm__ __volatile__("flush %0" : : "r" (ia + 2));
ia[3] = (ia[3] & ~0x1fff) | (low_bits & 0x3ff);
__asm__ __volatile__("flush %0" : : "r" (ia + 3));
struct memory_initiator *ia;
ia = list_entry(a, struct memory_initiator, node);
return ia->processor_pxm - ib->processor_pxm;
static u32 ia_phy_read32(struct iadev_priv *ia, unsigned int reg)
return readl(ia->phy + (reg >> 2));
static void ia_phy_write32(struct iadev_priv *ia, unsigned int reg, u32 val)
writel(val, ia->phy + (reg >> 2));
cr_tia = data->ia.cr_tia[BTINTEL_PCIE_TXQ_NUM];
cr_hia = data->ia.cr_hia[BTINTEL_PCIE_TXQ_NUM];
data->ia.cr_tia[BTINTEL_PCIE_TXQ_NUM] = cr_tia;
ipc_print_ia_ring(data->hdev, &data->ia, BTINTEL_PCIE_TXQ_NUM);
cr_hia = data->ia.cr_hia[BTINTEL_PCIE_RXQ_NUM];
cr_tia = data->ia.cr_tia[BTINTEL_PCIE_RXQ_NUM];
data->ia.cr_tia[BTINTEL_PCIE_RXQ_NUM] = cr_tia;
ipc_print_ia_ring(data->hdev, &data->ia, BTINTEL_PCIE_RXQ_NUM);
return data->ia.cr_hia[BTINTEL_PCIE_RXQ_NUM] == data->ia.cr_tia[BTINTEL_PCIE_RXQ_NUM];
return data->ia.cr_tia[BTINTEL_PCIE_TXQ_NUM] == data->ia.cr_hia[BTINTEL_PCIE_TXQ_NUM];
ci->addr_cr_hia = data->ia.cr_hia_p_addr;
ci->addr_tr_tia = data->ia.tr_tia_p_addr;
ci->addr_cr_tia = data->ia.cr_tia_p_addr;
ci->addr_tr_hia = data->ia.tr_hia_p_addr;
struct ia *ia)
ia->tr_hia_p_addr = p_addr;
ia->tr_hia = v_addr;
ia->tr_tia_p_addr = p_addr + sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES;
ia->tr_tia = v_addr + sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES;
ia->cr_hia_p_addr = p_addr + (sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES * 2);
ia->cr_hia = v_addr + (sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES * 2);
ia->cr_tia_p_addr = p_addr + (sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES * 3);
ia->cr_tia = v_addr + (sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES * 3);
btintel_pcie_setup_ia(data, p_addr, v_addr, &data->ia);
static inline void ipc_print_ia_ring(struct hci_dev *hdev, struct ia *ia,
ia->tr_hia[queue_num], ia->tr_tia[queue_num],
ia->cr_hia[queue_num], ia->cr_tia[queue_num]);
cr_hia = data->ia.cr_hia[BTINTEL_PCIE_RXQ_NUM];
cr_tia = data->ia.cr_tia[BTINTEL_PCIE_RXQ_NUM];
cr_hia = data->ia.cr_hia[BTINTEL_PCIE_TXQ_NUM];
cr_tia = data->ia.cr_tia[BTINTEL_PCIE_TXQ_NUM];
tfd_index = data->ia.tr_hia[BTINTEL_PCIE_TXQ_NUM];
data->ia.tr_hia[BTINTEL_PCIE_TXQ_NUM] = tfd_index;
frbd_index = data->ia.tr_hia[BTINTEL_PCIE_RXQ_NUM];
data->ia.tr_hia[BTINTEL_PCIE_RXQ_NUM] = frbd_index;
ipc_print_ia_ring(data->hdev, &data->ia, BTINTEL_PCIE_RXQ_NUM);
memset(data->ia.tr_hia, 0, sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES);
memset(data->ia.tr_tia, 0, sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES);
memset(data->ia.cr_hia, 0, sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES);
memset(data->ia.cr_tia, 0, sizeof(u16) * BTINTEL_PCIE_NUM_QUEUES);
struct ia ia;
u64 ia;
ia = gicr_insn(CDIA);
valid = GICV5_GICR_CDIA_VALID(ia);
hwirq = FIELD_GET(GICV5_HWIRQ_INTID, ia);
.ia = { 1, 0x000FFC00, 10 },
.ia = { 1, 0x000FFC00, 10 },
struct request_member ia; /* average current in mA */
const struct request_member *req = &parts->ia;
.ia = { 1, 0x00001FFE, 1 },
.ia = { 1, 0x00001FFE, 1 },
u8 ulp_class, u16 cqid, bool ia,
bool ia, bool wqec);
bool ia;
ia = (ctxp->flag & LPFC_NVME_ABTS_RCV) ? true : false;
LPFC_WQE_CQ_ID_DEFAULT, ia, true);
u16 iotag, u8 ulp_class, u16 cqid, bool ia,
if (ia) {
u16 iotag, u8 ulp_class, u16 cqid, bool ia,
if (ia)
bool ia, bool wqec)
cqid, ia, wqec);
bool ia;
ia = true;
ia = false;
LPFC_WQE_CQ_ID_DEFAULT, ia, false);
retval, ia, abtsiocbp->cmd_cmpl);
bool ia;
ia = false;
ia = true;
ia, false);
SCR_LOAD_REL (ia, 4),
SCR_LOAD_REL (ia, 4),
SCR_REG_REG (ia, SCR_ADD, 8),
SCR_STORE_REL (ia, 4),
SCR_LOAD_ABS (ia, 4),
SCR_STORE_REL (ia, 4),
SCR_STORE_REL (ia, 4),
SCR_LOAD_ABS (ia, 4),
} ia;
reply.ia.uuid[0] = call->net->uuid.time_low;
reply.ia.uuid[1] = htonl(ntohs(call->net->uuid.time_mid));
reply.ia.uuid[2] = htonl(ntohs(call->net->uuid.time_hi_and_version));
reply.ia.uuid[3] = htonl((s8) call->net->uuid.clock_seq_hi_and_reserved);
reply.ia.uuid[4] = htonl((s8) call->net->uuid.clock_seq_low);
reply.ia.uuid[loop + 5] = htonl((s8) call->net->uuid.node[loop]);
struct dentry *dentry, struct iattr *ia)
if (ia->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)) {
return simple_setattr(&nop_mnt_idmap, dentry, ia);
static int truncate_upper(struct dentry *dentry, struct iattr *ia,
if (unlikely((ia->ia_size == i_size))) {
if (ia->ia_size > i_size) {
(ia->ia_size - 1), 1);
- (ia->ia_size & ~PAGE_MASK));
truncate_setsize(inode, ia->ia_size);
lower_ia->ia_size = ia->ia_size;
ia->ia_size, num_zeros);
truncate_setsize(inode, ia->ia_size);
upper_size_to_lower_size(crypt_stat, ia->ia_size);
struct iattr ia = { .ia_valid = ATTR_SIZE, .ia_size = new_length };
rc = truncate_upper(dentry, &ia, &lower_ia);
struct dentry *dentry, struct iattr *ia)
rc = setattr_prepare(&nop_mnt_idmap, dentry, ia);
if (ia->ia_valid & ATTR_SIZE) {
rc = ecryptfs_inode_newsize_ok(inode, ia->ia_size);
memcpy(&lower_ia, ia, sizeof(lower_ia));
if (ia->ia_valid & ATTR_FILE)
lower_ia.ia_file = ecryptfs_file_to_lower(ia->ia_file);
if (ia->ia_valid & ATTR_SIZE) {
rc = truncate_upper(dentry, ia, &lower_ia);
struct iattr ia;
ia.ia_valid = ATTR_MODE | ATTR_CTIME;
ia.ia_ctime = current_time(inode);
ia.ia_mode = exfat_make_mode(sbi, attr, 0777);
ia.ia_mode = exfat_make_mode(sbi, attr, 0666 | (inode->i_mode & 0111));
file->f_path.dentry, &ia);
err = exfat_setattr(file_mnt_idmap(file), file->f_path.dentry, &ia);
fsnotify_change(file->f_path.dentry, ia.ia_valid);
err = fat_setattr(file_mnt_idmap(file), file->f_path.dentry, &ia);
fsnotify_change(file->f_path.dentry, ia.ia_valid);
struct iattr ia;
ia.ia_valid = ATTR_MODE | ATTR_CTIME;
ia.ia_ctime = current_time(inode);
ia.ia_mode = fat_make_mode(sbi, attr, S_IRWXUGO);
ia.ia_mode = fat_make_mode(sbi, attr,
file->f_path.dentry, &ia);
struct cuse_init_args *ia = container_of(args, typeof(*ia), ap.args);
struct fuse_args_pages *ap = &ia->ap;
struct cuse_init_out *arg = &ia->out;
kfree(ia);
struct cuse_init_args *ia;
ia = kzalloc_obj(*ia);
if (!ia)
ap = &ia->ap;
ia->in.major = FUSE_KERNEL_VERSION;
ia->in.minor = FUSE_KERNEL_MINOR_VERSION;
ia->in.flags |= CUSE_UNRESTRICTED_IOCTL;
ap->args.in_args[0].size = sizeof(ia->in);
ap->args.in_args[0].value = &ia->in;
ap->args.out_args[0].size = sizeof(ia->out);
ap->args.out_args[0].value = &ia->out;
ap->folios = &ia->folio;
ap->descs = &ia->desc;
ia->folio = folio;
ia->desc.length = ap->args.out_args[1].size;
kfree(ia);
struct fuse_io_args *ia = container_of(args, typeof(*ia), ap.args);
struct fuse_args_pages *ap = &ia->ap;
size_t count = ia->read.in.size;
fuse_short_read(inode, ia->read.attr_ver, num_read, ap);
if (ia->ff)
fuse_file_put(ia->ff, false);
fuse_io_free(ia);
static void fuse_send_readpages(struct fuse_io_args *ia, struct file *file,
struct fuse_args_pages *ap = &ia->ap;
fuse_read_args_fill(ia, file, pos, count, FUSE_READ);
ia->read.attr_ver = fuse_get_attr_version(fm->fc);
ia->ff = fuse_file_get(ff);
static void fuse_write_args_fill(struct fuse_io_args *ia, struct fuse_file *ff,
struct fuse_args *args = &ia->ap.args;
ia->write.in.fh = ff->fh;
ia->write.in.offset = pos;
ia->write.in.size = count;
args->in_args[0].size = sizeof(ia->write.in);
args->in_args[0].value = &ia->write.in;
args->out_args[0].size = sizeof(ia->write.out);
args->out_args[0].value = &ia->write.out;
static ssize_t fuse_send_write(struct fuse_io_args *ia, loff_t pos,
struct kiocb *iocb = ia->io->iocb;
struct fuse_write_in *inarg = &ia->write.in;
fuse_write_args_fill(ia, ff, pos, count);
if (ia->io->async)
return fuse_async_req_send(fm, ia, count);
err = fuse_simple_request(fm, &ia->ap.args);
if (!err && ia->write.out.size > count)
return err ?: ia->write.out.size;
static ssize_t fuse_send_write_pages(struct fuse_io_args *ia,
struct fuse_args_pages *ap = &ia->ap;
fuse_write_args_fill(ia, ff, pos, count);
ia->write.in.flags = fuse_write_flags(iocb);
ia->write.in.write_flags |= FUSE_WRITE_KILL_SUIDGID;
if (!err && ia->write.out.size > count)
short_write = ia->write.out.size < count;
count = ia->write.out.size;
if (ia->write.folio_locked && (i == ap->num_folios - 1))
static ssize_t fuse_fill_write_pages(struct fuse_io_args *ia,
struct fuse_args_pages *ap = &ia->ap;
ia->write.folio_locked = true;
struct fuse_io_args ia = {};
struct fuse_args_pages *ap = &ia.ap;
count = fuse_fill_write_pages(&ia, mapping, ii, pos, nr_pages);
err = fuse_send_write_pages(&ia, iocb, inode,
size_t num_written = ia.write.out.size;
struct fuse_io_args *ia;
ia = fuse_io_alloc(io, max_pages);
if (!ia)
fuse_io_free(ia);
fuse_io_free(ia);
err = fuse_get_user_pages(&ia->ap, iter, &nbytes, write,
ia->write.in.write_flags |= FUSE_WRITE_KILL_SUIDGID;
nres = fuse_send_write(ia, pos, nbytes, owner);
nres = fuse_send_read(ia, pos, nbytes, owner);
fuse_release_user_pages(&ia->ap, nres, io->should_dirty);
fuse_io_free(ia);
ia = NULL;
ia = fuse_io_alloc(io, max_pages);
if (!ia)
if (ia)
fuse_io_free(ia);
struct fuse_args_pages *ap = &wpa->ia.ap;
fuse_file_put(wpa->ia.ff, false);
struct fuse_args_pages *ap = &wpa->ia.ap;
struct fuse_args_pages *ap = &wpa->ia.ap;
struct fuse_write_in *inarg = &wpa->ia.write.in;
container_of(args, typeof(*wpa), ia.ap.args);
ap = &wpa->ia.ap;
struct fuse_args_pages *ap = &wpa->ia.ap;
fuse_write_args_fill(&wpa->ia, ff, folio_pos(folio) + offset, 0);
wpa->ia.write.in.write_flags |= FUSE_WRITE_CACHE;
wpa->ia.ff = ff;
ap = &wpa->ia.ap;
struct fuse_args_pages *ap = &data->wpa->ia.ap;
struct fuse_args_pages *ap = &wpa->ia.ap;
fuse_file_get(wpa->ia.ff);
ap = &wpa->ia.ap;
WARN_ON(!data->wpa->ia.ap.num_folios);
struct fuse_io_args ia;
void fuse_read_args_fill(struct fuse_io_args *ia, struct file *file, loff_t pos,
struct fuse_args *args = &ia->ap.args;
ia->read.in.fh = ff->fh;
ia->read.in.offset = pos;
ia->read.in.size = count;
ia->read.in.flags = file->f_flags;
args->in_args[0].size = sizeof(ia->read.in);
args->in_args[0].value = &ia->read.in;
struct fuse_io_args *ia;
ia = kzalloc_obj(*ia);
if (ia) {
ia->io = io;
ia->ap.folios = fuse_folios_alloc(nfolios, GFP_KERNEL,
&ia->ap.descs);
if (!ia->ap.folios) {
kfree(ia);
ia = NULL;
return ia;
static void fuse_io_free(struct fuse_io_args *ia)
kfree(ia->ap.folios);
kfree(ia);
struct fuse_io_args *ia = container_of(args, typeof(*ia), ap.args);
struct fuse_io_priv *io = ia->io;
if (ia->write.out.size > ia->write.in.size) {
nres = ia->write.out.size;
if (ia->write.in.size != ia->write.out.size)
pos = ia->write.in.offset - io->offset +
ia->write.out.size;
if (ia->read.in.size != outsize)
pos = ia->read.in.offset - io->offset + outsize;
fuse_release_user_pages(&ia->ap, err ?: nres, io->should_dirty);
fuse_io_free(ia);
struct fuse_io_args *ia, size_t num_bytes)
struct fuse_io_priv *io = ia->io;
ia->ap.args.end = fuse_aio_complete_req;
ia->ap.args.may_block = io->should_dirty;
err = fuse_simple_background(fm, &ia->ap.args, GFP_KERNEL);
fuse_aio_complete_req(fm, &ia->ap.args, err);
static ssize_t fuse_send_read(struct fuse_io_args *ia, loff_t pos, size_t count,
struct file *file = ia->io->iocb->ki_filp;
fuse_read_args_fill(ia, file, pos, count, FUSE_READ);
ia->read.in.read_flags |= FUSE_READ_LOCKOWNER;
ia->read.in.lock_owner = fuse_lock_owner_id(fm->fc, owner);
if (ia->io->async)
return fuse_async_req_send(fm, ia, count);
return fuse_simple_request(fm, &ia->ap.args);
struct fuse_io_args ia = {
fuse_read_args_fill(&ia, file, pos, desc.length, FUSE_READ);
res = fuse_simple_request(fm, &ia.ap.args);
fuse_short_read(inode, attr_ver, res, &ia.ap);
struct fuse_io_args *ia;
static void fuse_send_readpages(struct fuse_io_args *ia, struct file *file,
struct fuse_io_args *ia = data->ia;
if (ia && fuse_folios_need_send(fc, pos, len, &ia->ap, data->nr_bytes,
fuse_send_readpages(ia, data->file, data->nr_bytes,
data->ia = NULL;
ia = NULL;
if (!ia) {
data->ia = fuse_io_alloc(NULL, nr_pages);
if (!data->ia)
ia = data->ia;
ap = &ia->ap;
if (data->ia)
fuse_send_readpages(data->ia, data->file, data->nr_bytes,
void fuse_read_args_fill(struct fuse_io_args *ia, struct file *file, loff_t pos,
struct fuse_init_args *ia = container_of(args, typeof(*ia), args);
struct fuse_init_out *arg = &ia->out;
kfree(ia);
struct fuse_init_args *ia;
ia = kzalloc_obj(*ia, GFP_KERNEL | __GFP_NOFAIL);
ia->in.major = FUSE_KERNEL_VERSION;
ia->in.minor = FUSE_KERNEL_MINOR_VERSION;
ia->in.max_readahead = fm->sb->s_bdi->ra_pages * PAGE_SIZE;
ia->in.flags = flags;
ia->in.flags2 = flags >> 32;
ia->args.opcode = FUSE_INIT;
ia->args.in_numargs = 1;
ia->args.in_args[0].size = sizeof(ia->in);
ia->args.in_args[0].value = &ia->in;
ia->args.out_numargs = 1;
ia->args.out_argvar = true;
ia->args.out_args[0].size = sizeof(ia->out);
ia->args.out_args[0].value = &ia->out;
ia->args.force = true;
ia->args.nocreds = true;
return ia;
struct fuse_init_args *ia = fuse_new_init(fm);
err = fuse_simple_request(fm, &ia->args);
ia->args.end = process_init_reply;
err = fuse_simple_background(fm, &ia->args, GFP_KERNEL);
process_init_reply(fm, &ia->args, err);
struct fuse_io_args ia = {};
struct fuse_args *args = &ia.ap.args;
fuse_read_args_fill(&ia, file, ctx->pos, bufsize, FUSE_READDIRPLUS);
fuse_read_args_fill(&ia, file, ctx->pos, bufsize, FUSE_READDIR);
struct iomap_ioend *ia = container_of(a, struct iomap_ioend, io_list);
if (ia->io_offset < ib->io_offset)
if (ia->io_offset > ib->io_offset)
struct iattr ia = { .ia_valid = ATTR_ATIME | ATTR_CTIME | ATTR_MTIME | ATTR_DELEG };
ret = notify_change(&nop_mnt_idmap, f->f_path.dentry, &ia, NULL);
struct dentry *dentry, struct iattr *ia)
unsigned int old_ia_valid = ia->ia_valid;
ret = setattr_prepare(&nop_mnt_idmap, dentry, ia);
if (ia->ia_valid & ATTR_SIZE) {
if (ia->ia_size != size) {
ret = ramfs_nommu_resize(inode, ia->ia_size, size);
if (ret < 0 || ia->ia_valid == ATTR_SIZE)
ia->ia_valid |= ATTR_MTIME|ATTR_CTIME;
setattr_copy(&nop_mnt_idmap, inode, ia);
ia->ia_valid = old_ia_valid;
struct inode *inode, struct iattr *ia)
return ((ia->ia_valid & ATTR_SIZE) ||
i_uid_needs_update(idmap, ia, inode) ||
i_gid_needs_update(idmap, ia, inode));
const bdaddr_t ia = { { 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1 } };
err = smp_c1(k, r, preq, pres, _iat, &ia, _rat, &ra, res);
const bdaddr_t *ia, u8 _rat, const bdaddr_t *ra, u8 res[16])
SMP_DBG("iat %u ia %6phN rat %u ra %6phN", _iat, ia, _rat, ra);
memcpy(p2 + 6, ia, 6);
const struct ins *ia = a;
return strcmp(ia->name, ib->name);
unsigned long long ia; /* Instruction Address */
local.ia = be64toh(basicp->ia);
basic->AS, basic->prim_asn, basic->ia, basic->CL,
.ip = basic->ia,