Searched refs:cpu_to_be32 (Results 1 - 200 of 589) sorted by relevance

123

/linux-4.1.27/fs/nfsd/
H A Dnfsd.h149 #define nfs_ok cpu_to_be32(NFS_OK) nfs4_recoverydir()
150 #define nfserr_perm cpu_to_be32(NFSERR_PERM) nfs4_recoverydir()
151 #define nfserr_noent cpu_to_be32(NFSERR_NOENT) nfs4_recoverydir()
152 #define nfserr_io cpu_to_be32(NFSERR_IO) nfs4_recoverydir()
153 #define nfserr_nxio cpu_to_be32(NFSERR_NXIO) nfs4_recoverydir()
154 #define nfserr_eagain cpu_to_be32(NFSERR_EAGAIN) nfs4_recoverydir()
155 #define nfserr_acces cpu_to_be32(NFSERR_ACCES) nfs4_recoverydir()
156 #define nfserr_exist cpu_to_be32(NFSERR_EXIST) nfs4_recoverydir()
157 #define nfserr_xdev cpu_to_be32(NFSERR_XDEV) nfs4_recoverydir()
158 #define nfserr_nodev cpu_to_be32(NFSERR_NODEV) nfs4_recoverydir()
159 #define nfserr_notdir cpu_to_be32(NFSERR_NOTDIR) nfs4_recoverydir()
160 #define nfserr_isdir cpu_to_be32(NFSERR_ISDIR) nfs4_recoverydir()
161 #define nfserr_inval cpu_to_be32(NFSERR_INVAL) nfs4_recoverydir()
162 #define nfserr_fbig cpu_to_be32(NFSERR_FBIG) nfs4_recoverydir()
163 #define nfserr_nospc cpu_to_be32(NFSERR_NOSPC) nfs4_recoverydir()
164 #define nfserr_rofs cpu_to_be32(NFSERR_ROFS) nfs4_recoverydir()
165 #define nfserr_mlink cpu_to_be32(NFSERR_MLINK) nfs4_recoverydir()
166 #define nfserr_opnotsupp cpu_to_be32(NFSERR_OPNOTSUPP) nfs4_recoverydir()
167 #define nfserr_nametoolong cpu_to_be32(NFSERR_NAMETOOLONG) nfs4_recoverydir()
168 #define nfserr_notempty cpu_to_be32(NFSERR_NOTEMPTY) nfs4_recoverydir()
169 #define nfserr_dquot cpu_to_be32(NFSERR_DQUOT) nfs4_recoverydir()
170 #define nfserr_stale cpu_to_be32(NFSERR_STALE) nfs4_recoverydir()
171 #define nfserr_remote cpu_to_be32(NFSERR_REMOTE) nfs4_recoverydir()
172 #define nfserr_wflush cpu_to_be32(NFSERR_WFLUSH) nfs4_recoverydir()
173 #define nfserr_badhandle cpu_to_be32(NFSERR_BADHANDLE) nfs4_recoverydir()
174 #define nfserr_notsync cpu_to_be32(NFSERR_NOT_SYNC) nfs4_recoverydir()
175 #define nfserr_badcookie cpu_to_be32(NFSERR_BAD_COOKIE) nfs4_recoverydir()
176 #define nfserr_notsupp cpu_to_be32(NFSERR_NOTSUPP) nfs4_recoverydir()
177 #define nfserr_toosmall cpu_to_be32(NFSERR_TOOSMALL) nfs4_recoverydir()
178 #define nfserr_serverfault cpu_to_be32(NFSERR_SERVERFAULT) nfs4_recoverydir()
179 #define nfserr_badtype cpu_to_be32(NFSERR_BADTYPE) nfs4_recoverydir()
180 #define nfserr_jukebox cpu_to_be32(NFSERR_JUKEBOX) nfs4_recoverydir()
181 #define nfserr_denied cpu_to_be32(NFSERR_DENIED) nfs4_recoverydir()
182 #define nfserr_deadlock cpu_to_be32(NFSERR_DEADLOCK) nfs4_recoverydir()
183 #define nfserr_expired cpu_to_be32(NFSERR_EXPIRED) nfs4_recoverydir()
184 #define nfserr_bad_cookie cpu_to_be32(NFSERR_BAD_COOKIE) nfs4_recoverydir()
185 #define nfserr_same cpu_to_be32(NFSERR_SAME) nfs4_recoverydir()
186 #define nfserr_clid_inuse cpu_to_be32(NFSERR_CLID_INUSE) nfs4_recoverydir()
187 #define nfserr_stale_clientid cpu_to_be32(NFSERR_STALE_CLIENTID) nfs4_recoverydir()
188 #define nfserr_resource cpu_to_be32(NFSERR_RESOURCE) nfs4_recoverydir()
189 #define nfserr_moved cpu_to_be32(NFSERR_MOVED) nfs4_recoverydir()
190 #define nfserr_nofilehandle cpu_to_be32(NFSERR_NOFILEHANDLE) nfs4_recoverydir()
191 #define nfserr_minor_vers_mismatch cpu_to_be32(NFSERR_MINOR_VERS_MISMATCH) nfs4_recoverydir()
192 #define nfserr_share_denied cpu_to_be32(NFSERR_SHARE_DENIED) nfs4_recoverydir()
193 #define nfserr_stale_stateid cpu_to_be32(NFSERR_STALE_STATEID) nfs4_recoverydir()
194 #define nfserr_old_stateid cpu_to_be32(NFSERR_OLD_STATEID) nfs4_recoverydir()
195 #define nfserr_bad_stateid cpu_to_be32(NFSERR_BAD_STATEID) nfs4_recoverydir()
196 #define nfserr_bad_seqid cpu_to_be32(NFSERR_BAD_SEQID) nfs4_recoverydir()
197 #define nfserr_symlink cpu_to_be32(NFSERR_SYMLINK) nfs4_recoverydir()
198 #define nfserr_not_same cpu_to_be32(NFSERR_NOT_SAME) nfs4_recoverydir()
199 #define nfserr_lock_range cpu_to_be32(NFSERR_LOCK_RANGE) nfs4_recoverydir()
200 #define nfserr_restorefh cpu_to_be32(NFSERR_RESTOREFH) nfs4_recoverydir()
201 #define nfserr_attrnotsupp cpu_to_be32(NFSERR_ATTRNOTSUPP) nfs4_recoverydir()
202 #define nfserr_bad_xdr cpu_to_be32(NFSERR_BAD_XDR) nfs4_recoverydir()
203 #define nfserr_openmode cpu_to_be32(NFSERR_OPENMODE) nfs4_recoverydir()
204 #define nfserr_badowner cpu_to_be32(NFSERR_BADOWNER) nfs4_recoverydir()
205 #define nfserr_locks_held cpu_to_be32(NFSERR_LOCKS_HELD) nfs4_recoverydir()
206 #define nfserr_op_illegal cpu_to_be32(NFSERR_OP_ILLEGAL) nfs4_recoverydir()
207 #define nfserr_grace cpu_to_be32(NFSERR_GRACE) nfs4_recoverydir()
208 #define nfserr_no_grace cpu_to_be32(NFSERR_NO_GRACE) nfs4_recoverydir()
209 #define nfserr_reclaim_bad cpu_to_be32(NFSERR_RECLAIM_BAD) nfs4_recoverydir()
210 #define nfserr_badname cpu_to_be32(NFSERR_BADNAME) nfs4_recoverydir()
211 #define nfserr_cb_path_down cpu_to_be32(NFSERR_CB_PATH_DOWN) nfs4_recoverydir()
212 #define nfserr_locked cpu_to_be32(NFSERR_LOCKED) nfs4_recoverydir()
213 #define nfserr_wrongsec cpu_to_be32(NFSERR_WRONGSEC) nfs4_recoverydir()
214 #define nfserr_badiomode cpu_to_be32(NFS4ERR_BADIOMODE) nfs4_recoverydir()
215 #define nfserr_badlayout cpu_to_be32(NFS4ERR_BADLAYOUT) nfs4_recoverydir()
216 #define nfserr_bad_session_digest cpu_to_be32(NFS4ERR_BAD_SESSION_DIGEST) nfs4_recoverydir()
217 #define nfserr_badsession cpu_to_be32(NFS4ERR_BADSESSION) nfs4_recoverydir()
218 #define nfserr_badslot cpu_to_be32(NFS4ERR_BADSLOT) nfs4_recoverydir()
219 #define nfserr_complete_already cpu_to_be32(NFS4ERR_COMPLETE_ALREADY) nfs4_recoverydir()
220 #define nfserr_conn_not_bound_to_session cpu_to_be32(NFS4ERR_CONN_NOT_BOUND_TO_SESSION) nfs4_recoverydir()
221 #define nfserr_deleg_already_wanted cpu_to_be32(NFS4ERR_DELEG_ALREADY_WANTED) nfs4_recoverydir()
222 #define nfserr_back_chan_busy cpu_to_be32(NFS4ERR_BACK_CHAN_BUSY) nfs4_recoverydir()
223 #define nfserr_layouttrylater cpu_to_be32(NFS4ERR_LAYOUTTRYLATER) nfs4_recoverydir()
224 #define nfserr_layoutunavailable cpu_to_be32(NFS4ERR_LAYOUTUNAVAILABLE) nfs4_recoverydir()
225 #define nfserr_nomatching_layout cpu_to_be32(NFS4ERR_NOMATCHING_LAYOUT) nfs4_recoverydir()
226 #define nfserr_recallconflict cpu_to_be32(NFS4ERR_RECALLCONFLICT) nfs4_recoverydir()
227 #define nfserr_unknown_layouttype cpu_to_be32(NFS4ERR_UNKNOWN_LAYOUTTYPE) nfs4_recoverydir()
228 #define nfserr_seq_misordered cpu_to_be32(NFS4ERR_SEQ_MISORDERED) nfs4_recoverydir()
229 #define nfserr_sequence_pos cpu_to_be32(NFS4ERR_SEQUENCE_POS) nfs4_recoverydir()
230 #define nfserr_req_too_big cpu_to_be32(NFS4ERR_REQ_TOO_BIG) nfs4_recoverydir()
231 #define nfserr_rep_too_big cpu_to_be32(NFS4ERR_REP_TOO_BIG) nfs4_recoverydir()
232 #define nfserr_rep_too_big_to_cache cpu_to_be32(NFS4ERR_REP_TOO_BIG_TO_CACHE) nfs4_recoverydir()
233 #define nfserr_retry_uncached_rep cpu_to_be32(NFS4ERR_RETRY_UNCACHED_REP) nfs4_recoverydir()
234 #define nfserr_unsafe_compound cpu_to_be32(NFS4ERR_UNSAFE_COMPOUND) nfs4_recoverydir()
235 #define nfserr_too_many_ops cpu_to_be32(NFS4ERR_TOO_MANY_OPS) nfs4_recoverydir()
236 #define nfserr_op_not_in_session cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION) nfs4_recoverydir()
237 #define nfserr_hash_alg_unsupp cpu_to_be32(NFS4ERR_HASH_ALG_UNSUPP) nfs4_recoverydir()
238 #define nfserr_clientid_busy cpu_to_be32(NFS4ERR_CLIENTID_BUSY) nfs4_recoverydir()
239 #define nfserr_pnfs_io_hole cpu_to_be32(NFS4ERR_PNFS_IO_HOLE) nfs4_recoverydir()
240 #define nfserr_seq_false_retry cpu_to_be32(NFS4ERR_SEQ_FALSE_RETRY) nfs4_recoverydir()
241 #define nfserr_bad_high_slot cpu_to_be32(NFS4ERR_BAD_HIGH_SLOT) nfs4_recoverydir()
242 #define nfserr_deadsession cpu_to_be32(NFS4ERR_DEADSESSION) nfs4_recoverydir()
243 #define nfserr_encr_alg_unsupp cpu_to_be32(NFS4ERR_ENCR_ALG_UNSUPP) nfs4_recoverydir()
244 #define nfserr_pnfs_no_layout cpu_to_be32(NFS4ERR_PNFS_NO_LAYOUT) nfs4_recoverydir()
245 #define nfserr_not_only_op cpu_to_be32(NFS4ERR_NOT_ONLY_OP) nfs4_recoverydir()
246 #define nfserr_wrong_cred cpu_to_be32(NFS4ERR_WRONG_CRED) nfs4_recoverydir()
247 #define nfserr_wrong_type cpu_to_be32(NFS4ERR_WRONG_TYPE) nfs4_recoverydir()
248 #define nfserr_dirdeleg_unavail cpu_to_be32(NFS4ERR_DIRDELEG_UNAVAIL) nfs4_recoverydir()
249 #define nfserr_reject_deleg cpu_to_be32(NFS4ERR_REJECT_DELEG) nfs4_recoverydir()
250 #define nfserr_returnconflict cpu_to_be32(NFS4ERR_RETURNCONFLICT) nfs4_recoverydir()
251 #define nfserr_deleg_revoked cpu_to_be32(NFS4ERR_DELEG_REVOKED) nfs4_recoverydir()
252 #define nfserr_partner_notsupp cpu_to_be32(NFS4ERR_PARTNER_NOTSUPP) nfs4_recoverydir()
253 #define nfserr_partner_no_auth cpu_to_be32(NFS4ERR_PARTNER_NO_AUTH) nfs4_recoverydir()
254 #define nfserr_union_notsupp cpu_to_be32(NFS4ERR_UNION_NOTSUPP) nfs4_recoverydir()
255 #define nfserr_offload_denied cpu_to_be32(NFS4ERR_OFFLOAD_DENIED) nfs4_recoverydir()
256 #define nfserr_wrong_lfs cpu_to_be32(NFS4ERR_WRONG_LFS) nfs4_recoverydir()
257 #define nfserr_badlabel cpu_to_be32(NFS4ERR_BADLABEL) nfs4_recoverydir()
263 #define nfserr_dropit cpu_to_be32(30000) nfs4_recoverydir()
265 #define nfserr_eof cpu_to_be32(30001) nfs4_recoverydir()
267 #define nfserr_replay_me cpu_to_be32(11001) nfs4_recoverydir()
269 #define nfserr_replay_cache cpu_to_be32(11002) nfs4_recoverydir()
H A Dnfs4xdr.c1898 *p++ = cpu_to_be32(stat->ctime.tv_sec); encode_change()
1899 *p++ = cpu_to_be32(stat->ctime.tv_nsec); encode_change()
1906 *p++ = cpu_to_be32(c->atomic); encode_cinfo()
1911 *p++ = cpu_to_be32(c->before_ctime_sec); encode_cinfo()
1912 *p++ = cpu_to_be32(c->before_ctime_nsec); encode_cinfo()
1913 *p++ = cpu_to_be32(c->after_ctime_sec); encode_cinfo()
1914 *p++ = cpu_to_be32(c->after_ctime_nsec); encode_cinfo()
2049 *p++ = cpu_to_be32(ncomponents); nfsd4_encode_path()
2110 *p++ = cpu_to_be32(fslocs->locations_count); nfsd4_encode_fs_locations()
2154 *p++ = cpu_to_be32(1); nfsd4_encode_layout_type()
2155 *p++ = cpu_to_be32(layout_type); nfsd4_encode_layout_type()
2160 *p++ = cpu_to_be32(0); nfsd4_encode_layout_type()
2186 *p++ = cpu_to_be32(0); /* lfs */ nfsd4_encode_security_label()
2187 *p++ = cpu_to_be32(0); /* pi */ nfsd4_encode_security_label()
2336 *p++ = cpu_to_be32(3); nfsd4_encode_fattr()
2337 *p++ = cpu_to_be32(bmval0); nfsd4_encode_fattr()
2338 *p++ = cpu_to_be32(bmval1); nfsd4_encode_fattr()
2339 *p++ = cpu_to_be32(bmval2); nfsd4_encode_fattr()
2344 *p++ = cpu_to_be32(2); nfsd4_encode_fattr()
2345 *p++ = cpu_to_be32(bmval0); nfsd4_encode_fattr()
2346 *p++ = cpu_to_be32(bmval1); nfsd4_encode_fattr()
2351 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2352 *p++ = cpu_to_be32(bmval0); nfsd4_encode_fattr()
2374 *p++ = cpu_to_be32(2); nfsd4_encode_fattr()
2375 *p++ = cpu_to_be32(word0); nfsd4_encode_fattr()
2376 *p++ = cpu_to_be32(word1); nfsd4_encode_fattr()
2381 *p++ = cpu_to_be32(3); nfsd4_encode_fattr()
2382 *p++ = cpu_to_be32(word0); nfsd4_encode_fattr()
2383 *p++ = cpu_to_be32(word1); nfsd4_encode_fattr()
2384 *p++ = cpu_to_be32(word2); nfsd4_encode_fattr()
2396 *p++ = cpu_to_be32(dummy); nfsd4_encode_fattr()
2403 *p++ = cpu_to_be32(NFS4_FH_PERSISTENT); nfsd4_encode_fattr()
2405 *p++ = cpu_to_be32(NFS4_FH_PERSISTENT| nfsd4_encode_fattr()
2424 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2430 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2436 *p++ = cpu_to_be32(0); nfsd4_encode_fattr()
2451 *p++ = cpu_to_be32(0); nfsd4_encode_fattr()
2452 *p++ = cpu_to_be32(MAJOR(stat.dev)); nfsd4_encode_fattr()
2453 *p++ = cpu_to_be32(0); nfsd4_encode_fattr()
2454 *p++ = cpu_to_be32(MINOR(stat.dev)); nfsd4_encode_fattr()
2466 *p++ = cpu_to_be32(0); nfsd4_encode_fattr()
2472 *p++ = cpu_to_be32(nn->nfsd4_lease); nfsd4_encode_fattr()
2478 *p++ = cpu_to_be32(rdattr_err); nfsd4_encode_fattr()
2488 *p++ = cpu_to_be32(0); nfsd4_encode_fattr()
2494 *p++ = cpu_to_be32(acl->naces); nfsd4_encode_fattr()
2500 *p++ = cpu_to_be32(ace->type); nfsd4_encode_fattr()
2501 *p++ = cpu_to_be32(ace->flag); nfsd4_encode_fattr()
2502 *p++ = cpu_to_be32(ace->access_mask & nfsd4_encode_fattr()
2514 *p++ = cpu_to_be32(aclsupport ? nfsd4_encode_fattr()
2521 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2527 *p++ = cpu_to_be32(0); nfsd4_encode_fattr()
2533 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2539 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2581 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2593 *p++ = cpu_to_be32(255); nfsd4_encode_fattr()
2599 *p++ = cpu_to_be32(statfs.f_namelen); nfsd4_encode_fattr()
2617 *p++ = cpu_to_be32(stat.mode & S_IALLUGO); nfsd4_encode_fattr()
2623 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2629 *p++ = cpu_to_be32(stat.nlink); nfsd4_encode_fattr()
2645 *p++ = cpu_to_be32((u32) MAJOR(stat.rdev)); nfsd4_encode_fattr()
2646 *p++ = cpu_to_be32((u32) MINOR(stat.rdev)); nfsd4_encode_fattr()
2681 *p++ = cpu_to_be32(stat.atime.tv_nsec); nfsd4_encode_fattr()
2687 *p++ = cpu_to_be32(0); nfsd4_encode_fattr()
2688 *p++ = cpu_to_be32(1); nfsd4_encode_fattr()
2689 *p++ = cpu_to_be32(0); nfsd4_encode_fattr()
2696 *p++ = cpu_to_be32(stat.ctime.tv_nsec); nfsd4_encode_fattr()
2703 *p++ = cpu_to_be32(stat.mtime.tv_nsec); nfsd4_encode_fattr()
2735 *p++ = cpu_to_be32(stat.blksize); nfsd4_encode_fattr()
2748 *p++ = cpu_to_be32(3); nfsd4_encode_fattr()
2749 *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD0); nfsd4_encode_fattr()
2750 *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD1); nfsd4_encode_fattr()
2751 *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD2); nfsd4_encode_fattr()
2996 *p++ = cpu_to_be32(sid->si_generation); nfsd4_encode_stateid()
3012 *p++ = cpu_to_be32(access->ac_supported); nfsd4_encode_access()
3013 *p++ = cpu_to_be32(access->ac_resp_access); nfsd4_encode_access()
3029 *p++ = cpu_to_be32(bcts->dir); nfsd4_encode_bind_conn_to_session()
3031 *p++ = cpu_to_be32(0); nfsd4_encode_bind_conn_to_session()
3075 *p++ = cpu_to_be32(2); nfsd4_encode_create()
3076 *p++ = cpu_to_be32(create->cr_bmval[0]); nfsd4_encode_create()
3077 *p++ = cpu_to_be32(create->cr_bmval[1]); nfsd4_encode_create()
3142 *p++ = cpu_to_be32(ld->ld_type); nfsd4_encode_lock_denied()
3149 *p++ = cpu_to_be32(0); /* length of owner name */ nfsd4_encode_lock_denied()
3221 *p++ = cpu_to_be32(open->op_rflags); nfsd4_encode_open()
3222 *p++ = cpu_to_be32(2); nfsd4_encode_open()
3223 *p++ = cpu_to_be32(open->op_bmval[0]); nfsd4_encode_open()
3224 *p++ = cpu_to_be32(open->op_bmval[1]); nfsd4_encode_open()
3225 *p++ = cpu_to_be32(open->op_delegate_type); nfsd4_encode_open()
3237 *p++ = cpu_to_be32(open->op_recall); nfsd4_encode_open()
3242 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); nfsd4_encode_open()
3243 *p++ = cpu_to_be32(0); nfsd4_encode_open()
3244 *p++ = cpu_to_be32(0); nfsd4_encode_open()
3245 *p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */ nfsd4_encode_open()
3254 *p++ = cpu_to_be32(0); nfsd4_encode_open()
3259 *p++ = cpu_to_be32(NFS4_LIMIT_SIZE); nfsd4_encode_open()
3260 *p++ = cpu_to_be32(~(u32)0); nfsd4_encode_open()
3261 *p++ = cpu_to_be32(~(u32)0); nfsd4_encode_open()
3266 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); nfsd4_encode_open()
3267 *p++ = cpu_to_be32(0); nfsd4_encode_open()
3268 *p++ = cpu_to_be32(0); nfsd4_encode_open()
3269 *p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */ nfsd4_encode_open()
3278 *p++ = cpu_to_be32(open->op_why_no_deleg); nfsd4_encode_open()
3280 *p++ = cpu_to_be32(0); nfsd4_encode_open()
3286 *p++ = cpu_to_be32(open->op_why_no_deleg); nfsd4_encode_open()
3558 *p++ = cpu_to_be32(0); nfsd4_encode_readdir()
3559 *p++ = cpu_to_be32(0); nfsd4_encode_readdir()
3712 *p++ = cpu_to_be32(RPC_AUTH_GSS); nfsd4_do_encode_secinfo()
3714 *p++ = cpu_to_be32(info.qop); nfsd4_do_encode_secinfo()
3715 *p++ = cpu_to_be32(info.service); nfsd4_do_encode_secinfo()
3721 *p++ = cpu_to_be32(pf); nfsd4_do_encode_secinfo()
3771 *p++ = cpu_to_be32(3); nfsd4_encode_setattr()
3772 *p++ = cpu_to_be32(0); nfsd4_encode_setattr()
3773 *p++ = cpu_to_be32(0); nfsd4_encode_setattr()
3774 *p++ = cpu_to_be32(0); nfsd4_encode_setattr()
3777 *p++ = cpu_to_be32(3); nfsd4_encode_setattr()
3778 *p++ = cpu_to_be32(setattr->sa_bmval[0]); nfsd4_encode_setattr()
3779 *p++ = cpu_to_be32(setattr->sa_bmval[1]); nfsd4_encode_setattr()
3780 *p++ = cpu_to_be32(setattr->sa_bmval[2]); nfsd4_encode_setattr()
3803 *p++ = cpu_to_be32(0); nfsd4_encode_setclientid()
3804 *p++ = cpu_to_be32(0); nfsd4_encode_setclientid()
3819 *p++ = cpu_to_be32(write->wr_bytes_written); nfsd4_encode_write()
3820 *p++ = cpu_to_be32(write->wr_how_written); nfsd4_encode_write()
3864 *p++ = cpu_to_be32(exid->seqid); nfsd4_encode_exchange_id()
3865 *p++ = cpu_to_be32(exid->flags); nfsd4_encode_exchange_id()
3867 *p++ = cpu_to_be32(exid->spa_how); nfsd4_encode_exchange_id()
3879 *p++ = cpu_to_be32(2); nfsd4_encode_exchange_id()
3880 *p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[0]); nfsd4_encode_exchange_id()
3881 *p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[1]); nfsd4_encode_exchange_id()
3883 *p++ = cpu_to_be32(0); nfsd4_encode_exchange_id()
3909 *p++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */ nfsd4_encode_exchange_id()
3928 *p++ = cpu_to_be32(sess->seqid); nfsd4_encode_create_session()
3929 *p++ = cpu_to_be32(sess->flags); nfsd4_encode_create_session()
3934 *p++ = cpu_to_be32(0); /* headerpadsz */ nfsd4_encode_create_session()
3935 *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz); nfsd4_encode_create_session()
3936 *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz); nfsd4_encode_create_session()
3937 *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached); nfsd4_encode_create_session()
3938 *p++ = cpu_to_be32(sess->fore_channel.maxops); nfsd4_encode_create_session()
3939 *p++ = cpu_to_be32(sess->fore_channel.maxreqs); nfsd4_encode_create_session()
3940 *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs); nfsd4_encode_create_session()
3946 *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs); nfsd4_encode_create_session()
3952 *p++ = cpu_to_be32(0); /* headerpadsz */ nfsd4_encode_create_session()
3953 *p++ = cpu_to_be32(sess->back_channel.maxreq_sz); nfsd4_encode_create_session()
3954 *p++ = cpu_to_be32(sess->back_channel.maxresp_sz); nfsd4_encode_create_session()
3955 *p++ = cpu_to_be32(sess->back_channel.maxresp_cached); nfsd4_encode_create_session()
3956 *p++ = cpu_to_be32(sess->back_channel.maxops); nfsd4_encode_create_session()
3957 *p++ = cpu_to_be32(sess->back_channel.maxreqs); nfsd4_encode_create_session()
3958 *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs); nfsd4_encode_create_session()
3964 *p++ = cpu_to_be32(sess->back_channel.rdma_attrs); nfsd4_encode_create_session()
3984 *p++ = cpu_to_be32(seq->seqid); nfsd4_encode_sequence()
3985 *p++ = cpu_to_be32(seq->slotid); nfsd4_encode_sequence()
3987 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */ nfsd4_encode_sequence()
3988 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */ nfsd4_encode_sequence()
3989 *p++ = cpu_to_be32(seq->status_flags); nfsd4_encode_sequence()
4038 *p++ = cpu_to_be32(gdev->gd_layout_type); nfsd4_encode_getdeviceinfo()
4060 *p++ = cpu_to_be32(1); /* bitmap length */ nfsd4_encode_getdeviceinfo()
4061 *p++ = cpu_to_be32(gdev->gd_notify_types); nfsd4_encode_getdeviceinfo()
4083 *p++ = cpu_to_be32(needed_len); nfsd4_encode_getdeviceinfo()
4107 *p++ = cpu_to_be32(1); /* we always set return-on-close */ nfsd4_encode_layoutget()
4108 *p++ = cpu_to_be32(lgp->lg_sid.si_generation); nfsd4_encode_layoutget()
4112 *p++ = cpu_to_be32(1); /* we always return a single layout */ nfsd4_encode_layoutget()
4115 *p++ = cpu_to_be32(lgp->lg_seg.iomode); nfsd4_encode_layoutget()
4116 *p++ = cpu_to_be32(lgp->lg_layout_type); nfsd4_encode_layoutget()
4137 *p++ = cpu_to_be32(lcp->lc_size_chg); nfsd4_encode_layoutcommit()
4161 *p++ = cpu_to_be32(lrp->lrs_present); nfsd4_encode_layoutreturn()
4178 *p++ = cpu_to_be32(seek->seek_eof); nfsd4_encode_seek()
4324 *p++ = cpu_to_be32(op->opnum); nfsd4_encode_operation()
4395 *p++ = cpu_to_be32(op->opnum); nfsd4_encode_replay()
H A Dblocklayoutxdr.c26 *p++ = cpu_to_be32(len); nfsd4_block_encode_layoutget()
27 *p++ = cpu_to_be32(1); /* we always return a single extent */ nfsd4_block_encode_layoutget()
34 *p++ = cpu_to_be32(b->es); nfsd4_block_encode_layoutget()
51 *p++ = cpu_to_be32(b->type); nfsd4_block_encode_volume()
52 *p++ = cpu_to_be32(1); /* single signature */ nfsd4_block_encode_volume()
86 *p++ = cpu_to_be32(len); nfsd4_block_encode_getdeviceinfo()
87 *p++ = cpu_to_be32(dev->nr_volumes); nfsd4_block_encode_getdeviceinfo()
H A Dnfs4callback.c116 *p = cpu_to_be32(op); encode_nfs_cb_opnum4()
147 *p++ = cpu_to_be32(sid->si_generation); encode_stateid4()
266 *p++ = cpu_to_be32(hdr->minorversion); encode_cb_compound4args()
267 *p++ = cpu_to_be32(hdr->ident); encode_cb_compound4args()
270 *p = cpu_to_be32(hdr->nops); /* argarray element count */ encode_cb_compound4args()
279 *hdr->nops_p = cpu_to_be32(hdr->nops); encode_cb_nops()
365 *p++ = cpu_to_be32(session->se_cb_seq_nr); /* csa_sequenceid */ encode_cb_sequence4args()
572 *p++ = cpu_to_be32(OP_CB_LAYOUTRECALL); encode_cb_layout4args()
573 *p++ = cpu_to_be32(ls->ls_layout_type); encode_cb_layout4args()
574 *p++ = cpu_to_be32(IOMODE_ANY); encode_cb_layout4args()
575 *p++ = cpu_to_be32(1); encode_cb_layout4args()
576 *p = cpu_to_be32(RETURN_FILE); encode_cb_layout4args()
/linux-4.1.27/drivers/crypto/
H A Dtalitos.h267 #define DESC_HDR_DONE cpu_to_be32(0xff000000)
268 #define DESC_HDR_LO_ICCR1_MASK cpu_to_be32(0x00180000)
269 #define DESC_HDR_LO_ICCR1_PASS cpu_to_be32(0x00080000)
270 #define DESC_HDR_LO_ICCR1_FAIL cpu_to_be32(0x00100000)
273 #define DESC_HDR_SEL0_MASK cpu_to_be32(0xf0000000)
274 #define DESC_HDR_SEL0_AFEU cpu_to_be32(0x10000000)
275 #define DESC_HDR_SEL0_DEU cpu_to_be32(0x20000000)
276 #define DESC_HDR_SEL0_MDEUA cpu_to_be32(0x30000000)
277 #define DESC_HDR_SEL0_MDEUB cpu_to_be32(0xb0000000)
278 #define DESC_HDR_SEL0_RNG cpu_to_be32(0x40000000)
279 #define DESC_HDR_SEL0_PKEU cpu_to_be32(0x50000000)
280 #define DESC_HDR_SEL0_AESU cpu_to_be32(0x60000000)
281 #define DESC_HDR_SEL0_KEU cpu_to_be32(0x70000000)
282 #define DESC_HDR_SEL0_CRCU cpu_to_be32(0x80000000)
285 #define DESC_HDR_MODE0_ENCRYPT cpu_to_be32(0x00100000)
286 #define DESC_HDR_MODE0_AESU_CBC cpu_to_be32(0x00200000)
287 #define DESC_HDR_MODE0_DEU_CBC cpu_to_be32(0x00400000)
288 #define DESC_HDR_MODE0_DEU_3DES cpu_to_be32(0x00200000)
289 #define DESC_HDR_MODE0_MDEU_CONT cpu_to_be32(0x08000000)
290 #define DESC_HDR_MODE0_MDEU_INIT cpu_to_be32(0x01000000)
291 #define DESC_HDR_MODE0_MDEU_HMAC cpu_to_be32(0x00800000)
292 #define DESC_HDR_MODE0_MDEU_PAD cpu_to_be32(0x00400000)
293 #define DESC_HDR_MODE0_MDEU_SHA224 cpu_to_be32(0x00300000)
294 #define DESC_HDR_MODE0_MDEU_MD5 cpu_to_be32(0x00200000)
295 #define DESC_HDR_MODE0_MDEU_SHA256 cpu_to_be32(0x00100000)
296 #define DESC_HDR_MODE0_MDEU_SHA1 cpu_to_be32(0x00000000)
297 #define DESC_HDR_MODE0_MDEUB_SHA384 cpu_to_be32(0x00000000)
298 #define DESC_HDR_MODE0_MDEUB_SHA512 cpu_to_be32(0x00200000)
307 #define DESC_HDR_SEL1_MASK cpu_to_be32(0x000f0000)
308 #define DESC_HDR_SEL1_MDEUA cpu_to_be32(0x00030000)
309 #define DESC_HDR_SEL1_MDEUB cpu_to_be32(0x000b0000)
310 #define DESC_HDR_SEL1_CRCU cpu_to_be32(0x00080000)
313 #define DESC_HDR_MODE1_MDEU_CICV cpu_to_be32(0x00004000)
314 #define DESC_HDR_MODE1_MDEU_INIT cpu_to_be32(0x00001000)
315 #define DESC_HDR_MODE1_MDEU_HMAC cpu_to_be32(0x00000800)
316 #define DESC_HDR_MODE1_MDEU_PAD cpu_to_be32(0x00000400)
317 #define DESC_HDR_MODE1_MDEU_SHA224 cpu_to_be32(0x00000300)
318 #define DESC_HDR_MODE1_MDEU_MD5 cpu_to_be32(0x00000200)
319 #define DESC_HDR_MODE1_MDEU_SHA256 cpu_to_be32(0x00000100)
320 #define DESC_HDR_MODE1_MDEU_SHA1 cpu_to_be32(0x00000000)
321 #define DESC_HDR_MODE1_MDEUB_SHA384 cpu_to_be32(0x00000000)
322 #define DESC_HDR_MODE1_MDEUB_SHA512 cpu_to_be32(0x00000200)
337 #define DESC_HDR_DIR_INBOUND cpu_to_be32(0x00000002)
340 #define DESC_HDR_DONE_NOTIFY cpu_to_be32(0x00000001)
343 #define DESC_HDR_TYPE_AESU_CTR_NONSNOOP cpu_to_be32(0 << 3)
344 #define DESC_HDR_TYPE_IPSEC_ESP cpu_to_be32(1 << 3)
345 #define DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU cpu_to_be32(2 << 3)
346 #define DESC_HDR_TYPE_HMAC_SNOOP_NO_AFEU cpu_to_be32(4 << 3)
/linux-4.1.27/include/linux/
H A Dlibfdt_env.h9 #define cpu_to_fdt32(x) cpu_to_be32(x)
H A Dpim.h7 #define PIM_V1_VERSION cpu_to_be32(0x10000000)
14 #define PIM_NULL_REGISTER cpu_to_be32(0x40000000)
/linux-4.1.27/arch/powerpc/boot/
H A Dlibfdt_env.h16 #define cpu_to_fdt32(x) cpu_to_be32(x)
H A Dof.h29 #define cpu_to_be32(x) swab32(x) macro
36 #define cpu_to_be32(x) (x) macro
H A Doflib.c51 args.service = cpu_to_be32(ADDR(service)); of_call_prom()
52 args.nargs = cpu_to_be32(nargs); of_call_prom()
53 args.nret = cpu_to_be32(nret); of_call_prom()
57 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t)); of_call_prom()
76 args.service = cpu_to_be32(ADDR(service)); of_call_prom_ret()
77 args.nargs = cpu_to_be32(nargs); of_call_prom_ret()
78 args.nret = cpu_to_be32(nret); of_call_prom_ret()
82 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t)); of_call_prom_ret()
/linux-4.1.27/arch/arm/boot/compressed/
H A Dlibfdt_env.h11 #define cpu_to_fdt32(x) cpu_to_be32(x)
/linux-4.1.27/arch/powerpc/perf/
H A Dhv-common.c17 .counter_request = cpu_to_be32( hv_perf_caps_get()
19 .starting_index = cpu_to_be32(-1), hv_perf_caps_get()
/linux-4.1.27/drivers/gpu/drm/radeon/
H A Drv730_dpm.c109 sclk->sclk_value = cpu_to_be32(engine_clock); rv730_populate_sclk_value()
110 sclk->vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); rv730_populate_sclk_value()
111 sclk->vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); rv730_populate_sclk_value()
112 sclk->vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); rv730_populate_sclk_value()
113 sclk->vCG_SPLL_SPREAD_SPECTRUM = cpu_to_be32(cg_spll_spread_spectrum); rv730_populate_sclk_value()
114 sclk->vCG_SPLL_SPREAD_SPECTRUM_2 = cpu_to_be32(cg_spll_spread_spectrum_2); rv730_populate_sclk_value()
186 mclk->mclk730.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); rv730_populate_mclk_value()
187 mclk->mclk730.vDLL_CNTL = cpu_to_be32(dll_cntl); rv730_populate_mclk_value()
188 mclk->mclk730.mclk_value = cpu_to_be32(memory_clock); rv730_populate_mclk_value()
189 mclk->mclk730.vMPLL_FUNC_CNTL = cpu_to_be32(mpll_func_cntl); rv730_populate_mclk_value()
190 mclk->mclk730.vMPLL_FUNC_CNTL2 = cpu_to_be32(mpll_func_cntl_2); rv730_populate_mclk_value()
191 mclk->mclk730.vMPLL_FUNC_CNTL3 = cpu_to_be32(mpll_func_cntl_3); rv730_populate_mclk_value()
192 mclk->mclk730.vMPLL_SS = cpu_to_be32(mpll_ss); rv730_populate_mclk_value()
193 mclk->mclk730.vMPLL_SS2 = cpu_to_be32(mpll_ss2); rv730_populate_mclk_value()
297 table->ACPIState.levels[0].mclk.mclk730.vMPLL_FUNC_CNTL = cpu_to_be32(mpll_func_cntl); rv730_populate_smc_acpi_state()
298 table->ACPIState.levels[0].mclk.mclk730.vMPLL_FUNC_CNTL2 = cpu_to_be32(mpll_func_cntl_2); rv730_populate_smc_acpi_state()
299 table->ACPIState.levels[0].mclk.mclk730.vMPLL_FUNC_CNTL3 = cpu_to_be32(mpll_func_cntl_3); rv730_populate_smc_acpi_state()
300 table->ACPIState.levels[0].mclk.mclk730.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); rv730_populate_smc_acpi_state()
301 table->ACPIState.levels[0].mclk.mclk730.vDLL_CNTL = cpu_to_be32(dll_cntl); rv730_populate_smc_acpi_state()
305 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); rv730_populate_smc_acpi_state()
306 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); rv730_populate_smc_acpi_state()
307 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); rv730_populate_smc_acpi_state()
328 cpu_to_be32(pi->clk_regs.rv730.mpll_func_cntl); rv730_populate_smc_initial_state()
330 cpu_to_be32(pi->clk_regs.rv730.mpll_func_cntl2); rv730_populate_smc_initial_state()
332 cpu_to_be32(pi->clk_regs.rv730.mpll_func_cntl3); rv730_populate_smc_initial_state()
334 cpu_to_be32(pi->clk_regs.rv730.mclk_pwrmgt_cntl); rv730_populate_smc_initial_state()
336 cpu_to_be32(pi->clk_regs.rv730.dll_cntl); rv730_populate_smc_initial_state()
338 cpu_to_be32(pi->clk_regs.rv730.mpll_ss); rv730_populate_smc_initial_state()
340 cpu_to_be32(pi->clk_regs.rv730.mpll_ss2); rv730_populate_smc_initial_state()
343 cpu_to_be32(initial_state->low.mclk); rv730_populate_smc_initial_state()
346 cpu_to_be32(pi->clk_regs.rv730.cg_spll_func_cntl); rv730_populate_smc_initial_state()
348 cpu_to_be32(pi->clk_regs.rv730.cg_spll_func_cntl_2); rv730_populate_smc_initial_state()
350 cpu_to_be32(pi->clk_regs.rv730.cg_spll_func_cntl_3); rv730_populate_smc_initial_state()
352 cpu_to_be32(pi->clk_regs.rv730.cg_spll_spread_spectrum); rv730_populate_smc_initial_state()
354 cpu_to_be32(pi->clk_regs.rv730.cg_spll_spread_spectrum_2); rv730_populate_smc_initial_state()
357 cpu_to_be32(initial_state->low.sclk); rv730_populate_smc_initial_state()
372 table->initialState.levels[0].aT = cpu_to_be32(a_t); rv730_populate_smc_initial_state()
374 table->initialState.levels[0].bSP = cpu_to_be32(pi->dsp); rv730_populate_smc_initial_state()
H A Drv740_dpm.c177 sclk->sclk_value = cpu_to_be32(engine_clock); rv740_populate_sclk_value()
178 sclk->vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); rv740_populate_sclk_value()
179 sclk->vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); rv740_populate_sclk_value()
180 sclk->vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); rv740_populate_sclk_value()
181 sclk->vCG_SPLL_SPREAD_SPECTRUM = cpu_to_be32(cg_spll_spread_spectrum); rv740_populate_sclk_value()
182 sclk->vCG_SPLL_SPREAD_SPECTRUM_2 = cpu_to_be32(cg_spll_spread_spectrum_2); rv740_populate_sclk_value()
272 mclk->mclk770.mclk_value = cpu_to_be32(memory_clock); rv740_populate_mclk_value()
273 mclk->mclk770.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); rv740_populate_mclk_value()
274 mclk->mclk770.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); rv740_populate_mclk_value()
275 mclk->mclk770.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); rv740_populate_mclk_value()
276 mclk->mclk770.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); rv740_populate_mclk_value()
277 mclk->mclk770.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); rv740_populate_mclk_value()
278 mclk->mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl); rv740_populate_mclk_value()
279 mclk->mclk770.vMPLL_SS = cpu_to_be32(mpll_ss1); rv740_populate_mclk_value()
280 mclk->mclk770.vMPLL_SS2 = cpu_to_be32(mpll_ss2); rv740_populate_mclk_value()
374 table->ACPIState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); rv740_populate_smc_acpi_state()
375 table->ACPIState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); rv740_populate_smc_acpi_state()
376 table->ACPIState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); rv740_populate_smc_acpi_state()
377 table->ACPIState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); rv740_populate_smc_acpi_state()
378 table->ACPIState.levels[0].mclk.mclk770.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); rv740_populate_smc_acpi_state()
379 table->ACPIState.levels[0].mclk.mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl); rv740_populate_smc_acpi_state()
383 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); rv740_populate_smc_acpi_state()
384 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); rv740_populate_smc_acpi_state()
385 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); rv740_populate_smc_acpi_state()
H A Dcypress_dpm.c597 mclk->mclk770.mclk_value = cpu_to_be32(memory_clock); cypress_populate_mclk_value()
598 mclk->mclk770.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); cypress_populate_mclk_value()
599 mclk->mclk770.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); cypress_populate_mclk_value()
600 mclk->mclk770.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); cypress_populate_mclk_value()
601 mclk->mclk770.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); cypress_populate_mclk_value()
602 mclk->mclk770.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); cypress_populate_mclk_value()
603 mclk->mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl); cypress_populate_mclk_value()
604 mclk->mclk770.vMPLL_SS = cpu_to_be32(mpll_ss1); cypress_populate_mclk_value()
605 mclk->mclk770.vMPLL_SS2 = cpu_to_be32(mpll_ss2); cypress_populate_mclk_value()
821 data->value[i] = cpu_to_be32(entry->mc_data[j]); cypress_convert_mc_registers()
1244 cpu_to_be32(pi->clk_regs.rv770.mpll_ad_func_cntl); cypress_populate_smc_initial_state()
1246 cpu_to_be32(pi->clk_regs.rv770.mpll_ad_func_cntl_2); cypress_populate_smc_initial_state()
1248 cpu_to_be32(pi->clk_regs.rv770.mpll_dq_func_cntl); cypress_populate_smc_initial_state()
1250 cpu_to_be32(pi->clk_regs.rv770.mpll_dq_func_cntl_2); cypress_populate_smc_initial_state()
1252 cpu_to_be32(pi->clk_regs.rv770.mclk_pwrmgt_cntl); cypress_populate_smc_initial_state()
1254 cpu_to_be32(pi->clk_regs.rv770.dll_cntl); cypress_populate_smc_initial_state()
1257 cpu_to_be32(pi->clk_regs.rv770.mpll_ss1); cypress_populate_smc_initial_state()
1259 cpu_to_be32(pi->clk_regs.rv770.mpll_ss2); cypress_populate_smc_initial_state()
1262 cpu_to_be32(initial_state->low.mclk); cypress_populate_smc_initial_state()
1265 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl); cypress_populate_smc_initial_state()
1267 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl_2); cypress_populate_smc_initial_state()
1269 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl_3); cypress_populate_smc_initial_state()
1271 cpu_to_be32(pi->clk_regs.rv770.cg_spll_spread_spectrum); cypress_populate_smc_initial_state()
1273 cpu_to_be32(pi->clk_regs.rv770.cg_spll_spread_spectrum_2); cypress_populate_smc_initial_state()
1276 cpu_to_be32(initial_state->low.sclk); cypress_populate_smc_initial_state()
1297 table->initialState.levels[0].aT = cpu_to_be32(a_t); cypress_populate_smc_initial_state()
1299 table->initialState.levels[0].bSP = cpu_to_be32(pi->dsp); cypress_populate_smc_initial_state()
1434 cpu_to_be32(mpll_ad_func_cntl); cypress_populate_smc_acpi_state()
1436 cpu_to_be32(mpll_ad_func_cntl_2); cypress_populate_smc_acpi_state()
1438 cpu_to_be32(mpll_dq_func_cntl); cypress_populate_smc_acpi_state()
1440 cpu_to_be32(mpll_dq_func_cntl_2); cypress_populate_smc_acpi_state()
1442 cpu_to_be32(mclk_pwrmgt_cntl); cypress_populate_smc_acpi_state()
1443 table->ACPIState.levels[0].mclk.mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl); cypress_populate_smc_acpi_state()
1448 cpu_to_be32(spll_func_cntl); cypress_populate_smc_acpi_state()
1450 cpu_to_be32(spll_func_cntl_2); cypress_populate_smc_acpi_state()
1452 cpu_to_be32(spll_func_cntl_3); cypress_populate_smc_acpi_state()
1519 table->lowSMIO[i] |= cpu_to_be32(voltage_table->entries[i].smio_low); cypress_populate_smc_voltage_table()
1537 cpu_to_be32(eg_pi->vddc_voltage_table.mask_low); cypress_populate_smc_voltage_tables()
1555 cpu_to_be32(eg_pi->vddci_voltage_table.mask_low); cypress_populate_smc_voltage_tables()
H A Drv770_dpm.c290 smc_state->levels[i].aT = cpu_to_be32(a_t); rv770_populate_smc_t()
297 cpu_to_be32(a_t); rv770_populate_smc_t()
310 smc_state->levels[i].bSP = cpu_to_be32(pi->dsp); rv770_populate_smc_sp()
313 cpu_to_be32(pi->psp); rv770_populate_smc_sp()
473 mclk->mclk770.mclk_value = cpu_to_be32(memory_clock); rv770_populate_mclk_value()
474 mclk->mclk770.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); rv770_populate_mclk_value()
475 mclk->mclk770.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); rv770_populate_mclk_value()
476 mclk->mclk770.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); rv770_populate_mclk_value()
477 mclk->mclk770.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); rv770_populate_mclk_value()
478 mclk->mclk770.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); rv770_populate_mclk_value()
479 mclk->mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl); rv770_populate_mclk_value()
556 sclk->sclk_value = cpu_to_be32(engine_clock); rv770_populate_sclk_value()
557 sclk->vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); rv770_populate_sclk_value()
558 sclk->vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); rv770_populate_sclk_value()
559 sclk->vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); rv770_populate_sclk_value()
560 sclk->vCG_SPLL_SPREAD_SPECTRUM = cpu_to_be32(cg_spll_spread_spectrum); rv770_populate_sclk_value()
561 sclk->vCG_SPLL_SPREAD_SPECTRUM_2 = cpu_to_be32(cg_spll_spread_spectrum_2); rv770_populate_sclk_value()
982 table->ACPIState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); rv770_populate_smc_acpi_state()
983 table->ACPIState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); rv770_populate_smc_acpi_state()
984 table->ACPIState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); rv770_populate_smc_acpi_state()
985 table->ACPIState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); rv770_populate_smc_acpi_state()
987 table->ACPIState.levels[0].mclk.mclk770.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); rv770_populate_smc_acpi_state()
988 table->ACPIState.levels[0].mclk.mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl); rv770_populate_smc_acpi_state()
992 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); rv770_populate_smc_acpi_state()
993 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); rv770_populate_smc_acpi_state()
994 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); rv770_populate_smc_acpi_state()
1032 cpu_to_be32(pi->clk_regs.rv770.mpll_ad_func_cntl); rv770_populate_smc_initial_state()
1034 cpu_to_be32(pi->clk_regs.rv770.mpll_ad_func_cntl_2); rv770_populate_smc_initial_state()
1036 cpu_to_be32(pi->clk_regs.rv770.mpll_dq_func_cntl); rv770_populate_smc_initial_state()
1038 cpu_to_be32(pi->clk_regs.rv770.mpll_dq_func_cntl_2); rv770_populate_smc_initial_state()
1040 cpu_to_be32(pi->clk_regs.rv770.mclk_pwrmgt_cntl); rv770_populate_smc_initial_state()
1042 cpu_to_be32(pi->clk_regs.rv770.dll_cntl); rv770_populate_smc_initial_state()
1045 cpu_to_be32(pi->clk_regs.rv770.mpll_ss1); rv770_populate_smc_initial_state()
1047 cpu_to_be32(pi->clk_regs.rv770.mpll_ss2); rv770_populate_smc_initial_state()
1050 cpu_to_be32(initial_state->low.mclk); rv770_populate_smc_initial_state()
1053 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl); rv770_populate_smc_initial_state()
1055 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl_2); rv770_populate_smc_initial_state()
1057 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl_3); rv770_populate_smc_initial_state()
1059 cpu_to_be32(pi->clk_regs.rv770.cg_spll_spread_spectrum); rv770_populate_smc_initial_state()
1061 cpu_to_be32(pi->clk_regs.rv770.cg_spll_spread_spectrum_2); rv770_populate_smc_initial_state()
1064 cpu_to_be32(initial_state->low.sclk); rv770_populate_smc_initial_state()
1078 table->initialState.levels[0].aT = cpu_to_be32(a_t); rv770_populate_smc_initial_state()
1080 table->initialState.levels[0].bSP = cpu_to_be32(pi->dsp); rv770_populate_smc_initial_state()
1124 cpu_to_be32(pi->vddc_table[i].low_smio); rv770_populate_smc_vddc_table()
1129 cpu_to_be32(pi->vddc_mask_low); rv770_populate_smc_vddc_table()
1150 cpu_to_be32(pi->mvdd_low_smio[MVDD_HIGH_INDEX]); rv770_populate_smc_mvdd_table()
1152 cpu_to_be32(pi->mvdd_low_smio[MVDD_LOW_INDEX]); rv770_populate_smc_mvdd_table()
1156 cpu_to_be32(pi->mvdd_mask_low); rv770_populate_smc_mvdd_table()
H A Dni_dpm.c1265 table->lowSMIO[i] |= cpu_to_be32(voltage_table->entries[i].smio_low); ni_populate_smc_voltage_table()
1280 cpu_to_be32(eg_pi->vddc_voltage_table.mask_low); ni_populate_smc_voltage_tables()
1295 cpu_to_be32(eg_pi->vddci_voltage_table.mask_low); ni_populate_smc_voltage_tables()
1483 cpu_to_be32(ni_scale_power_for_smc(tdp_limit, scaling_factor)); ni_populate_smc_tdp_limits()
1485 cpu_to_be32(ni_scale_power_for_smc(near_tdp_limit, scaling_factor)); ni_populate_smc_tdp_limits()
1487 cpu_to_be32(ni_scale_power_for_smc((near_tdp_limit * NISLANDS_DPM2_TDP_SAFE_LIMIT_PERCENT) / 100, ni_populate_smc_tdp_limits()
1490 cpu_to_be32(ni_scale_power_for_smc(power_boost_limit, scaling_factor)); ni_populate_smc_tdp_limits()
1631 arb_regs->mc_arb_dram_timing = cpu_to_be32(dram_timing); ni_populate_memory_timing_parameters()
1632 arb_regs->mc_arb_dram_timing2 = cpu_to_be32(dram_timing2); ni_populate_memory_timing_parameters()
1693 cpu_to_be32(ni_pi->clock_registers.mpll_ad_func_cntl); ni_populate_smc_initial_state()
1695 cpu_to_be32(ni_pi->clock_registers.mpll_ad_func_cntl_2); ni_populate_smc_initial_state()
1697 cpu_to_be32(ni_pi->clock_registers.mpll_dq_func_cntl); ni_populate_smc_initial_state()
1699 cpu_to_be32(ni_pi->clock_registers.mpll_dq_func_cntl_2); ni_populate_smc_initial_state()
1701 cpu_to_be32(ni_pi->clock_registers.mclk_pwrmgt_cntl); ni_populate_smc_initial_state()
1703 cpu_to_be32(ni_pi->clock_registers.dll_cntl); ni_populate_smc_initial_state()
1705 cpu_to_be32(ni_pi->clock_registers.mpll_ss1); ni_populate_smc_initial_state()
1707 cpu_to_be32(ni_pi->clock_registers.mpll_ss2); ni_populate_smc_initial_state()
1709 cpu_to_be32(initial_state->performance_levels[0].mclk); ni_populate_smc_initial_state()
1712 cpu_to_be32(ni_pi->clock_registers.cg_spll_func_cntl); ni_populate_smc_initial_state()
1714 cpu_to_be32(ni_pi->clock_registers.cg_spll_func_cntl_2); ni_populate_smc_initial_state()
1716 cpu_to_be32(ni_pi->clock_registers.cg_spll_func_cntl_3); ni_populate_smc_initial_state()
1718 cpu_to_be32(ni_pi->clock_registers.cg_spll_func_cntl_4); ni_populate_smc_initial_state()
1720 cpu_to_be32(ni_pi->clock_registers.cg_spll_spread_spectrum); ni_populate_smc_initial_state()
1722 cpu_to_be32(ni_pi->clock_registers.cg_spll_spread_spectrum_2); ni_populate_smc_initial_state()
1724 cpu_to_be32(initial_state->performance_levels[0].sclk); ni_populate_smc_initial_state()
1754 table->initialState.levels[0].aT = cpu_to_be32(reg); ni_populate_smc_initial_state()
1756 table->initialState.levels[0].bSP = cpu_to_be32(pi->dsp); ni_populate_smc_initial_state()
1784 table->initialState.levels[0].SQPowerThrottle = cpu_to_be32(reg); ni_populate_smc_initial_state()
1787 table->initialState.levels[0].SQPowerThrottle_2 = cpu_to_be32(reg); ni_populate_smc_initial_state()
1905 table->ACPIState.levels[0].mclk.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); ni_populate_smc_acpi_state()
1906 table->ACPIState.levels[0].mclk.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); ni_populate_smc_acpi_state()
1907 table->ACPIState.levels[0].mclk.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); ni_populate_smc_acpi_state()
1908 table->ACPIState.levels[0].mclk.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); ni_populate_smc_acpi_state()
1909 table->ACPIState.levels[0].mclk.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); ni_populate_smc_acpi_state()
1910 table->ACPIState.levels[0].mclk.vDLL_CNTL = cpu_to_be32(dll_cntl); ni_populate_smc_acpi_state()
1914 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); ni_populate_smc_acpi_state()
1915 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); ni_populate_smc_acpi_state()
1916 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); ni_populate_smc_acpi_state()
1917 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_4 = cpu_to_be32(spll_func_cntl_4); ni_populate_smc_acpi_state()
1932 table->ACPIState.levels[0].SQPowerThrottle = cpu_to_be32(reg); ni_populate_smc_acpi_state()
1935 table->ACPIState.levels[0].SQPowerThrottle_2 = cpu_to_be32(reg); ni_populate_smc_acpi_state()
2078 sclk->sclk_value = cpu_to_be32(sclk_tmp.sclk_value); ni_populate_sclk_value()
2079 sclk->vCG_SPLL_FUNC_CNTL = cpu_to_be32(sclk_tmp.vCG_SPLL_FUNC_CNTL); ni_populate_sclk_value()
2080 sclk->vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(sclk_tmp.vCG_SPLL_FUNC_CNTL_2); ni_populate_sclk_value()
2081 sclk->vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(sclk_tmp.vCG_SPLL_FUNC_CNTL_3); ni_populate_sclk_value()
2082 sclk->vCG_SPLL_FUNC_CNTL_4 = cpu_to_be32(sclk_tmp.vCG_SPLL_FUNC_CNTL_4); ni_populate_sclk_value()
2083 sclk->vCG_SPLL_SPREAD_SPECTRUM = cpu_to_be32(sclk_tmp.vCG_SPLL_SPREAD_SPECTRUM); ni_populate_sclk_value()
2084 sclk->vCG_SPLL_SPREAD_SPECTRUM_2 = cpu_to_be32(sclk_tmp.vCG_SPLL_SPREAD_SPECTRUM_2); ni_populate_sclk_value()
2142 spll_table->freq[i] = cpu_to_be32(tmp); ni_init_smc_spll_table()
2146 spll_table->ss[i] = cpu_to_be32(tmp); ni_init_smc_spll_table()
2281 mclk->mclk_value = cpu_to_be32(memory_clock); ni_populate_mclk_value()
2282 mclk->vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); ni_populate_mclk_value()
2283 mclk->vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); ni_populate_mclk_value()
2284 mclk->vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); ni_populate_mclk_value()
2285 mclk->vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); ni_populate_mclk_value()
2286 mclk->vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); ni_populate_mclk_value()
2287 mclk->vDLL_CNTL = cpu_to_be32(dll_cntl); ni_populate_mclk_value()
2288 mclk->vMPLL_SS = cpu_to_be32(mpll_ss1); ni_populate_mclk_value()
2289 mclk->vMPLL_SS2 = cpu_to_be32(mpll_ss2); ni_populate_mclk_value()
2303 smc_state->levels[i].bSP = cpu_to_be32(pi->dsp); ni_populate_smc_sp()
2306 cpu_to_be32(pi->psp); ni_populate_smc_sp()
2407 smc_state->levels[0].aT = cpu_to_be32(a_t); ni_populate_smc_t()
2411 smc_state->levels[0].aT = cpu_to_be32(0); ni_populate_smc_t()
2438 smc_state->levels[i].aT = cpu_to_be32(a_t); ni_populate_smc_t()
2444 smc_state->levels[i + 1].aT = cpu_to_be32(a_t); ni_populate_smc_t()
2587 smc_state->levels[i].SQPowerThrottle = cpu_to_be32(sq_power_throttle); ni_populate_sq_ramping_values()
2588 smc_state->levels[i].SQPowerThrottle_2 = cpu_to_be32(sq_power_throttle2); ni_populate_sq_ramping_values()
2668 cpu_to_be32(threshold / 512)); ni_convert_power_state_to_smc()
2951 data->value[i] = cpu_to_be32(entry->mc_data[j]); ni_convert_mc_registers()
3082 cac_tables->cac_lkge_lut[i][j] = cpu_to_be32(smc_leakage); ni_init_driver_calculated_leakage_table()
3088 cac_tables->cac_lkge_lut[i][j] = cpu_to_be32(max_leakage); ni_init_driver_calculated_leakage_table()
3128 cpu_to_be32(ni_scale_power_for_smc(smc_leakage, scaling_factor)); ni_init_simplified_leakage_table()
3134 cpu_to_be32(ni_scale_power_for_smc(max_leakage, scaling_factor)); ni_init_simplified_leakage_table()
3184 cac_tables->pwr_const = cpu_to_be32(ni_pi->cac_data.pwr_const); ni_initialize_smc_cac_tables()
3185 cac_tables->dc_cacValue = cpu_to_be32(ni_pi->cac_data.dc_cac_value); ni_initialize_smc_cac_tables()
3186 cac_tables->bif_cacValue = cpu_to_be32(ni_pi->cac_data.bif_cac_value); ni_initialize_smc_cac_tables()
H A Dsi_dpm.c2182 cpu_to_be32(si_scale_power_for_smc(tdp_limit, scaling_factor) * 1000); si_populate_smc_tdp_limits()
2184 cpu_to_be32(si_scale_power_for_smc(near_tdp_limit, scaling_factor) * 1000); si_populate_smc_tdp_limits()
2186 cpu_to_be32(si_scale_power_for_smc((near_tdp_limit * SISLANDS_DPM2_TDP_SAFE_LIMIT_PERCENT) / 100, scaling_factor) * 1000); si_populate_smc_tdp_limits()
2200 papm_parm->NearTDPLimitTherm = cpu_to_be32(ppm->dgpu_tdp); si_populate_smc_tdp_limits()
2201 papm_parm->dGPU_T_Limit = cpu_to_be32(ppm->tj_max); si_populate_smc_tdp_limits()
2202 papm_parm->dGPU_T_Warning = cpu_to_be32(95); si_populate_smc_tdp_limits()
2203 papm_parm->dGPU_T_Hysteresis = cpu_to_be32(5); si_populate_smc_tdp_limits()
2232 cpu_to_be32(si_scale_power_for_smc(rdev->pm.dpm.near_tdp_limit_adjusted, scaling_factor) * 1000); si_populate_smc_tdp_limits_2()
2234 cpu_to_be32(si_scale_power_for_smc((rdev->pm.dpm.near_tdp_limit_adjusted * SISLANDS_DPM2_TDP_SAFE_LIMIT_PERCENT) / 100, scaling_factor) * 1000); si_populate_smc_tdp_limits_2()
2428 smc_state->levels[i].SQPowerThrottle = cpu_to_be32(sq_power_throttle); si_populate_sq_ramping_values()
2429 smc_state->levels[i].SQPowerThrottle_2 = cpu_to_be32(sq_power_throttle2); si_populate_sq_ramping_values()
2499 dte_tables->K = cpu_to_be32(table_size); si_initialize_smc_dte_tables()
2500 dte_tables->T0 = cpu_to_be32(dte_data->t0); si_initialize_smc_dte_tables()
2501 dte_tables->MaxT = cpu_to_be32(dte_data->max_t); si_initialize_smc_dte_tables()
2505 dte_tables->Tthreshold = cpu_to_be32(dte_data->t_threshold); si_initialize_smc_dte_tables()
2511 dte_tables->tau[i] = cpu_to_be32(dte_data->tau[i]); si_initialize_smc_dte_tables()
2512 dte_tables->R[i] = cpu_to_be32(dte_data->r[i]); si_initialize_smc_dte_tables()
2519 dte_tables->Tdep_tau[i] = cpu_to_be32(dte_data->tdep_tau[i]); si_initialize_smc_dte_tables()
2520 dte_tables->Tdep_R[i] = cpu_to_be32(dte_data->tdep_r[i]); si_initialize_smc_dte_tables()
2701 cac_tables->l2numWin_TDP = cpu_to_be32(si_pi->dyn_powertune_data.l2_lta_window_size); si_initialize_smc_cac_tables()
2704 cac_tables->lkge_lut_V0 = cpu_to_be32((u32)vddc_min); si_initialize_smc_cac_tables()
2705 cac_tables->lkge_lut_Vstep = cpu_to_be32((u32)vddc_step); si_initialize_smc_cac_tables()
2706 cac_tables->R_LL = cpu_to_be32(load_line_slope); si_initialize_smc_cac_tables()
2707 cac_tables->WinTime = cpu_to_be32(si_pi->dyn_powertune_data.wintime); si_initialize_smc_cac_tables()
2708 cac_tables->calculation_repeats = cpu_to_be32(2); si_initialize_smc_cac_tables()
2709 cac_tables->dc_cac = cpu_to_be32(0); si_initialize_smc_cac_tables()
2712 cac_tables->lkge_lut_T0 = cpu_to_be32((u32)t0); si_initialize_smc_cac_tables()
2713 cac_tables->lkge_lut_Tstep = cpu_to_be32((u32)t_step); si_initialize_smc_cac_tables()
2891 spll_table->freq[i] = cpu_to_be32(tmp); si_init_smc_spll_table()
2895 spll_table->ss[i] = cpu_to_be32(tmp); si_init_smc_spll_table()
3983 table->lowSMIO[i] |= cpu_to_be32(voltage_table->entries[i].smio_low); si_populate_smc_voltage_table()
4005 cpu_to_be32(eg_pi->vddc_voltage_table.mask_low); si_populate_smc_voltage_tables()
4019 cpu_to_be32(eg_pi->vddci_voltage_table.mask_low); si_populate_smc_voltage_tables()
4027 cpu_to_be32(si_pi->mvdd_voltage_table.mask_low); si_populate_smc_voltage_tables()
4036 cpu_to_be32(si_pi->vddc_phase_shed_table.mask_low); si_populate_smc_voltage_tables()
4250 arb_regs->mc_arb_dram_timing = cpu_to_be32(dram_timing); si_populate_memory_timing_parameters()
4251 arb_regs->mc_arb_dram_timing2 = cpu_to_be32(dram_timing2); si_populate_memory_timing_parameters()
4316 cpu_to_be32(si_pi->clock_registers.dll_cntl); si_populate_smc_initial_state()
4318 cpu_to_be32(si_pi->clock_registers.mclk_pwrmgt_cntl); si_populate_smc_initial_state()
4320 cpu_to_be32(si_pi->clock_registers.mpll_ad_func_cntl); si_populate_smc_initial_state()
4322 cpu_to_be32(si_pi->clock_registers.mpll_dq_func_cntl); si_populate_smc_initial_state()
4324 cpu_to_be32(si_pi->clock_registers.mpll_func_cntl); si_populate_smc_initial_state()
4326 cpu_to_be32(si_pi->clock_registers.mpll_func_cntl_1); si_populate_smc_initial_state()
4328 cpu_to_be32(si_pi->clock_registers.mpll_func_cntl_2); si_populate_smc_initial_state()
4330 cpu_to_be32(si_pi->clock_registers.mpll_ss1); si_populate_smc_initial_state()
4332 cpu_to_be32(si_pi->clock_registers.mpll_ss2); si_populate_smc_initial_state()
4335 cpu_to_be32(initial_state->performance_levels[0].mclk); si_populate_smc_initial_state()
4338 cpu_to_be32(si_pi->clock_registers.cg_spll_func_cntl); si_populate_smc_initial_state()
4340 cpu_to_be32(si_pi->clock_registers.cg_spll_func_cntl_2); si_populate_smc_initial_state()
4342 cpu_to_be32(si_pi->clock_registers.cg_spll_func_cntl_3); si_populate_smc_initial_state()
4344 cpu_to_be32(si_pi->clock_registers.cg_spll_func_cntl_4); si_populate_smc_initial_state()
4346 cpu_to_be32(si_pi->clock_registers.cg_spll_spread_spectrum); si_populate_smc_initial_state()
4348 cpu_to_be32(si_pi->clock_registers.cg_spll_spread_spectrum_2); si_populate_smc_initial_state()
4351 cpu_to_be32(initial_state->performance_levels[0].sclk); si_populate_smc_initial_state()
4391 table->initialState.levels[0].aT = cpu_to_be32(reg); si_populate_smc_initial_state()
4393 table->initialState.levels[0].bSP = cpu_to_be32(pi->dsp); si_populate_smc_initial_state()
4419 table->initialState.levels[0].SQPowerThrottle = cpu_to_be32(reg); si_populate_smc_initial_state()
4422 table->initialState.levels[0].SQPowerThrottle_2 = cpu_to_be32(reg); si_populate_smc_initial_state()
4518 cpu_to_be32(dll_cntl); si_populate_smc_acpi_state()
4520 cpu_to_be32(mclk_pwrmgt_cntl); si_populate_smc_acpi_state()
4522 cpu_to_be32(mpll_ad_func_cntl); si_populate_smc_acpi_state()
4524 cpu_to_be32(mpll_dq_func_cntl); si_populate_smc_acpi_state()
4526 cpu_to_be32(mpll_func_cntl); si_populate_smc_acpi_state()
4528 cpu_to_be32(mpll_func_cntl_1); si_populate_smc_acpi_state()
4530 cpu_to_be32(mpll_func_cntl_2); si_populate_smc_acpi_state()
4532 cpu_to_be32(si_pi->clock_registers.mpll_ss1); si_populate_smc_acpi_state()
4534 cpu_to_be32(si_pi->clock_registers.mpll_ss2); si_populate_smc_acpi_state()
4537 cpu_to_be32(spll_func_cntl); si_populate_smc_acpi_state()
4539 cpu_to_be32(spll_func_cntl_2); si_populate_smc_acpi_state()
4541 cpu_to_be32(spll_func_cntl_3); si_populate_smc_acpi_state()
4543 cpu_to_be32(spll_func_cntl_4); si_populate_smc_acpi_state()
4560 table->ACPIState.levels[0].SQPowerThrottle = cpu_to_be32(reg); si_populate_smc_acpi_state()
4563 table->ACPIState.levels[0].SQPowerThrottle_2 = cpu_to_be32(reg); si_populate_smc_acpi_state()
4799 sclk->sclk_value = cpu_to_be32(sclk_tmp.sclk_value); si_populate_sclk_value()
4800 sclk->vCG_SPLL_FUNC_CNTL = cpu_to_be32(sclk_tmp.vCG_SPLL_FUNC_CNTL); si_populate_sclk_value()
4801 sclk->vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(sclk_tmp.vCG_SPLL_FUNC_CNTL_2); si_populate_sclk_value()
4802 sclk->vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(sclk_tmp.vCG_SPLL_FUNC_CNTL_3); si_populate_sclk_value()
4803 sclk->vCG_SPLL_FUNC_CNTL_4 = cpu_to_be32(sclk_tmp.vCG_SPLL_FUNC_CNTL_4); si_populate_sclk_value()
4804 sclk->vCG_SPLL_SPREAD_SPECTRUM = cpu_to_be32(sclk_tmp.vCG_SPLL_SPREAD_SPECTRUM); si_populate_sclk_value()
4805 sclk->vCG_SPLL_SPREAD_SPECTRUM_2 = cpu_to_be32(sclk_tmp.vCG_SPLL_SPREAD_SPECTRUM_2); si_populate_sclk_value()
4886 mclk->mclk_value = cpu_to_be32(memory_clock); si_populate_mclk_value()
4887 mclk->vMPLL_FUNC_CNTL = cpu_to_be32(mpll_func_cntl); si_populate_mclk_value()
4888 mclk->vMPLL_FUNC_CNTL_1 = cpu_to_be32(mpll_func_cntl_1); si_populate_mclk_value()
4889 mclk->vMPLL_FUNC_CNTL_2 = cpu_to_be32(mpll_func_cntl_2); si_populate_mclk_value()
4890 mclk->vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); si_populate_mclk_value()
4891 mclk->vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); si_populate_mclk_value()
4892 mclk->vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); si_populate_mclk_value()
4893 mclk->vDLL_CNTL = cpu_to_be32(dll_cntl); si_populate_mclk_value()
4894 mclk->vMPLL_SS = cpu_to_be32(mpll_ss1); si_populate_mclk_value()
4895 mclk->vMPLL_SS2 = cpu_to_be32(mpll_ss2); si_populate_mclk_value()
4909 smc_state->levels[i].bSP = cpu_to_be32(pi->dsp); si_populate_smc_sp()
4912 cpu_to_be32(pi->psp); si_populate_smc_sp()
5040 smc_state->levels[0].aT = cpu_to_be32(a_t); si_populate_smc_t()
5044 smc_state->levels[0].aT = cpu_to_be32(0); si_populate_smc_t()
5062 smc_state->levels[i].aT = cpu_to_be32(a_t); si_populate_smc_t()
5067 smc_state->levels[i + 1].aT = cpu_to_be32(a_t); si_populate_smc_t()
5549 data->value[i] = cpu_to_be32(entry->mc_data[j]); si_convert_mc_registers()
6006 fan_table.refresh_period = cpu_to_be32((rdev->pm.dpm.fan.cycle_delay * si_thermal_setup_fan_table()
H A Dci_dpm.c458 dpm_table->BAPM_TEMP_GRADIENT = cpu_to_be32(pt_defaults->bapm_temp_gradient); ci_populate_bapm_parameters_in_dpm_table()
1003 fan_table.RefreshPeriod = cpu_to_be32((rdev->pm.dpm.fan.cycle_delay * ci_thermal_setup_fan_table()
1316 low_sclk_interrupt_t = cpu_to_be32(pi->low_sclk_interrupt_t); ci_update_sclk_t()
2206 table->VddcLevelCount = cpu_to_be32(table->VddcLevelCount); ci_populate_smc_vddc_table()
2229 table->VddciLevelCount = cpu_to_be32(table->VddciLevelCount); ci_populate_smc_vddci_table()
2252 table->MvddLevelCount = cpu_to_be32(table->MvddLevelCount); ci_populate_smc_mvdd_table()
2509 arb_regs->McArbDramTiming = cpu_to_be32(dram_timing); ci_populate_memory_timing_parameters()
2510 arb_regs->McArbDramTiming2 = cpu_to_be32(dram_timing2); ci_populate_memory_timing_parameters()
2609 table->LinkLevel[i].DownT = cpu_to_be32(5); ci_populate_smc_link_level()
2610 table->LinkLevel[i].UpT = cpu_to_be32(30); ci_populate_smc_link_level()
2653 table->UvdLevel[count].VclkFrequency = cpu_to_be32(table->UvdLevel[count].VclkFrequency); ci_populate_smc_uvd_level()
2654 table->UvdLevel[count].DclkFrequency = cpu_to_be32(table->UvdLevel[count].DclkFrequency); ci_populate_smc_uvd_level()
2686 table->VceLevel[count].Frequency = cpu_to_be32(table->VceLevel[count].Frequency); ci_populate_smc_vce_level()
2719 table->AcpLevel[count].Frequency = cpu_to_be32(table->AcpLevel[count].Frequency); ci_populate_smc_acp_level()
2751 table->SamuLevel[count].Frequency = cpu_to_be32(table->SamuLevel[count].Frequency); ci_populate_smc_samu_level()
2939 memory_level->MinVddc = cpu_to_be32(memory_level->MinVddc * VOLTAGE_SCALE); ci_populate_single_memory_level()
2940 memory_level->MinVddcPhases = cpu_to_be32(memory_level->MinVddcPhases); ci_populate_single_memory_level()
2941 memory_level->MinVddci = cpu_to_be32(memory_level->MinVddci * VOLTAGE_SCALE); ci_populate_single_memory_level()
2942 memory_level->MinMvdd = cpu_to_be32(memory_level->MinMvdd * VOLTAGE_SCALE); ci_populate_single_memory_level()
2944 memory_level->MclkFrequency = cpu_to_be32(memory_level->MclkFrequency); ci_populate_single_memory_level()
2946 memory_level->MpllFuncCntl = cpu_to_be32(memory_level->MpllFuncCntl); ci_populate_single_memory_level()
2947 memory_level->MpllFuncCntl_1 = cpu_to_be32(memory_level->MpllFuncCntl_1); ci_populate_single_memory_level()
2948 memory_level->MpllFuncCntl_2 = cpu_to_be32(memory_level->MpllFuncCntl_2); ci_populate_single_memory_level()
2949 memory_level->MpllAdFuncCntl = cpu_to_be32(memory_level->MpllAdFuncCntl); ci_populate_single_memory_level()
2950 memory_level->MpllDqFuncCntl = cpu_to_be32(memory_level->MpllDqFuncCntl); ci_populate_single_memory_level()
2951 memory_level->MclkPwrmgtCntl = cpu_to_be32(memory_level->MclkPwrmgtCntl); ci_populate_single_memory_level()
2952 memory_level->DllCntl = cpu_to_be32(memory_level->DllCntl); ci_populate_single_memory_level()
2953 memory_level->MpllSs1 = cpu_to_be32(memory_level->MpllSs1); ci_populate_single_memory_level()
2954 memory_level->MpllSs2 = cpu_to_be32(memory_level->MpllSs2); ci_populate_single_memory_level()
2974 table->ACPILevel.MinVddc = cpu_to_be32(pi->acpi_vddc * VOLTAGE_SCALE); ci_populate_smc_acpi_level()
2976 table->ACPILevel.MinVddc = cpu_to_be32(pi->min_vddc_in_pp_table * VOLTAGE_SCALE); ci_populate_smc_acpi_level()
3007 table->ACPILevel.Flags = cpu_to_be32(table->ACPILevel.Flags); ci_populate_smc_acpi_level()
3008 table->ACPILevel.MinVddcPhases = cpu_to_be32(table->ACPILevel.MinVddcPhases); ci_populate_smc_acpi_level()
3009 table->ACPILevel.SclkFrequency = cpu_to_be32(table->ACPILevel.SclkFrequency); ci_populate_smc_acpi_level()
3010 table->ACPILevel.CgSpllFuncCntl = cpu_to_be32(table->ACPILevel.CgSpllFuncCntl); ci_populate_smc_acpi_level()
3011 table->ACPILevel.CgSpllFuncCntl2 = cpu_to_be32(table->ACPILevel.CgSpllFuncCntl2); ci_populate_smc_acpi_level()
3012 table->ACPILevel.CgSpllFuncCntl3 = cpu_to_be32(table->ACPILevel.CgSpllFuncCntl3); ci_populate_smc_acpi_level()
3013 table->ACPILevel.CgSpllFuncCntl4 = cpu_to_be32(table->ACPILevel.CgSpllFuncCntl4); ci_populate_smc_acpi_level()
3014 table->ACPILevel.SpllSpreadSpectrum = cpu_to_be32(table->ACPILevel.SpllSpreadSpectrum); ci_populate_smc_acpi_level()
3015 table->ACPILevel.SpllSpreadSpectrum2 = cpu_to_be32(table->ACPILevel.SpllSpreadSpectrum2); ci_populate_smc_acpi_level()
3016 table->ACPILevel.CcPwrDynRm = cpu_to_be32(table->ACPILevel.CcPwrDynRm); ci_populate_smc_acpi_level()
3017 table->ACPILevel.CcPwrDynRm1 = cpu_to_be32(table->ACPILevel.CcPwrDynRm1); ci_populate_smc_acpi_level()
3025 cpu_to_be32(pi->acpi_vddci * VOLTAGE_SCALE); ci_populate_smc_acpi_level()
3028 cpu_to_be32(pi->min_vddci_in_pp_table * VOLTAGE_SCALE); ci_populate_smc_acpi_level()
3035 cpu_to_be32(voltage_level.Voltage * VOLTAGE_SCALE); ci_populate_smc_acpi_level()
3042 table->MemoryACPILevel.DllCntl = cpu_to_be32(dll_cntl); ci_populate_smc_acpi_level()
3043 table->MemoryACPILevel.MclkPwrmgtCntl = cpu_to_be32(mclk_pwrmgt_cntl); ci_populate_smc_acpi_level()
3045 cpu_to_be32(pi->clock_registers.mpll_ad_func_cntl); ci_populate_smc_acpi_level()
3047 cpu_to_be32(pi->clock_registers.mpll_dq_func_cntl); ci_populate_smc_acpi_level()
3049 cpu_to_be32(pi->clock_registers.mpll_func_cntl); ci_populate_smc_acpi_level()
3051 cpu_to_be32(pi->clock_registers.mpll_func_cntl_1); ci_populate_smc_acpi_level()
3053 cpu_to_be32(pi->clock_registers.mpll_func_cntl_2); ci_populate_smc_acpi_level()
3054 table->MemoryACPILevel.MpllSs1 = cpu_to_be32(pi->clock_registers.mpll_ss1); ci_populate_smc_acpi_level()
3055 table->MemoryACPILevel.MpllSs2 = cpu_to_be32(pi->clock_registers.mpll_ss2); ci_populate_smc_acpi_level()
3122 state->CcPwrDynRm = cpu_to_be32(state->CcPwrDynRm); ci_populate_ulv_level()
3123 state->CcPwrDynRm1 = cpu_to_be32(state->CcPwrDynRm1); ci_populate_ulv_level()
3231 graphic_level->Flags = cpu_to_be32(graphic_level->Flags); ci_populate_single_graphic_level()
3232 graphic_level->MinVddc = cpu_to_be32(graphic_level->MinVddc * VOLTAGE_SCALE); ci_populate_single_graphic_level()
3233 graphic_level->MinVddcPhases = cpu_to_be32(graphic_level->MinVddcPhases); ci_populate_single_graphic_level()
3234 graphic_level->SclkFrequency = cpu_to_be32(graphic_level->SclkFrequency); ci_populate_single_graphic_level()
3236 graphic_level->CgSpllFuncCntl3 = cpu_to_be32(graphic_level->CgSpllFuncCntl3); ci_populate_single_graphic_level()
3237 graphic_level->CgSpllFuncCntl4 = cpu_to_be32(graphic_level->CgSpllFuncCntl4); ci_populate_single_graphic_level()
3238 graphic_level->SpllSpreadSpectrum = cpu_to_be32(graphic_level->SpllSpreadSpectrum); ci_populate_single_graphic_level()
3239 graphic_level->SpllSpreadSpectrum2 = cpu_to_be32(graphic_level->SpllSpreadSpectrum2); ci_populate_single_graphic_level()
3240 graphic_level->CcPwrDynRm = cpu_to_be32(graphic_level->CcPwrDynRm); ci_populate_single_graphic_level()
3241 graphic_level->CcPwrDynRm1 = cpu_to_be32(graphic_level->CcPwrDynRm1); ci_populate_single_graphic_level()
3646 table->SystemFlags = cpu_to_be32(table->SystemFlags); ci_init_smc_table()
3647 table->SmioMaskVddcVid = cpu_to_be32(table->SmioMaskVddcVid); ci_init_smc_table()
3648 table->SmioMaskVddcPhase = cpu_to_be32(table->SmioMaskVddcPhase); ci_init_smc_table()
3649 table->SmioMaskVddciVid = cpu_to_be32(table->SmioMaskVddciVid); ci_init_smc_table()
3650 table->SmioMaskMvddVid = cpu_to_be32(table->SmioMaskMvddVid); ci_init_smc_table()
3651 table->SclkStepSize = cpu_to_be32(table->SclkStepSize); ci_init_smc_table()
4679 data->value[i] = cpu_to_be32(entry->mc_data[j]); ci_convert_mc_registers()
/linux-4.1.27/include/linux/lockd/
H A Dxdr4.h18 #define nlm4_deadlock cpu_to_be32(NLM_DEADLCK)
19 #define nlm4_rofs cpu_to_be32(NLM_ROFS)
20 #define nlm4_stale_fh cpu_to_be32(NLM_STALE_FH)
21 #define nlm4_fbig cpu_to_be32(NLM_FBIG)
22 #define nlm4_failed cpu_to_be32(NLM_FAILED)
H A Dxdr.h28 #define nlm_granted cpu_to_be32(NLM_LCK_GRANTED)
29 #define nlm_lck_denied cpu_to_be32(NLM_LCK_DENIED)
30 #define nlm_lck_denied_nolocks cpu_to_be32(NLM_LCK_DENIED_NOLOCKS)
31 #define nlm_lck_blocked cpu_to_be32(NLM_LCK_BLOCKED)
32 #define nlm_lck_denied_grace_period cpu_to_be32(NLM_LCK_DENIED_GRACE_PERIOD)
34 #define nlm_drop_reply cpu_to_be32(30000)
/linux-4.1.27/include/linux/sunrpc/
H A Dxdr.h74 #define xdr_zero cpu_to_be32(0)
75 #define xdr_one cpu_to_be32(1)
76 #define xdr_two cpu_to_be32(2)
78 #define rpc_success cpu_to_be32(RPC_SUCCESS)
79 #define rpc_prog_unavail cpu_to_be32(RPC_PROG_UNAVAIL)
80 #define rpc_prog_mismatch cpu_to_be32(RPC_PROG_MISMATCH)
81 #define rpc_proc_unavail cpu_to_be32(RPC_PROC_UNAVAIL)
82 #define rpc_garbage_args cpu_to_be32(RPC_GARBAGE_ARGS)
83 #define rpc_system_err cpu_to_be32(RPC_SYSTEM_ERR)
84 #define rpc_drop_reply cpu_to_be32(RPC_DROP_REPLY)
86 #define rpc_auth_ok cpu_to_be32(RPC_AUTH_OK)
87 #define rpc_autherr_badcred cpu_to_be32(RPC_AUTH_BADCRED)
88 #define rpc_autherr_rejectedcred cpu_to_be32(RPC_AUTH_REJECTEDCRED)
89 #define rpc_autherr_badverf cpu_to_be32(RPC_AUTH_BADVERF)
90 #define rpc_autherr_rejectedverf cpu_to_be32(RPC_AUTH_REJECTEDVERF)
91 #define rpc_autherr_tooweak cpu_to_be32(RPC_AUTH_TOOWEAK)
92 #define rpcsec_gsserr_credproblem cpu_to_be32(RPCSEC_GSS_CREDPROBLEM)
93 #define rpcsec_gsserr_ctxproblem cpu_to_be32(RPCSEC_GSS_CTXPROBLEM)
94 #define rpc_autherr_oldseqnum cpu_to_be32(101)
H A Drpc_rdma.h46 #define rpcrdma_version cpu_to_be32(RPCRDMA_VERSION)
124 #define rdma_msg cpu_to_be32(RDMA_MSG)
125 #define rdma_nomsg cpu_to_be32(RDMA_NOMSG)
126 #define rdma_msgp cpu_to_be32(RDMA_MSGP)
127 #define rdma_done cpu_to_be32(RDMA_DONE)
128 #define rdma_error cpu_to_be32(RDMA_ERROR)
/linux-4.1.27/drivers/net/ethernet/mellanox/mlx4/
H A Den_resources.c48 context->flags = cpu_to_be32(7 << 16 | rss << MLX4_RSS_QPC_FLAG_OFFSET); mlx4_en_fill_qp_context()
49 context->pd = cpu_to_be32(mdev->priv_pdn); mlx4_en_fill_qp_context()
61 context->usr_page = cpu_to_be32(mdev->priv_uar.index); mlx4_en_fill_qp_context()
62 context->local_qpn = cpu_to_be32(qpn); mlx4_en_fill_qp_context()
70 context->cqn_send = cpu_to_be32(cqn); mlx4_en_fill_qp_context()
71 context->cqn_recv = cpu_to_be32(cqn); mlx4_en_fill_qp_context()
74 context->param3 |= cpu_to_be32(1 << 30); mlx4_en_fill_qp_context()
79 context->srqn = cpu_to_be32(7 << 28); /* this fills bits 30:28 */ mlx4_en_fill_qp_context()
H A Den_dcb_nl.c389 hw_qcn->modify_enable_high = cpu_to_be32( mlx4_en_dcbnl_ieee_setqcn()
391 hw_qcn->modify_enable_low = cpu_to_be32(MODIFY_ENABLE_LOW_MASK); mlx4_en_dcbnl_ieee_setqcn()
393 hw_qcn->extended_enable = cpu_to_be32(qcn->rpg_enable[i] << RPG_ENABLE_BIT); mlx4_en_dcbnl_ieee_setqcn()
394 hw_qcn->rppp_max_rps = cpu_to_be32(qcn->rppp_max_rps[i]); mlx4_en_dcbnl_ieee_setqcn()
395 hw_qcn->rpg_time_reset = cpu_to_be32(qcn->rpg_time_reset[i]); mlx4_en_dcbnl_ieee_setqcn()
396 hw_qcn->rpg_byte_reset = cpu_to_be32(qcn->rpg_byte_reset[i]); mlx4_en_dcbnl_ieee_setqcn()
397 hw_qcn->rpg_threshold = cpu_to_be32(qcn->rpg_threshold[i]); mlx4_en_dcbnl_ieee_setqcn()
398 hw_qcn->rpg_max_rate = cpu_to_be32(qcn->rpg_max_rate[i]); mlx4_en_dcbnl_ieee_setqcn()
399 hw_qcn->rpg_ai_rate = cpu_to_be32(qcn->rpg_ai_rate[i]); mlx4_en_dcbnl_ieee_setqcn()
400 hw_qcn->rpg_hai_rate = cpu_to_be32(qcn->rpg_hai_rate[i]); mlx4_en_dcbnl_ieee_setqcn()
401 hw_qcn->rpg_gd = cpu_to_be32(qcn->rpg_gd[i]); mlx4_en_dcbnl_ieee_setqcn()
402 hw_qcn->rpg_min_dec_fac = cpu_to_be32(qcn->rpg_min_dec_fac[i]); mlx4_en_dcbnl_ieee_setqcn()
403 hw_qcn->rpg_min_rate = cpu_to_be32(qcn->rpg_min_rate[i]); mlx4_en_dcbnl_ieee_setqcn()
406 hw_qcn->extended_enable |= cpu_to_be32(1 << CN_TAG_BIT); mlx4_en_dcbnl_ieee_setqcn()
H A Dmr.c400 mpt_entry->pd_flags = cpu_to_be32(pd_flags | mlx4_mr_hw_change_pd()
414 mpt_entry->flags = cpu_to_be32(flags); mlx4_mr_hw_change_access()
603 mpt_entry->entity_size = cpu_to_be32(page_shift); mlx4_mr_rereg_mem_write()
604 mpt_entry->flags &= ~(cpu_to_be32(MLX4_MPT_FLAG_FREE | mlx4_mr_rereg_mem_write()
607 mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_PHYSICAL); mlx4_mr_rereg_mem_write()
613 mpt_entry->mtt_sz = cpu_to_be32(1 << mr->mtt.order); mlx4_mr_rereg_mem_write()
617 mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_FREE); mlx4_mr_rereg_mem_write()
618 mpt_entry->pd_flags |= cpu_to_be32(MLX4_MPT_PD_FLAG_FAST_REG | mlx4_mr_rereg_mem_write()
621 mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_SW_OWNS); mlx4_mr_rereg_mem_write()
645 mpt_entry->flags = cpu_to_be32(MLX4_MPT_FLAG_MIO | mlx4_mr_enable()
649 mpt_entry->key = cpu_to_be32(key_to_hw_index(mr->key)); mlx4_mr_enable()
650 mpt_entry->pd_flags = cpu_to_be32(mr->pd | MLX4_MPT_PD_FLAG_EN_INV); mlx4_mr_enable()
653 mpt_entry->entity_size = cpu_to_be32(mr->mtt.page_shift); mlx4_mr_enable()
656 mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_PHYSICAL); mlx4_mr_enable()
665 mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_FREE); mlx4_mr_enable()
666 mpt_entry->pd_flags |= cpu_to_be32(MLX4_MPT_PD_FLAG_FAST_REG | mlx4_mr_enable()
668 mpt_entry->mtt_sz = cpu_to_be32(1 << mr->mtt.order); mlx4_mr_enable()
670 mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_SW_OWNS); mlx4_mr_enable()
861 mpt_entry->key = cpu_to_be32(key_to_hw_index(mw->key)); mlx4_mw_enable()
862 mpt_entry->pd_flags = cpu_to_be32(mw->pd); mlx4_mw_enable()
864 mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_FREE); mlx4_mw_enable()
865 mpt_entry->qpn = cpu_to_be32(MLX4_MPT_QP_FLAG_BOUND_QP); mlx4_mw_enable()
866 mpt_entry->pd_flags |= cpu_to_be32(MLX4_MPT_PD_FLAG_EN_INV); mlx4_mw_enable()
1029 fmr->mpt->key = cpu_to_be32(key); mlx4_map_phys_fmr()
1030 fmr->mpt->lkey = cpu_to_be32(key); mlx4_map_phys_fmr()
H A Den_tx.c210 ring->doorbell_qpn = cpu_to_be32(ring->qp.qpn << 8); mlx4_en_activate_tx_ring()
211 ring->mr_key = cpu_to_be32(mdev->mr.key); mlx4_en_activate_tx_ring()
216 ring->context.usr_page = cpu_to_be32(ring->bf.uar->index); mlx4_en_activate_tx_ring()
245 __be32 stamp = cpu_to_be32(STAMP_VAL | (!!owner << STAMP_SHIFT)); mlx4_en_stamp_wqe()
268 stamp ^= cpu_to_be32(0x80000000); mlx4_en_stamp_wqe()
645 inl->byte_count = cpu_to_be32(1 << 31 | skb->len); build_inline_wqe()
647 inl->byte_count = cpu_to_be32(1 << 31 | MIN_PKT_LEN); build_inline_wqe()
657 inl->byte_count = cpu_to_be32(1 << 31 | spc); build_inline_wqe()
679 inl->byte_count = cpu_to_be32(1 << 31 | (skb->len - spc)); build_inline_wqe()
816 data->byte_count = cpu_to_be32(byte_count); mlx4_en_xmit()
833 data->byte_count = cpu_to_be32(byte_count); mlx4_en_xmit()
856 tx_desc->ctrl.srcrb_flags |= cpu_to_be32(MLX4_WQE_CTRL_IP_CSUM | mlx4_en_xmit()
859 tx_desc->ctrl.srcrb_flags |= cpu_to_be32(MLX4_WQE_CTRL_IP_CSUM); mlx4_en_xmit()
879 op_own = cpu_to_be32(MLX4_OPCODE_LSO | (1 << 6)) | mlx4_en_xmit()
881 cpu_to_be32(MLX4_EN_BIT_DESC_OWN) : 0); mlx4_en_xmit()
884 tx_desc->lso.mss_hdr_size = cpu_to_be32( mlx4_en_xmit()
899 op_own = cpu_to_be32(MLX4_OPCODE_SEND) | mlx4_en_xmit()
901 cpu_to_be32(MLX4_EN_BIT_DESC_OWN) : 0); mlx4_en_xmit()
916 op_own |= cpu_to_be32(MLX4_WQE_CTRL_IIP | MLX4_WQE_CTRL_ILP); mlx4_en_xmit()
918 op_own |= cpu_to_be32(MLX4_WQE_CTRL_IIP); mlx4_en_xmit()
942 cpu_to_be32(real_size); mlx4_en_xmit()
H A Dcq.c198 cq_context->logsize_usrpage = cpu_to_be32(ilog2(entries) << 24); mlx4_cq_resize()
202 cq_context->mtt_base_addr_l = cpu_to_be32(mtt_addr & 0xffffffff); mlx4_cq_resize()
317 cq_context->flags = cpu_to_be32(!!collapsed << 18); mlx4_cq_alloc()
319 cq_context->flags |= cpu_to_be32(1 << 19); mlx4_cq_alloc()
321 cq_context->logsize_usrpage = cpu_to_be32((ilog2(nent) << 24) | uar->index); mlx4_cq_alloc()
327 cq_context->mtt_base_addr_l = cpu_to_be32(mtt_addr & 0xffffffff); mlx4_cq_alloc()
H A Dfw_qos.c208 in_param->vpp_p_up[i] = cpu_to_be32(vpp_p_up[i]); mlx4_ALLOCATE_VPP_set()
273 ctx->qos_p_up[i].bw_share = cpu_to_be32(in_param[i].bw_share); mlx4_SET_VPORT_QOS_set()
275 cpu_to_be32(in_param[i].max_avg_bw); mlx4_SET_VPORT_QOS_set()
277 cpu_to_be32(in_param[i].enable << 31); mlx4_SET_VPORT_QOS_set()
H A Dsrq.c191 srq_context->state_logsize_srqn = cpu_to_be32((ilog2(srq->max) << 24) | mlx4_srq_alloc()
195 srq_context->pg_offset_cqn = cpu_to_be32(cqn & 0xffffff); mlx4_srq_alloc()
200 srq_context->mtt_base_addr_l = cpu_to_be32(mtt_addr & 0xffffffff); mlx4_srq_alloc()
201 srq_context->pd = cpu_to_be32(pdn); mlx4_srq_alloc()
H A Dmcg.c219 mgm->qp[members_count++] = cpu_to_be32(pqp->qpn & MGM_QPN_MASK); new_steering_entry()
222 mgm->members_count = cpu_to_be32(members_count | (prot << 30)); new_steering_entry()
503 cpu_to_be32(qpn & MGM_QPN_MASK); add_promisc_qp()
505 cpu_to_be32(members_count | add_promisc_qp()
526 mgm->qp[members_count++] = cpu_to_be32(dqp->qpn & MGM_QPN_MASK); add_promisc_qp()
528 mgm->members_count = cpu_to_be32(members_count | MLX4_PROT_ETH << 30); add_promisc_qp()
592 mgm->qp[members_count++] = cpu_to_be32(dqp->qpn & MGM_QPN_MASK); remove_promisc_qp()
593 mgm->members_count = cpu_to_be32(members_count | MLX4_PROT_ETH << 30); remove_promisc_qp()
656 cpu_to_be32(--members_count | remove_promisc_qp()
783 hw->qpn = cpu_to_be32(ctrl->qpn); trans_rule_ctrl_to_hw()
887 cpu_to_be32(be32_to_cpu(spec->vxlan.vni) << 8); parse_trans_rule()
889 cpu_to_be32(be32_to_cpu(spec->vxlan.vni_mask) << 8); parse_trans_rule()
1159 mgm->qp[members_count++] = cpu_to_be32((qp->qpn & MGM_QPN_MASK) | mlx4_qp_attach_common()
1162 mgm->qp[members_count++] = cpu_to_be32(qp->qpn & MGM_QPN_MASK); mlx4_qp_attach_common()
1164 mgm->members_count = cpu_to_be32(members_count | (u32) prot << 30); mlx4_qp_attach_common()
1177 mgm->next_gid_index = cpu_to_be32(index << 6); mlx4_qp_attach_common()
1261 mgm->members_count = cpu_to_be32(--members_count | (u32) prot << 30); mlx4_qp_detach_common()
1272 mgm->members_count = cpu_to_be32((u32) prot << 30); mlx4_qp_detach_common()
1303 mgm->next_gid_index = cpu_to_be32(cur_next_index << 6); mlx4_qp_detach_common()
H A Den_rx.c221 cpu_to_be32(priv->frag_info[i].frag_size); mlx4_en_init_rx_desc()
222 rx_desc->data[i].lkey = cpu_to_be32(priv->mdev->mr.key); mlx4_en_init_rx_desc()
231 rx_desc->data[i].lkey = cpu_to_be32(MLX4_EN_MEMTYPE_PAD); mlx4_en_init_rx_desc()
255 *ring->wqres.db.db = cpu_to_be32(ring->prod & 0xffff); mlx4_en_update_rx_prod_db()
734 if (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_VLAN_PRESENT_MASK) && check_csum()
848 (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_L2_TUNNEL));
915 cpu_to_be32(MLX4_CQE_VLAN_PRESENT_MASK)) &&
1135 context->param3 |= cpu_to_be32(1 << 29); mlx4_en_config_rss_qp()
1238 rss_context->base_qpn = cpu_to_be32(ilog2(rss_rings) << 24 | mlx4_en_config_rss_steer()
1240 rss_context->default_qpn = cpu_to_be32(rss_map->base_qpn); mlx4_en_config_rss_steer()
H A Dport.c415 table->entries[free] = cpu_to_be32(vlan | MLX4_VLAN_VALID); __mlx4_register_vlan()
521 *(__be32 *) (&inbuf[20]) = cpu_to_be32(port); mlx4_get_port_ib_caps()
732 cpu_to_be32(port_info->base_qpn); mlx4_common_set_port()
736 qpn_context->promisc = cpu_to_be32( mlx4_common_set_port()
741 qpn_context->mcast = cpu_to_be32( mlx4_common_set_port()
954 ((__be32 *) mailbox->buf)[0] = cpu_to_be32( mlx4_SET_PORT()
1017 context->base_qpn = cpu_to_be32(base_qpn); mlx4_SET_PORT_qpn_calc()
1019 context->promisc = cpu_to_be32(promisc << SET_PORT_PROMISC_SHIFT | mlx4_SET_PORT_qpn_calc()
1021 context->mcast = cpu_to_be32(m_promisc << SET_PORT_MC_PROMISC_SHIFT | mlx4_SET_PORT_qpn_calc()
1116 *((__be32 *)mailbox->buf) = cpu_to_be32(time); mlx4_SET_PORT_BEACON()
H A Dqp.c166 context->mtt_base_addr_l = cpu_to_be32(mtt_addr & 0xffffffff); __mlx4_qp_modify()
170 *(__be32 *) mailbox->buf = cpu_to_be32(optpar); __mlx4_qp_modify()
174 cpu_to_be32(qp->qpn); __mlx4_qp_modify()
442 cmd->qp_context.param3 |= cpu_to_be32(MLX4_STRIP_VLAN); mlx4_update_qp()
892 context->flags &= cpu_to_be32(~(0xf << 28)); mlx4_qp_to_ready()
893 context->flags |= cpu_to_be32(states[i + 1] << 28); mlx4_qp_to_ready()
/linux-4.1.27/drivers/char/tpm/
H A Dtpm2-cmd.c230 .length = cpu_to_be32(TPM2_PCR_READ_IN_SIZE),
231 .ordinal = cpu_to_be32(TPM2_CC_PCR_READ)
254 cmd.params.pcrread_in.pcr_selects_cnt = cpu_to_be32(1); tpm2_pcr_read()
278 .length = cpu_to_be32(TPM2_GET_PCREXTEND_IN_SIZE),
279 .ordinal = cpu_to_be32(TPM2_CC_PCR_EXTEND)
298 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx); tpm2_pcr_extend()
300 cpu_to_be32(sizeof(struct tpm2_null_auth_area)); tpm2_pcr_extend()
302 cpu_to_be32(TPM2_RS_PW); tpm2_pcr_extend()
306 cmd.params.pcrextend_in.digest_cnt = cpu_to_be32(1); tpm2_pcr_extend()
322 .length = cpu_to_be32(TPM2_GETRANDOM_IN_SIZE),
323 .ordinal = cpu_to_be32(TPM2_CC_GET_RANDOM)
379 .length = cpu_to_be32(TPM2_GET_TPM_PT_IN_SIZE),
380 .ordinal = cpu_to_be32(TPM2_CC_GET_CAPABILITY)
401 cmd.params.get_tpm_pt_in.cap_id = cpu_to_be32(TPM2_CAP_TPM_PROPERTIES); tpm2_get_tpm_pt()
402 cmd.params.get_tpm_pt_in.property_id = cpu_to_be32(property_id); tpm2_get_tpm_pt()
403 cmd.params.get_tpm_pt_in.property_cnt = cpu_to_be32(1); tpm2_get_tpm_pt()
418 .length = cpu_to_be32(TPM2_STARTUP_IN_SIZE),
419 .ordinal = cpu_to_be32(TPM2_CC_STARTUP)
450 .length = cpu_to_be32(TPM2_SHUTDOWN_IN_SIZE),
451 .ordinal = cpu_to_be32(TPM2_CC_SHUTDOWN)
512 .length = cpu_to_be32(TPM2_SELF_TEST_IN_SIZE),
513 .ordinal = cpu_to_be32(TPM2_CC_SELF_TEST)
579 cmd.params.pcrread_in.pcr_selects_cnt = cpu_to_be32(1); tpm2_do_selftest()
631 cmd.params.get_tpm_pt_in.cap_id = cpu_to_be32(TPM2_CAP_TPM_PROPERTIES); tpm2_probe()
632 cmd.params.get_tpm_pt_in.property_id = cpu_to_be32(0x100); tpm2_probe()
633 cmd.params.get_tpm_pt_in.property_cnt = cpu_to_be32(1); tpm2_probe()
H A Dtpm.h298 TPM_CAP_FLAG = cpu_to_be32(4),
299 TPM_CAP_PROP = cpu_to_be32(5),
300 CAP_VERSION_1_1 = cpu_to_be32(0x06),
301 CAP_VERSION_1_2 = cpu_to_be32(0x1A)
305 TPM_CAP_PROP_PCR = cpu_to_be32(0x101),
306 TPM_CAP_PROP_MANUFACTURER = cpu_to_be32(0x103),
307 TPM_CAP_FLAG_PERM = cpu_to_be32(0x108),
308 TPM_CAP_FLAG_VOL = cpu_to_be32(0x109),
309 TPM_CAP_PROP_OWNER = cpu_to_be32(0x111),
310 TPM_CAP_PROP_TIS_TIMEOUT = cpu_to_be32(0x115),
311 TPM_CAP_PROP_TIS_DURATION = cpu_to_be32(0x120),
H A Dtpm-interface.c424 #define TPM_ORD_GET_CAP cpu_to_be32(101)
425 #define TPM_ORD_GET_RANDOM cpu_to_be32(70)
429 .length = cpu_to_be32(22),
444 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(0); tpm_getcap()
445 tpm_cmd.header.in.length -= cpu_to_be32(sizeof(__be32)); tpm_getcap()
452 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); tpm_getcap()
468 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); tpm_gen_interrupt()
476 #define TPM_ORD_STARTUP cpu_to_be32(153)
482 .length = cpu_to_be32(12),
506 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); tpm_get_timeouts()
519 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); tpm_get_timeouts()
580 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); tpm_get_timeouts()
622 .length = cpu_to_be32(10),
623 .ordinal = cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST),
644 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
648 .length = cpu_to_be32(14),
658 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx); tpm_pcr_read_dev()
706 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
710 .length = cpu_to_be32(34),
731 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx); tpm_pcr_extend()
771 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(0); tpm_do_selftest()
880 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
885 .length = cpu_to_be32(10),
912 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(tpm_suspend_pcr); tpm_pm_suspend()
968 .length = cpu_to_be32(14),
1003 tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes); tpm_get_random()
/linux-4.1.27/crypto/
H A Dfcrypt.c76 #define Z(x) cpu_to_be32(x << 3)
113 #define Z(x) cpu_to_be32(((x & 0x1f) << 27) | (x >> 5))
150 #define Z(x) cpu_to_be32(x << 11)
187 #define Z(x) cpu_to_be32(x << 19)
331 ctx->sched[0x0] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
332 ctx->sched[0x1] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
333 ctx->sched[0x2] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
334 ctx->sched[0x3] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
335 ctx->sched[0x4] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
336 ctx->sched[0x5] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
337 ctx->sched[0x6] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
338 ctx->sched[0x7] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
339 ctx->sched[0x8] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
340 ctx->sched[0x9] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
341 ctx->sched[0xa] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
342 ctx->sched[0xb] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
343 ctx->sched[0xc] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
344 ctx->sched[0xd] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
345 ctx->sched[0xe] = cpu_to_be32(k); ror56_64(k, 11); fcrypt_setkey()
346 ctx->sched[0xf] = cpu_to_be32(k); fcrypt_setkey()
372 ctx->sched[0x0] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
373 ctx->sched[0x1] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
374 ctx->sched[0x2] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
375 ctx->sched[0x3] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
376 ctx->sched[0x4] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
377 ctx->sched[0x5] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
378 ctx->sched[0x6] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
379 ctx->sched[0x7] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
380 ctx->sched[0x8] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
381 ctx->sched[0x9] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
382 ctx->sched[0xa] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
383 ctx->sched[0xb] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
384 ctx->sched[0xc] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
385 ctx->sched[0xd] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
386 ctx->sched[0xe] = cpu_to_be32(lo); ror56(hi, lo, 11); fcrypt_setkey()
387 ctx->sched[0xf] = cpu_to_be32(lo); fcrypt_setkey()
H A Dblowfish_generic.c71 out_blk[0] = cpu_to_be32(yr); bf_encrypt()
72 out_blk[1] = cpu_to_be32(yl); bf_encrypt()
105 out_blk[0] = cpu_to_be32(yr); bf_decrypt()
106 out_blk[1] = cpu_to_be32(yl); bf_decrypt()
H A Dcast6_generic.c210 dst[0] = cpu_to_be32(block[0]); __cast6_encrypt()
211 dst[1] = cpu_to_be32(block[1]); __cast6_encrypt()
212 dst[2] = cpu_to_be32(block[2]); __cast6_encrypt()
213 dst[3] = cpu_to_be32(block[3]); __cast6_encrypt()
248 dst[0] = cpu_to_be32(block[0]); __cast6_decrypt()
249 dst[1] = cpu_to_be32(block[1]); __cast6_decrypt()
250 dst[2] = cpu_to_be32(block[2]); __cast6_decrypt()
251 dst[3] = cpu_to_be32(block[3]); __cast6_decrypt()
H A Dseed.c398 dst[0] = cpu_to_be32(x3); seed_encrypt()
399 dst[1] = cpu_to_be32(x4); seed_encrypt()
400 dst[2] = cpu_to_be32(x1); seed_encrypt()
401 dst[3] = cpu_to_be32(x2); seed_encrypt()
436 dst[0] = cpu_to_be32(x3); seed_decrypt()
437 dst[1] = cpu_to_be32(x4); seed_decrypt()
438 dst[2] = cpu_to_be32(x1); seed_decrypt()
439 dst[3] = cpu_to_be32(x2); seed_decrypt()
/linux-4.1.27/sound/firewire/
H A Dcmp.c145 c->last_pcr_value = cpu_to_be32(0x80000000); cmp_connection_init()
169 *used = !!(pcr & cpu_to_be32(PCR_BCAST_CONN | cmp_connection_check_used()
191 ipcr &= ~cpu_to_be32(PCR_BCAST_CONN | ipcr_set_modify()
194 ipcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); ipcr_set_modify()
195 ipcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); ipcr_set_modify()
232 opcr &= ~cpu_to_be32(PCR_BCAST_CONN | opcr_set_modify()
238 opcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); opcr_set_modify()
239 opcr |= cpu_to_be32(xspd << OPCR_XSPEED_SHIFT); opcr_set_modify()
240 opcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); opcr_set_modify()
241 opcr |= cpu_to_be32(spd << OPCR_SPEED_SHIFT); opcr_set_modify()
242 opcr |= cpu_to_be32(get_overhead_id(c) << OPCR_OVERHEAD_ID_SHIFT); opcr_set_modify()
249 if (pcr & cpu_to_be32(PCR_BCAST_CONN | pcr_set_check()
254 if (!(pcr & cpu_to_be32(PCR_ONLINE))) { pcr_set_check()
372 return pcr & ~cpu_to_be32(PCR_BCAST_CONN | PCR_P2P_CONN_MASK); pcr_break_modify()
H A Disight.c180 payload->signature == cpu_to_be32(0x73676874/*"sght"*/))) { isight_packet()
226 value = cpu_to_be32(ch | (isight->device->max_speed << SPEED_SHIFT)); isight_connect()
355 err = reg_write(isight, REG_SAMPLE_RATE, cpu_to_be32(RATE_48000)); isight_start_streaming()
363 err = reg_write(isight, REG_AUDIO_ENABLE, cpu_to_be32(AUDIO_ENABLE)); isight_start_streaming()
512 cpu_to_be32(value->value.integer.value[0])); isight_gain_put()
/linux-4.1.27/fs/xfs/libxfs/
H A Dxfs_dir2_data.c79 case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC): __xfs_dir3_data_check()
80 case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC): __xfs_dir3_data_check()
95 case cpu_to_be32(XFS_DIR3_DATA_MAGIC): __xfs_dir3_data_check()
96 case cpu_to_be32(XFS_DIR2_DATA_MAGIC): __xfs_dir3_data_check()
173 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || __xfs_dir3_data_check()
174 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) { __xfs_dir3_data_check()
195 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || __xfs_dir3_data_check()
196 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) { __xfs_dir3_data_check()
199 cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) __xfs_dir3_data_check()
221 if (hdr3->magic != cpu_to_be32(XFS_DIR3_DATA_MAGIC)) xfs_dir3_data_verify()
228 if (hdr3->magic != cpu_to_be32(XFS_DIR2_DATA_MAGIC)) xfs_dir3_data_verify()
248 case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC): xfs_dir3_data_reada_verify()
249 case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC): xfs_dir3_data_reada_verify()
253 case cpu_to_be32(XFS_DIR2_DATA_MAGIC): xfs_dir3_data_reada_verify()
254 case cpu_to_be32(XFS_DIR3_DATA_MAGIC): xfs_dir3_data_reada_verify()
367 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_freefind()
368 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) || xfs_dir2_data_freefind()
369 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_freefind()
370 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_freefind()
426 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_freeinsert()
427 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_freeinsert()
428 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) || xfs_dir2_data_freeinsert()
429 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_freeinsert()
469 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_freeremove()
470 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_freeremove()
471 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) || xfs_dir2_data_freeremove()
472 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_freeremove()
516 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_freescan()
517 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) || xfs_dir2_data_freescan()
518 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_freescan()
519 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_freescan()
531 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_freescan()
532 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) { xfs_dir2_data_freescan()
605 hdr3->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC); xfs_dir3_data_init()
611 hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC); xfs_dir3_data_init()
650 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_log_entry()
651 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) || xfs_dir2_data_log_entry()
652 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_log_entry()
653 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_log_entry()
671 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_log_header()
672 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) || xfs_dir2_data_log_header()
673 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_log_header()
674 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_log_header()
692 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_log_unused()
693 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) || xfs_dir2_data_log_unused()
694 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_log_unused()
695 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_log_unused()
739 if (hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_make_free()
740 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC)) xfs_dir2_data_make_free()
745 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_make_free()
746 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_make_free()
922 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_data_use_free()
923 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) || xfs_dir2_data_use_free()
924 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) || xfs_dir2_data_use_free()
925 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)); xfs_dir2_data_use_free()
H A Dxfs_inode_buf.c254 to->di_uid = cpu_to_be32(from->di_uid); xfs_dinode_to_disk()
255 to->di_gid = cpu_to_be32(from->di_gid); xfs_dinode_to_disk()
256 to->di_nlink = cpu_to_be32(from->di_nlink); xfs_dinode_to_disk()
260 to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec); xfs_dinode_to_disk()
261 to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec); xfs_dinode_to_disk()
262 to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec); xfs_dinode_to_disk()
263 to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec); xfs_dinode_to_disk()
264 to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec); xfs_dinode_to_disk()
265 to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec); xfs_dinode_to_disk()
268 to->di_extsize = cpu_to_be32(from->di_extsize); xfs_dinode_to_disk()
269 to->di_nextents = cpu_to_be32(from->di_nextents); xfs_dinode_to_disk()
273 to->di_dmevmask = cpu_to_be32(from->di_dmevmask); xfs_dinode_to_disk()
276 to->di_gen = cpu_to_be32(from->di_gen); xfs_dinode_to_disk()
280 to->di_crtime.t_sec = cpu_to_be32(from->di_crtime.t_sec); xfs_dinode_to_disk()
281 to->di_crtime.t_nsec = cpu_to_be32(from->di_crtime.t_nsec); xfs_dinode_to_disk()
H A Dxfs_alloc_btree.c96 new->s = cpu_to_be32(bno); xfs_allocbt_alloc_block()
234 rec->alloc.ar_startblock = cpu_to_be32(cur->bc_rec.a.ar_startblock); xfs_allocbt_init_rec_from_cur()
235 rec->alloc.ar_blockcount = cpu_to_be32(cur->bc_rec.a.ar_blockcount); xfs_allocbt_init_rec_from_cur()
295 case cpu_to_be32(XFS_ABTB_CRC_MAGIC): xfs_allocbt_verify()
306 case cpu_to_be32(XFS_ABTB_MAGIC): xfs_allocbt_verify()
313 case cpu_to_be32(XFS_ABTC_CRC_MAGIC): xfs_allocbt_verify()
324 case cpu_to_be32(XFS_ABTC_MAGIC): xfs_allocbt_verify()
342 block->bb_u.s.bb_leftsib != cpu_to_be32(NULLAGBLOCK))) xfs_allocbt_verify()
346 block->bb_u.s.bb_rightsib != cpu_to_be32(NULLAGBLOCK))) xfs_allocbt_verify()
H A Dxfs_ialloc_btree.c118 new->s = cpu_to_be32(XFS_FSB_TO_AGBNO(args.mp, args.fsbno)); xfs_inobt_alloc_block()
169 rec->inobt.ir_startino = cpu_to_be32(cur->bc_rec.i.ir_startino); xfs_inobt_init_rec_from_cur()
170 rec->inobt.ir_freecount = cpu_to_be32(cur->bc_rec.i.ir_freecount); xfs_inobt_init_rec_from_cur()
229 case cpu_to_be32(XFS_IBT_CRC_MAGIC): xfs_inobt_verify()
230 case cpu_to_be32(XFS_FIBT_CRC_MAGIC): xfs_inobt_verify()
241 case cpu_to_be32(XFS_IBT_MAGIC): xfs_inobt_verify()
242 case cpu_to_be32(XFS_FIBT_MAGIC): xfs_inobt_verify()
258 block->bb_u.s.bb_leftsib != cpu_to_be32(NULLAGBLOCK))) xfs_inobt_verify()
262 block->bb_u.s.bb_rightsib != cpu_to_be32(NULLAGBLOCK))) xfs_inobt_verify()
H A Dxfs_da_format.c475 to->hdr.info.forw = cpu_to_be32(from->forw); xfs_dir2_leaf_hdr_to_disk()
476 to->hdr.info.back = cpu_to_be32(from->back); xfs_dir2_leaf_hdr_to_disk()
509 hdr3->info.hdr.forw = cpu_to_be32(from->forw); xfs_dir3_leaf_hdr_to_disk()
510 hdr3->info.hdr.back = cpu_to_be32(from->back); xfs_dir3_leaf_hdr_to_disk()
551 to->hdr.info.forw = cpu_to_be32(from->forw); xfs_da2_node_hdr_to_disk()
552 to->hdr.info.back = cpu_to_be32(from->back); xfs_da2_node_hdr_to_disk()
581 hdr3->info.hdr.forw = cpu_to_be32(from->forw); xfs_da3_node_hdr_to_disk()
582 hdr3->info.hdr.back = cpu_to_be32(from->back); xfs_da3_node_hdr_to_disk()
675 to->hdr.magic = cpu_to_be32(from->magic); xfs_dir2_free_hdr_to_disk()
676 to->hdr.firstdb = cpu_to_be32(from->firstdb); xfs_dir2_free_hdr_to_disk()
677 to->hdr.nvalid = cpu_to_be32(from->nvalid); xfs_dir2_free_hdr_to_disk()
678 to->hdr.nused = cpu_to_be32(from->nused); xfs_dir2_free_hdr_to_disk()
705 hdr3->hdr.magic = cpu_to_be32(from->magic); xfs_dir3_free_hdr_to_disk()
706 hdr3->firstdb = cpu_to_be32(from->firstdb); xfs_dir3_free_hdr_to_disk()
707 hdr3->nvalid = cpu_to_be32(from->nvalid); xfs_dir3_free_hdr_to_disk()
708 hdr3->nused = cpu_to_be32(from->nused); xfs_dir3_free_hdr_to_disk()
H A Dxfs_symlink_remote.c63 dsl->sl_magic = cpu_to_be32(XFS_SYMLINK_MAGIC); xfs_symlink_hdr_set()
64 dsl->sl_offset = cpu_to_be32(offset); xfs_symlink_hdr_set()
65 dsl->sl_bytes = cpu_to_be32(size); xfs_symlink_hdr_set()
108 if (dsl->sl_magic != cpu_to_be32(XFS_SYMLINK_MAGIC)) xfs_symlink_verify()
H A Dxfs_dir2_block.c68 if (hdr3->magic != cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) xfs_dir3_block_verify()
75 if (hdr3->magic != cpu_to_be32(XFS_DIR2_BLOCK_MAGIC)) xfs_dir3_block_verify()
157 hdr3->magic = cpu_to_be32(XFS_DIR3_BLOCK_MAGIC); xfs_dir3_block_init()
164 hdr3->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC); xfs_dir3_block_init()
298 if (blp[fromidx].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) { xfs_dir2_block_compact()
318 btp->stale = cpu_to_be32(1); xfs_dir2_block_compact()
489 cpu_to_be32(XFS_DIR2_NULL_DATAPTR); xfs_dir2_block_addname()
495 cpu_to_be32(XFS_DIR2_NULL_DATAPTR) && xfs_dir2_block_addname()
532 blp[mid].hashval = cpu_to_be32(args->hashval); xfs_dir2_block_addname()
533 blp[mid].address = cpu_to_be32(xfs_dir2_byte_to_dataptr( xfs_dir2_block_addname()
807 blp[ent].address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR); xfs_dir2_block_removename()
965 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_leaf_to_block()
966 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC)); xfs_dir2_leaf_to_block()
1001 btp->count = cpu_to_be32(leafhdr.count - leafhdr.stale); xfs_dir2_leaf_to_block()
1009 if (ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) xfs_dir2_leaf_to_block()
1141 btp->count = cpu_to_be32(sfp->count + 2); /* ., .. */ xfs_dir2_sf_to_block()
1162 blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot); xfs_dir2_sf_to_block()
1163 blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr( xfs_dir2_sf_to_block()
1176 blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot); xfs_dir2_sf_to_block()
1177 blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr( xfs_dir2_sf_to_block()
1229 blp[2 + i].hashval = cpu_to_be32(mp->m_dirnameops-> xfs_dir2_sf_to_block()
1231 blp[2 + i].address = cpu_to_be32(xfs_dir2_byte_to_dataptr( xfs_dir2_sf_to_block()
H A Dxfs_sb.c459 to->sb_magicnum = cpu_to_be32(from->sb_magicnum); xfs_sb_to_disk()
460 to->sb_blocksize = cpu_to_be32(from->sb_blocksize); xfs_sb_to_disk()
469 to->sb_rextsize = cpu_to_be32(from->sb_rextsize); xfs_sb_to_disk()
470 to->sb_agblocks = cpu_to_be32(from->sb_agblocks); xfs_sb_to_disk()
471 to->sb_agcount = cpu_to_be32(from->sb_agcount); xfs_sb_to_disk()
472 to->sb_rbmblocks = cpu_to_be32(from->sb_rbmblocks); xfs_sb_to_disk()
473 to->sb_logblocks = cpu_to_be32(from->sb_logblocks); xfs_sb_to_disk()
494 to->sb_inoalignmt = cpu_to_be32(from->sb_inoalignmt); xfs_sb_to_disk()
495 to->sb_unit = cpu_to_be32(from->sb_unit); xfs_sb_to_disk()
496 to->sb_width = cpu_to_be32(from->sb_width); xfs_sb_to_disk()
500 to->sb_logsunit = cpu_to_be32(from->sb_logsunit); xfs_sb_to_disk()
508 to->sb_features2 = cpu_to_be32(from->sb_features2); xfs_sb_to_disk()
509 to->sb_bad_features2 = cpu_to_be32(from->sb_bad_features2); xfs_sb_to_disk()
512 to->sb_features_compat = cpu_to_be32(from->sb_features_compat); xfs_sb_to_disk()
514 cpu_to_be32(from->sb_features_ro_compat); xfs_sb_to_disk()
516 cpu_to_be32(from->sb_features_incompat); xfs_sb_to_disk()
518 cpu_to_be32(from->sb_features_log_incompat); xfs_sb_to_disk()
570 if (dsb->sb_magicnum == cpu_to_be32(XFS_SB_MAGIC) && xfs_sb_read_verify()
606 if (dsb->sb_magicnum == cpu_to_be32(XFS_SB_MAGIC)) { xfs_sb_quiet_read_verify()
H A Dxfs_dir2_leaf.c131 if (ents[i].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) xfs_dir3_leaf_check_int()
452 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC)) xfs_dir2_block_to_leaf()
453 hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC); xfs_dir2_block_to_leaf()
455 hdr->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC); xfs_dir2_block_to_leaf()
463 ltp->bestcount = cpu_to_be32(1); xfs_dir2_block_to_leaf()
490 cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) xfs_dir3_leaf_find_stale()
501 cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) xfs_dir3_leaf_find_stale()
561 cpu_to_be32(XFS_DIR2_NULL_DATAPTR)); xfs_dir3_leaf_find_entry()
582 ASSERT(ents[highstale].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)); xfs_dir3_leaf_find_entry()
888 lep->hashval = cpu_to_be32(args->hashval); xfs_dir2_leaf_addname()
889 lep->address = cpu_to_be32( xfs_dir2_leaf_addname()
929 if (ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) xfs_dir3_leaf_compact()
1005 ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) { xfs_dir3_leaf_compact_x1()
1400 lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR); xfs_dir2_leaf_removename()
1620 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || xfs_dir2_leaf_trim_data()
1621 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC)); xfs_dir2_leaf_trim_data()
1780 ltp->bestcount = cpu_to_be32(freehdr.nvalid); xfs_dir2_node_to_leaf()
/linux-4.1.27/drivers/infiniband/core/
H A Dcm_msgs.h112 return cpu_to_be32(be32_to_cpu(req_msg->offset32) >> 8); cm_req_get_local_qpn()
117 req_msg->offset32 = cpu_to_be32((be32_to_cpu(qpn) << 8) | cm_req_set_local_qpn()
129 req_msg->offset32 = cpu_to_be32(resp_res | cm_req_set_resp_res()
142 req_msg->offset36 = cpu_to_be32(init_depth | cm_req_set_init_depth()
155 req_msg->offset40 = cpu_to_be32((resp_timeout << 3) | cm_req_set_remote_resp_timeout()
180 req_msg->offset40 = cpu_to_be32((be32_to_cpu( cm_req_set_qp_type()
185 req_msg->offset40 = cpu_to_be32((be32_to_cpu( cm_req_set_qp_type()
191 req_msg->offset40 = cpu_to_be32(be32_to_cpu( cm_req_set_qp_type()
205 req_msg->offset40 = cpu_to_be32((flow_ctrl & 0x1) | cm_req_set_flow_ctrl()
212 return cpu_to_be32(be32_to_cpu(req_msg->offset44) >> 8); cm_req_get_starting_psn()
218 req_msg->offset44 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) | cm_req_set_starting_psn()
230 req_msg->offset44 = cpu_to_be32((resp_timeout << 3) | cm_req_set_local_resp_timeout()
242 req_msg->offset44 = cpu_to_be32((retry_count & 0x7) | cm_req_set_retry_count()
292 return cpu_to_be32(be32_to_cpu(req_msg->primary_offset88) >> 12); cm_req_get_primary_flow_label()
298 req_msg->primary_offset88 = cpu_to_be32( cm_req_set_primary_flow_label()
312 req_msg->primary_offset88 = cpu_to_be32( cm_req_set_primary_packet_rate()
354 return cpu_to_be32(be32_to_cpu(req_msg->alt_offset132) >> 12); cm_req_get_alt_flow_label()
360 req_msg->alt_offset132 = cpu_to_be32( cm_req_set_alt_flow_label()
374 req_msg->alt_offset132 = cpu_to_be32( cm_req_set_alt_packet_rate()
520 return cpu_to_be32(be32_to_cpu(rep_msg->offset12) >> 8); cm_rep_get_local_qpn()
525 rep_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) | cm_rep_set_local_qpn()
531 return cpu_to_be32(be32_to_cpu(rep_msg->offset16) >> 8); cm_rep_get_local_eecn()
536 rep_msg->offset16 = cpu_to_be32((be32_to_cpu(eecn) << 8) | cm_rep_set_local_eecn()
548 return cpu_to_be32(be32_to_cpu(rep_msg->offset20) >> 8); cm_rep_get_starting_psn()
554 rep_msg->offset20 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) | cm_rep_set_starting_psn()
640 return cpu_to_be32(be32_to_cpu(dreq_msg->offset8) >> 8); cm_dreq_get_remote_qpn()
645 dreq_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) | cm_dreq_set_remote_qpn()
689 return cpu_to_be32(be32_to_cpu(lap_msg->offset12) >> 8); cm_lap_get_remote_qpn()
694 lap_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) | cm_lap_set_remote_qpn()
707 lap_msg->offset12 = cpu_to_be32((resp_timeout << 3) | cm_lap_set_remote_resp_timeout()
714 return cpu_to_be32(be32_to_cpu(lap_msg->offset56) >> 12); cm_lap_get_flow_label()
720 lap_msg->offset56 = cpu_to_be32( cm_lap_set_flow_label()
733 lap_msg->offset56 = cpu_to_be32(traffic_class | cm_lap_set_traffic_class()
825 return cpu_to_be32(be32_to_cpu(sidr_rep_msg->offset8) >> 8); cm_sidr_rep_get_qpn()
831 sidr_rep_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) | cm_sidr_rep_set_qpn()
H A Dpacker.c84 mask = cpu_to_be32(((1ull << desc[i].size_bits) - 1) << shift); ib_pack()
86 *addr = (*addr & ~mask) | (cpu_to_be32(val) & mask); ib_pack()
132 case 32: *(__be32 *) (structure + offset) = cpu_to_be32(val); break; value_write()
H A Dmad_rmpp.c128 ack->rmpp_hdr.seg_num = cpu_to_be32(rmpp_recv->seg_num); format_ack()
129 ack->rmpp_hdr.paylen_newwin = cpu_to_be32(rmpp_recv->newwin); format_ack()
196 rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(1); ack_ds_ack()
569 rmpp_mad->rmpp_hdr.seg_num = cpu_to_be32(++mad_send_wr->seg_num); send_next_seg()
581 rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(paylen); send_next_seg()
749 if (rmpp_hdr->seg_num == cpu_to_be32(1)) { process_rmpp_data()
/linux-4.1.27/drivers/infiniband/hw/mthca/
H A Dmthca_qp.c354 return cpu_to_be32(hw_access_flags); get_hw_access_flags()
533 cpu_to_be32((ah->sl << 28) | mthca_path_set()
538 path->sl_tclass_flowlabel = cpu_to_be32(ah->sl << 28); mthca_path_set()
564 qp_context->flags = cpu_to_be32((to_mthca_state(new_state) << 28) | __mthca_modify_qp()
566 qp_context->flags |= cpu_to_be32(MTHCA_QP_BIT_DE); __mthca_modify_qp()
568 qp_context->flags |= cpu_to_be32(MTHCA_QP_PM_MIGRATED << 11); __mthca_modify_qp()
570 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_PM_STATE); __mthca_modify_qp()
573 qp_context->flags |= cpu_to_be32(MTHCA_QP_PM_MIGRATED << 11); __mthca_modify_qp()
576 qp_context->flags |= cpu_to_be32(MTHCA_QP_PM_REARM << 11); __mthca_modify_qp()
579 qp_context->flags |= cpu_to_be32(MTHCA_QP_PM_ARMED << 11); __mthca_modify_qp()
611 cpu_to_be32(to_mucontext(qp->ibqp.uobject->context)->uar.index); __mthca_modify_qp()
613 qp_context->usr_page = cpu_to_be32(dev->driver_uar.index); __mthca_modify_qp()
614 qp_context->local_qpn = cpu_to_be32(qp->qpn); __mthca_modify_qp()
616 qp_context->remote_qpn = cpu_to_be32(attr->dest_qp_num); __mthca_modify_qp()
621 cpu_to_be32(qp->port << 24); __mthca_modify_qp()
625 cpu_to_be32(attr->port_num << 24); __mthca_modify_qp()
626 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_PORT_NUM); __mthca_modify_qp()
632 cpu_to_be32(attr->pkey_index); __mthca_modify_qp()
633 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_PKEY_INDEX); __mthca_modify_qp()
639 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_RNR_RETRY | __mthca_modify_qp()
648 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_PRIMARY_ADDR_PATH); __mthca_modify_qp()
658 qp_context->tavor_sched_queue |= cpu_to_be32(sched_queue); __mthca_modify_qp()
661 cpu_to_be32(MTHCA_QP_OPTPAR_SCHED_QUEUE); __mthca_modify_qp()
666 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_ACK_TIMEOUT); __mthca_modify_qp()
686 qp_context->alt_path.port_pkey |= cpu_to_be32(attr->alt_pkey_index | __mthca_modify_qp()
689 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_ALT_ADDR_PATH); __mthca_modify_qp()
693 qp_context->pd = cpu_to_be32(to_mpd(ibqp->pd)->pd_num); __mthca_modify_qp()
695 qp_context->wqe_lkey = cpu_to_be32(qp->mr.ibmr.lkey); __mthca_modify_qp()
696 qp_context->params1 = cpu_to_be32((MTHCA_ACK_REQ_FREQ << 28) | __mthca_modify_qp()
700 qp_context->params1 |= cpu_to_be32(MTHCA_QP_BIT_SSC); __mthca_modify_qp()
702 qp_context->params1 |= cpu_to_be32(attr->retry_cnt << 16); __mthca_modify_qp()
703 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_RETRY_COUNT); __mthca_modify_qp()
709 cpu_to_be32(MTHCA_QP_BIT_SRE | __mthca_modify_qp()
712 cpu_to_be32(fls(attr->max_rd_atomic - 1) << 21); __mthca_modify_qp()
714 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_SRA_MAX); __mthca_modify_qp()
718 qp_context->next_send_psn = cpu_to_be32(attr->sq_psn); __mthca_modify_qp()
719 qp_context->cqn_snd = cpu_to_be32(to_mcq(ibqp->send_cq)->cqn); __mthca_modify_qp()
722 qp_context->snd_wqe_base_l = cpu_to_be32(qp->send_wqe_offset); __mthca_modify_qp()
723 qp_context->snd_db_index = cpu_to_be32(qp->sq.db_index); __mthca_modify_qp()
729 cpu_to_be32(fls(attr->max_dest_rd_atomic - 1) << 21); __mthca_modify_qp()
731 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_RRA_MAX); __mthca_modify_qp()
736 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_RWE | __mthca_modify_qp()
741 qp_context->params2 |= cpu_to_be32(MTHCA_QP_BIT_RSC); __mthca_modify_qp()
744 qp_context->params2 |= cpu_to_be32(MTHCA_QP_BIT_RIC); __mthca_modify_qp()
747 qp_context->rnr_nextrecvpsn |= cpu_to_be32(attr->min_rnr_timer << 24); __mthca_modify_qp()
748 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_RNR_TIMEOUT); __mthca_modify_qp()
751 qp_context->rnr_nextrecvpsn |= cpu_to_be32(attr->rq_psn); __mthca_modify_qp()
754 cpu_to_be32(dev->qp_table.rdb_base + __mthca_modify_qp()
758 qp_context->cqn_rcv = cpu_to_be32(to_mcq(ibqp->recv_cq)->cqn); __mthca_modify_qp()
761 qp_context->rcv_db_index = cpu_to_be32(qp->rq.db_index); __mthca_modify_qp()
764 qp_context->qkey = cpu_to_be32(attr->qkey); __mthca_modify_qp()
765 qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_Q_KEY); __mthca_modify_qp()
769 qp_context->srqn = cpu_to_be32(1 << 24 | __mthca_modify_qp()
1199 next->nda_op = cpu_to_be32(((i + 1) & (qp->rq.max - 1)) << mthca_alloc_qp_common()
1201 next->ee_nds = cpu_to_be32(size); mthca_alloc_qp_common()
1206 scatter->lkey = cpu_to_be32(MTHCA_INVAL_LKEY); mthca_alloc_qp_common()
1211 next->nda_op = cpu_to_be32((((i + 1) & (qp->sq.max - 1)) << mthca_alloc_qp_common()
1494 mlx->flags &= ~cpu_to_be32(MTHCA_NEXT_SOLICIT | 1); build_mlx_header()
1495 mlx->flags |= cpu_to_be32((!sqp->qp.ibqp.qp_num ? MTHCA_MLX_VL15 : 0) | build_mlx_header()
1527 sqp->ud_header.bth.destination_qpn = cpu_to_be32(wr->wr.ud.remote_qpn); build_mlx_header()
1528 sqp->ud_header.bth.psn = cpu_to_be32((sqp->send_psn++) & ((1 << 24) - 1)); build_mlx_header()
1529 sqp->ud_header.deth.qkey = cpu_to_be32(wr->wr.ud.remote_qkey & 0x80000000 ? build_mlx_header()
1531 sqp->ud_header.deth.source_qpn = cpu_to_be32(sqp->qp.ibqp.qp_num); build_mlx_header()
1537 data->byte_count = cpu_to_be32(header_size); build_mlx_header()
1538 data->lkey = cpu_to_be32(to_mpd(sqp->qp.ibqp.pd)->ntmr.ibmr.lkey); build_mlx_header()
1567 rseg->rkey = cpu_to_be32(rkey); set_raddr_seg()
1587 useg->lkey = cpu_to_be32(to_mah(wr->wr.ud.ah)->key); set_tavor_ud_seg()
1589 useg->dqpn = cpu_to_be32(wr->wr.ud.remote_qpn); set_tavor_ud_seg()
1590 useg->qkey = cpu_to_be32(wr->wr.ud.remote_qkey); set_tavor_ud_seg()
1598 useg->dqpn = cpu_to_be32(wr->wr.ud.remote_qpn); set_arbel_ud_seg()
1599 useg->qkey = cpu_to_be32(wr->wr.ud.remote_qkey); set_arbel_ud_seg()
1651 cpu_to_be32(MTHCA_NEXT_CQ_UPDATE) : 0) | mthca_tavor_post_send()
1653 cpu_to_be32(MTHCA_NEXT_SOLICIT) : 0) | mthca_tavor_post_send()
1654 cpu_to_be32(1); mthca_tavor_post_send()
1745 cpu_to_be32((1 << 31) | 4); mthca_tavor_post_send()
1761 cpu_to_be32(((ind << qp->sq.wqe_shift) + mthca_tavor_post_send()
1766 cpu_to_be32((nreq ? 0 : MTHCA_NEXT_DBD) | size | mthca_tavor_post_send()
1849 cpu_to_be32(MTHCA_NEXT_DBD); mthca_tavor_post_receive()
1870 cpu_to_be32(MTHCA_NEXT_DBD | size); mthca_tavor_post_receive()
1961 *qp->sq.db = cpu_to_be32(qp->sq.head & 0xffff); mthca_arbel_post_send()
1990 cpu_to_be32(MTHCA_NEXT_CQ_UPDATE) : 0) | mthca_arbel_post_send()
1992 cpu_to_be32(MTHCA_NEXT_SOLICIT) : 0) | mthca_arbel_post_send()
1994 cpu_to_be32(MTHCA_NEXT_IP_CSUM | MTHCA_NEXT_TCP_UDP_CSUM) : 0) | mthca_arbel_post_send()
1995 cpu_to_be32(1); mthca_arbel_post_send()
2086 cpu_to_be32((1 << 31) | 4); mthca_arbel_post_send()
2102 cpu_to_be32(((ind << qp->sq.wqe_shift) + mthca_arbel_post_send()
2107 cpu_to_be32(MTHCA_NEXT_DBD | size | mthca_arbel_post_send()
2134 *qp->sq.db = cpu_to_be32(qp->sq.head & 0xffff); mthca_arbel_post_send()
2220 *qp->rq.db = cpu_to_be32(qp->rq.head & 0xffff); mthca_arbel_post_receive()
2246 *dbd = !!(next->ee_nds & cpu_to_be32(MTHCA_NEXT_DBD)); mthca_free_err_wqe()
2247 if (next->ee_nds & cpu_to_be32(0x3f)) mthca_free_err_wqe()
2248 *new_wqe = (next->nda_op & cpu_to_be32(~0x3f)) | mthca_free_err_wqe()
2249 (next->ee_nds & cpu_to_be32(0x3f)); mthca_free_err_wqe()
H A Dmthca_mcg.c165 if (mgm->qp[i] == cpu_to_be32(ibqp->qp_num | (1 << 31))) { mthca_multicast_attach()
170 } else if (!(mgm->qp[i] & cpu_to_be32(1 << 31))) { mthca_multicast_attach()
171 mgm->qp[i] = cpu_to_be32(ibqp->qp_num | (1 << 31)); mthca_multicast_attach()
197 mgm->next_gid_index = cpu_to_be32(index << 6); mthca_multicast_attach()
242 if (mgm->qp[i] == cpu_to_be32(ibqp->qp_num | (1 << 31))) mthca_multicast_detach()
244 if (!(mgm->qp[i] & cpu_to_be32(1 << 31))) mthca_multicast_detach()
297 mgm->next_gid_index = cpu_to_be32(curr_next_index << 6); mthca_multicast_detach()
H A Dmthca_wqe.h119 dseg->byte_count = cpu_to_be32(sg->length); mthca_set_data_seg()
120 dseg->lkey = cpu_to_be32(sg->lkey); mthca_set_data_seg()
127 dseg->lkey = cpu_to_be32(MTHCA_INVAL_LKEY); mthca_set_data_seg_inval()
H A Dmthca_srq.c103 context->state_pd = cpu_to_be32(pd->pd_num); mthca_tavor_init_srq_context()
104 context->lkey = cpu_to_be32(srq->mr.ibmr.lkey); mthca_tavor_init_srq_context()
108 cpu_to_be32(to_mucontext(pd->ibpd.uobject->context)->uar.index); mthca_tavor_init_srq_context()
110 context->uar = cpu_to_be32(dev->driver_uar.index); mthca_tavor_init_srq_context()
128 context->state_logsize_srqn = cpu_to_be32(logsize << 24 | srq->srqn); mthca_arbel_init_srq_context()
129 context->lkey = cpu_to_be32(srq->mr.ibmr.lkey); mthca_arbel_init_srq_context()
130 context->db_index = cpu_to_be32(srq->db_index); mthca_arbel_init_srq_context()
131 context->logstride_usrpage = cpu_to_be32((srq->wqe_shift - 4) << 29); mthca_arbel_init_srq_context()
134 cpu_to_be32(to_mucontext(pd->ibpd.uobject->context)->uar.index); mthca_arbel_init_srq_context()
136 context->logstride_usrpage |= cpu_to_be32(dev->driver_uar.index); mthca_arbel_init_srq_context()
137 context->eq_pd = cpu_to_be32(MTHCA_EQ_ASYNC << 24 | pd->pd_num); mthca_arbel_init_srq_context()
191 scatter->lkey = cpu_to_be32(MTHCA_INVAL_LKEY); mthca_alloc_srq_buf()
530 cpu_to_be32(MTHCA_NEXT_DBD); mthca_tavor_post_srq_recv()
633 *srq->db = cpu_to_be32(srq->counter); mthca_arbel_post_srq_recv()
H A Dmthca_mr.c459 mpt_entry->flags = cpu_to_be32(MTHCA_MPT_FLAG_SW_OWNS | mthca_mr_alloc()
464 mpt_entry->flags |= cpu_to_be32(MTHCA_MPT_FLAG_PHYSICAL); mthca_mr_alloc()
466 mpt_entry->page_size = cpu_to_be32(buffer_size_shift - 12); mthca_mr_alloc()
467 mpt_entry->key = cpu_to_be32(key); mthca_mr_alloc()
468 mpt_entry->pd = cpu_to_be32(pd); mthca_mr_alloc()
631 mpt_entry->flags = cpu_to_be32(MTHCA_MPT_FLAG_SW_OWNS | mthca_fmr_alloc()
636 mpt_entry->page_size = cpu_to_be32(mr->attr.page_shift - 12); mthca_fmr_alloc()
637 mpt_entry->key = cpu_to_be32(key); mthca_fmr_alloc()
638 mpt_entry->pd = cpu_to_be32(pd); mthca_fmr_alloc()
744 mpt_entry.lkey = cpu_to_be32(key); mthca_tavor_map_phys_fmr()
793 fmr->mem.arbel.mpt->key = cpu_to_be32(key); mthca_arbel_map_phys_fmr()
794 fmr->mem.arbel.mpt->lkey = cpu_to_be32(key); mthca_arbel_map_phys_fmr()
H A Dmthca_doorbell.h93 hi = (__force u32) cpu_to_be32(hi); mthca_write64()
94 lo = (__force u32) cpu_to_be32(lo); mthca_write64()
H A Dmthca_cq.c208 *cq->set_ci_db = cpu_to_be32(cq->cons_index); update_cons_index()
310 if (cqe->my_qpn == cpu_to_be32(qpn)) { mthca_cq_clean()
473 if (!(new_wqe & cpu_to_be32(0x3f)) || (!cqe->db_cnt && dbd)) handle_error_cqe()
751 db_rec[0] = cpu_to_be32(cq->cons_index); mthca_arbel_arm_cq()
752 db_rec[1] = cpu_to_be32((cq->cqn << 8) | (2 << 5) | (sn << 3) | mthca_arbel_arm_cq()
831 cq_context->flags = cpu_to_be32(MTHCA_CQ_STATUS_OK | mthca_init_cq()
834 cq_context->logsize_usrpage = cpu_to_be32((ffs(nent) - 1) << 24); mthca_init_cq()
836 cq_context->logsize_usrpage |= cpu_to_be32(ctx->uar.index); mthca_init_cq()
838 cq_context->logsize_usrpage |= cpu_to_be32(dev->driver_uar.index); mthca_init_cq()
839 cq_context->error_eqn = cpu_to_be32(dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn); mthca_init_cq()
840 cq_context->comp_eqn = cpu_to_be32(dev->eq_table.eq[MTHCA_EQ_COMP].eqn); mthca_init_cq()
841 cq_context->pd = cpu_to_be32(pdn); mthca_init_cq()
842 cq_context->lkey = cpu_to_be32(cq->buf.mr.ibmr.lkey); mthca_init_cq()
843 cq_context->cqn = cpu_to_be32(cq->cqn); mthca_init_cq()
846 cq_context->ci_db = cpu_to_be32(cq->set_ci_db_index); mthca_init_cq()
847 cq_context->state_db = cpu_to_be32(cq->arm_db_index); mthca_init_cq()
H A Dmthca_av.c201 av->port_pd = cpu_to_be32(pd->pd_num | (ah_attr->port_num << 24)); mthca_create_ah()
206 av->sl_tclass_flowlabel = cpu_to_be32(ah_attr->sl << 28); mthca_create_ah()
213 cpu_to_be32((ah_attr->grh.traffic_class << 20) | mthca_create_ah()
218 av->dgid[3] = cpu_to_be32(2); mthca_create_ah()
279 ah->av->sl_tclass_flowlabel & cpu_to_be32(0xfffff); mthca_read_ah()
H A Dmthca_cmd.c209 __raw_writel((__force u32) cpu_to_be32(in_param >> 32), ptr + offs[0]); mthca_cmd_post_dbell()
211 __raw_writel((__force u32) cpu_to_be32(in_param & 0xfffffffful), ptr + offs[1]); mthca_cmd_post_dbell()
213 __raw_writel((__force u32) cpu_to_be32(in_modifier), ptr + offs[2]); mthca_cmd_post_dbell()
215 __raw_writel((__force u32) cpu_to_be32(out_param >> 32), ptr + offs[3]); mthca_cmd_post_dbell()
217 __raw_writel((__force u32) cpu_to_be32(out_param & 0xfffffffful), ptr + offs[4]); mthca_cmd_post_dbell()
219 __raw_writel((__force u32) cpu_to_be32(token << 16), ptr + offs[5]); mthca_cmd_post_dbell()
221 __raw_writel((__force u32) cpu_to_be32((1 << HCR_GO_BIT) | mthca_cmd_post_dbell()
257 __raw_writel((__force u32) cpu_to_be32(in_param >> 32), dev->hcr + 0 * 4); mthca_cmd_post_hcr()
258 __raw_writel((__force u32) cpu_to_be32(in_param & 0xfffffffful), dev->hcr + 1 * 4); mthca_cmd_post_hcr()
259 __raw_writel((__force u32) cpu_to_be32(in_modifier), dev->hcr + 2 * 4); mthca_cmd_post_hcr()
260 __raw_writel((__force u32) cpu_to_be32(out_param >> 32), dev->hcr + 3 * 4); mthca_cmd_post_hcr()
261 __raw_writel((__force u32) cpu_to_be32(out_param & 0xfffffffful), dev->hcr + 4 * 4); mthca_cmd_post_hcr()
262 __raw_writel((__force u32) cpu_to_be32(token << 16), dev->hcr + 5 * 4); mthca_cmd_post_hcr()
267 __raw_writel((__force u32) cpu_to_be32((1 << HCR_GO_BIT) | mthca_cmd_post_hcr()
1365 *(inbox + INIT_HCA_FLAGS2_OFFSET / 4) &= ~cpu_to_be32(1 << 1); mthca_INIT_HCA()
1367 *(inbox + INIT_HCA_FLAGS2_OFFSET / 4) |= cpu_to_be32(1 << 1); mthca_INIT_HCA()
1372 *(inbox + INIT_HCA_FLAGS2_OFFSET / 4) |= cpu_to_be32(1); mthca_INIT_HCA()
1376 *(inbox + INIT_HCA_FLAGS2_OFFSET / 4) |= cpu_to_be32(7 << 3); mthca_INIT_HCA()
H A Dmthca_eq.c193 __raw_writel((__force u32) cpu_to_be32(ci), arbel_set_eq_ci()
528 eq_context->flags = cpu_to_be32(MTHCA_EQ_STATUS_OK | mthca_create_eq()
533 eq_context->flags |= cpu_to_be32(MTHCA_EQ_STATE_ARBEL); mthca_create_eq()
535 eq_context->logsize_usrpage = cpu_to_be32((ffs(eq->nent) - 1) << 24); mthca_create_eq()
537 eq_context->arbel_pd = cpu_to_be32(dev->driver_pd.pd_num); mthca_create_eq()
539 eq_context->logsize_usrpage |= cpu_to_be32(dev->driver_uar.index); mthca_create_eq()
540 eq_context->tavor_pd = cpu_to_be32(dev->driver_pd.pd_num); mthca_create_eq()
543 eq_context->lkey = cpu_to_be32(eq->mr.ibmr.lkey); mthca_create_eq()
/linux-4.1.27/fs/gfs2/
H A Dexport.c46 fh[0] = cpu_to_be32(ip->i_no_formal_ino >> 32); gfs2_encode_fh()
47 fh[1] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF); gfs2_encode_fh()
48 fh[2] = cpu_to_be32(ip->i_no_addr >> 32); gfs2_encode_fh()
49 fh[3] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF); gfs2_encode_fh()
57 fh[4] = cpu_to_be32(ip->i_no_formal_ino >> 32); gfs2_encode_fh()
58 fh[5] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF); gfs2_encode_fh()
59 fh[6] = cpu_to_be32(ip->i_no_addr >> 32); gfs2_encode_fh()
60 fh[7] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF); gfs2_encode_fh()
H A Drecovery.c124 if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) || gfs2_log_header_in()
125 str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH)) gfs2_log_header_in()
412 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); clean_journal()
413 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); clean_journal()
415 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); clean_journal()
416 lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); clean_journal()
418 lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT); clean_journal()
419 lh->lh_blkno = cpu_to_be32(lblock); clean_journal()
421 lh->lh_hash = cpu_to_be32(hash); clean_journal()
H A Dlops.c383 ld->ld_header.mh_magic = cpu_to_be32(GFS2_MAGIC); gfs2_get_log_desc()
384 ld->ld_header.mh_type = cpu_to_be32(GFS2_METATYPE_LD); gfs2_get_log_desc()
385 ld->ld_header.mh_format = cpu_to_be32(GFS2_FORMAT_LD); gfs2_get_log_desc()
386 ld->ld_type = cpu_to_be32(ld_type); gfs2_get_log_desc()
387 ld->ld_length = cpu_to_be32(ld_length); gfs2_get_log_desc()
388 ld->ld_data1 = cpu_to_be32(ld_data1); gfs2_get_log_desc()
401 if (*ptr == cpu_to_be32(GFS2_MAGIC)) gfs2_check_magic()
645 mh->mh_magic = cpu_to_be32(GFS2_MAGIC); list_for_each_entry()
646 mh->mh_type = cpu_to_be32(GFS2_METATYPE_LB); list_for_each_entry()
647 mh->mh_format = cpu_to_be32(GFS2_FORMAT_LB); list_for_each_entry()
803 *eptr = cpu_to_be32(GFS2_MAGIC); databuf_lo_scan_elements()
H A Dutil.h127 mh->mh_type = cpu_to_be32(type); gfs2_metatype_set()
128 mh->mh_format = cpu_to_be32(format); gfs2_metatype_set()
H A Ddir.h75 dent->de_hash = cpu_to_be32(name->hash); gfs2_qstr2dirent()
H A Dsuper.c700 str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC); gfs2_dinode_out()
701 str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI); gfs2_dinode_out()
702 str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI); gfs2_dinode_out()
705 str->di_mode = cpu_to_be32(ip->i_inode.i_mode); gfs2_dinode_out()
706 str->di_uid = cpu_to_be32(i_uid_read(&ip->i_inode)); gfs2_dinode_out()
707 str->di_gid = cpu_to_be32(i_gid_read(&ip->i_inode)); gfs2_dinode_out()
708 str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink); gfs2_dinode_out()
719 str->di_flags = cpu_to_be32(ip->i_diskflags); gfs2_dinode_out()
721 str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) && gfs2_dinode_out()
725 str->di_entries = cpu_to_be32(ip->i_entries); gfs2_dinode_out()
728 str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec); gfs2_dinode_out()
729 str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec); gfs2_dinode_out()
730 str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec); gfs2_dinode_out()
/linux-4.1.27/drivers/infiniband/hw/mlx4/
H A Dqp.c104 [IB_WR_SEND] = cpu_to_be32(MLX4_OPCODE_SEND),
105 [IB_WR_LSO] = cpu_to_be32(MLX4_OPCODE_LSO),
106 [IB_WR_SEND_WITH_IMM] = cpu_to_be32(MLX4_OPCODE_SEND_IMM),
107 [IB_WR_RDMA_WRITE] = cpu_to_be32(MLX4_OPCODE_RDMA_WRITE),
108 [IB_WR_RDMA_WRITE_WITH_IMM] = cpu_to_be32(MLX4_OPCODE_RDMA_WRITE_IMM),
109 [IB_WR_RDMA_READ] = cpu_to_be32(MLX4_OPCODE_RDMA_READ),
110 [IB_WR_ATOMIC_CMP_AND_SWP] = cpu_to_be32(MLX4_OPCODE_ATOMIC_CS),
111 [IB_WR_ATOMIC_FETCH_AND_ADD] = cpu_to_be32(MLX4_OPCODE_ATOMIC_FA),
112 [IB_WR_SEND_WITH_INV] = cpu_to_be32(MLX4_OPCODE_SEND_INVAL),
113 [IB_WR_LOCAL_INV] = cpu_to_be32(MLX4_OPCODE_LOCAL_INVAL),
114 [IB_WR_FAST_REG_MR] = cpu_to_be32(MLX4_OPCODE_FMR),
115 [IB_WR_MASKED_ATOMIC_CMP_AND_SWP] = cpu_to_be32(MLX4_OPCODE_MASKED_ATOMIC_CS),
116 [IB_WR_MASKED_ATOMIC_FETCH_AND_ADD] = cpu_to_be32(MLX4_OPCODE_MASKED_ATOMIC_FA),
117 [IB_WR_BIND_MW] = cpu_to_be32(MLX4_OPCODE_BIND_MW),
221 stamp = ind & qp->sq.wqe_cnt ? cpu_to_be32(0x7fffffff) : stamp_send_wqe()
222 cpu_to_be32(0xffffffff); stamp_send_wqe()
232 *wqe = cpu_to_be32(0xffffffff); stamp_send_wqe()
251 av->port_pd = cpu_to_be32((qp->port << 24) | to_mpd(qp->ibqp.pd)->pdn); post_nop_wqe()
258 inl->byte_count = cpu_to_be32(1 << 31 | (size - s - sizeof *inl)); post_nop_wqe()
268 ctrl->owner_opcode = cpu_to_be32(MLX4_OPCODE_NOP | MLX4_WQE_CTRL_NEC) | post_nop_wqe()
269 (n & qp->sq.wqe_cnt ? cpu_to_be32(1 << 31) : 0); post_nop_wqe()
704 qp->sq_signal_bits = cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE); create_qp_common()
1254 return cpu_to_be32(hw_access_flags); to_mlx4_access_flags()
1305 cpu_to_be32((ah->grh.traffic_class << 20) | _mlx4_set_path()
1470 context->flags = cpu_to_be32((to_mlx4_state(new_state) << 28) | __mlx4_ib_modify_qp()
1474 context->flags |= cpu_to_be32(MLX4_QP_PM_MIGRATED << 11); __mlx4_ib_modify_qp()
1479 context->flags |= cpu_to_be32(MLX4_QP_PM_MIGRATED << 11); __mlx4_ib_modify_qp()
1482 context->flags |= cpu_to_be32(MLX4_QP_PM_REARM << 11); __mlx4_ib_modify_qp()
1485 context->flags |= cpu_to_be32(MLX4_QP_PM_ARMED << 11); __mlx4_ib_modify_qp()
1520 context->xrcd = cpu_to_be32((u32) qp->xrcdn); __mlx4_ib_modify_qp()
1522 context->param3 |= cpu_to_be32(1 << 30); __mlx4_ib_modify_qp()
1526 context->usr_page = cpu_to_be32(to_mucontext(ibqp->uobject->context)->uar.index); __mlx4_ib_modify_qp()
1528 context->usr_page = cpu_to_be32(dev->priv_uar.index); __mlx4_ib_modify_qp()
1531 context->remote_qpn = cpu_to_be32(attr->dest_qp_num); __mlx4_ib_modify_qp()
1598 context->pd = cpu_to_be32(pd->pdn); __mlx4_ib_modify_qp()
1599 context->cqn_send = cpu_to_be32(send_cq->mcq.cqn); __mlx4_ib_modify_qp()
1600 context->cqn_recv = cpu_to_be32(recv_cq->mcq.cqn); __mlx4_ib_modify_qp()
1601 context->params1 = cpu_to_be32(MLX4_IB_ACK_REQ_FREQ << 28); __mlx4_ib_modify_qp()
1605 context->params1 |= cpu_to_be32(1 << 11); __mlx4_ib_modify_qp()
1608 context->params1 |= cpu_to_be32(attr->rnr_retry << 13); __mlx4_ib_modify_qp()
1613 context->params1 |= cpu_to_be32(attr->retry_cnt << 16); __mlx4_ib_modify_qp()
1620 cpu_to_be32(fls(attr->max_rd_atomic - 1) << 21); __mlx4_ib_modify_qp()
1625 context->next_send_psn = cpu_to_be32(attr->sq_psn); __mlx4_ib_modify_qp()
1630 cpu_to_be32(fls(attr->max_dest_rd_atomic - 1) << 21); __mlx4_ib_modify_qp()
1640 context->params2 |= cpu_to_be32(MLX4_QP_BIT_RIC); __mlx4_ib_modify_qp()
1643 context->rnr_nextrecvpsn |= cpu_to_be32(attr->min_rnr_timer << 24); __mlx4_ib_modify_qp()
1647 context->rnr_nextrecvpsn |= cpu_to_be32(attr->rq_psn); __mlx4_ib_modify_qp()
1653 context->qkey = cpu_to_be32(IB_QP_SET_QKEY); __mlx4_ib_modify_qp()
1665 context->qkey = cpu_to_be32(attr->qkey); __mlx4_ib_modify_qp()
1671 context->srqn = cpu_to_be32(1 << 24 | to_msrq(ibqp->srq)->msrq.srqn); __mlx4_ib_modify_qp()
1718 if (!(context->flags & cpu_to_be32(1 << MLX4_RSS_QPC_FLAG_OFFSET))) __mlx4_ib_modify_qp()
1719 context->srqn = cpu_to_be32(7 << 28); __mlx4_ib_modify_qp()
1755 ctrl->owner_opcode = cpu_to_be32(1 << 31); __mlx4_ib_modify_qp()
2073 mlx->flags &= cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE); build_sriov_qp0_header()
2076 mlx->flags |= cpu_to_be32(MLX4_WQE_MLX_VL15 | 0x1 | MLX4_WQE_MLX_SLR); build_sriov_qp0_header()
2084 sqp->ud_header.bth.destination_qpn = cpu_to_be32(wr->wr.ud.remote_qpn); build_sriov_qp0_header()
2087 cpu_to_be32(mdev->dev->caps.qp0_tunnel[sqp->qp.port - 1]); build_sriov_qp0_header()
2089 sqp->ud_header.bth.psn = cpu_to_be32((sqp->send_psn++) & ((1 << 24) - 1)); build_sriov_qp0_header()
2097 sqp->ud_header.deth.qkey = cpu_to_be32(qkey); build_sriov_qp0_header()
2098 sqp->ud_header.deth.source_qpn = cpu_to_be32(sqp->qp.mqp.qpn); build_sriov_qp0_header()
2114 inl->byte_count = cpu_to_be32(1 << 31 | header_size); build_sriov_qp0_header()
2118 inl->byte_count = cpu_to_be32(1 << 31 | spc); build_sriov_qp0_header()
2137 inl->byte_count = cpu_to_be32(1 << 31 | (header_size - spc)); build_sriov_qp0_header()
2218 ah->av.ib.sl_tclass_flowlabel & cpu_to_be32(0xfffff); build_mlx_header()
2243 mlx->flags &= cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE); build_mlx_header()
2246 mlx->flags |= cpu_to_be32((!sqp->qp.ibqp.qp_num ? MLX4_WQE_MLX_VL15 : 0) | build_mlx_header()
2250 if (ah->av.ib.port_pd & cpu_to_be32(0x80000000)) build_mlx_header()
2251 mlx->flags |= cpu_to_be32(0x1); /* force loopback */ build_mlx_header()
2294 mlx->flags |= cpu_to_be32(MLX4_WQE_CTRL_FORCE_LOOPBACK); build_mlx_header()
2312 sqp->ud_header.bth.destination_qpn = cpu_to_be32(wr->wr.ud.remote_qpn); build_mlx_header()
2313 sqp->ud_header.bth.psn = cpu_to_be32((sqp->send_psn++) & ((1 << 24) - 1)); build_mlx_header()
2314 sqp->ud_header.deth.qkey = cpu_to_be32(wr->wr.ud.remote_qkey & 0x80000000 ? build_mlx_header()
2316 sqp->ud_header.deth.source_qpn = cpu_to_be32(sqp->qp.ibqp.qp_num); build_mlx_header()
2342 inl->byte_count = cpu_to_be32(1 << 31 | header_size); build_mlx_header()
2346 inl->byte_count = cpu_to_be32(1 << 31 | spc); build_mlx_header()
2365 inl->byte_count = cpu_to_be32(1 << 31 | (header_size - spc)); build_mlx_header()
2394 cpu_to_be32(MLX4_WQE_FMR_AND_BIND_PERM_ATOMIC) : 0) | convert_access()
2396 cpu_to_be32(MLX4_WQE_FMR_AND_BIND_PERM_REMOTE_WRITE) : 0) | convert_access()
2398 cpu_to_be32(MLX4_WQE_FMR_AND_BIND_PERM_REMOTE_READ) : 0) | convert_access()
2399 (acc & IB_ACCESS_LOCAL_WRITE ? cpu_to_be32(MLX4_WQE_FMR_PERM_LOCAL_WRITE) : 0) | convert_access()
2400 cpu_to_be32(MLX4_WQE_FMR_PERM_LOCAL_READ); convert_access()
2414 fseg->mem_key = cpu_to_be32(wr->wr.fast_reg.rkey); set_fmr_seg()
2419 fseg->page_size = cpu_to_be32(wr->wr.fast_reg.page_shift); set_fmr_seg()
2428 cpu_to_be32(MLX4_WQE_FMR_AND_BIND_PERM_REMOTE_READ | set_bind_seg()
2433 bseg->flags2 |= cpu_to_be32(MLX4_WQE_BIND_TYPE_2); set_bind_seg()
2435 bseg->flags2 |= cpu_to_be32(MLX4_WQE_BIND_ZERO_BASED); set_bind_seg()
2436 bseg->new_rkey = cpu_to_be32(wr->wr.bind_mw.rkey); set_bind_seg()
2437 bseg->lkey = cpu_to_be32(wr->wr.bind_mw.bind_info.mr->lkey); set_bind_seg()
2445 iseg->mem_key = cpu_to_be32(rkey); set_local_inv_seg()
2452 rseg->rkey = cpu_to_be32(rkey); set_raddr_seg()
2484 dseg->dqpn = cpu_to_be32(wr->wr.ud.remote_qpn); set_datagram_seg()
2485 dseg->qkey = cpu_to_be32(wr->wr.ud.remote_qkey); set_datagram_seg()
2500 sqp_av.port_pd = av->ib.port_pd | cpu_to_be32(0x80000000); set_tunnel_datagram_seg()
2503 cpu_to_be32(0xf0000000); set_tunnel_datagram_seg()
2507 dseg->dqpn = cpu_to_be32(dev->dev->caps.qp1_tunnel[port - 1]); set_tunnel_datagram_seg()
2509 dseg->dqpn = cpu_to_be32(dev->dev->caps.qp0_tunnel[port - 1]); set_tunnel_datagram_seg()
2511 dseg->qkey = cpu_to_be32(IB_QP_SET_QKEY); set_tunnel_datagram_seg()
2523 hdr.remote_qpn = cpu_to_be32(wr->wr.ud.remote_qpn); build_tunnel_header()
2525 hdr.qkey = cpu_to_be32(wr->wr.ud.remote_qkey); build_tunnel_header()
2534 inl->byte_count = cpu_to_be32(1 << 31 | sizeof (hdr)); build_tunnel_header()
2539 inl->byte_count = cpu_to_be32(1 << 31 | spc); build_tunnel_header()
2544 inl->byte_count = cpu_to_be32(1 << 31 | (sizeof (hdr) - spc)); build_tunnel_header()
2569 iseg->byte_count = cpu_to_be32((1 << 31) | 4); set_mlx_icrc_seg()
2574 dseg->lkey = cpu_to_be32(sg->lkey); set_data_seg()
2587 dseg->byte_count = cpu_to_be32(sg->length); set_data_seg()
2592 dseg->byte_count = cpu_to_be32(sg->length); __set_data_seg()
2593 dseg->lkey = cpu_to_be32(sg->lkey); __set_data_seg()
2604 *blh = cpu_to_be32(1 << 6); build_lso_seg()
2612 *lso_hdr_sz = cpu_to_be32(wr->wr.ud.mss << 16 | wr->wr.ud.hlen); build_lso_seg()
2625 return cpu_to_be32(wr->ex.invalidate_rkey); send_ieth()
2636 inl->byte_count = cpu_to_be32(1 << 31); add_zero_len_inline()
2691 cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE) : 0) | mlx4_ib_post_send()
2693 cpu_to_be32(MLX4_WQE_CTRL_SOLICITED) : 0) | mlx4_ib_post_send()
2695 cpu_to_be32(MLX4_WQE_CTRL_IP_CSUM | mlx4_ib_post_send()
2747 cpu_to_be32(MLX4_WQE_CTRL_STRONG_ORDER); mlx4_ib_post_send()
2755 cpu_to_be32(MLX4_WQE_CTRL_STRONG_ORDER); mlx4_ib_post_send()
2763 cpu_to_be32(MLX4_WQE_CTRL_STRONG_ORDER); mlx4_ib_post_send()
2788 *(__be32 *) wqe |= cpu_to_be32(0x80000000); mlx4_ib_post_send()
2903 (ind & qp->sq.wqe_cnt ? cpu_to_be32(1 << 31) : 0) | blh; mlx4_ib_post_send()
3000 cpu_to_be32(sizeof (struct mlx4_ib_proxy_sqp_hdr)); mlx4_ib_post_recv()
3002 scat->lkey = cpu_to_be32(wr->sg_list->lkey); mlx4_ib_post_recv()
3013 scat[i].lkey = cpu_to_be32(MLX4_INVALID_LKEY); mlx4_ib_post_recv()
3032 *qp->db.db = cpu_to_be32(qp->rq.head & 0xffff); mlx4_ib_post_recv()
3210 qp->sq_signal_bits == cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE) ? mlx4_ib_query_qp()
H A Dah.c48 ah->av.ib.port_pd = cpu_to_be32(to_mpd(pd)->pdn | (ah_attr->port_num << 24)); create_ib_ah()
55 cpu_to_be32((ah_attr->grh.traffic_class << 20) | create_ib_ah()
67 ah->av.ib.sl_tclass_flowlabel = cpu_to_be32(ah_attr->sl << 28); create_ib_ah()
91 ah->av.eth.port_pd = cpu_to_be32(to_mpd(pd)->pdn | (ah_attr->port_num << 24)); create_iboe_ah()
108 ah->av.eth.sl_tclass_flowlabel = cpu_to_be32(ah_attr->sl << 29); create_iboe_ah()
H A Dsrq.c161 scatter->lkey = cpu_to_be32(MLX4_INVALID_LKEY); mlx4_ib_create_srq()
349 scat[i].byte_count = cpu_to_be32(wr->sg_list[i].length); mlx4_ib_post_srq_recv()
350 scat[i].lkey = cpu_to_be32(wr->sg_list[i].lkey); mlx4_ib_post_srq_recv()
356 scat[i].lkey = cpu_to_be32(MLX4_INVALID_LKEY); mlx4_ib_post_srq_recv()
370 *srq->db.db = cpu_to_be32(srq->wqe_ctr); mlx4_ib_post_srq_recv()
/linux-4.1.27/arch/powerpc/mm/
H A Dvphn.c48 cpu_to_be32(last << 16 | new); vphn_unpack_associativity()
56 cpu_to_be32(new & VPHN_FIELD_MASK); vphn_unpack_associativity()
67 unpacked[0] = cpu_to_be32(nr_assoc_doms); vphn_unpack_associativity()
/linux-4.1.27/tools/testing/selftests/powerpc/vphn/
H A Dvphn.c48 cpu_to_be32(last << 16 | new); vphn_unpack_associativity()
56 cpu_to_be32(new & VPHN_FIELD_MASK); vphn_unpack_associativity()
67 unpacked[0] = cpu_to_be32(nr_assoc_doms); vphn_unpack_associativity()
H A Dtest-vphn.c7 #define cpu_to_be32(x) bswap_32(x) macro
12 #define cpu_to_be32(x) (x) macro
/linux-4.1.27/fs/xfs/
H A Dxfs_fsops.c230 agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC); xfs_growfs_data_private()
231 agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION); xfs_growfs_data_private()
232 agf->agf_seqno = cpu_to_be32(agno); xfs_growfs_data_private()
239 agf->agf_length = cpu_to_be32(agsize); xfs_growfs_data_private()
240 agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp)); xfs_growfs_data_private()
241 agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp)); xfs_growfs_data_private()
242 agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1); xfs_growfs_data_private()
243 agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1); xfs_growfs_data_private()
244 agf->agf_flfirst = cpu_to_be32(1); xfs_growfs_data_private()
248 agf->agf_freeblks = cpu_to_be32(tmpsize); xfs_growfs_data_private()
249 agf->agf_longest = cpu_to_be32(tmpsize); xfs_growfs_data_private()
272 agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC); xfs_growfs_data_private()
273 agfl->agfl_seqno = cpu_to_be32(agno); xfs_growfs_data_private()
279 agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK); xfs_growfs_data_private()
299 agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC); xfs_growfs_data_private()
300 agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION); xfs_growfs_data_private()
301 agi->agi_seqno = cpu_to_be32(agno); xfs_growfs_data_private()
302 agi->agi_length = cpu_to_be32(agsize); xfs_growfs_data_private()
304 agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp)); xfs_growfs_data_private()
305 agi->agi_level = cpu_to_be32(1); xfs_growfs_data_private()
307 agi->agi_newino = cpu_to_be32(NULLAGINO); xfs_growfs_data_private()
308 agi->agi_dirino = cpu_to_be32(NULLAGINO); xfs_growfs_data_private()
312 agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp)); xfs_growfs_data_private()
313 agi->agi_free_level = cpu_to_be32(1); xfs_growfs_data_private()
316 agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO); xfs_growfs_data_private()
344 arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp)); xfs_growfs_data_private()
345 arec->ar_blockcount = cpu_to_be32( xfs_growfs_data_private()
373 arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp)); xfs_growfs_data_private()
374 arec->ar_blockcount = cpu_to_be32( xfs_growfs_data_private()
H A Dxfs_icreate_item.c178 icp->ic_format.icl_ag = cpu_to_be32(agno); xfs_icreate_log()
179 icp->ic_format.icl_agbno = cpu_to_be32(agbno); xfs_icreate_log()
180 icp->ic_format.icl_count = cpu_to_be32(count); xfs_icreate_log()
181 icp->ic_format.icl_isize = cpu_to_be32(inode_size); xfs_icreate_log()
182 icp->ic_format.icl_length = cpu_to_be32(length); xfs_icreate_log()
183 icp->ic_format.icl_gen = cpu_to_be32(generation); xfs_icreate_log()
H A Dxfs_acl.c99 aclp->acl_cnt = cpu_to_be32(acl->a_count); xfs_acl_to_disk()
104 ace->ae_tag = cpu_to_be32(acl_e->e_tag); xfs_acl_to_disk()
107 ace->ae_id = cpu_to_be32(xfs_kuid_to_uid(acl_e->e_uid)); xfs_acl_to_disk()
110 ace->ae_id = cpu_to_be32(xfs_kgid_to_gid(acl_e->e_gid)); xfs_acl_to_disk()
113 ace->ae_id = cpu_to_be32(ACL_UNDEFINED_ID); xfs_acl_to_disk()
/linux-4.1.27/drivers/net/wireless/ath/ar5523/
H A Dar5523.c252 hdr->len = cpu_to_be32(xferlen); ar5523_cmd()
253 hdr->code = cpu_to_be32(code); ar5523_cmd()
257 hdr->magic = cpu_to_be32(1 << 24); ar5523_cmd()
305 write.reg = cpu_to_be32(reg); ar5523_config()
306 write.len = cpu_to_be32(0); /* 0 = single write */ ar5523_config()
307 *(__be32 *)write.data = cpu_to_be32(val); ar5523_config()
322 write.reg = cpu_to_be32(reg); ar5523_config_multi()
323 write.len = cpu_to_be32(len); ar5523_config_multi()
341 which_be = cpu_to_be32(which); ar5523_get_status()
354 cap_be = cpu_to_be32(cap); ar5523_get_capability()
419 led.lednum = cpu_to_be32(lednum); ar5523_set_ledsteady()
420 led.ledmode = cpu_to_be32(ledmode); ar5523_set_ledsteady()
433 rxfilter.bits = cpu_to_be32(bits); ar5523_set_rxfilter()
434 rxfilter.op = cpu_to_be32(op); ar5523_set_rxfilter()
443 __be32 qid = cpu_to_be32(0); ar5523_reset_tx_queues()
457 reset.flags |= cpu_to_be32(UATH_CHAN_2GHZ); ar5523_set_chan()
458 reset.flags |= cpu_to_be32(UATH_CHAN_OFDM); ar5523_set_chan()
459 reset.freq = cpu_to_be32(conf->chandef.chan->center_freq); ar5523_set_chan()
460 reset.maxrdpower = cpu_to_be32(50); /* XXX */ ar5523_set_chan()
461 reset.channelchange = cpu_to_be32(1); ar5523_set_chan()
462 reset.keeprccontent = cpu_to_be32(0); ar5523_set_chan()
475 qinfo.qid = cpu_to_be32(0); ar5523_queue_init()
476 qinfo.len = cpu_to_be32(sizeof(qinfo.attr)); ar5523_queue_init()
477 qinfo.attr.priority = cpu_to_be32(0); /* XXX */ ar5523_queue_init()
478 qinfo.attr.aifs = cpu_to_be32(3); ar5523_queue_init()
479 qinfo.attr.logcwmin = cpu_to_be32(4); ar5523_queue_init()
480 qinfo.attr.logcwmax = cpu_to_be32(10); ar5523_queue_init()
481 qinfo.attr.bursttime = cpu_to_be32(0); ar5523_queue_init()
482 qinfo.attr.mode = cpu_to_be32(0); ar5523_queue_init()
483 qinfo.attr.qflags = cpu_to_be32(1); /* XXX? */ ar5523_queue_init()
842 desc->msglen = cpu_to_be32(skb->len); ar5523_tx_work_locked()
844 desc->buflen = cpu_to_be32(paylen); ar5523_tx_work_locked()
845 desc->type = cpu_to_be32(WDCMSG_SEND); ar5523_tx_work_locked()
846 desc->flags = cpu_to_be32(UATH_TX_NOTIFY); ar5523_tx_work_locked()
849 desc->connid = cpu_to_be32(AR5523_ID_BSS); ar5523_tx_work_locked()
851 desc->connid = cpu_to_be32(AR5523_ID_BROADCAST); ar5523_tx_work_locked()
856 desc->txqid = cpu_to_be32(txqid); ar5523_tx_work_locked()
1001 val = cpu_to_be32(0); ar5523_start()
1035 val = cpu_to_be32(TARGET_DEVICE_AWAKE); ar5523_start()
1229 rates.connid = cpu_to_be32(2); /* XXX */ ar5523_set_basic_rates()
1230 rates.size = cpu_to_be32(sizeof(struct ar5523_cmd_rateset)); ar5523_set_basic_rates()
1245 create.connid = cpu_to_be32(2); ar5523_create_connection()
1246 create.bssid = cpu_to_be32(0); ar5523_create_connection()
1248 create.size = cpu_to_be32(sizeof(struct ar5523_cmd_rateset)); ar5523_create_connection()
1253 create.connattr.wlanmode = cpu_to_be32(wlan_mode); ar5523_create_connection()
1265 associd.defaultrateix = cpu_to_be32(0); /* XXX */ ar5523_write_associd()
1266 associd.associd = cpu_to_be32(bss->aid); ar5523_write_associd()
1267 associd.timoffset = cpu_to_be32(0x3b); /* XXX */ ar5523_write_associd()
1373 setup.sw_ver_major = cpu_to_be32(ATH_SW_VER_MAJOR); ar5523_host_available()
1374 setup.sw_ver_minor = cpu_to_be32(ATH_SW_VER_MINOR); ar5523_host_available()
1375 setup.sw_ver_patch = cpu_to_be32(ATH_SW_VER_PATCH); ar5523_host_available()
1376 setup.sw_ver_build = cpu_to_be32(ATH_SW_VER_BUILD); ar5523_host_available()
1517 txblock->flags = cpu_to_be32(AR5523_WRITE_BLOCK); ar5523_load_firmware()
1518 txblock->total = cpu_to_be32(fw->size); ar5523_load_firmware()
1525 txblock->remain = cpu_to_be32(len - mlen); ar5523_load_firmware()
1526 txblock->len = cpu_to_be32(mlen); ar5523_load_firmware()
/linux-4.1.27/fs/hfsplus/
H A Dcatalog.c47 key->cat.parent = cpu_to_be32(parent); hfsplus_cat_build_key()
62 key->cat.parent = cpu_to_be32(parent); hfsplus_cat_build_key_with_cnid()
73 key->cat.parent = cpu_to_be32(parent); hfsplus_cat_build_key_uni()
93 perms->owner = cpu_to_be32(i_uid_read(inode)); hfsplus_cat_set_perms()
94 perms->group = cpu_to_be32(i_gid_read(inode)); hfsplus_cat_set_perms()
97 perms->dev = cpu_to_be32(inode->i_nlink); hfsplus_cat_set_perms()
99 perms->dev = cpu_to_be32(inode->i_rdev); hfsplus_cat_set_perms()
117 folder->id = cpu_to_be32(inode->i_ino); hfsplus_cat_build_record()
135 file->id = cpu_to_be32(cnid); hfsplus_cat_build_record()
145 cpu_to_be32(HFSP_SYMLINK_TYPE); hfsplus_cat_build_record()
147 cpu_to_be32(HFSP_SYMLINK_CREATOR); hfsplus_cat_build_record()
150 cpu_to_be32(sbi->type); hfsplus_cat_build_record()
152 cpu_to_be32(sbi->creator); hfsplus_cat_build_record()
161 cpu_to_be32(HFSP_HARDLINK_TYPE); hfsplus_cat_build_record()
163 cpu_to_be32(HFSP_HFSPLUS_CREATOR); hfsplus_cat_build_record()
169 cpu_to_be32(HFSPLUS_I(inode)->linkid); hfsplus_cat_build_record()
183 entry->thread.parentID = cpu_to_be32(parentid); hfsplus_fill_cat_thread()
345 fd.search_key->cat.parent = cpu_to_be32(dir->i_ino); hfsplus_delete_cat()
H A Dbitmap.c114 *curr++ = cpu_to_be32(n); hfsplus_block_allocate()
125 *curr++ = cpu_to_be32(0xffffffff); hfsplus_block_allocate()
151 *curr = cpu_to_be32(n); hfsplus_block_allocate()
199 *curr++ &= cpu_to_be32(mask); hfsplus_block_free()
202 *curr++ &= cpu_to_be32(mask); hfsplus_block_free()
229 *curr &= cpu_to_be32(mask); hfsplus_block_free()
H A Dsuper.c209 vhdr->free_blocks = cpu_to_be32(sbi->free_blocks); hfsplus_sync_fs()
210 vhdr->next_cnid = cpu_to_be32(sbi->next_cnid); hfsplus_sync_fs()
211 vhdr->folder_count = cpu_to_be32(sbi->folder_count); hfsplus_sync_fs()
212 vhdr->file_count = cpu_to_be32(sbi->file_count); hfsplus_sync_fs()
287 vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_UNMNT); hfsplus_put_super()
288 vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_INCNSTNT); hfsplus_put_super()
337 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) { hfsplus_remount()
344 cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) { hfsplus_remount()
349 cpu_to_be32(HFSPLUS_VOL_JOURNALED)) { hfsplus_remount()
452 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) { hfsplus_fill_super()
457 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) { hfsplus_fill_super()
460 } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) && hfsplus_fill_super()
539 vhdr->last_mount_vers = cpu_to_be32(HFSP_MOUNT_VERSION); hfsplus_fill_super()
542 vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_UNMNT); hfsplus_fill_super()
543 vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_INCNSTNT); hfsplus_fill_super()
H A Dioctl.c42 cpu_to_be32(parent_ino(dentry)); hfsplus_ioctl_bless()
49 vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(cnid); hfsplus_ioctl_bless()
53 cpu_to_be32(parent_ino(dentry)); hfsplus_ioctl_bless()
H A Dbtree.c296 head->root = cpu_to_be32(tree->root); hfs_btree_write()
297 head->leaf_count = cpu_to_be32(tree->leaf_count); hfs_btree_write()
298 head->leaf_head = cpu_to_be32(tree->leaf_head); hfs_btree_write()
299 head->leaf_tail = cpu_to_be32(tree->leaf_tail); hfs_btree_write()
300 head->node_count = cpu_to_be32(tree->node_count); hfs_btree_write()
301 head->free_nodes = cpu_to_be32(tree->free_nodes); hfs_btree_write()
302 head->attributes = cpu_to_be32(tree->attributes); hfs_btree_write()
324 cnid = cpu_to_be32(idx); hfs_bmap_new_bmap()
H A Dbrec.c152 cnid = cpu_to_be32(new_node->this); hfs_brec_insert()
319 node_desc.next = cpu_to_be32(new_node->next); hfs_bnode_split()
320 node_desc.prev = cpu_to_be32(new_node->prev); hfs_bnode_split()
330 node_desc.next = cpu_to_be32(node->next); hfs_bnode_split()
338 node_desc.prev = cpu_to_be32(next_node->prev); hfs_bnode_split()
433 cnid = cpu_to_be32(new_node->this); hfs_brec_update_parent()
488 node_desc.next = cpu_to_be32(new_node->next); hfs_btree_inc_height()
489 node_desc.prev = cpu_to_be32(new_node->prev); hfs_btree_inc_height()
515 cnid = cpu_to_be32(node->this); hfs_btree_inc_height()
H A Dextents.c44 key->ext.cnid = cpu_to_be32(cnid); hfsplus_ext_build_key()
45 key->ext.start_block = cpu_to_be32(block); hfsplus_ext_build_key()
317 extent->start_block = cpu_to_be32(alloc_block); hfsplus_add_extent()
320 extent->block_count = cpu_to_be32(block_count); hfsplus_add_extent()
370 extent->block_count = cpu_to_be32(count); hfsplus_free_extents()
477 hip->first_extents[0].start_block = cpu_to_be32(start); hfsplus_file_extend()
478 hip->first_extents[0].block_count = cpu_to_be32(len); hfsplus_file_extend()
520 hip->cached_extents[0].start_block = cpu_to_be32(start); hfsplus_file_extend()
521 hip->cached_extents[0].block_count = cpu_to_be32(len); hfsplus_file_extend()
/linux-4.1.27/drivers/i2c/busses/
H A Di2c-opal.c103 req.size = cpu_to_be32(msgs[0].len); i2c_opal_master_xfer()
113 req.subaddr = cpu_to_be32(req.subaddr); i2c_opal_master_xfer()
114 req.size = cpu_to_be32(msgs[1].len); i2c_opal_master_xfer()
143 req.size = cpu_to_be32(1); i2c_opal_smbus_xfer()
151 req.size = cpu_to_be32(1); i2c_opal_smbus_xfer()
152 req.subaddr = cpu_to_be32(command); i2c_opal_smbus_xfer()
163 req.size = cpu_to_be32(2); i2c_opal_smbus_xfer()
164 req.subaddr = cpu_to_be32(command); i2c_opal_smbus_xfer()
171 req.size = cpu_to_be32(data->block[0]); i2c_opal_smbus_xfer()
172 req.subaddr = cpu_to_be32(command); i2c_opal_smbus_xfer()
/linux-4.1.27/drivers/infiniband/hw/cxgb3/
H A Diwch_qp.c61 wqe->send.rem_stag = cpu_to_be32(wr->ex.invalidate_rkey); build_rdma_send()
77 wqe->send.sgl[i].stag = cpu_to_be32(wr->sg_list[i].lkey); build_rdma_send()
78 wqe->send.sgl[i].len = cpu_to_be32(wr->sg_list[i].length); build_rdma_send()
81 wqe->send.num_sgle = cpu_to_be32(wr->num_sge); build_rdma_send()
83 wqe->send.plen = cpu_to_be32(plen); build_rdma_send()
98 wqe->write.stag_sink = cpu_to_be32(wr->wr.rdma.rkey); build_rdma_write()
104 wqe->write.sgl[0].len = cpu_to_be32(0); build_rdma_write()
105 wqe->write.num_sgle = cpu_to_be32(0); build_rdma_write()
115 cpu_to_be32(wr->sg_list[i].lkey); build_rdma_write()
117 cpu_to_be32(wr->sg_list[i].length); build_rdma_write()
121 wqe->write.num_sgle = cpu_to_be32(wr->num_sge); build_rdma_write()
124 wqe->write.plen = cpu_to_be32(plen); build_rdma_write()
140 wqe->read.rem_stag = cpu_to_be32(wr->wr.rdma.rkey); build_rdma_read()
142 wqe->read.local_stag = cpu_to_be32(wr->sg_list[0].lkey); build_rdma_read()
143 wqe->read.local_len = cpu_to_be32(wr->sg_list[0].length); build_rdma_read()
158 wqe->fastreg.stag = cpu_to_be32(wr->wr.fast_reg.rkey); build_fastreg()
159 wqe->fastreg.len = cpu_to_be32(wr->wr.fast_reg.length); build_fastreg()
160 wqe->fastreg.va_base_hi = cpu_to_be32(wr->wr.fast_reg.iova_start >> 32); build_fastreg()
162 cpu_to_be32(wr->wr.fast_reg.iova_start & 0xffffffff); build_fastreg()
163 wqe->fastreg.page_type_perms = cpu_to_be32( build_fastreg()
194 wqe->local_inv.stag = cpu_to_be32(wr->ex.invalidate_rkey); build_inv_stag()
262 wqe->recv.num_sgle = cpu_to_be32(wr->num_sge); build_rdma_recv()
264 wqe->recv.sgl[i].stag = cpu_to_be32(wr->sg_list[i].lkey); build_rdma_recv()
265 wqe->recv.sgl[i].len = cpu_to_be32(wr->sg_list[i].length); build_rdma_recv()
272 wqe->recv.pbl_addr[i] = cpu_to_be32(pbl_addr[i]); build_rdma_recv()
310 wqe->recv.num_sgle = cpu_to_be32(wr->num_sge); build_zero_stag_recv()
331 wqe->recv.sgl[i].len = cpu_to_be32(wr->sg_list[i].length); build_zero_stag_recv()
333 wqe->recv.pbl_addr[i] = cpu_to_be32(pbl_offset); build_zero_stag_recv()
579 wqe->bind.mr_stag = cpu_to_be32(mw_bind->bind_info.mr->lkey); iwch_bind_mw()
580 wqe->bind.mw_stag = cpu_to_be32(mw->rkey); iwch_bind_mw()
581 wqe->bind.mw_len = cpu_to_be32(mw_bind->bind_info.length); iwch_bind_mw()
595 wqe->bind.mr_pbl_addr = cpu_to_be32(pbl_addr); iwch_bind_mw()
759 wqe->read.rem_stag = cpu_to_be32(1); iwch_post_zb_read()
761 wqe->read.local_stag = cpu_to_be32(1); iwch_post_zb_read()
762 wqe->read.local_len = cpu_to_be32(0); iwch_post_zb_read()
764 wqe->send.wrh.op_seop_flags = cpu_to_be32(V_FW_RIWR_OP(T3_WR_READ)); iwch_post_zb_read()
765 wqe->send.wrh.gen_tid_len = cpu_to_be32(V_FW_RIWR_TID(ep->hwtid)| iwch_post_zb_read()
796 wqe->send.wrh.op_seop_flags = cpu_to_be32(V_FW_RIWR_OP(T3_WR_SEND) | iwch_post_terminate()
798 wqe->send.wrh.gen_tid_len = cpu_to_be32(V_FW_RIWR_TID(qhp->ep->hwtid)); iwch_post_terminate()
H A Dcxio_hal.c151 wqe->flags = cpu_to_be32(MODQP_WRITE_EC); cxio_hal_clear_qp_ctx()
357 cqe.header = cpu_to_be32(V_CQE_STATUS(TPT_ERR_SWFLUSH) | insert_recv_cqe()
394 cqe.header = cpu_to_be32(V_CQE_STATUS(TPT_ERR_SWFLUSH) | insert_sq_cqe()
439 swcqe->header |= cpu_to_be32(V_CQE_SWCQE(1)); cxio_flush_hw_cq()
569 wqe->flags = cpu_to_be32(MODQP_WRITE_EC); cxio_hal_init_ctrl_qp()
729 tpt.valid_stag_pdid = cpu_to_be32(F_TPT_VALID | __cxio_tpt_op()
734 tpt.flags_pagesize_qpid = cpu_to_be32(V_TPT_PERM(perm) | __cxio_tpt_op()
738 tpt.rsvd_pbl_addr = cpu_to_be32(V_TPT_PBL_ADDR(PBL_OFF(rdev_p, pbl_addr)>>3)); __cxio_tpt_op()
739 tpt.len = cpu_to_be32(len); __cxio_tpt_op()
740 tpt.va_hi = cpu_to_be32((u32) (to >> 32)); __cxio_tpt_op()
741 tpt.va_low_or_fbo = cpu_to_be32((u32) (to & 0xFFFFFFFFULL)); __cxio_tpt_op()
743 tpt.rsvd_pbl_size = cpu_to_be32(V_TPT_PBL_SIZE(pbl_size >> 2)); __cxio_tpt_op()
842 wqe->wrh.op_seop_flags = cpu_to_be32(V_FW_RIWR_OP(T3_WR_INIT)); cxio_rdma_init()
843 wqe->wrh.gen_tid_len = cpu_to_be32(V_FW_RIWR_TID(attr->tid) | cxio_rdma_init()
846 wqe->qpid = cpu_to_be32(attr->qpid); cxio_rdma_init()
847 wqe->pdid = cpu_to_be32(attr->pdid); cxio_rdma_init()
848 wqe->scqid = cpu_to_be32(attr->scqid); cxio_rdma_init()
849 wqe->rcqid = cpu_to_be32(attr->rcqid); cxio_rdma_init()
850 wqe->rq_addr = cpu_to_be32(attr->rq_addr - rdev_p->rnic_info.rqt_base); cxio_rdma_init()
851 wqe->rq_size = cpu_to_be32(attr->rq_size); cxio_rdma_init()
859 wqe->ord = cpu_to_be32(attr->ord); cxio_rdma_init()
860 wqe->ird = cpu_to_be32(attr->ird); cxio_rdma_init()
862 wqe->qp_dma_size = cpu_to_be32(attr->qp_dma_size); cxio_rdma_init()
863 wqe->irs = cpu_to_be32(attr->irs); cxio_rdma_init()
/linux-4.1.27/arch/mips/cavium-octeon/
H A Docteon-platform.c754 f = cpu_to_be32(octeon_get_io_clock_rate()); octeon_prune_device_tree()
831 __be32 width = cpu_to_be32(8); octeon_prune_device_tree()
836 new_reg[0] = cpu_to_be32(cs); octeon_prune_device_tree()
837 new_reg[1] = cpu_to_be32(0); octeon_prune_device_tree()
838 new_reg[2] = cpu_to_be32(0x10000); octeon_prune_device_tree()
839 new_reg[3] = cpu_to_be32(cs + 1); octeon_prune_device_tree()
840 new_reg[4] = cpu_to_be32(0); octeon_prune_device_tree()
841 new_reg[5] = cpu_to_be32(0x10000); octeon_prune_device_tree()
852 ranges[(cs * 5) + 2] = cpu_to_be32(region_base >> 32); octeon_prune_device_tree()
853 ranges[(cs * 5) + 3] = cpu_to_be32(region_base & 0xffffffff); octeon_prune_device_tree()
854 ranges[(cs * 5) + 4] = cpu_to_be32(region_size); octeon_prune_device_tree()
857 ranges[(cs * 5) + 2] = cpu_to_be32(region1_base >> 32); octeon_prune_device_tree()
858 ranges[(cs * 5) + 3] = cpu_to_be32(region1_base & 0xffffffff); octeon_prune_device_tree()
859 ranges[(cs * 5) + 4] = cpu_to_be32(region1_size); octeon_prune_device_tree()
897 new_reg[0] = cpu_to_be32(cs); octeon_prune_device_tree()
898 new_reg[1] = cpu_to_be32(0x20); octeon_prune_device_tree()
899 new_reg[2] = cpu_to_be32(0x20); octeon_prune_device_tree()
900 new_reg[3] = cpu_to_be32(cs); octeon_prune_device_tree()
901 new_reg[4] = cpu_to_be32(0); octeon_prune_device_tree()
902 new_reg[5] = cpu_to_be32(0x20); octeon_prune_device_tree()
913 ranges[(cs * 5) + 2] = cpu_to_be32(region_base >> 32); octeon_prune_device_tree()
914 ranges[(cs * 5) + 3] = cpu_to_be32(region_base & 0xffffffff); octeon_prune_device_tree()
915 ranges[(cs * 5) + 4] = cpu_to_be32(region_size); octeon_prune_device_tree()
959 new_f[0] = cpu_to_be32(48000000); octeon_prune_device_tree()
/linux-4.1.27/drivers/infiniband/hw/mlx5/
H A Dqp.c686 cpu_to_be32((page_shift - MLX5_ADAPTER_PAGE_SHIFT) << 24); create_user_qp()
687 (*in)->ctx.params2 = cpu_to_be32(offset << 6); create_user_qp()
689 (*in)->ctx.qp_counter_set_usr_page = cpu_to_be32(uar_index); create_user_qp()
784 (*in)->ctx.qp_counter_set_usr_page = cpu_to_be32(uar_index); create_kernel_qp()
786 cpu_to_be32((qp->buf.page_shift - MLX5_ADAPTER_PAGE_SHIFT) << 24); create_kernel_qp()
788 (*in)->ctx.params1 |= cpu_to_be32(1 << 11); create_kernel_qp()
849 return cpu_to_be32(MLX5_SRQ_RQ); get_rx_type()
851 return cpu_to_be32(MLX5_ZERO_LEN_RQ); get_rx_type()
853 return cpu_to_be32(MLX5_NON_ZERO_RQ); get_rx_type()
952 in->ctx.flags = cpu_to_be32(to_mlx5_st(init_attr->qp_type) << 16 | create_qp_common()
956 in->ctx.flags_pd = cpu_to_be32(to_mpd(pd ? pd : devr->p0)->pdn); create_qp_common()
958 in->ctx.flags_pd = cpu_to_be32(MLX5_QP_LAT_SENSITIVE); create_qp_common()
961 in->ctx.flags_pd |= cpu_to_be32(MLX5_QP_ENABLE_SIG); create_qp_common()
964 in->ctx.flags_pd |= cpu_to_be32(MLX5_QP_BLOCK_MCAST); create_qp_common()
1001 in->ctx.cqn_recv = cpu_to_be32(to_mcq(devr->c0)->mcq.cqn); create_qp_common()
1002 in->ctx.cqn_send = cpu_to_be32(to_mcq(devr->c0)->mcq.cqn); create_qp_common()
1003 in->ctx.rq_type_srqn |= cpu_to_be32(to_msrq(devr->s0)->msrq.srqn); create_qp_common()
1004 in->ctx.xrcd = cpu_to_be32(to_mxrcd(init_attr->xrcd)->xrcdn); create_qp_common()
1007 in->ctx.cqn_recv = cpu_to_be32(to_mcq(devr->c0)->mcq.cqn); create_qp_common()
1008 in->ctx.xrcd = cpu_to_be32(to_mxrcd(devr->x1)->xrcdn); create_qp_common()
1009 in->ctx.rq_type_srqn |= cpu_to_be32(to_msrq(devr->s0)->msrq.srqn); create_qp_common()
1013 in->ctx.xrcd = cpu_to_be32(to_mxrcd(devr->x0)->xrcdn); create_qp_common()
1014 in->ctx.rq_type_srqn |= cpu_to_be32(to_msrq(init_attr->srq)->msrq.srqn); create_qp_common()
1016 in->ctx.xrcd = cpu_to_be32(to_mxrcd(devr->x1)->xrcdn); create_qp_common()
1017 in->ctx.rq_type_srqn |= cpu_to_be32(to_msrq(devr->s0)->msrq.srqn); create_qp_common()
1022 in->ctx.cqn_send = cpu_to_be32(to_mcq(init_attr->send_cq)->mcq.cqn); create_qp_common()
1025 in->ctx.cqn_recv = cpu_to_be32(to_mcq(init_attr->recv_cq)->mcq.cqn); create_qp_common()
1348 return cpu_to_be32(hw_access_flags); to_mlx5_access_flags()
1403 cpu_to_be32((ah->grh.traffic_class << 20) | mlx5_set_path()
1592 context->flags = cpu_to_be32(err << 16); __mlx5_ib_modify_qp()
1595 context->flags |= cpu_to_be32(MLX5_QP_PM_MIGRATED << 11); __mlx5_ib_modify_qp()
1599 context->flags |= cpu_to_be32(MLX5_QP_PM_MIGRATED << 11); __mlx5_ib_modify_qp()
1602 context->flags |= cpu_to_be32(MLX5_QP_PM_REARM << 11); __mlx5_ib_modify_qp()
1605 context->flags |= cpu_to_be32(MLX5_QP_PM_ARMED << 11); __mlx5_ib_modify_qp()
1626 context->log_pg_sz_remote_qpn = cpu_to_be32(attr->dest_qp_num); __mlx5_ib_modify_qp()
1660 context->flags_pd = cpu_to_be32(pd ? pd->pdn : to_mpd(dev->devr.p0)->pdn); __mlx5_ib_modify_qp()
1661 context->cqn_send = send_cq ? cpu_to_be32(send_cq->mcq.cqn) : 0; __mlx5_ib_modify_qp()
1662 context->cqn_recv = recv_cq ? cpu_to_be32(recv_cq->mcq.cqn) : 0; __mlx5_ib_modify_qp()
1663 context->params1 = cpu_to_be32(MLX5_IB_ACK_REQ_FREQ << 28); __mlx5_ib_modify_qp()
1666 context->params1 |= cpu_to_be32(attr->rnr_retry << 13); __mlx5_ib_modify_qp()
1669 context->params1 |= cpu_to_be32(attr->retry_cnt << 16); __mlx5_ib_modify_qp()
1674 cpu_to_be32(fls(attr->max_rd_atomic - 1) << 21); __mlx5_ib_modify_qp()
1678 context->next_send_psn = cpu_to_be32(attr->sq_psn); __mlx5_ib_modify_qp()
1683 cpu_to_be32(fls(attr->max_dest_rd_atomic - 1) << 21); __mlx5_ib_modify_qp()
1690 context->rnr_nextrecvpsn |= cpu_to_be32(attr->min_rnr_timer << 24); __mlx5_ib_modify_qp()
1693 context->rnr_nextrecvpsn |= cpu_to_be32(attr->rq_psn); __mlx5_ib_modify_qp()
1696 context->qkey = cpu_to_be32(attr->qkey); __mlx5_ib_modify_qp()
1728 in->optparam = cpu_to_be32(optpar); __mlx5_ib_modify_qp()
1846 rseg->rkey = cpu_to_be32(rkey); set_raddr_seg()
1854 dseg->av.dqp_dct = cpu_to_be32(wr->wr.ud.remote_qpn | MLX5_EXTENDED_UD_AV); set_datagram_seg()
1855 dseg->av.key.qkey.qkey = cpu_to_be32(wr->wr.ud.remote_qkey); set_datagram_seg()
1860 dseg->byte_count = cpu_to_be32(sg->length); set_data_ptr_seg()
1861 dseg->lkey = cpu_to_be32(sg->lkey); set_data_ptr_seg()
2014 seg->qpn_mkey7_0 = cpu_to_be32((wr->wr.fast_reg.rkey & 0xff) | 0xffffff00); set_mkey_segment()
2015 seg->flags_pd = cpu_to_be32(MLX5_MKEY_REMOTE_INVAL); set_mkey_segment()
2018 seg->xlt_oct_size = cpu_to_be32((wr->wr.fast_reg.page_list_len + 1) / 2); set_mkey_segment()
2034 seg->flags_pd = cpu_to_be32(to_mpd(umrwr->pd)->pdn); set_reg_mkey_segment()
2039 seg->qpn_mkey7_0 = cpu_to_be32(0xffffff00 | set_reg_mkey_segment()
2057 dseg->byte_count = cpu_to_be32(ALIGN(sizeof(u64) * wr->wr.fast_reg.page_list_len, 64)); set_frwr_pages()
2058 dseg->lkey = cpu_to_be32(pd->pa_lkey); set_frwr_pages()
2069 return cpu_to_be32(wr->ex.invalidate_rkey); send_ieth()
2125 seg->byte_count = cpu_to_be32(inl | MLX5_INLINE_SEG); set_data_inl_seg()
2161 inl->dif_reftag = cpu_to_be32(domain->sig.dif.ref_tag); mlx5_fill_inl_bsf()
2196 basic->raw_data_size = cpu_to_be32(data_size); mlx5_set_bsf()
2204 basic->m_bfs_psv = cpu_to_be32(msig->psv_memory.psv_idx); mlx5_set_bsf()
2229 basic->w_bfs_psv = cpu_to_be32(msig->psv_wire.psv_idx); mlx5_set_bsf()
2267 data_klm->bcount = cpu_to_be32(data_len); set_sig_data_segment()
2268 data_klm->key = cpu_to_be32(data_key); set_sig_data_segment()
2302 sblock_ctrl->bcount_per_cycle = cpu_to_be32(block_size + set_sig_data_segment()
2304 sblock_ctrl->op = cpu_to_be32(MLX5_STRIDE_BLOCK_OP); set_sig_data_segment()
2305 sblock_ctrl->repeat_count = cpu_to_be32(data_len / block_size); set_sig_data_segment()
2309 data_sentry->key = cpu_to_be32(data_key); set_sig_data_segment()
2314 prot_sentry->key = cpu_to_be32(prot_key); set_sig_data_segment()
2352 seg->qpn_mkey7_0 = cpu_to_be32((sig_key & 0xff) | 0xffffff00); set_sig_mkey_segment()
2353 seg->flags_pd = cpu_to_be32(MLX5_MKEY_REMOTE_INVAL | sigerr << 26 | set_sig_mkey_segment()
2356 seg->xlt_oct_size = cpu_to_be32(be16_to_cpu(get_klm_octo(nelements))); set_sig_mkey_segment()
2357 seg->bsfs_octo_size = cpu_to_be32(MLX5_MKEY_BSF_OCTO_SIZE); set_sig_mkey_segment()
2428 psv_seg->psv_num = cpu_to_be32(psv_idx); set_psv_wr()
2433 psv_seg->transient_sig = cpu_to_be32(domain->sig.dif.bg << 16 | set_psv_wr()
2435 psv_seg->ref_tag = cpu_to_be32(domain->sig.dif.ref_tag); set_psv_wr()
2572 ctrl->opmod_idx_opcode = cpu_to_be32(((u32)(qp->sq.cur_post) << 8) | finish_wqe()
2574 ctrl->qpn_ds = cpu_to_be32(size | (qp->mqp.qpn << 8)); finish_wqe()
2668 ctrl->imm = cpu_to_be32(wr->ex.invalidate_rkey); mlx5_ib_post_send()
2681 ctrl->imm = cpu_to_be32(wr->wr.fast_reg.rkey); mlx5_ib_post_send()
2695 ctrl->imm = cpu_to_be32(mr->ibmr.rkey); mlx5_ib_post_send()
2795 ctrl->imm = cpu_to_be32(wr->wr.fast_reg.rkey); mlx5_ib_post_send()
2855 qp->db.db[MLX5_SND_DBR] = cpu_to_be32(qp->sq.cur_post); mlx5_ib_post_send()
2933 scat[i].lkey = cpu_to_be32(MLX5_INVALID_LKEY); mlx5_ib_post_recv()
2956 *qp->db.db = cpu_to_be32(qp->rq.head & 0xffff); mlx5_ib_post_recv()
H A Dsrq.c139 (*in)->ctx.pgoff_cqn = cpu_to_be32(offset << 26); create_srq_user()
296 in->ctx.pgoff_cqn |= cpu_to_be32(to_mcq(init_attr->ext.xrc.cq)->mcq.cqn); mlx5_ib_create_srq()
299 in->ctx.pgoff_cqn |= cpu_to_be32(to_mcq(dev->devr.c0)->mcq.cqn); mlx5_ib_create_srq()
302 in->ctx.flags_xrcd = cpu_to_be32((flgs & 0xFF000000) | (xrcdn & 0xFFFFFF)); mlx5_ib_create_srq()
304 in->ctx.pd = cpu_to_be32(to_mpd(pd)->pdn); mlx5_ib_create_srq()
459 scat[i].byte_count = cpu_to_be32(wr->sg_list[i].length); mlx5_ib_post_srq_recv()
460 scat[i].lkey = cpu_to_be32(wr->sg_list[i].lkey); mlx5_ib_post_srq_recv()
466 scat[i].lkey = cpu_to_be32(MLX5_INVALID_LKEY); mlx5_ib_post_srq_recv()
479 *srq->db.db = cpu_to_be32(srq->wqe_ctr); mlx5_ib_post_srq_recv()
H A Dmr.c163 in->seg.xlt_oct_size = cpu_to_be32((npages + 1) / 2); add_keys()
164 in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); add_keys()
647 seg->flags_pd = cpu_to_be32(to_mpd(pd)->pdn | MLX5_MKEY_LEN64); mlx5_ib_get_dma_mr()
648 seg->qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); mlx5_ib_get_dma_mr()
996 in->flags = pg_cap ? cpu_to_be32(MLX5_MKEY_INBOX_PG_ACCESS) : 0; reg_create()
999 in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn); reg_create()
1003 in->seg.xlt_oct_size = cpu_to_be32(get_octo_len(virt_addr, length, 1 << page_shift)); reg_create()
1005 in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); reg_create()
1006 in->xlat_oct_act_size = cpu_to_be32(get_octo_len(virt_addr, length, reg_create()
1246 in->seg.xlt_oct_size = cpu_to_be32(ndescs); mlx5_ib_create_mr()
1247 in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); mlx5_ib_create_mr()
1248 in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn); mlx5_ib_create_mr()
1254 in->seg.flags_pd = cpu_to_be32(be32_to_cpu(in->seg.flags_pd) | mlx5_ib_create_mr()
1256 in->seg.bsfs_octo_size = cpu_to_be32(MLX5_MKEY_BSF_OCTO_SIZE); mlx5_ib_create_mr()
1361 in->seg.xlt_oct_size = cpu_to_be32((max_page_list_len + 1) / 2); mlx5_ib_alloc_fast_reg_mr()
1362 in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); mlx5_ib_alloc_fast_reg_mr()
1364 in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn); mlx5_ib_alloc_fast_reg_mr()
/linux-4.1.27/drivers/infiniband/hw/cxgb4/
H A Dqp.c273 res_wr->op_nres = cpu_to_be32( create_qp()
277 res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16)); create_qp()
289 res->u.sqrq.fetchszm_to_iqid = cpu_to_be32( create_qp()
295 res->u.sqrq.dcaen_to_eqsize = cpu_to_be32( create_qp()
303 res->u.sqrq.eqid = cpu_to_be32(wq->sq.qid); create_qp()
314 res->u.sqrq.fetchszm_to_iqid = cpu_to_be32( create_qp()
319 res->u.sqrq.dcaen_to_eqsize = cpu_to_be32( create_qp()
327 res->u.sqrq.eqid = cpu_to_be32(wq->rq.qid); create_qp()
398 immdp->immdlen = cpu_to_be32(plen); build_immd()
446 wqe->send.sendop_pkd = cpu_to_be32( build_rdma_send()
449 wqe->send.sendop_pkd = cpu_to_be32( build_rdma_send()
455 wqe->send.sendop_pkd = cpu_to_be32( build_rdma_send()
458 wqe->send.sendop_pkd = cpu_to_be32( build_rdma_send()
460 wqe->send.stag_inv = cpu_to_be32(wr->ex.invalidate_rkey); build_rdma_send()
497 wqe->send.plen = cpu_to_be32(plen); build_rdma_send()
511 wqe->write.stag_sink = cpu_to_be32(wr->wr.rdma.rkey); build_rdma_write()
540 wqe->write.plen = cpu_to_be32(plen); build_rdma_write()
549 wqe->read.stag_src = cpu_to_be32(wr->wr.rdma.rkey); build_rdma_read()
550 wqe->read.to_src_hi = cpu_to_be32((u32)(wr->wr.rdma.remote_addr build_rdma_read()
552 wqe->read.to_src_lo = cpu_to_be32((u32)wr->wr.rdma.remote_addr); build_rdma_read()
553 wqe->read.stag_sink = cpu_to_be32(wr->sg_list[0].lkey); build_rdma_read()
554 wqe->read.plen = cpu_to_be32(wr->sg_list[0].length); build_rdma_read()
555 wqe->read.to_sink_hi = cpu_to_be32((u32)(wr->sg_list[0].addr build_rdma_read()
557 wqe->read.to_sink_lo = cpu_to_be32((u32)(wr->sg_list[0].addr)); build_rdma_read()
559 wqe->read.stag_src = cpu_to_be32(2); build_rdma_read()
562 wqe->read.stag_sink = cpu_to_be32(2); build_rdma_read()
607 wqe->fr.len_lo = cpu_to_be32(wr->wr.fast_reg.length); build_fastreg()
608 wqe->fr.stag = cpu_to_be32(wr->wr.fast_reg.rkey); build_fastreg()
609 wqe->fr.va_hi = cpu_to_be32(wr->wr.fast_reg.iova_start >> 32); build_fastreg()
610 wqe->fr.va_lo_fbo = cpu_to_be32(wr->wr.fast_reg.iova_start & build_fastreg()
629 sglp->len0 = cpu_to_be32(pbllen); build_fastreg()
637 imdp->immdlen = cpu_to_be32(pbllen); build_fastreg()
663 wqe->inv.stag_inv = cpu_to_be32(wr->ex.invalidate_rkey); build_inv_stag()
1085 wqe->op_compl = cpu_to_be32(FW_WR_OP_V(FW_RI_INIT_WR)); post_terminate()
1086 wqe->flowid_len16 = cpu_to_be32( post_terminate()
1091 wqe->u.terminate.immdlen = cpu_to_be32(sizeof *term); post_terminate()
1206 wqe->op_compl = cpu_to_be32( rdma_fini()
1209 wqe->flowid_len16 = cpu_to_be32( rdma_fini()
1233 init->u.write.stag_sink = cpu_to_be32(1); build_rtr_msg()
1242 init->u.read.stag_src = cpu_to_be32(1); build_rtr_msg()
1243 init->u.read.to_src_lo = cpu_to_be32(1); build_rtr_msg()
1244 init->u.read.stag_sink = cpu_to_be32(1); build_rtr_msg()
1245 init->u.read.to_sink_lo = cpu_to_be32(1); build_rtr_msg()
1275 wqe->op_compl = cpu_to_be32( rdma_init()
1278 wqe->flowid_len16 = cpu_to_be32( rdma_init()
1303 wqe->u.init.pdid = cpu_to_be32(qhp->attr.pd); rdma_init()
1304 wqe->u.init.qpid = cpu_to_be32(qhp->wq.sq.qid); rdma_init()
1305 wqe->u.init.sq_eqid = cpu_to_be32(qhp->wq.sq.qid); rdma_init()
1306 wqe->u.init.rq_eqid = cpu_to_be32(qhp->wq.rq.qid); rdma_init()
1307 wqe->u.init.scqid = cpu_to_be32(qhp->attr.scq); rdma_init()
1308 wqe->u.init.rcqid = cpu_to_be32(qhp->attr.rcq); rdma_init()
1309 wqe->u.init.ord_max = cpu_to_be32(qhp->attr.max_ord); rdma_init()
1310 wqe->u.init.ird_max = cpu_to_be32(qhp->attr.max_ird); rdma_init()
1311 wqe->u.init.iss = cpu_to_be32(qhp->ep->snd_seq); rdma_init()
1312 wqe->u.init.irs = cpu_to_be32(qhp->ep->rcv_seq); rdma_init()
1313 wqe->u.init.hwrqsize = cpu_to_be32(qhp->wq.rq.rqt_size); rdma_init()
1314 wqe->u.init.hwrqaddr = cpu_to_be32(qhp->wq.rq.rqt_hwaddr - rdma_init()
H A Dmem.c84 req->wr.wr_hi = cpu_to_be32(FW_WR_OP_V(FW_ULPTX_WR) | _c4iw_write_mem_dma_aligned()
87 req->wr.wr_mid = cpu_to_be32(FW_WR_LEN16_V(DIV_ROUND_UP(wr_len, 16))); _c4iw_write_mem_dma_aligned()
88 req->cmd = cpu_to_be32(ULPTX_CMD_V(ULP_TX_MEM_WRITE)); _c4iw_write_mem_dma_aligned()
89 req->cmd |= cpu_to_be32(T5_ULP_MEMIO_ORDER_V(1)); _c4iw_write_mem_dma_aligned()
90 req->dlen = cpu_to_be32(ULP_MEMIO_DATA_LEN_V(len>>5)); _c4iw_write_mem_dma_aligned()
91 req->len16 = cpu_to_be32(DIV_ROUND_UP(wr_len-sizeof(req->wr), 16)); _c4iw_write_mem_dma_aligned()
92 req->lock_addr = cpu_to_be32(ULP_MEMIO_ADDR_V(addr)); _c4iw_write_mem_dma_aligned()
95 sgl->cmd_nsge = cpu_to_be32(ULPTX_CMD_V(ULP_TX_SC_DSGL) | _c4iw_write_mem_dma_aligned()
97 sgl->len0 = cpu_to_be32(len); _c4iw_write_mem_dma_aligned()
117 __be32 cmd = cpu_to_be32(ULPTX_CMD_V(ULP_TX_MEM_WRITE)); _c4iw_write_mem_inline()
120 cmd |= cpu_to_be32(ULP_MEMIO_ORDER_F); _c4iw_write_mem_inline()
122 cmd |= cpu_to_be32(T5_ULP_MEMIO_IMM_F); _c4iw_write_mem_inline()
145 req->wr.wr_hi = cpu_to_be32(FW_WR_OP_V(FW_ULPTX_WR) | _c4iw_write_mem_inline()
149 req->wr.wr_hi = cpu_to_be32(FW_WR_OP_V(FW_ULPTX_WR)); _c4iw_write_mem_inline()
150 req->wr.wr_mid = cpu_to_be32( _c4iw_write_mem_inline()
154 req->dlen = cpu_to_be32(ULP_MEMIO_DATA_LEN_V( _c4iw_write_mem_inline()
156 req->len16 = cpu_to_be32(DIV_ROUND_UP(wr_len-sizeof(req->wr), _c4iw_write_mem_inline()
158 req->lock_addr = cpu_to_be32(ULP_MEMIO_ADDR_V(addr + i * 3)); _c4iw_write_mem_inline()
161 sc->cmd_more = cpu_to_be32(ULPTX_CMD_V(ULP_TX_SC_IMM)); _c4iw_write_mem_inline()
162 sc->len = cpu_to_be32(roundup(copy_len, T4_ULPTX_MIN_IO)); _c4iw_write_mem_inline()
289 tpt.valid_to_pdid = cpu_to_be32(FW_RI_TPTE_VALID_F | write_tpt_entry()
293 tpt.locread_to_qpid = cpu_to_be32(FW_RI_TPTE_PERM_V(perm) | write_tpt_entry()
298 tpt.nosnoop_pbladdr = !pbl_size ? 0 : cpu_to_be32( write_tpt_entry()
300 tpt.len_lo = cpu_to_be32((u32)(len & 0xffffffffUL)); write_tpt_entry()
301 tpt.va_hi = cpu_to_be32((u32)(to >> 32)); write_tpt_entry()
302 tpt.va_lo_fbo = cpu_to_be32((u32)(to & 0xffffffffUL)); write_tpt_entry()
303 tpt.dca_mwbcnt_pstag = cpu_to_be32(0); write_tpt_entry()
304 tpt.len_hi = cpu_to_be32((u32)(len >> 32)); write_tpt_entry()
H A Dcm.c230 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_TID_RELEASE, hwtid)); release_tid()
475 flowc->op_to_nparams = cpu_to_be32(FW_WR_OP_V(FW_FLOWC_WR) | send_flowc()
477 flowc->flowid_len16 = cpu_to_be32(FW_WR_LEN16_V(DIV_ROUND_UP(flowclen, send_flowc()
481 flowc->mnemval[0].val = cpu_to_be32(FW_PFVF_CMD_PFN_V send_flowc()
484 flowc->mnemval[1].val = cpu_to_be32(ep->tx_chan); send_flowc()
486 flowc->mnemval[2].val = cpu_to_be32(ep->tx_chan); send_flowc()
488 flowc->mnemval[3].val = cpu_to_be32(ep->rss_qid); send_flowc()
490 flowc->mnemval[4].val = cpu_to_be32(ep->snd_seq); send_flowc()
492 flowc->mnemval[5].val = cpu_to_be32(ep->rcv_seq); send_flowc()
494 flowc->mnemval[6].val = cpu_to_be32(ep->snd_win); send_flowc()
496 flowc->mnemval[7].val = cpu_to_be32(ep->emss); send_flowc()
527 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_CLOSE_CON_REQ, send_halfclose()
549 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_REQ, ep->hwtid)); send_abort()
702 OPCODE_TID(req) = cpu_to_be32( send_connect()
710 req->params = cpu_to_be32(cxgb4_select_ntuple( send_connect()
713 req->opt2 = cpu_to_be32(opt2); send_connect()
718 OPCODE_TID(req6) = cpu_to_be32( send_connect()
732 req6->params = cpu_to_be32(cxgb4_select_ntuple( send_connect()
735 req6->opt2 = cpu_to_be32(opt2); send_connect()
747 OPCODE_TID(t5_req) = cpu_to_be32( send_connect()
759 t5_req->rsvd = cpu_to_be32(isn); send_connect()
762 t5_req->opt2 = cpu_to_be32(opt2); send_connect()
767 OPCODE_TID(t5_req6) = cpu_to_be32( send_connect()
785 t5_req6->rsvd = cpu_to_be32(isn); send_connect()
788 t5_req6->opt2 = cpu_to_be32(opt2); send_connect()
821 req->op_to_immdlen = cpu_to_be32( send_mpa_req()
825 req->flowid_len16 = cpu_to_be32( send_mpa_req()
828 req->plen = cpu_to_be32(mpalen); send_mpa_req()
829 req->tunnel_to_proxy = cpu_to_be32( send_mpa_req()
915 req->op_to_immdlen = cpu_to_be32( send_mpa_reject()
919 req->flowid_len16 = cpu_to_be32( send_mpa_reject()
922 req->plen = cpu_to_be32(mpalen); send_mpa_reject()
923 req->tunnel_to_proxy = cpu_to_be32( send_mpa_reject()
995 req->op_to_immdlen = cpu_to_be32( send_mpa_reply()
999 req->flowid_len16 = cpu_to_be32( send_mpa_reply()
1002 req->plen = cpu_to_be32(mpalen); send_mpa_reply()
1003 req->tunnel_to_proxy = cpu_to_be32( send_mpa_reply()
1274 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_RX_DATA_ACK, update_rx_credits()
1276 req->credit_dack = cpu_to_be32(credits | RX_FORCE_ACK_F | update_rx_credits()
1772 req->le.filter = cpu_to_be32(cxgb4_select_ntuple( send_fw_act_open_req()
1825 req->tcb.opt2 = cpu_to_be32((__force u32)req->tcb.opt2); send_fw_act_open_req()
2188 OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_PASS_ACCEPT_RPL, accept_cr()
2241 rpl5->iss = cpu_to_be32(isn); accept_cr()
2246 rpl->opt2 = cpu_to_be32(opt2); accept_cr()
2668 OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_RPL, ep->hwtid)); peer_abort()
3563 req->hdr_len = cpu_to_be32(SYN_RX_CHAN_V(RX_CHAN_G( build_cpl_pass_accept_req()
3572 req->tos_stid = cpu_to_be32(PASS_OPEN_TID_V(stid) | build_cpl_pass_accept_req()
3669 if (!(cpl->l2info & cpu_to_be32(RXF_SYN_F))) rx_pkt()
3682 stid = (__force int) cpu_to_be32((__force u32) rss->hash_val); rx_pkt()
3755 filter = (__force unsigned int) cpu_to_be32(cxgb4_select_ntuple( rx_pkt()
H A Dcq.c53 res_wr->op_nres = cpu_to_be32( destroy_cq()
57 res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16)); destroy_cq()
62 res->u.cq.iqid = cpu_to_be32(cq->cqid); destroy_cq()
123 res_wr->op_nres = cpu_to_be32( create_cq()
127 res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16)); create_cq()
132 res->u.cq.iqid = cpu_to_be32(cq->cqid); create_cq()
133 res->u.cq.iqandst_to_iqandstindex = cpu_to_be32( create_cq()
192 cqe.header = cpu_to_be32(CQE_STATUS_V(T4_ERR_SWFLUSH) | insert_recv_cqe()
225 cqe.header = cpu_to_be32(CQE_STATUS_V(T4_ERR_SWFLUSH) | insert_sq_cqe()
410 swcqe->header |= cpu_to_be32(CQE_SWCQE_V(1)); c4iw_flush_hw_cq()
/linux-4.1.27/fs/hfs/
H A Dbtree.c173 head->root = cpu_to_be32(tree->root); hfs_btree_write()
174 head->leaf_count = cpu_to_be32(tree->leaf_count); hfs_btree_write()
175 head->leaf_head = cpu_to_be32(tree->leaf_head); hfs_btree_write()
176 head->leaf_tail = cpu_to_be32(tree->leaf_tail); hfs_btree_write()
177 head->node_count = cpu_to_be32(tree->node_count); hfs_btree_write()
178 head->free_nodes = cpu_to_be32(tree->free_nodes); hfs_btree_write()
179 head->attributes = cpu_to_be32(tree->attributes); hfs_btree_write()
202 cnid = cpu_to_be32(idx); hfs_bmap_new_bmap()
H A Dbitmap.c85 *curr++ = cpu_to_be32(n); hfs_find_set_zero_bits()
95 *curr++ = cpu_to_be32(0xffffffff); hfs_find_set_zero_bits()
107 *curr = cpu_to_be32(n); hfs_find_set_zero_bits()
220 *curr &= cpu_to_be32(mask); hfs_clear_vbm_bits()
223 *curr++ &= cpu_to_be32(mask); hfs_clear_vbm_bits()
235 *curr &= cpu_to_be32(mask); hfs_clear_vbm_bits()
H A Dbrec.c152 cnid = cpu_to_be32(new_node->this); hfs_brec_insert()
315 node_desc.next = cpu_to_be32(new_node->next); hfs_bnode_split()
316 node_desc.prev = cpu_to_be32(new_node->prev); hfs_bnode_split()
326 node_desc.next = cpu_to_be32(node->next); hfs_bnode_split()
334 node_desc.prev = cpu_to_be32(next_node->prev); hfs_bnode_split()
429 cnid = cpu_to_be32(new_node->this); hfs_brec_update_parent()
484 node_desc.next = cpu_to_be32(new_node->next); hfs_btree_inc_height()
485 node_desc.prev = cpu_to_be32(new_node->prev); hfs_btree_inc_height()
510 cnid = cpu_to_be32(node->this); hfs_btree_inc_height()
H A Dcatalog.c26 key->cat.ParID = cpu_to_be32(parent); hfs_cat_build_key()
43 rec->dir.DirID = cpu_to_be32(cnid); hfs_cat_build_record()
55 rec->file.FlNum = cpu_to_be32(cnid); hfs_cat_build_record()
71 rec->thread.ParID = cpu_to_be32(parentid); hfs_cat_build_thread()
H A Dpart_tbl.c81 p->pdFSID == cpu_to_be32(0x54465331)/*"TFS1"*/ && hfs_part_find()
H A Dmdb.c270 mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id); hfs_mdb_commit()
273 mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count); hfs_mdb_commit()
274 mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count); hfs_mdb_commit()
H A Dsuper.c137 if (sbi->s_creator != cpu_to_be32(0x3f3f3f3f)) hfs_show_options()
139 if (sbi->s_type != cpu_to_be32(0x3f3f3f3f)) hfs_show_options()
240 hsb->s_type = hsb->s_creator = cpu_to_be32(0x3f3f3f3f); /* == '????' */ parse_options()
/linux-4.1.27/arch/powerpc/crypto/
H A Dsha256-spe-glue.c170 dst[0] = cpu_to_be32(sctx->state[0]); ppc_spe_sha256_final()
171 dst[1] = cpu_to_be32(sctx->state[1]); ppc_spe_sha256_final()
172 dst[2] = cpu_to_be32(sctx->state[2]); ppc_spe_sha256_final()
173 dst[3] = cpu_to_be32(sctx->state[3]); ppc_spe_sha256_final()
174 dst[4] = cpu_to_be32(sctx->state[4]); ppc_spe_sha256_final()
175 dst[5] = cpu_to_be32(sctx->state[5]); ppc_spe_sha256_final()
176 dst[6] = cpu_to_be32(sctx->state[6]); ppc_spe_sha256_final()
177 dst[7] = cpu_to_be32(sctx->state[7]); ppc_spe_sha256_final()
H A Dsha1-spe-glue.c148 dst[0] = cpu_to_be32(sctx->state[0]); ppc_spe_sha1_final()
149 dst[1] = cpu_to_be32(sctx->state[1]); ppc_spe_sha1_final()
150 dst[2] = cpu_to_be32(sctx->state[2]); ppc_spe_sha1_final()
151 dst[3] = cpu_to_be32(sctx->state[3]); ppc_spe_sha1_final()
152 dst[4] = cpu_to_be32(sctx->state[4]); ppc_spe_sha1_final()
/linux-4.1.27/sound/firewire/fireworks/
H A Dfireworks_command.c135 header->length = cpu_to_be32(cmd_bytes / sizeof(__be32)); efw_transaction()
136 header->version = cpu_to_be32(1); efw_transaction()
137 header->seqnum = cpu_to_be32(seqnum); efw_transaction()
138 header->category = cpu_to_be32(category); efw_transaction()
139 header->command = cpu_to_be32(command); efw_transaction()
187 addr[0] = cpu_to_be32(addr_high); snd_efw_command_set_resp_addr()
188 addr[1] = cpu_to_be32(addr_low); snd_efw_command_set_resp_addr()
206 __be32 param = cpu_to_be32(mode); snd_efw_command_set_tx_mode()
/linux-4.1.27/drivers/infiniband/hw/amso1100/
H A Dc2_qp.c158 wr.ord = cpu_to_be32(C2_QP_NO_ATTR_CHANGE); c2_qp_modify()
159 wr.ird = cpu_to_be32(C2_QP_NO_ATTR_CHANGE); c2_qp_modify()
160 wr.sq_depth = cpu_to_be32(C2_QP_NO_ATTR_CHANGE); c2_qp_modify()
161 wr.rq_depth = cpu_to_be32(C2_QP_NO_ATTR_CHANGE); c2_qp_modify()
170 wr.next_qp_state = cpu_to_be32(to_c2_state(attr->qp_state)); c2_qp_modify()
195 cpu_to_be32(to_c2_state(attr->cur_qp_state)); c2_qp_modify()
269 wr.ord = cpu_to_be32(ord); c2_qp_set_read_limits()
270 wr.ird = cpu_to_be32(ird); c2_qp_set_read_limits()
271 wr.sq_depth = cpu_to_be32(C2_QP_NO_ATTR_CHANGE); c2_qp_set_read_limits()
272 wr.rq_depth = cpu_to_be32(C2_QP_NO_ATTR_CHANGE); c2_qp_set_read_limits()
273 wr.next_qp_state = cpu_to_be32(C2_QP_NO_ATTR_CHANGE); c2_qp_set_read_limits()
464 wr.sq_depth = cpu_to_be32(qp_attrs->cap.max_send_wr + 1); c2_alloc_qp()
465 wr.rq_depth = cpu_to_be32(qp_attrs->cap.max_recv_wr + 1); c2_alloc_qp()
467 wr.flags = cpu_to_be32(QP_RDMA_READ | QP_RDMA_WRITE | QP_MW_BIND | c2_alloc_qp()
469 wr.send_sgl_depth = cpu_to_be32(qp_attrs->cap.max_send_sge); c2_alloc_qp()
470 wr.recv_sgl_depth = cpu_to_be32(qp_attrs->cap.max_recv_sge); c2_alloc_qp()
471 wr.rdma_write_sgl_depth = cpu_to_be32(qp_attrs->cap.max_send_sge); c2_alloc_qp()
474 wr.ord = cpu_to_be32(C2_MAX_ORD_PER_QP); c2_alloc_qp()
475 wr.ird = cpu_to_be32(C2_MAX_IRD_PER_QP); c2_alloc_qp()
683 dst->stag = cpu_to_be32(src->lkey); move_sgl()
685 dst->length = cpu_to_be32(src->length); move_sgl()
771 ((c2wr_hdr_t *) wr)->magic = cpu_to_be32(CCWR_MAGIC); qp_wr_post()
832 cpu_to_be32(ib_wr->ex.invalidate_rkey); c2_post_send()
848 wr.sqwr.send.sge_len = cpu_to_be32(tot_len); c2_post_send()
863 cpu_to_be32(ib_wr->wr.rdma.rkey); c2_post_send()
871 wr.sqwr.rdma_write.sge_len = cpu_to_be32(tot_len); c2_post_send()
888 cpu_to_be32(ib_wr->sg_list->lkey); c2_post_send()
892 cpu_to_be32(ib_wr->wr.rdma.rkey); c2_post_send()
896 cpu_to_be32(ib_wr->sg_list->length); c2_post_send()
H A Dc2_mm.c92 wr->addrs_length = cpu_to_be32(count); send_pbl_messages()
105 wr->flags = cpu_to_be32(MEM_PBL_COMPLETE); send_pbl_messages()
231 wr->pbe_size = cpu_to_be32(page_size); c2_nsmr_register_phys_kern()
232 wr->length = cpu_to_be32(length); c2_nsmr_register_phys_kern()
233 wr->pbl_depth = cpu_to_be32(pbl_depth); c2_nsmr_register_phys_kern()
234 wr->fbo = cpu_to_be32(offset); c2_nsmr_register_phys_kern()
236 wr->addrs_length = cpu_to_be32(count); c2_nsmr_register_phys_kern()
294 cpu_to_be32(mr->ibmr.lkey), c2_nsmr_register_phys_kern()
338 wr.stag_index = cpu_to_be32(stag_index); c2_stag_dealloc()
H A Dc2_mq.c49 m->magic = cpu_to_be32(CCWR_MAGIC); c2_mq_alloc()
103 __raw_writel(cpu_to_be32(~CCWR_MAGIC), &m->magic); c2_mq_free()
H A Dc2_cm.c107 cpu_to_be32(iw_param->private_data_len); c2_llp_connect()
166 wr.backlog = cpu_to_be32(backlog); c2_llp_service_create()
348 wr->private_data_length = cpu_to_be32(iw_param->private_data_len); c2_llp_accept()
/linux-4.1.27/fs/affs/
H A Dbitmap.c75 *data = cpu_to_be32(tmp | mask); affs_free_block()
79 *(__be32 *)bh->b_data = cpu_to_be32(tmp - mask); affs_free_block()
219 *data = cpu_to_be32(tmp & ~mask); affs_alloc_block()
223 *(__be32 *)bh->b_data = cpu_to_be32(tmp + mask); affs_alloc_block()
326 ((__be32 *)bh->b_data)[offset] = cpu_to_be32(new); affs_init_bitmap()
330 //*(__be32 *)bh->b_data = cpu_to_be32(old - new); affs_init_bitmap()
339 ((__be32 *)bh->b_data)[0] = cpu_to_be32(-affs_checksum_block(sb, bh)); affs_init_bitmap()
H A Dinode.c185 if (tail->stype == cpu_to_be32(ST_ROOT)) { affs_write_inode()
188 tail->protect = cpu_to_be32(AFFS_I(inode)->i_protect); affs_write_inode()
189 tail->size = cpu_to_be32(inode->i_size); affs_write_inode()
379 AFFS_HEAD(bh)->ptype = cpu_to_be32(T_SHORT); affs_add_entry()
380 AFFS_HEAD(bh)->key = cpu_to_be32(bh->b_blocknr); affs_add_entry()
382 AFFS_TAIL(sb, bh)->stype = cpu_to_be32(type); affs_add_entry()
383 AFFS_TAIL(sb, bh)->parent = cpu_to_be32(dir->i_ino); affs_add_entry()
388 AFFS_TAIL(sb, bh)->original = cpu_to_be32(inode->i_ino); affs_add_entry()
390 AFFS_TAIL(sb, inode_bh)->link_chain = cpu_to_be32(block); affs_add_entry()
H A Dfile.c133 AFFS_HEAD(new_bh)->ptype = cpu_to_be32(T_LIST); affs_alloc_extblock()
134 AFFS_HEAD(new_bh)->key = cpu_to_be32(blocknr); affs_alloc_extblock()
135 AFFS_TAIL(sb, new_bh)->stype = cpu_to_be32(ST_FILE); affs_alloc_extblock()
136 AFFS_TAIL(sb, new_bh)->parent = cpu_to_be32(inode->i_ino); affs_alloc_extblock()
144 AFFS_TAIL(sb, bh)->extension = cpu_to_be32(blocknr); affs_alloc_extblock()
334 AFFS_BLOCK(sb, ext_bh, block) = cpu_to_be32(blocknr); affs_get_block()
335 AFFS_HEAD(ext_bh)->block_count = cpu_to_be32(block + 1); affs_get_block()
344 AFFS_HEAD(ext_bh)->first_data = cpu_to_be32(blocknr); affs_get_block()
578 AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA); affs_extent_file_ofs()
579 AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino); affs_extent_file_ofs()
580 AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx); affs_extent_file_ofs()
581 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp); affs_extent_file_ofs()
592 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr); affs_extent_file_ofs()
728 AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA); affs_write_end_ofs()
729 AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino); affs_write_end_ofs()
730 AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx); affs_write_end_ofs()
731 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(bsize); affs_write_end_ofs()
741 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr); affs_write_end_ofs()
762 AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA); affs_write_end_ofs()
763 AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino); affs_write_end_ofs()
764 AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx); affs_write_end_ofs()
765 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp); affs_write_end_ofs()
775 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr); affs_write_end_ofs()
780 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp); affs_write_end_ofs()
901 AFFS_HEAD(ext_bh)->block_count = cpu_to_be32(i); affs_truncate()
H A Damigaffs.c47 AFFS_TAIL(sb, bh)->parent = cpu_to_be32(dir->i_ino); affs_insert_hash()
52 AFFS_HEAD(dir_bh)->table[offset] = cpu_to_be32(ino); affs_insert_hash()
54 AFFS_TAIL(sb, dir_bh)->hash_chain = cpu_to_be32(ino); affs_insert_hash()
365 *checksumptr = cpu_to_be32(-checksum); affs_fix_checksum()
382 ds->days = cpu_to_be32(days); secs_to_datestamp()
383 ds->mins = cpu_to_be32(minute); secs_to_datestamp()
384 ds->ticks = cpu_to_be32(secs * 50); secs_to_datestamp()
/linux-4.1.27/drivers/mtd/ubi/
H A Dfastmap.c120 new->vol_id = cpu_to_be32(vol_id); new_fm_vhdr()
1132 fmsb->magic = cpu_to_be32(UBI_FM_SB_MAGIC); ubi_write_fastmap()
1134 fmsb->used_blocks = cpu_to_be32(new_fm->used_blocks); ubi_write_fastmap()
1138 fmh->magic = cpu_to_be32(UBI_FM_HDR_MAGIC); ubi_write_fastmap()
1147 fmpl1->magic = cpu_to_be32(UBI_FM_POOL_MAGIC); ubi_write_fastmap()
1152 fmpl1->pebs[i] = cpu_to_be32(ubi->fm_pool.pebs[i]); ubi_write_fastmap()
1158 fmpl2->magic = cpu_to_be32(UBI_FM_POOL_MAGIC); ubi_write_fastmap()
1163 fmpl2->pebs[i] = cpu_to_be32(ubi->fm_wl_pool.pebs[i]); ubi_write_fastmap()
1170 fec->pnum = cpu_to_be32(wl_e->pnum); ubi_for_each_free_peb()
1172 fec->ec = cpu_to_be32(wl_e->ec); ubi_for_each_free_peb()
1178 fmh->free_peb_count = cpu_to_be32(free_peb_count);
1183 fec->pnum = cpu_to_be32(wl_e->pnum); ubi_for_each_used_peb()
1185 fec->ec = cpu_to_be32(wl_e->ec); ubi_for_each_used_peb()
1195 fec->pnum = cpu_to_be32(wl_e->pnum); ubi_for_each_protected_peb()
1197 fec->ec = cpu_to_be32(wl_e->ec); ubi_for_each_protected_peb()
1203 fmh->used_peb_count = cpu_to_be32(used_peb_count);
1208 fec->pnum = cpu_to_be32(wl_e->pnum); ubi_for_each_scrub_peb()
1210 fec->ec = cpu_to_be32(wl_e->ec); ubi_for_each_scrub_peb()
1216 fmh->scrub_peb_count = cpu_to_be32(scrub_peb_count);
1226 fec->pnum = cpu_to_be32(wl_e->pnum);
1228 fec->ec = cpu_to_be32(wl_e->ec);
1235 fmh->erase_peb_count = cpu_to_be32(erase_peb_count);
1249 fvh->magic = cpu_to_be32(UBI_FM_VHDR_MAGIC);
1250 fvh->vol_id = cpu_to_be32(vol->vol_id);
1252 fvh->used_ebs = cpu_to_be32(vol->used_ebs);
1253 fvh->data_pad = cpu_to_be32(vol->data_pad);
1254 fvh->last_eb_bytes = cpu_to_be32(vol->last_eb_bytes);
1264 feba->pnum[j] = cpu_to_be32(vol->eba_tbl[j]);
1266 feba->reserved_pebs = cpu_to_be32(j);
1267 feba->magic = cpu_to_be32(UBI_FM_EBA_MAGIC);
1269 fmh->vol_count = cpu_to_be32(vol_count);
1270 fmh->bad_peb_count = cpu_to_be32(ubi->bad_peb_count);
1286 fmsb->block_loc[i] = cpu_to_be32(new_fm->e[i]->pnum);
1288 fmsb->block_ec[i] = cpu_to_be32(new_fm->e[i]->ec);
1292 fmsb->data_crc = cpu_to_be32(crc32(UBI_CRC32_INIT, fm_raw,
1297 dvhdr->lnum = cpu_to_be32(i);
H A Deba.c720 vid_hdr->vol_id = cpu_to_be32(vol_id); ubi_eba_write_leb()
721 vid_hdr->lnum = cpu_to_be32(lnum); ubi_eba_write_leb()
723 vid_hdr->data_pad = cpu_to_be32(vol->data_pad); ubi_eba_write_leb()
837 vid_hdr->vol_id = cpu_to_be32(vol_id); ubi_eba_write_leb_st()
838 vid_hdr->lnum = cpu_to_be32(lnum); ubi_eba_write_leb_st()
840 vid_hdr->data_pad = cpu_to_be32(vol->data_pad); ubi_eba_write_leb_st()
844 vid_hdr->data_size = cpu_to_be32(data_size); ubi_eba_write_leb_st()
845 vid_hdr->used_ebs = cpu_to_be32(used_ebs); ubi_eba_write_leb_st()
846 vid_hdr->data_crc = cpu_to_be32(crc); ubi_eba_write_leb_st()
958 vid_hdr->vol_id = cpu_to_be32(vol_id); ubi_eba_atomic_leb_change()
959 vid_hdr->lnum = cpu_to_be32(lnum); ubi_eba_atomic_leb_change()
961 vid_hdr->data_pad = cpu_to_be32(vol->data_pad); ubi_eba_atomic_leb_change()
965 vid_hdr->data_size = cpu_to_be32(len); ubi_eba_atomic_leb_change()
967 vid_hdr->data_crc = cpu_to_be32(crc); ubi_eba_atomic_leb_change()
1186 vid_hdr->data_size = cpu_to_be32(data_size); ubi_eba_copy_leb()
1187 vid_hdr->data_crc = cpu_to_be32(crc); ubi_eba_copy_leb()
/linux-4.1.27/drivers/net/ethernet/chelsio/cxgb4vf/
H A Dt4vf_hw.c294 vi_cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_VI_CMD) | t4vf_port_init()
297 vi_cmd.alloc_to_len16 = cpu_to_be32(FW_LEN16(vi_cmd)); t4vf_port_init()
315 port_cmd.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PORT_CMD) | t4vf_port_init()
320 cpu_to_be32(FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_GET_PORT_INFO) | t4vf_port_init()
350 cmd.op_to_write = cpu_to_be32(FW_CMD_OP_V(FW_RESET_CMD) | t4vf_fw_reset()
352 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd)); t4vf_fw_reset()
378 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_PARAMS_CMD) | t4vf_query_params()
383 cmd.retval_len16 = cpu_to_be32(FW_CMD_LEN16_V(len16)); t4vf_query_params()
416 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_PARAMS_CMD) | t4vf_set_params()
421 cmd.retval_len16 = cpu_to_be32(FW_CMD_LEN16_V(len16)); t4vf_set_params()
423 p->mnem = cpu_to_be32(*params++); t4vf_set_params()
424 p->val = cpu_to_be32(*vals++); t4vf_set_params()
710 cmd.op_to_write = cpu_to_be32(FW_CMD_OP_V(FW_RSS_GLB_CONFIG_CMD) | t4vf_get_rss_glb_config()
713 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd)); t4vf_get_rss_glb_config()
786 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_PFVF_CMD) | t4vf_get_vfres()
789 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd)); t4vf_get_vfres()
834 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_RSS_VI_CONFIG_CMD) | t4vf_read_rss_vi_config()
838 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd)); t4vf_read_rss_vi_config()
884 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_RSS_VI_CONFIG_CMD) | t4vf_write_rss_vi_config()
888 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd)); t4vf_write_rss_vi_config()
905 cmd.u.basicvirtual.defaultq_to_udpen = cpu_to_be32(word); t4vf_write_rss_vi_config()
942 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_RSS_IND_TBL_CMD) | t4vf_config_rss_range()
946 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd)); t4vf_config_rss_range()
996 *qp++ = cpu_to_be32(FW_RSS_IND_TBL_CMD_IQ0_V(qbuf[0]) | t4vf_config_rss_range()
1031 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_VI_CMD) | t4vf_alloc_vi()
1035 cmd.alloc_to_len16 = cpu_to_be32(FW_LEN16(cmd) | t4vf_alloc_vi()
1061 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_VI_CMD) | t4vf_free_vi()
1064 cmd.alloc_to_len16 = cpu_to_be32(FW_LEN16(cmd) | t4vf_free_vi()
1085 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_ENABLE_CMD) | t4vf_enable_vi()
1089 cmd.ien_to_len16 = cpu_to_be32(FW_VI_ENABLE_CMD_IEN_V(rx_en) | t4vf_enable_vi()
1109 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_ENABLE_CMD) | t4vf_identify_port()
1113 cmd.ien_to_len16 = cpu_to_be32(FW_VI_ENABLE_CMD_LED_F | t4vf_identify_port()
1151 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_RXMODE_CMD) | t4vf_set_rxmode()
1155 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd)); t4vf_set_rxmode()
1157 cpu_to_be32(FW_VI_RXMODE_CMD_MTU_V(mtu) | t4vf_set_rxmode()
1211 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_MAC_CMD) | t4vf_alloc_mac_filt()
1217 cpu_to_be32(FW_VI_MAC_CMD_FREEMACS_V(free) | t4vf_alloc_mac_filt()
1300 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_MAC_CMD) | t4vf_change_mac()
1304 cmd.freemacs_to_len16 = cpu_to_be32(FW_CMD_LEN16_V(len16)); t4vf_change_mac()
1337 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_MAC_CMD) | t4vf_set_addr_hash()
1341 cmd.freemacs_to_len16 = cpu_to_be32(FW_VI_MAC_CMD_HASHVECEN_F | t4vf_set_addr_hash()
1379 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_STATS_CMD) | t4vf_get_port_stats()
1383 cmd.retval_len16 = cpu_to_be32(FW_CMD_LEN16_V(len16)); t4vf_get_port_stats()
1438 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_IQ_CMD) | t4vf_iq_free()
1441 cmd.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_FREE_F | t4vf_iq_free()
1444 cpu_to_be32(FW_IQ_CMD_TYPE_V(iqtype)); t4vf_iq_free()
1464 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_EQ_ETH_CMD) | t4vf_eth_eq_free()
1467 cmd.alloc_to_len16 = cpu_to_be32(FW_EQ_ETH_CMD_FREE_F | t4vf_eth_eq_free()
1469 cmd.eqid_pkd = cpu_to_be32(FW_EQ_ETH_CMD_EQID_V(eqid)); t4vf_eth_eq_free()
H A Dsge.c940 to->len[0] = cpu_to_be32(skb_frag_size(&si->frags[i])); write_sgl()
941 to->len[1] = cpu_to_be32(skb_frag_size(&si->frags[++i])); write_sgl()
946 to->len[0] = cpu_to_be32(skb_frag_size(&si->frags[i])); write_sgl()
947 to->len[1] = cpu_to_be32(0); write_sgl()
1258 wr->equiq_to_len16 = cpu_to_be32(wr_mid); t4vf_eth_xmit()
1259 wr->r3[0] = cpu_to_be32(0); t4vf_eth_xmit()
1260 wr->r3[1] = cpu_to_be32(0); t4vf_eth_xmit()
1277 cpu_to_be32(FW_WR_OP_V(FW_ETH_TX_PKT_VM_WR) | t4vf_eth_xmit()
1284 cpu_to_be32(LSO_OPCODE(CPL_TX_PKT_LSO) | t4vf_eth_xmit()
1293 lso->seqno_offset = cpu_to_be32(0); t4vf_eth_xmit()
1295 lso->len = cpu_to_be32(skb->len); t4vf_eth_xmit()
1297 lso->len = cpu_to_be32(LSO_T5_XFER_SIZE(skb->len)); t4vf_eth_xmit()
1314 cpu_to_be32(FW_WR_OP_V(FW_ETH_TX_PKT_VM_WR) | t4vf_eth_xmit()
1341 cpl->ctrl0 = cpu_to_be32(TXPKT_OPCODE(CPL_TX_PKT_XT) | t4vf_eth_xmit()
1611 if ((pkt->l2info & cpu_to_be32(RXF_TCP_F)) && t4vf_ethrx_handler()
2218 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_IQ_CMD) | t4vf_sge_alloc_rxq()
2222 cmd.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_ALLOC_F | t4vf_sge_alloc_rxq()
2226 cpu_to_be32(FW_IQ_CMD_TYPE_V(FW_IQ_TYPE_FL_INT_CAP) | t4vf_sge_alloc_rxq()
2270 cpu_to_be32( t4vf_sge_alloc_rxq()
2394 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_EQ_ETH_CMD) | t4vf_sge_alloc_eth_txq()
2398 cmd.alloc_to_len16 = cpu_to_be32(FW_EQ_ETH_CMD_ALLOC_F | t4vf_sge_alloc_eth_txq()
2401 cmd.viid_pkd = cpu_to_be32(FW_EQ_ETH_CMD_AUTOEQUEQE_F | t4vf_sge_alloc_eth_txq()
2404 cpu_to_be32(FW_EQ_ETH_CMD_HOSTFCMODE_V(SGE_HOSTFCMODE_STPG) | t4vf_sge_alloc_eth_txq()
2408 cpu_to_be32(FW_EQ_ETH_CMD_FBMIN_V(SGE_FETCHBURSTMIN_64B) | t4vf_sge_alloc_eth_txq()
/linux-4.1.27/drivers/mtd/nand/
H A Domap_elm.c187 val = cpu_to_be32(*(u32 *) &ecc[9]); elm_load_syndrome()
192 val = cpu_to_be32(*(u32 *) &ecc[5]); elm_load_syndrome()
197 val = cpu_to_be32(*(u32 *) &ecc[1]); elm_load_syndrome()
207 val = (cpu_to_be32(*(u32 *) &ecc[3]) >> 4) | elm_load_syndrome()
213 val = cpu_to_be32(*(u32 *) &ecc[0]) >> 12; elm_load_syndrome()
217 val = cpu_to_be32(*(u32 *) &ecc[22]); elm_load_syndrome()
220 val = cpu_to_be32(*(u32 *) &ecc[18]); elm_load_syndrome()
223 val = cpu_to_be32(*(u32 *) &ecc[14]); elm_load_syndrome()
226 val = cpu_to_be32(*(u32 *) &ecc[10]); elm_load_syndrome()
229 val = cpu_to_be32(*(u32 *) &ecc[6]); elm_load_syndrome()
232 val = cpu_to_be32(*(u32 *) &ecc[2]); elm_load_syndrome()
235 val = cpu_to_be32(*(u32 *) &ecc[0]) >> 16; elm_load_syndrome()
/linux-4.1.27/drivers/net/wireless/prism54/
H A Dislpci_eth.c284 avs->version = cpu_to_be32(P80211CAPTURE_VERSION); islpci_monitor_rx()
285 avs->length = cpu_to_be32(sizeof (struct avs_80211_1_header)); islpci_monitor_rx()
288 avs->phytype = cpu_to_be32(6); /*OFDM: 6 for (g), 8 for (a) */ islpci_monitor_rx()
289 avs->channel = cpu_to_be32(channel_of_freq(freq)); islpci_monitor_rx()
290 avs->datarate = cpu_to_be32(rate * 5); islpci_monitor_rx()
291 avs->antenna = cpu_to_be32(0); /*unknown */ islpci_monitor_rx()
292 avs->priority = cpu_to_be32(0); /*unknown */ islpci_monitor_rx()
293 avs->ssi_type = cpu_to_be32(3); /*2: dBm, 3: raw RSSI */ islpci_monitor_rx()
294 avs->ssi_signal = cpu_to_be32(rssi & 0x7f); islpci_monitor_rx()
295 avs->ssi_noise = cpu_to_be32(priv->local_iwstatistics.qual.noise); /*better than 'undefined', I assume */ islpci_monitor_rx()
296 avs->preamble = cpu_to_be32(0); /*unknown */ islpci_monitor_rx()
297 avs->encoding = cpu_to_be32(0); /*unknown */ islpci_monitor_rx()
/linux-4.1.27/drivers/net/ethernet/sgi/
H A Dioc3-eth.c171 #define ioc3_w_mcr(v) do { ioc3->mcr = cpu_to_be32(v); } while (0)
172 #define ioc3_w_gpcr_s(v) do { ioc3->gpcr_s = cpu_to_be32(v); } while (0)
174 #define ioc3_w_emcr(v) do { ioc3->emcr = cpu_to_be32(v); } while (0)
176 #define ioc3_w_eisr(v) do { ioc3->eisr = cpu_to_be32(v); } while (0)
178 #define ioc3_w_eier(v) do { ioc3->eier = cpu_to_be32(v); } while (0)
180 #define ioc3_w_ercsr(v) do { ioc3->ercsr = cpu_to_be32(v); } while (0)
182 #define ioc3_w_erbr_h(v) do { ioc3->erbr_h = cpu_to_be32(v); } while (0)
184 #define ioc3_w_erbr_l(v) do { ioc3->erbr_l = cpu_to_be32(v); } while (0)
186 #define ioc3_w_erbar(v) do { ioc3->erbar = cpu_to_be32(v); } while (0)
188 #define ioc3_w_ercir(v) do { ioc3->ercir = cpu_to_be32(v); } while (0)
190 #define ioc3_w_erpir(v) do { ioc3->erpir = cpu_to_be32(v); } while (0)
192 #define ioc3_w_ertr(v) do { ioc3->ertr = cpu_to_be32(v); } while (0)
194 #define ioc3_w_etcsr(v) do { ioc3->etcsr = cpu_to_be32(v); } while (0)
196 #define ioc3_w_ersr(v) do { ioc3->ersr = cpu_to_be32(v); } while (0)
198 #define ioc3_w_etcdc(v) do { ioc3->etcdc = cpu_to_be32(v); } while (0)
200 #define ioc3_w_ebir(v) do { ioc3->ebir = cpu_to_be32(v); } while (0)
202 #define ioc3_w_etbr_h(v) do { ioc3->etbr_h = cpu_to_be32(v); } while (0)
204 #define ioc3_w_etbr_l(v) do { ioc3->etbr_l = cpu_to_be32(v); } while (0)
206 #define ioc3_w_etcir(v) do { ioc3->etcir = cpu_to_be32(v); } while (0)
208 #define ioc3_w_etpir(v) do { ioc3->etpir = cpu_to_be32(v); } while (0)
210 #define ioc3_w_emar_h(v) do { ioc3->emar_h = cpu_to_be32(v); } while (0)
212 #define ioc3_w_emar_l(v) do { ioc3->emar_l = cpu_to_be32(v); } while (0)
214 #define ioc3_w_ehar_h(v) do { ioc3->ehar_h = cpu_to_be32(v); } while (0)
216 #define ioc3_w_ehar_l(v) do { ioc3->ehar_l = cpu_to_be32(v); } while (0)
218 #define ioc3_w_micr(v) do { ioc3->micr = cpu_to_be32(v); } while (0)
220 #define ioc3_w_midr_r(v) do { ioc3->midr_r = cpu_to_be32(v); } while (0)
222 #define ioc3_w_midr_w(v) do { ioc3->midr_w = cpu_to_be32(v); } while (0)
1474 desc->cmd = cpu_to_be32(len | ETXD_INTWHENDONE | ETXD_D0V | w0); ioc3_start_xmit()
1475 desc->bufcnt = cpu_to_be32(len); ioc3_start_xmit()
1481 desc->cmd = cpu_to_be32(len | ETXD_INTWHENDONE | ioc3_start_xmit()
1483 desc->bufcnt = cpu_to_be32((s1 << ETXD_B1CNT_SHIFT) | ioc3_start_xmit()
1489 desc->cmd = cpu_to_be32(len | ETXD_INTWHENDONE | ETXD_B1V | w0); ioc3_start_xmit()
1490 desc->bufcnt = cpu_to_be32(len << ETXD_B1CNT_SHIFT); ioc3_start_xmit()
/linux-4.1.27/fs/nfs/
H A Dnfs2xdr.c227 *p++ = cpu_to_be32(timep->tv_sec); xdr_encode_time()
229 *p++ = cpu_to_be32(timep->tv_nsec / NSEC_PER_USEC); xdr_encode_time()
231 *p++ = cpu_to_be32(0); xdr_encode_time()
245 *p++ = cpu_to_be32(timep->tv_sec); xdr_encode_current_server_time()
246 *p++ = cpu_to_be32(1000000); xdr_encode_current_server_time()
349 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); xdr_time_not_set()
350 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); xdr_time_not_set()
361 *p++ = cpu_to_be32(attr->ia_mode); encode_sattr()
363 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); encode_sattr()
365 *p++ = cpu_to_be32(from_kuid(&init_user_ns, attr->ia_uid)); encode_sattr()
367 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); encode_sattr()
369 *p++ = cpu_to_be32(from_kgid(&init_user_ns, attr->ia_gid)); encode_sattr()
371 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); encode_sattr()
373 *p++ = cpu_to_be32((u32)attr->ia_size); encode_sattr()
375 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); encode_sattr()
442 *p = cpu_to_be32(length); encode_path()
628 *p++ = cpu_to_be32(offset); encode_readargs()
629 *p++ = cpu_to_be32(count); encode_readargs()
630 *p = cpu_to_be32(count); encode_readargs()
664 *p++ = cpu_to_be32(offset); encode_writeargs()
665 *p++ = cpu_to_be32(offset); encode_writeargs()
666 *p++ = cpu_to_be32(count); encode_writeargs()
669 *p = cpu_to_be32(count); encode_writeargs()
774 *p++ = cpu_to_be32(args->cookie); encode_readdirargs()
775 *p = cpu_to_be32(args->count); encode_readdirargs()
H A Dnfs4xdr.c935 *p = cpu_to_be32(n); encode_uint32()
970 *p++ = cpu_to_be32(hdr->minorversion); encode_compound_hdr()
972 *p = cpu_to_be32(hdr->nops); encode_compound_hdr()
1082 *p++ = cpu_to_be32(bmval_len); encode_attrs()
1084 *p++ = cpu_to_be32(bmval[i]); encode_attrs()
1085 *p++ = cpu_to_be32(len); encode_attrs()
1090 *p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO); encode_attrs()
1097 *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME); encode_attrs()
1099 *p++ = cpu_to_be32(iap->ia_atime.tv_nsec); encode_attrs()
1101 *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME); encode_attrs()
1105 *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME); encode_attrs()
1107 *p++ = cpu_to_be32(iap->ia_mtime.tv_nsec); encode_attrs()
1109 *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME); encode_attrs()
1112 *p++ = cpu_to_be32(label->lfs); encode_attrs()
1113 *p++ = cpu_to_be32(label->pi); encode_attrs()
1114 *p++ = cpu_to_be32(label->len); encode_attrs()
1141 *p = cpu_to_be32(args->count); encode_commit()
1154 *p = cpu_to_be32(create->u.symlink.len); encode_create()
1160 *p++ = cpu_to_be32(create->u.device.specdata1); encode_create()
1161 *p = cpu_to_be32(create->u.device.specdata2); encode_create()
1178 *p++ = cpu_to_be32(1); encode_getattr_one()
1179 *p = cpu_to_be32(bitmap); encode_getattr_one()
1188 *p++ = cpu_to_be32(2); encode_getattr_two()
1189 *p++ = cpu_to_be32(bm0); encode_getattr_two()
1190 *p = cpu_to_be32(bm1); encode_getattr_two()
1203 *p++ = cpu_to_be32(3); encode_getattr_three()
1204 *p++ = cpu_to_be32(bm0); encode_getattr_three()
1205 *p++ = cpu_to_be32(bm1); encode_getattr_three()
1206 *p = cpu_to_be32(bm2); encode_getattr_three()
1209 *p++ = cpu_to_be32(2); encode_getattr_three()
1210 *p++ = cpu_to_be32(bm0); encode_getattr_three()
1211 *p = cpu_to_be32(bm1); encode_getattr_three()
1214 *p++ = cpu_to_be32(1); encode_getattr_three()
1215 *p = cpu_to_be32(bm0); encode_getattr_three()
1284 *p++ = cpu_to_be32(20); encode_lockowner()
1286 *p++ = cpu_to_be32(lowner->s_dev); encode_lockowner()
1300 *p++ = cpu_to_be32(nfs4_lock_type(args->fl, args->block)); encode_lock()
1301 *p++ = cpu_to_be32(args->reclaim); encode_lock()
1304 *p = cpu_to_be32(args->new_lock_owner); encode_lock()
1323 *p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0)); encode_lockt()
1359 *p++ = cpu_to_be32(share_access); encode_share_access()
1360 *p = cpu_to_be32(0); /* for linux, share_deny = 0 always */ encode_share_access()
1374 *p++ = cpu_to_be32(24); encode_openhdr()
1376 *p++ = cpu_to_be32(arg->server->s_dev); encode_openhdr()
1377 *p++ = cpu_to_be32(arg->id.uniquifier); encode_openhdr()
1389 *p = cpu_to_be32(NFS4_CREATE_UNCHECKED); encode_createmode()
1393 *p = cpu_to_be32(NFS4_CREATE_GUARDED); encode_createmode()
1397 *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE); encode_createmode()
1401 *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1); encode_createmode()
1415 *p = cpu_to_be32(NFS4_OPEN_NOCREATE); encode_opentype()
1418 *p = cpu_to_be32(NFS4_OPEN_CREATE); encode_opentype()
1430 *p = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE); encode_delegation_type()
1433 *p = cpu_to_be32(NFS4_OPEN_DELEGATE_READ); encode_delegation_type()
1436 *p = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE); encode_delegation_type()
1448 *p = cpu_to_be32(NFS4_OPEN_CLAIM_NULL); encode_claim_null()
1457 *p = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS); encode_claim_previous()
1466 *p = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR); encode_claim_delegate_cur()
1476 *p = cpu_to_be32(NFS4_OPEN_CLAIM_FH); encode_claim_fh()
1484 *p = cpu_to_be32(NFS4_OPEN_CLAIM_DELEG_CUR_FH); encode_claim_delegate_cur_fh()
1551 *p = cpu_to_be32(args->count); encode_read()
1588 *p++ = cpu_to_be32(dircount); encode_readdir()
1589 *p++ = cpu_to_be32(readdir->count); encode_readdir()
1590 *p++ = cpu_to_be32(attrlen); encode_readdir()
1592 *p++ = cpu_to_be32(attrs[i]); encode_readdir()
1643 *p++ = cpu_to_be32(1); encode_setacl()
1644 *p = cpu_to_be32(FATTR4_WORD0_ACL); encode_setacl()
1646 *p = cpu_to_be32(arg->acl_len); encode_setacl()
1672 *p = cpu_to_be32(setclientid->sc_prog); encode_setclientid()
1676 *p = cpu_to_be32(setclientid->sc_cb_ident); encode_setclientid()
1697 *p++ = cpu_to_be32(args->stable); encode_write()
1698 *p = cpu_to_be32(args->count); encode_write()
1727 *p++ = cpu_to_be32(args->dir); encode_bind_conn_to_session()
1728 *p = (args->use_conn_in_rdma_mode) ? cpu_to_be32(1) : cpu_to_be32(0); encode_bind_conn_to_session()
1785 *p = cpu_to_be32(0); encode_exchange_id()
1810 *p++ = cpu_to_be32(args->seqid); /*Sequence id */ encode_create_session()
1811 *p++ = cpu_to_be32(args->flags); /*flags */ encode_create_session()
1814 *p++ = cpu_to_be32(0); /* header padding size */ encode_create_session()
1815 *p++ = cpu_to_be32(args->fc_attrs.max_rqst_sz); /* max req size */ encode_create_session()
1816 *p++ = cpu_to_be32(args->fc_attrs.max_resp_sz); /* max resp size */ encode_create_session()
1817 *p++ = cpu_to_be32(max_resp_sz_cached); /* Max resp sz cached */ encode_create_session()
1818 *p++ = cpu_to_be32(args->fc_attrs.max_ops); /* max operations */ encode_create_session()
1819 *p++ = cpu_to_be32(args->fc_attrs.max_reqs); /* max requests */ encode_create_session()
1820 *p++ = cpu_to_be32(0); /* rdmachannel_attrs */ encode_create_session()
1823 *p++ = cpu_to_be32(0); /* header padding size */ encode_create_session()
1824 *p++ = cpu_to_be32(args->bc_attrs.max_rqst_sz); /* max req size */ encode_create_session()
1825 *p++ = cpu_to_be32(args->bc_attrs.max_resp_sz); /* max resp size */ encode_create_session()
1826 *p++ = cpu_to_be32(args->bc_attrs.max_resp_sz_cached); /* Max resp sz cached */ encode_create_session()
1827 *p++ = cpu_to_be32(args->bc_attrs.max_ops); /* max operations */ encode_create_session()
1828 *p++ = cpu_to_be32(args->bc_attrs.max_reqs); /* max requests */ encode_create_session()
1829 *p++ = cpu_to_be32(0); /* rdmachannel_attrs */ encode_create_session()
1831 *p++ = cpu_to_be32(args->cb_program); /* cb_program */ encode_create_session()
1832 *p++ = cpu_to_be32(1); encode_create_session()
1833 *p++ = cpu_to_be32(RPC_AUTH_UNIX); /* auth_sys */ encode_create_session()
1836 *p++ = cpu_to_be32(nn->boot_time.tv_nsec); /* stamp */ encode_create_session()
1838 *p++ = cpu_to_be32(0); /* UID */ encode_create_session()
1839 *p++ = cpu_to_be32(0); /* GID */ encode_create_session()
1840 *p = cpu_to_be32(0); /* No more gids */ encode_create_session()
1899 *p++ = cpu_to_be32(slot->seq_nr); encode_sequence()
1900 *p++ = cpu_to_be32(slot->slot_nr); encode_sequence()
1901 *p++ = cpu_to_be32(tp->highest_used_slotid); encode_sequence()
1902 *p = cpu_to_be32(args->sa_cache_this); encode_sequence()
1918 *p++ = cpu_to_be32(args->pdev->layout_type); encode_getdeviceinfo()
1919 *p++ = cpu_to_be32(args->pdev->maxcount); /* gdia_maxcount */ encode_getdeviceinfo()
1922 *p++ = cpu_to_be32(1); /* bitmap length */ encode_getdeviceinfo()
1923 *p++ = cpu_to_be32(args->notify_types); encode_getdeviceinfo()
1935 *p++ = cpu_to_be32(0); /* Signal layout available */ encode_layoutget()
1936 *p++ = cpu_to_be32(args->type); encode_layoutget()
1937 *p++ = cpu_to_be32(args->range.iomode); encode_layoutget()
1969 *p = cpu_to_be32(0); /* reclaim */ encode_layoutcommit()
1972 *p++ = cpu_to_be32(1); /* newoffset = TRUE */ encode_layoutcommit()
1974 *p++ = cpu_to_be32(0); /* Never send time_modify_changed */ encode_layoutcommit()
1975 *p++ = cpu_to_be32(NFS_SERVER(args->inode)->pnfs_curr_ld->id);/* type */ encode_layoutcommit()
2000 *p++ = cpu_to_be32(0); /* reclaim. always 0 for now */ encode_layoutreturn()
2001 *p++ = cpu_to_be32(args->layout_type); encode_layoutreturn()
2002 *p++ = cpu_to_be32(args->range.iomode); encode_layoutreturn()
2003 *p = cpu_to_be32(RETURN_FILE); encode_layoutreturn()
H A Dnfs3xdr.c145 *p = cpu_to_be32(value); encode_uint32()
417 *p++ = cpu_to_be32(MAJOR(rdev)); encode_specdata3()
418 *p = cpu_to_be32(MINOR(rdev)); encode_specdata3()
489 *p++ = cpu_to_be32(timep->tv_sec); xdr_encode_nfstime3()
490 *p++ = cpu_to_be32(timep->tv_nsec); xdr_encode_nfstime3()
589 *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO); encode_sattr3()
595 *p++ = cpu_to_be32(from_kuid(&init_user_ns, attr->ia_uid)); encode_sattr3()
601 *p++ = cpu_to_be32(from_kgid(&init_user_ns, attr->ia_gid)); encode_sattr3()
964 *p = cpu_to_be32(args->count); encode_read3args()
1003 *p++ = cpu_to_be32(args->count); encode_write3args()
1004 *p++ = cpu_to_be32(args->stable); encode_write3args()
1005 *p = cpu_to_be32(args->count); encode_write3args()
1237 *p = cpu_to_be32(args->count); encode_readdir3args()
1275 *p++ = cpu_to_be32(args->count >> 3); encode_readdirplus3args()
1277 *p = cpu_to_be32(args->count); encode_readdirplus3args()
1307 *p = cpu_to_be32(args->count); encode_commit3args()
H A Dcallback_proc.c244 return cpu_to_be32(res); nfs4_callback_layoutrecall()
269 res = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION); nfs4_callback_devicenotify()
501 status = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION); nfs4_callback_recallany()
508 status = cpu_to_be32(NFS4ERR_INVAL); nfs4_callback_recallany()
512 status = cpu_to_be32(NFS4_OK); nfs4_callback_recallany()
/linux-4.1.27/include/linux/unaligned/
H A Daccess_ok.h59 *((__be32 *)p) = cpu_to_be32(val); put_unaligned_be32()
/linux-4.1.27/include/uapi/linux/
H A Dromfs_fs.h18 #define __mk4(a,b,c,d) cpu_to_be32(__mkl(__mkw(a,b),__mkw(c,d)))
/linux-4.1.27/net/mpls/
H A Dinternal.h33 cpu_to_be32((label << MPLS_LS_LABEL_SHIFT) | mpls_entry_encode()
/linux-4.1.27/include/linux/mlx4/
H A Dcq.h149 *cq->arm_db = cpu_to_be32(sn << 28 | cmd | ci); mlx4_cq_arm()
157 doorbell[0] = cpu_to_be32(sn << 28 | cmd | cq->cqn); mlx4_cq_arm()
158 doorbell[1] = cpu_to_be32(ci); mlx4_cq_arm()
165 *cq->set_ci_db = cpu_to_be32(cq->cons_index & 0xffffff); mlx4_cq_set_ci()
/linux-4.1.27/include/linux/mlx5/
H A Dcq.h130 *cq->set_ci_db = cpu_to_be32(cq->cons_index & 0xffffff); mlx5_cq_set_ci()
150 *cq->arm_db = cpu_to_be32(sn << 28 | cmd | ci); mlx5_cq_arm()
157 doorbell[0] = cpu_to_be32(sn << 28 | cmd | ci); mlx5_cq_arm()
158 doorbell[1] = cpu_to_be32(cq->cqn); mlx5_cq_arm()
/linux-4.1.27/fs/befs/
H A Dendian.h47 return (__force fs32)cpu_to_be32(n); cpu_to_fs32()
97 run.allocation_group = cpu_to_be32(n.allocation_group); cpu_to_fsrun()
H A Dbefs_fs_types.h59 #define BEFS_BYTEORDER_NATIVE_BE (__force fs32)cpu_to_be32(BEFS_BYTEORDER_NATIVE)
63 #define BEFS_SUPER_MAGIC1_BE (__force fs32)cpu_to_be32(BEFS_SUPER_MAGIC1)
/linux-4.1.27/drivers/zorro/
H A Dzorro-sysfs.c77 cd.cd_BoardAddr = cpu_to_be32(zorro_resource_start(z)); zorro_read_config()
78 cd.cd_BoardSize = cpu_to_be32(zorro_resource_len(z)); zorro_read_config()
H A Dproc.c48 cd.cd_BoardAddr = cpu_to_be32(zorro_resource_start(z)); proc_bus_zorro_read()
49 cd.cd_BoardSize = cpu_to_be32(zorro_resource_len(z)); proc_bus_zorro_read()
/linux-4.1.27/drivers/target/sbp/
H A Dsbp_target.c312 req->status.status = cpu_to_be32( sbp_management_request_login()
322 req->status.status = cpu_to_be32( sbp_management_request_login()
364 req->status.status = cpu_to_be32( sbp_management_request_login()
377 req->status.status = cpu_to_be32( sbp_management_request_login()
391 req->status.status = cpu_to_be32( sbp_management_request_login()
409 req->status.status = cpu_to_be32( sbp_management_request_login()
436 req->status.status = cpu_to_be32( sbp_management_request_login()
456 req->status.status = cpu_to_be32( sbp_management_request_login()
473 req->status.status = cpu_to_be32( sbp_management_request_login()
482 response->misc = cpu_to_be32( sbp_management_request_login()
485 response->reconnect_hold = cpu_to_be32(sess->reconnect_hold & 0xffff); sbp_management_request_login()
499 req->status.status = cpu_to_be32( sbp_management_request_login()
507 req->status.status = cpu_to_be32( sbp_management_request_login()
519 req->status.status = cpu_to_be32( sbp_management_request_query_logins()
538 req->status.status = cpu_to_be32( sbp_management_request_reconnect()
552 req->status.status = cpu_to_be32( sbp_management_request_reconnect()
561 req->status.status = cpu_to_be32( sbp_management_request_reconnect()
578 req->status.status = cpu_to_be32( sbp_management_request_reconnect()
598 req->status.status = cpu_to_be32( sbp_management_request_logout()
610 req->status.status = cpu_to_be32( sbp_management_request_logout()
618 req->status.status = cpu_to_be32( sbp_management_request_logout()
716 *(__be32 *)data = cpu_to_be32(state); tgt_agent_rw_agent_state()
909 req->status.status |= cpu_to_be32( tgt_agent_process_work()
920 req->status.status |= cpu_to_be32( tgt_agent_process_work()
969 req->status.status = cpu_to_be32(STATUS_BLOCK_ORB_OFFSET_HIGH( tgt_agent_fetch_work()
971 req->status.orb_low = cpu_to_be32( tgt_agent_fetch_work()
980 req->status.status |= cpu_to_be32( tgt_agent_fetch_work()
1001 req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC( tgt_agent_fetch_work()
1005 req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC( tgt_agent_fetch_work()
1245 req->status.status |= cpu_to_be32( sbp_handle_command()
1392 req->status.status |= cpu_to_be32( sbp_sense_mangle()
1428 req->status.status |= cpu_to_be32( sbp_sense_mangle()
1442 req->status.status |= cpu_to_be32( sbp_send_sense()
1505 req->status.status = cpu_to_be32( sbp_mgt_agent_process()
1518 req->status.status = cpu_to_be32( sbp_mgt_agent_process()
1527 req->status.status = cpu_to_be32( sbp_mgt_agent_process()
1536 req->status.status = cpu_to_be32( sbp_mgt_agent_process()
1545 req->status.status = cpu_to_be32( sbp_mgt_agent_process()
1555 req->status.status = cpu_to_be32( sbp_mgt_agent_process()
1562 req->status.status |= cpu_to_be32( sbp_mgt_agent_process()
1566 req->status.orb_low = cpu_to_be32(agent->orb_offset); sbp_mgt_agent_process()
1773 req->status.status |= cpu_to_be32( sbp_write_pending()
1820 req->status.status |= cpu_to_be32( sbp_queue_data_in()
H A Dsbp_target.h204 ptr->high = cpu_to_be32(addr >> 32); addr_to_sbp2_pointer()
205 ptr->low = cpu_to_be32(addr); addr_to_sbp2_pointer()
/linux-4.1.27/arch/powerpc/kvm/
H A Dbook3s_rtas.c39 args->rets[0] = cpu_to_be32(rc); kvm_rtas_set_xive()
61 args->rets[1] = cpu_to_be32(server); kvm_rtas_get_xive()
62 args->rets[2] = cpu_to_be32(priority); kvm_rtas_get_xive()
64 args->rets[0] = cpu_to_be32(rc); kvm_rtas_get_xive()
83 args->rets[0] = cpu_to_be32(rc); kvm_rtas_int_off()
102 args->rets[0] = cpu_to_be32(rc); kvm_rtas_int_on()
/linux-4.1.27/drivers/firewire/
H A Dcore-card.c63 *block |= cpu_to_be32(crc); fw_compute_block_crc()
117 config_rom[0] = cpu_to_be32( generate_config_rom()
119 config_rom[1] = cpu_to_be32(BIB_BUS_NAME); generate_config_rom()
120 config_rom[2] = cpu_to_be32( generate_config_rom()
126 config_rom[3] = cpu_to_be32(card->guid >> 32); generate_config_rom()
127 config_rom[4] = cpu_to_be32(card->guid); generate_config_rom()
130 config_rom[6] = cpu_to_be32(NODE_CAPABILITIES); generate_config_rom()
137 config_rom[i++] = cpu_to_be32(desc->immediate); generate_config_rom()
138 config_rom[i] = cpu_to_be32(desc->key | (j - i)); generate_config_rom()
144 config_rom[5] = cpu_to_be32((i - 5 - 1) << 16); generate_config_rom()
149 config_rom[i + k] = cpu_to_be32(desc->data[k]); generate_config_rom()
374 transaction_data[0] = cpu_to_be32(0x3f); bm_work()
375 transaction_data[1] = cpu_to_be32(local_id); bm_work()
509 transaction_data[0] = cpu_to_be32(CSR_STATE_BIT_CMSTR); bm_work()
H A Dsbp2.c509 orb_pointer.low = cpu_to_be32(orb->request_bus); sbp2_send_orb()
584 orb->request.response.low = cpu_to_be32(orb->response_bus); sbp2_send_management_orb()
586 orb->request.misc = cpu_to_be32( sbp2_send_management_orb()
590 orb->request.length = cpu_to_be32( sbp2_send_management_orb()
594 cpu_to_be32(lu->address_handler.offset >> 32); sbp2_send_management_orb()
596 cpu_to_be32(lu->address_handler.offset); sbp2_send_management_orb()
600 orb->request.misc |= cpu_to_be32( sbp2_send_management_orb()
799 __be32 d = cpu_to_be32(SBP2_CYCLE_LIMIT | SBP2_RETRY_LIMIT); sbp2_set_busy_timeout()
1300 if (orb->request.misc & cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT)) sbp2_unmap_scatterlist()
1417 cpu_to_be32(lu->tgt->address_high); sbp2_map_scatterlist()
1419 cpu_to_be32(sg_dma_address(sg)); sbp2_map_scatterlist()
1421 cpu_to_be32(COMMAND_ORB_DATA_SIZE(sg_dma_len(sg))); sbp2_map_scatterlist()
1426 orb->page_table[i].high = cpu_to_be32(sg_dma_len(sg) << 16); for_each_sg()
1427 orb->page_table[i].low = cpu_to_be32(sg_dma_address(sg)); for_each_sg()
1443 orb->request.data_descriptor.high = cpu_to_be32(lu->tgt->address_high);
1444 orb->request.data_descriptor.low = cpu_to_be32(orb->page_table_bus);
1445 orb->request.misc |= cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT |
1474 orb->request.next.high = cpu_to_be32(SBP2_ORB_NULL); sbp2_scsi_queuecommand()
1475 orb->request.misc = cpu_to_be32( sbp2_scsi_queuecommand()
1481 orb->request.misc |= cpu_to_be32(COMMAND_ORB_DIRECTION); sbp2_scsi_queuecommand()
H A Dcore-iso.c251 data[0] = cpu_to_be32(old); manage_bandwidth()
252 data[1] = cpu_to_be32(new); manage_bandwidth()
280 old = all = allocate ? cpu_to_be32(~0) : 0; manage_channel()
288 bit = cpu_to_be32(1 << (31 - channel)); manage_channel()
/linux-4.1.27/drivers/net/ethernet/mellanox/mlx5/core/
H A Dmr.c65 in->seg.qpn_mkey7_0 |= cpu_to_be32(key); mlx5_core_create_mkey()
129 in.mkey = cpu_to_be32(mlx5_mkey_to_idx(mr->key)); mlx5_core_destroy_mkey()
151 in.mkey = cpu_to_be32(mlx5_mkey_to_idx(mr->key)); mlx5_core_query_mkey()
201 in.npsv_pd = cpu_to_be32((npsvs << 28) | pdn); mlx5_core_create_psv()
230 in.psv_number = cpu_to_be32(psv_num); mlx5_core_destroy_psv()
H A Dqp.c234 din.qpn = cpu_to_be32(qp->qpn); mlx5_core_create_qp()
262 in.qpn = cpu_to_be32(qp->qpn); mlx5_core_destroy_qp()
328 in->qpn = cpu_to_be32(qp->qpn); mlx5_core_qp_modify()
360 in.qpn = cpu_to_be32(qp->qpn); mlx5_core_qp_query()
403 in.xrcdn = cpu_to_be32(xrcdn); mlx5_core_xrcd_dealloc()
431 in.flags_qpn = cpu_to_be32((qpn & MLX5_QPN_MASK) | mlx5_core_page_fault_resume()
H A Dmcg.c74 in.qpn = cpu_to_be32(qpn); mlx5_core_attach_mcg()
96 in.qpn = cpu_to_be32(qpn); mlx5_core_detach_mcg()
H A Dport.c57 in->arg = cpu_to_be32(arg); mlx5_core_access_reg()
96 in.caps_127_96 = cpu_to_be32(caps); mlx5_set_port_caps()
H A Dsrq.c118 din.srqn = cpu_to_be32(srq->srqn); mlx5_core_create_srq()
148 in.srqn = cpu_to_be32(srq->srqn); mlx5_core_destroy_srq()
174 in.srqn = cpu_to_be32(srq->srqn); mlx5_core_query_srq()
198 in.srqn = cpu_to_be32(srq->srqn); mlx5_core_arm_srq()
H A Dpd.c91 in.pdn = cpu_to_be32(pdn); mlx5_core_dealloc_pd()
/linux-4.1.27/drivers/misc/genwqe/
H A Dcard_ddcb.h136 #define DDCB_INTR_BE32 cpu_to_be32(0x00000004)
137 #define DDCB_PURGE_BE32 cpu_to_be32(0x00000002)
138 #define DDCB_NEXT_BE32 cpu_to_be32(0x00000001)
139 #define DDCB_COMPLETED_BE32 cpu_to_be32(0x00004000)
140 #define DDCB_FETCHED_BE32 cpu_to_be32(0x00000400)
H A Dcard_dev.c585 *(__be32 *)&req->__asiv[24] = cpu_to_be32(0); do_flash_update()
587 *(__be32 *)&req->__asiv[28] = cpu_to_be32(crc); do_flash_update()
595 *(__be32 *)&req->asiv[8] = cpu_to_be32(tocopy); do_flash_update()
596 *(__be32 *)&req->asiv[12] = cpu_to_be32(0); /* resvd */ do_flash_update()
598 *(__be32 *)&req->asiv[24] = cpu_to_be32(load->uid<<24); do_flash_update()
599 *(__be32 *)&req->asiv[28] = cpu_to_be32(crc); do_flash_update()
711 *(__be32 *)&cmd->__asiv[24] = cpu_to_be32(0); do_flash_read()
713 *(__be32 *)&cmd->__asiv[28] = cpu_to_be32(0) /* CRC */; do_flash_read()
717 *(__be32 *)&cmd->asiv[8] = cpu_to_be32(tocopy); do_flash_read()
718 *(__be32 *)&cmd->asiv[12] = cpu_to_be32(0); /* resvd */ do_flash_read()
720 *(__be32 *)&cmd->asiv[24] = cpu_to_be32(load->uid<<24); do_flash_read()
721 *(__be32 *)&cmd->asiv[28] = cpu_to_be32(0); /* CRC */ do_flash_read()
/linux-4.1.27/drivers/scsi/ibmvscsi/
H A Dibmvfc.c1174 login_info->ostype = cpu_to_be32(IBMVFC_OS_LINUX); ibmvfc_set_login_info()
1176 login_info->max_payload = cpu_to_be32(sizeof(struct ibmvfc_fcp_cmd_iu)); ibmvfc_set_login_info()
1177 login_info->max_response = cpu_to_be32(sizeof(struct ibmvfc_fcp_rsp)); ibmvfc_set_login_info()
1178 login_info->partition_num = cpu_to_be32(vhost->partition_number); ibmvfc_set_login_info()
1179 login_info->vfc_frame_version = cpu_to_be32(1); ibmvfc_set_login_info()
1185 login_info->max_cmds = cpu_to_be32(max_requests + IBMVFC_NUM_INTERNAL_REQ); ibmvfc_set_login_info()
1188 login_info->async.len = cpu_to_be32(vhost->async_crq.size * sizeof(*vhost->async_crq.msgs)); ibmvfc_set_login_info()
1314 md[i].len = cpu_to_be32(sg_dma_len(sg)); scsi_for_each_sg()
1378 data->len = cpu_to_be32(sg_mapped * sizeof(struct srp_direct_buf)); ibmvfc_map_sg_data()
1635 vfc_cmd->resp.len = cpu_to_be32(sizeof(vfc_cmd->rsp)); ibmvfc_queuecommand_lck()
1636 vfc_cmd->frame_type = cpu_to_be32(IBMVFC_SCSI_FCP_TYPE); ibmvfc_queuecommand_lck()
1637 vfc_cmd->payload_len = cpu_to_be32(sizeof(vfc_cmd->iu)); ibmvfc_queuecommand_lck()
1638 vfc_cmd->resp_len = cpu_to_be32(sizeof(vfc_cmd->rsp)); ibmvfc_queuecommand_lck()
1639 vfc_cmd->cancel_key = cpu_to_be32((unsigned long)cmnd->device->hostdata); ibmvfc_queuecommand_lck()
1641 vfc_cmd->iu.xfer_len = cpu_to_be32(scsi_bufflen(cmnd)); ibmvfc_queuecommand_lck()
1726 tmf->common.version = cpu_to_be32(1); ibmvfc_bsg_timeout()
1727 tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD); ibmvfc_bsg_timeout()
1730 tmf->cancel_key = cpu_to_be32(IBMVFC_PASSTHRU_CANCEL_KEY); ibmvfc_bsg_timeout()
1731 tmf->my_cancel_key = cpu_to_be32(IBMVFC_INTERNAL_CANCEL_KEY); ibmvfc_bsg_timeout()
1783 plogi->common.version = cpu_to_be32(1); ibmvfc_bsg_plogi()
1784 plogi->common.opcode = cpu_to_be32(IBMVFC_PORT_LOGIN); ibmvfc_bsg_plogi()
1898 mad->common.version = cpu_to_be32(1); ibmvfc_bsg_request()
1899 mad->common.opcode = cpu_to_be32(IBMVFC_PASSTHRU); ibmvfc_bsg_request()
1904 mad->cmd_ioba.len = cpu_to_be32(sizeof(mad->iu)); ibmvfc_bsg_request()
1906 mad->iu.cmd_len = cpu_to_be32(job->request_payload.payload_len); ibmvfc_bsg_request()
1907 mad->iu.rsp_len = cpu_to_be32(job->reply_payload.payload_len); ibmvfc_bsg_request()
1908 mad->iu.flags = cpu_to_be32(fc_flags); ibmvfc_bsg_request()
1909 mad->iu.cancel_key = cpu_to_be32(IBMVFC_PASSTHRU_CANCEL_KEY); ibmvfc_bsg_request()
1912 mad->iu.cmd.len = cpu_to_be32(sg_dma_len(job->request_payload.sg_list)); ibmvfc_bsg_request()
1914 mad->iu.rsp.len = cpu_to_be32(sg_dma_len(job->reply_payload.sg_list)); ibmvfc_bsg_request()
1981 tmf->resp.len = cpu_to_be32(sizeof(tmf->rsp)); ibmvfc_reset_device()
1982 tmf->frame_type = cpu_to_be32(IBMVFC_SCSI_FCP_TYPE); ibmvfc_reset_device()
1983 tmf->payload_len = cpu_to_be32(sizeof(tmf->iu)); ibmvfc_reset_device()
1984 tmf->resp_len = cpu_to_be32(sizeof(tmf->rsp)); ibmvfc_reset_device()
1985 tmf->cancel_key = cpu_to_be32((unsigned long)sdev->hostdata); ibmvfc_reset_device()
2179 tmf->common.version = cpu_to_be32(1); ibmvfc_cancel_all()
2180 tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD); ibmvfc_cancel_all()
2187 tmf->flags = cpu_to_be32((type | IBMVFC_TMF_LUA_VALID)); ibmvfc_cancel_all()
2189 tmf->flags = cpu_to_be32(((type & IBMVFC_TMF_SUPPRESS_ABTS) | IBMVFC_TMF_LUA_VALID)); ibmvfc_cancel_all()
2190 tmf->cancel_key = cpu_to_be32((unsigned long)sdev->hostdata); ibmvfc_cancel_all()
2191 tmf->my_cancel_key = cpu_to_be32((unsigned long)starget->hostdata); ibmvfc_cancel_all()
2311 tmf->resp.len = cpu_to_be32(sizeof(tmf->rsp)); ibmvfc_abort_task_set()
2312 tmf->frame_type = cpu_to_be32(IBMVFC_SCSI_FCP_TYPE); ibmvfc_abort_task_set()
2313 tmf->payload_len = cpu_to_be32(sizeof(tmf->iu)); ibmvfc_abort_task_set()
2314 tmf->resp_len = cpu_to_be32(sizeof(tmf->rsp)); ibmvfc_abort_task_set()
2315 tmf->cancel_key = cpu_to_be32((unsigned long)sdev->hostdata); ibmvfc_abort_task_set()
3376 prli->common.version = cpu_to_be32(1); ibmvfc_tgt_send_prli()
3377 prli->common.opcode = cpu_to_be32(IBMVFC_PROCESS_LOGIN); ibmvfc_tgt_send_prli()
3383 prli->parms.service_parms = cpu_to_be32(IBMVFC_PRLI_INITIATOR_FUNC); ibmvfc_tgt_send_prli()
3474 plogi->common.version = cpu_to_be32(1); ibmvfc_tgt_send_plogi()
3475 plogi->common.opcode = cpu_to_be32(IBMVFC_PORT_LOGIN); ibmvfc_tgt_send_plogi()
3547 mad->common.version = cpu_to_be32(1); ibmvfc_tgt_implicit_logout()
3548 mad->common.opcode = cpu_to_be32(IBMVFC_IMPLICIT_LOGOUT); ibmvfc_tgt_implicit_logout()
3636 mad->common.version = cpu_to_be32(1); ibmvfc_init_passthru()
3637 mad->common.opcode = cpu_to_be32(IBMVFC_PASSTHRU); ibmvfc_init_passthru()
3641 mad->cmd_ioba.len = cpu_to_be32(sizeof(mad->iu)); ibmvfc_init_passthru()
3642 mad->iu.cmd_len = cpu_to_be32(sizeof(mad->fc_iu.payload)); ibmvfc_init_passthru()
3643 mad->iu.rsp_len = cpu_to_be32(sizeof(mad->fc_iu.response)); ibmvfc_init_passthru()
3647 mad->iu.cmd.len = cpu_to_be32(sizeof(mad->fc_iu.payload)); ibmvfc_init_passthru()
3651 mad->iu.rsp.len = cpu_to_be32(sizeof(mad->fc_iu.response)); ibmvfc_init_passthru()
3710 tmf->common.version = cpu_to_be32(1); ibmvfc_adisc_timeout()
3711 tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD); ibmvfc_adisc_timeout()
3714 tmf->cancel_key = cpu_to_be32(tgt->cancel_key); ibmvfc_adisc_timeout()
3756 mad->iu.flags = cpu_to_be32(IBMVFC_FC_ELS); ibmvfc_tgt_adisc()
3758 mad->iu.cancel_key = cpu_to_be32(tgt->cancel_key); ibmvfc_tgt_adisc()
3760 mad->fc_iu.payload[0] = cpu_to_be32(IBMVFC_ADISC); ibmvfc_tgt_adisc()
3765 mad->fc_iu.payload[6] = cpu_to_be32(be64_to_cpu(vhost->login_buf->resp.scsi_id) & 0x00ffffff); ibmvfc_tgt_adisc()
3860 query_tgt->common.version = cpu_to_be32(1); ibmvfc_tgt_query_target()
3861 query_tgt->common.opcode = cpu_to_be32(IBMVFC_QUERY_TARGET); ibmvfc_tgt_query_target()
3989 mad->common.version = cpu_to_be32(1); ibmvfc_discover_targets()
3990 mad->common.opcode = cpu_to_be32(IBMVFC_DISC_TARGETS); ibmvfc_discover_targets()
3992 mad->bufflen = cpu_to_be32(vhost->disc_buf_sz); ibmvfc_discover_targets()
3994 mad->buffer.len = cpu_to_be32(vhost->disc_buf_sz); ibmvfc_discover_targets()
4104 mad->common.version = cpu_to_be32(1); ibmvfc_npiv_login()
4105 mad->common.opcode = cpu_to_be32(IBMVFC_NPIV_LOGIN); ibmvfc_npiv_login()
4108 mad->buffer.len = cpu_to_be32(sizeof(*vhost->login_buf)); ibmvfc_npiv_login()
4165 mad->common.version = cpu_to_be32(1); ibmvfc_npiv_logout()
4166 mad->common.opcode = cpu_to_be32(IBMVFC_NPIV_LOGOUT); ibmvfc_npiv_logout()
/linux-4.1.27/block/partitions/
H A Damiga.c50 if (*(__be32 *)data != cpu_to_be32(IDNAME_RIGIDDISK)) amiga_partition()
95 if (pb->pb_ID != cpu_to_be32(IDNAME_PARTITION)) amiga_partition()
/linux-4.1.27/sound/firewire/bebob/
H A Dbebob_hwdep.c83 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); hwdep_get_info()
84 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); hwdep_get_info()
/linux-4.1.27/sound/firewire/dice/
H A Ddice-hwdep.c81 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); hwdep_get_info()
82 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); hwdep_get_info()
/linux-4.1.27/sound/firewire/oxfw/
H A Doxfw-hwdep.c81 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); hwdep_get_info()
82 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); hwdep_get_info()
/linux-4.1.27/drivers/atm/
H A Dambassador.c331 __be32 be = cpu_to_be32 (data); wr_mem()
601 while (ptrs->out->request != cpu_to_be32 (SRB_COMPLETE)) { command_do()
758 cmd.request = cpu_to_be32 (SRB_FLUSH_BUFFER_Q); drain_rx_pool()
759 cmd.args.flush.flags = cpu_to_be32 (pool << SRB_POOL_SHIFT); drain_rx_pool()
807 rx.host_address = cpu_to_be32 (virt_to_bus (skb->data)); fill_rx_pool()
1160 cmd.request = cpu_to_be32 (SRB_MODIFY_VC_RATE); amb_open()
1161 cmd.args.modify_rate.vc = cpu_to_be32 (vci); // vpi 0 amb_open()
1162 cmd.args.modify_rate.rate = cpu_to_be32 (tx_rate_bits << SRB_RATE_SHIFT); amb_open()
1166 cmd.request = cpu_to_be32 (SRB_MODIFY_VC_FLAGS); amb_open()
1167 cmd.args.modify_flags.vc = cpu_to_be32 (vci); // vpi 0 amb_open()
1168 cmd.args.modify_flags.flags = cpu_to_be32 amb_open()
1175 cmd.request = cpu_to_be32 (SRB_OPEN_VC); amb_open()
1176 cmd.args.open.vc = cpu_to_be32 (vci); // vpi 0 amb_open()
1177 cmd.args.open.flags = cpu_to_be32 (tx_vc_bits << SRB_FLAGS_SHIFT); amb_open()
1178 cmd.args.open.rate = cpu_to_be32 (tx_rate_bits << SRB_RATE_SHIFT); amb_open()
1201 cmd.request = cpu_to_be32 (SRB_MODIFY_VC_FLAGS); amb_open()
1202 cmd.args.modify_flags.vc = cpu_to_be32 (vci); // vpi 0 amb_open()
1203 cmd.args.modify_flags.flags = cpu_to_be32 amb_open()
1208 cmd.request = cpu_to_be32 (SRB_OPEN_VC); amb_open()
1209 cmd.args.open.vc = cpu_to_be32 (vci); // vpi 0 amb_open()
1210 cmd.args.open.flags = cpu_to_be32 (pool << SRB_POOL_SHIFT); amb_open()
1211 cmd.args.open.rate = cpu_to_be32 (0); amb_open()
1245 cmd.request = cpu_to_be32 (SRB_MODIFY_VC_RATE); amb_close()
1246 cmd.args.modify_rate.vc = cpu_to_be32 (vci); // vpi 0 amb_close()
1247 cmd.args.modify_rate.rate = cpu_to_be32 (0); amb_close()
1251 cmd.request = cpu_to_be32 (SRB_CLOSE_VC); amb_close()
1252 cmd.args.close.vc = cpu_to_be32 (vci); // vpi 0 amb_close()
1270 cmd.request = cpu_to_be32 (SRB_MODIFY_VC_FLAGS); amb_close()
1271 cmd.args.modify_flags.vc = cpu_to_be32 (vci); // vpi 0 amb_close()
1272 cmd.args.modify_flags.flags = cpu_to_be32 amb_close()
1276 cmd.request = cpu_to_be32 (SRB_CLOSE_VC); amb_close()
1277 cmd.args.close.vc = cpu_to_be32 (vci); // vpi 0 amb_close()
1359 tx_descr->tx_frag.bytes = cpu_to_be32 (tx_len); amb_send()
1360 tx_descr->tx_frag.address = cpu_to_be32 (virt_to_bus (tx_data)); amb_send()
1374 tx.tx_descr_addr = cpu_to_be32 (virt_to_bus (&tx_descr->tx_frag)); amb_send()
1403 rx.host_address = cpu_to_be32 (virt_to_bus (skb->data));
1758 lb->command = cpu_to_be32 (cmd); do_loader_command()
1759 lb->valid = cpu_to_be32 (DMA_VALID); do_loader_command()
1766 while (!lb->result || lb->result == cpu_to_be32 (COMMAND_IN_PROGRESS)) do_loader_command()
1822 tb->count = cpu_to_be32(be16_to_cpu(rec->len) / 4); loader_write()
1838 tb->count = cpu_to_be32(be16_to_cpu(rec->len) / 4); loader_verify()
1851 lb->payload.start = cpu_to_be32 (address); loader_start()
1983 return cpu_to_be32 (virt_to_bus (addr)); bus_addr()
2007 a.rec_struct[pool].buffer_size = cpu_to_be32 (dev->rxq[pool].buffer_size); amb_talk()
2039 cmd.request = cpu_to_be32 (SRB_GET_VERSION); amb_ucode_version()
2056 cmd.request = cpu_to_be32 (SRB_GET_BIA); amb_esi()
/linux-4.1.27/drivers/scsi/qla2xxx/
H A Dqla_gs.c1499 ct_req->req.rpa.attrs.count = cpu_to_be32(FDMI_PORT_ATTR_COUNT); qla2x00_fdmi_rpa()
1519 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmi_rpa()
1522 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmi_rpa()
1527 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmi_rpa()
1532 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmi_rpa()
1538 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmi_rpa()
1543 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmi_rpa()
1547 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmi_rpa()
1561 cpu_to_be32(FDMI_PORT_SPEED_1GB); qla2x00_fdmi_rpa()
1565 cpu_to_be32(FDMI_PORT_SPEED_2GB); qla2x00_fdmi_rpa()
1569 cpu_to_be32(FDMI_PORT_SPEED_4GB); qla2x00_fdmi_rpa()
1573 cpu_to_be32(FDMI_PORT_SPEED_8GB); qla2x00_fdmi_rpa()
1577 cpu_to_be32(FDMI_PORT_SPEED_10GB); qla2x00_fdmi_rpa()
1581 cpu_to_be32(FDMI_PORT_SPEED_16GB); qla2x00_fdmi_rpa()
1585 cpu_to_be32(FDMI_PORT_SPEED_32GB); qla2x00_fdmi_rpa()
1589 cpu_to_be32(FDMI_PORT_SPEED_UNKNOWN); qla2x00_fdmi_rpa()
1604 eiter->a.max_frame_size = cpu_to_be32(eiter->a.max_frame_size); qla2x00_fdmi_rpa()
1708 ct_req->req.rhba2.entry_count = cpu_to_be32(1); qla2x00_fdmiv2_rhba()
1713 ct_req->req.rhba2.attrs.count = cpu_to_be32(FDMIV2_HBA_ATTR_COUNT); qla2x00_fdmiv2_rhba()
1876 eiter->a.max_ct_len = cpu_to_be32(eiter->a.max_ct_len); qla2x00_fdmiv2_rhba()
1899 eiter->a.vendor_id = cpu_to_be32(0x1077); qla2x00_fdmiv2_rhba()
1909 eiter->a.num_ports = cpu_to_be32(1); qla2x00_fdmiv2_rhba()
2074 ct_req->req.rpa2.attrs.count = cpu_to_be32(FDMIV2_PORT_ATTR_COUNT); qla2x00_fdmiv2_rpa()
2094 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmiv2_rpa()
2097 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmiv2_rpa()
2102 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmiv2_rpa()
2107 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmiv2_rpa()
2113 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmiv2_rpa()
2118 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmiv2_rpa()
2122 eiter->a.sup_speed = cpu_to_be32( qla2x00_fdmiv2_rpa()
2135 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_1GB); qla2x00_fdmiv2_rpa()
2138 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_2GB); qla2x00_fdmiv2_rpa()
2141 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_4GB); qla2x00_fdmiv2_rpa()
2144 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_8GB); qla2x00_fdmiv2_rpa()
2147 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_10GB); qla2x00_fdmiv2_rpa()
2150 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_16GB); qla2x00_fdmiv2_rpa()
2153 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_32GB); qla2x00_fdmiv2_rpa()
2156 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_UNKNOWN); qla2x00_fdmiv2_rpa()
2171 eiter->a.max_frame_size = cpu_to_be32(eiter->a.max_frame_size); qla2x00_fdmiv2_rpa()
2245 eiter->a.port_type = cpu_to_be32(NS_NX_PORT_TYPE); qla2x00_fdmiv2_rpa()
2255 eiter->a.port_supported_cos = cpu_to_be32(FC_CLASS_3); qla2x00_fdmiv2_rpa()
2289 eiter->a.port_state = cpu_to_be32(1); qla2x00_fdmiv2_rpa()
2299 eiter->a.num_ports = cpu_to_be32(1); qla2x00_fdmiv2_rpa()
2309 eiter->a.port_id = cpu_to_be32(vha->d_id.b24); qla2x00_fdmiv2_rpa()
/linux-4.1.27/drivers/usb/usbip/
H A Dusbip_common.c458 base->command = cpu_to_be32(base->command); correct_endian_basic()
459 base->seqnum = cpu_to_be32(base->seqnum); correct_endian_basic()
460 base->devid = cpu_to_be32(base->devid); correct_endian_basic()
461 base->direction = cpu_to_be32(base->direction); correct_endian_basic()
462 base->ep = cpu_to_be32(base->ep); correct_endian_basic()
476 pdu->transfer_flags = cpu_to_be32(pdu->transfer_flags); correct_endian_cmd_submit()
514 pdu->seqnum = cpu_to_be32(pdu->seqnum); correct_endian_cmd_unlink()
566 iso->offset = cpu_to_be32(iso->offset); usbip_iso_packet_correct_endian()
567 iso->length = cpu_to_be32(iso->length); usbip_iso_packet_correct_endian()
568 iso->status = cpu_to_be32(iso->status); usbip_iso_packet_correct_endian()
569 iso->actual_length = cpu_to_be32(iso->actual_length); usbip_iso_packet_correct_endian()
/linux-4.1.27/fs/nfs/objlayout/
H A Dpnfs_osd_xdr_cli.c363 *p++ = cpu_to_be32(lou->dsu_valid); pnfs_osd_xdr_encode_layoutupdate()
366 *p++ = cpu_to_be32(lou->olu_ioerr_flag); pnfs_osd_xdr_encode_layoutupdate()
402 *p++ = cpu_to_be32(ioerr->oer_iswrite); pnfs_osd_xdr_encode_ioerr()
403 *p = cpu_to_be32(ioerr->oer_errno); pnfs_osd_xdr_encode_ioerr()
/linux-4.1.27/include/net/
H A Dtransp_v6.h50 #define LOOPBACK4_IPV6 cpu_to_be32(0x7f000006)
/linux-4.1.27/lib/
H A Dcrc32defs.h67 * msbit-first. Be sure to use cpu_to_be32() to append the computed CRC.
/linux-4.1.27/arch/powerpc/kernel/
H A Drtas.c103 args->token = cpu_to_be32(10); call_rtas_display_status()
104 args->nargs = cpu_to_be32(1); call_rtas_display_status()
105 args->nret = cpu_to_be32(1); call_rtas_display_status()
107 args->args[0] = cpu_to_be32(c); call_rtas_display_status()
383 err_args.token = cpu_to_be32(rtas_last_error_token); __fetch_rtas_last_error()
384 err_args.nargs = cpu_to_be32(2); __fetch_rtas_last_error()
385 err_args.nret = cpu_to_be32(1); __fetch_rtas_last_error()
386 err_args.args[0] = cpu_to_be32(__pa(rtas_err_buf)); __fetch_rtas_last_error()
387 err_args.args[1] = cpu_to_be32(bufsz); __fetch_rtas_last_error()
436 rtas_args->token = cpu_to_be32(token); rtas_call()
437 rtas_args->nargs = cpu_to_be32(nargs); rtas_call()
438 rtas_args->nret = cpu_to_be32(nret); rtas_call()
442 rtas_args->args[i] = cpu_to_be32(va_arg(list, __u32)); rtas_call()
1082 args.rets[0] = cpu_to_be32(RTAS_NOT_SUSPENDABLE); ppc_rtas()
1084 args.rets[0] = cpu_to_be32(-1); ppc_rtas()
H A Dpaca.c37 .desc = cpu_to_be32(0xd397d781), /* "LpPa" */
126 s->persistent = cpu_to_be32(SLB_NUM_BOLTED); init_slb_shadow()
127 s->buffer_length = cpu_to_be32(sizeof(*s)); init_slb_shadow()
H A Dprom_init.c224 args.service = cpu_to_be32(ADDR(service)); call_prom()
225 args.nargs = cpu_to_be32(nargs); call_prom()
226 args.nret = cpu_to_be32(nret); call_prom()
230 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t)); call_prom()
249 args.service = cpu_to_be32(ADDR(service)); call_prom_ret()
250 args.nargs = cpu_to_be32(nargs); call_prom_ret()
251 args.nret = cpu_to_be32(nret); call_prom_ret()
255 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t)); call_prom_ret()
1141 val = cpu_to_be32(2); prom_init_mem()
1144 val = cpu_to_be32(1); prom_init_mem()
1394 val = cpu_to_be32(base); prom_instantiate_rtas()
1397 val = cpu_to_be32(entry); prom_instantiate_rtas()
1683 reg = cpu_to_be32(-1); /* make sparse happy */ prom_hold_cpus()
1796 val = cpu_to_be32(stdout_node); prom_init_stdout()
2013 *(__be32 *)room = cpu_to_be32(token); \
2187 *(__be32 *)valp = cpu_to_be32(node); scan_dt_build_struct()
2260 hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu); flatten_device_tree()
2261 hdr->magic = cpu_to_be32(OF_DT_HEADER); flatten_device_tree()
2262 hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start); flatten_device_tree()
2263 hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start); flatten_device_tree()
2264 hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start); flatten_device_tree()
2265 hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start); flatten_device_tree()
2266 hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start); flatten_device_tree()
2267 hdr->version = cpu_to_be32(OF_DT_VERSION); flatten_device_tree()
2269 hdr->last_comp_version = cpu_to_be32(0x10); flatten_device_tree()
/linux-4.1.27/fs/jbd2/
H A Dcommit.c108 h->h_chksum[0] = cpu_to_be32(csum); jbd2_commit_block_csum_set()
139 tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER); journal_submit_commit_record()
140 tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK); journal_submit_commit_record()
141 tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid); journal_submit_commit_record()
143 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec); journal_submit_commit_record()
149 tmp->h_chksum[0] = cpu_to_be32(crc32_sum); journal_submit_commit_record()
319 tag->t_blocknr = cpu_to_be32(block & (u32)~0); write_tag_block()
321 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1); write_tag_block()
337 tail->t_checksum = cpu_to_be32(csum); jbd2_descr_block_csum_set()
352 seq = cpu_to_be32(sequence); jbd2_block_tag_csum_set()
360 tag3->t_checksum = cpu_to_be32(csum32); jbd2_block_tag_csum_set()
631 header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER); jbd2_journal_commit_transaction()
632 header->h_blocktype = cpu_to_be32(JBD2_DESCRIPTOR_BLOCK); jbd2_journal_commit_transaction()
633 header->h_sequence = cpu_to_be32(commit_transaction->t_tid); jbd2_journal_commit_transaction()
H A Drecovery.c194 return provided == cpu_to_be32(calculated); jbd2_descr_block_csum_verify()
397 return provided == cpu_to_be32(calculated); jbd2_commit_block_csum_verify()
410 seq = cpu_to_be32(sequence); jbd2_block_tag_csum_verify()
415 return tag3->t_checksum == cpu_to_be32(csum32); jbd2_block_tag_csum_verify()
499 if (tmp->h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER)) { do_one_pass()
634 cpu_to_be32(JBD2_MAGIC_NUMBER); do_one_pass()
835 return provided == cpu_to_be32(calculated); jbd2_revoke_block_csum_verify()
H A Drevoke.c615 header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER); write_one_revoke_record()
616 header->h_blocktype = cpu_to_be32(JBD2_REVOKE_BLOCK); write_one_revoke_record()
617 header->h_sequence = cpu_to_be32(transaction->t_tid); write_one_revoke_record()
632 cpu_to_be32(record->blocknr); write_one_revoke_record()
650 tail->r_checksum = cpu_to_be32(csum); jbd2_revoke_csum_set()
672 header->r_count = cpu_to_be32(offset); flush_descriptor()
/linux-4.1.27/fs/lockd/
H A Dclntxdr.c109 *p = cpu_to_be32(value); encode_int32()
269 *p++ = cpu_to_be32(l_offset); encode_nlm_holder()
270 *p = cpu_to_be32(l_len); encode_nlm_holder()
353 *p++ = cpu_to_be32(lock->svid); encode_nlm_lock()
356 *p++ = cpu_to_be32(l_offset); encode_nlm_lock()
357 *p = cpu_to_be32(l_len); encode_nlm_lock()
/linux-4.1.27/sound/soc/fsl/
H A Dfsl_dma.c173 link->source_addr = cpu_to_be32(dma_private->dma_buf_next); fsl_dma_update_pointers()
175 link->source_attr = cpu_to_be32(CCSR_DMA_ATR_SNOOP | fsl_dma_update_pointers()
179 link->dest_addr = cpu_to_be32(dma_private->dma_buf_next); fsl_dma_update_pointers()
181 link->dest_attr = cpu_to_be32(CCSR_DMA_ATR_SNOOP | fsl_dma_update_pointers()
646 link->count = cpu_to_be32(period_size); fsl_dma_hw_params()
666 link->source_addr = cpu_to_be32(temp_addr); fsl_dma_hw_params()
667 link->source_attr = cpu_to_be32(CCSR_DMA_ATR_SNOOP | fsl_dma_hw_params()
670 link->dest_addr = cpu_to_be32(ssi_sxx_phys); fsl_dma_hw_params()
671 link->dest_attr = cpu_to_be32(CCSR_DMA_ATR_NOSNOOP | fsl_dma_hw_params()
674 link->source_addr = cpu_to_be32(ssi_sxx_phys); fsl_dma_hw_params()
675 link->source_attr = cpu_to_be32(CCSR_DMA_ATR_NOSNOOP | fsl_dma_hw_params()
678 link->dest_addr = cpu_to_be32(temp_addr); fsl_dma_hw_params()
679 link->dest_attr = cpu_to_be32(CCSR_DMA_ATR_SNOOP | fsl_dma_hw_params()
/linux-4.1.27/drivers/block/drbd/
H A Ddrbd_main.c581 h->magic = cpu_to_be32(DRBD_MAGIC); prepare_header80()
591 h->length = cpu_to_be32(size); prepare_header95()
598 h->magic = cpu_to_be32(DRBD_MAGIC_100); prepare_header100()
601 h->length = cpu_to_be32(size); prepare_header100()
755 p->resync_rate = cpu_to_be32(dc->resync_rate); drbd_send_sync_param()
756 p->c_plan_ahead = cpu_to_be32(dc->c_plan_ahead); drbd_send_sync_param()
757 p->c_delay_target = cpu_to_be32(dc->c_delay_target); drbd_send_sync_param()
758 p->c_fill_target = cpu_to_be32(dc->c_fill_target); drbd_send_sync_param()
759 p->c_max_rate = cpu_to_be32(dc->c_max_rate); drbd_send_sync_param()
762 p->resync_rate = cpu_to_be32(DRBD_RESYNC_RATE_DEF); drbd_send_sync_param()
763 p->c_plan_ahead = cpu_to_be32(DRBD_C_PLAN_AHEAD_DEF); drbd_send_sync_param()
764 p->c_delay_target = cpu_to_be32(DRBD_C_DELAY_TARGET_DEF); drbd_send_sync_param()
765 p->c_fill_target = cpu_to_be32(DRBD_C_FILL_TARGET_DEF); drbd_send_sync_param()
766 p->c_max_rate = cpu_to_be32(DRBD_C_MAX_RATE_DEF); drbd_send_sync_param()
804 p->protocol = cpu_to_be32(nc->wire_protocol); __drbd_send_protocol()
805 p->after_sb_0p = cpu_to_be32(nc->after_sb_0p); __drbd_send_protocol()
806 p->after_sb_1p = cpu_to_be32(nc->after_sb_1p); __drbd_send_protocol()
807 p->after_sb_2p = cpu_to_be32(nc->after_sb_2p); __drbd_send_protocol()
808 p->two_primaries = cpu_to_be32(nc->two_primaries); __drbd_send_protocol()
814 p->conn_flags = cpu_to_be32(cf); __drbd_send_protocol()
961 p->max_bio_size = cpu_to_be32(max_bio_size); drbd_send_sizes()
980 p->state = cpu_to_be32(peer_device->device->state.i); /* Within the send mutex */ drbd_send_current_state()
1003 p->state = cpu_to_be32(state.i); /* Within the send mutex */ drbd_send_state()
1016 p->mask = cpu_to_be32(mask.i); drbd_send_state_req()
1017 p->val = cpu_to_be32(val.i); drbd_send_state_req()
1032 p->mask = cpu_to_be32(mask.i); conn_send_state_req()
1033 p->val = cpu_to_be32(val.i); conn_send_state_req()
1045 p->retcode = cpu_to_be32(retcode); drbd_send_sr_reply()
1059 p->retcode = cpu_to_be32(retcode); conn_send_sr_reply()
1303 p->set_size = cpu_to_be32(set_size); drbd_send_b_ack()
1331 p->seq_num = cpu_to_be32(atomic_inc_return(&peer_device->device->packet_seq)); _drbd_send_ack()
1343 _drbd_send_ack(peer_device, cmd, dp->sector, cpu_to_be32(data_size), drbd_send_ack_dp()
1364 cpu_to_be32(peer_req->i.size), drbd_send_ack()
1375 cpu_to_be32(blksize), drbd_send_ack_ex()
1391 p->blksize = cpu_to_be32(size); drbd_send_drequest()
1409 p->blksize = cpu_to_be32(size); drbd_send_drequest_csum()
1424 p->blksize = cpu_to_be32(size); drbd_send_ov_request()
1637 p->seq_num = cpu_to_be32(atomic_inc_return(&device->packet_seq)); drbd_send_dblock()
1651 p->dp_flags = cpu_to_be32(dp_flags); drbd_send_dblock()
1655 t->size = cpu_to_be32(req->i.size); drbd_send_dblock()
1748 p->blksize = cpu_to_be32(req->i.size); drbd_send_out_of_sync()
3066 buffer->flags = cpu_to_be32(device->ldev->md.flags); drbd_md_write()
3067 buffer->magic = cpu_to_be32(DRBD_MD_MAGIC_84_UNCLEAN); drbd_md_write()
3069 buffer->md_size_sect = cpu_to_be32(device->ldev->md.md_size_sect); drbd_md_write()
3070 buffer->al_offset = cpu_to_be32(device->ldev->md.al_offset); drbd_md_write()
3071 buffer->al_nr_extents = cpu_to_be32(device->act_log->nr_elements); drbd_md_write()
3072 buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE); drbd_md_write()
3075 buffer->bm_offset = cpu_to_be32(device->ldev->md.bm_offset); drbd_md_write()
3076 buffer->la_peer_max_bio_size = cpu_to_be32(device->peer_max_bio_size); drbd_md_write()
3078 buffer->al_stripes = cpu_to_be32(device->ldev->md.al_stripes); drbd_md_write()
3079 buffer->al_stripe_size_4k = cpu_to_be32(device->ldev->md.al_stripe_size_4k); drbd_md_write()
/linux-4.1.27/drivers/net/ethernet/chelsio/cxgb4/
H A Dcxgb4_dcb.h45 cpu_to_be32(FW_CMD_OP_V(FW_PORT_CMD) | \
50 cpu_to_be32(FW_PORT_CMD_ACTION_V(__action) | \
/linux-4.1.27/drivers/scsi/
H A Dsd_dif.c142 pi->ref_tag = cpu_to_be32(phys); bip_for_each_vec()
194 pi->ref_tag = cpu_to_be32(virt); bip_for_each_vec()
H A Dipr.c668 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl)); ipr_reinit_ipr_cmnd()
887 cpu_to_be32(IPR_IOASC_IOA_WAS_RESET); for_each_hrrq()
889 cpu_to_be32(IPR_DRIVER_ILID); for_each_hrrq()
1007 ioadl64->flags = cpu_to_be32(flags); ipr_init_ioadl()
1008 ioadl64->data_len = cpu_to_be32(len); ipr_init_ioadl()
1012 cpu_to_be32(sizeof(struct ipr_ioadl64_desc)); ipr_init_ioadl()
1013 ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len); ipr_init_ioadl()
1015 ioadl->flags_and_data_len = cpu_to_be32(flags | len); ipr_init_ioadl()
1016 ioadl->address = cpu_to_be32(dma_addr); ipr_init_ioadl()
1020 cpu_to_be32(sizeof(struct ipr_ioadl_desc)); ipr_init_ioadl()
1021 ipr_cmd->ioarcb.read_data_transfer_length = cpu_to_be32(len); ipr_init_ioadl()
1024 cpu_to_be32(sizeof(struct ipr_ioadl_desc)); ipr_init_ioadl()
1025 ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len); ipr_init_ioadl()
1093 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_send_hcam()
2500 hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw)); ipr_handle_log_data()
2778 *dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg)); ipr_get_sis64_dump_data_section()
2839 *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox)); ipr_get_ldump_data_section()
3885 ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len); ipr_build_ucode_ioadl64()
3888 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg); ipr_build_ucode_ioadl64()
3890 ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE); ipr_build_ucode_ioadl64()
3891 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i])); ipr_build_ucode_ioadl64()
3895 ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); ipr_build_ucode_ioadl64()
3916 ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len); ipr_build_ucode_ioadl()
3919 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); ipr_build_ucode_ioadl()
3923 cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i])); ipr_build_ucode_ioadl()
3925 cpu_to_be32(sg_dma_address(&scatterlist[i])); ipr_build_ucode_ioadl()
3929 cpu_to_be32(IPR_IOADL_FLAGS_LAST); ipr_build_ucode_ioadl()
5750 ioarcb->data_transfer_length = cpu_to_be32(length); ipr_build_ioadl64()
5752 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg); ipr_build_ioadl64()
5761 ioadl64[i].flags = cpu_to_be32(ioadl_flags); ipr_build_ioadl64()
5762 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg)); ipr_build_ioadl64()
5766 ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); ipr_build_ioadl64()
5804 ioarcb->data_transfer_length = cpu_to_be32(length); ipr_build_ioadl()
5806 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); ipr_build_ioadl()
5809 ioarcb->read_data_transfer_length = cpu_to_be32(length); ipr_build_ioadl()
5811 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); ipr_build_ioadl()
5816 ioarcb->write_ioadl_addr = cpu_to_be32((ipr_cmd->dma_addr) + ipr_build_ioadl()
5823 cpu_to_be32(ioadl_flags | sg_dma_len(sg)); ipr_build_ioadl()
5824 ioadl[i].address = cpu_to_be32(sg_dma_address(sg)); ipr_build_ioadl()
5827 ioadl[i-1].flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); ipr_build_ioadl()
5892 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl)); ipr_reinit_ipr_cmnd_for_erp()
6670 ioarcb->data_transfer_length = cpu_to_be32(len); ipr_build_ata_ioadl64()
6672 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg); ipr_build_ata_ioadl64()
6677 ioadl64->flags = cpu_to_be32(ioadl_flags); ipr_build_ata_ioadl64()
6678 ioadl64->data_len = cpu_to_be32(sg_dma_len(sg)); ipr_build_ata_ioadl64()
6686 last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); ipr_build_ata_ioadl64()
6712 ioarcb->data_transfer_length = cpu_to_be32(len); ipr_build_ata_ioadl()
6714 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); ipr_build_ata_ioadl()
6717 ioarcb->read_data_transfer_length = cpu_to_be32(len); ipr_build_ata_ioadl()
6719 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); ipr_build_ata_ioadl()
6723 ioadl->flags_and_data_len = cpu_to_be32(ioadl_flags | sg_dma_len(sg)); ipr_build_ata_ioadl()
6724 ioadl->address = cpu_to_be32(sg_dma_address(sg)); ipr_build_ata_ioadl()
6731 last_ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); ipr_build_ata_ioadl()
7106 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_set_supported_devs()
7271 bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate); ipr_modify_ioafp_mode_page_28()
7330 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11, ipr_ioafp_mode_select_page28()
7432 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), ipr_ioafp_mode_sense_page28()
7472 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11, ipr_ioafp_mode_select_page24()
7520 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), ipr_ioafp_mode_sense_page24()
7651 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_ioafp_query_ioa_cfg()
7685 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_ioafp_inquiry()
7869 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_ioafp_identify_hrrq()
8296 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR); ipr_reset_restore_cfg_space()
8395 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR); ipr_reset_start_bist()
8686 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_reset_cancel_hcam()
8758 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_reset_ucode_download()
8802 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_reset_shutdown_ioa()
9351 ioarcb->a.ioarcb_host_pci_addr = cpu_to_be32(dma_addr); ipr_alloc_cmd_blks()
9353 ioarcb->host_response_handle = cpu_to_be32(i << 2); ipr_alloc_cmd_blks()
9361 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl)); ipr_alloc_cmd_blks()
9364 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, s.ioasa)); ipr_alloc_cmd_blks()
10497 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); ipr_halt()
/linux-4.1.27/drivers/of/
H A Dof_pci_irq.c87 laddr[0] = cpu_to_be32((pdev->bus->number << 16) | (pdev->devfn << 8)); of_irq_parse_pci()
88 laddr[1] = laddr[2] = cpu_to_be32(0); of_irq_parse_pci()
H A Dresolver.c106 *(uint32_t *)prop->value = cpu_to_be32(node->phandle); for_each_property_of_node()
186 *(__be32 *)(sprop->value + offset) = cpu_to_be32(phandle);
265 *(__be32 *)(sprop->value + off) = cpu_to_be32(phandle);
/linux-4.1.27/drivers/block/rsxx/
H A Dconfig.c65 hdr->version = (__force u32) cpu_to_be32(hdr->version); config_hdr_cpu_to_be()
66 hdr->crc = (__force u32) cpu_to_be32(hdr->crc); config_hdr_cpu_to_be()
/linux-4.1.27/drivers/iio/gyro/
H A Dadxrs450.c115 st->tx = cpu_to_be32(tx); adxrs450_spi_read_reg_16()
151 st->tx = cpu_to_be32(tx); adxrs450_spi_write_reg_16()
184 st->tx = cpu_to_be32(ADXRS450_SENSOR_DATA); adxrs450_spi_sensor_data()
221 st->tx = cpu_to_be32(tx); adxrs450_spi_initial()
/linux-4.1.27/drivers/target/iscsi/
H A Discsi_target.c1566 if (hdr->ttt == cpu_to_be32(0xFFFFFFFF)) { iscsit_setup_nop_out()
1619 if (hdr->ttt != cpu_to_be32(0xFFFFFFFF)) { iscsit_process_nop_out()
1655 if (payload_length && hdr->ttt == cpu_to_be32(0xFFFFFFFF)) { iscsit_handle_nop_out()
1783 hdr->refcmdsn = cpu_to_be32(ISCSI_RESERVED_TAG); iscsit_handle_task_mgt_cmd()
2552 hdr->statsn = cpu_to_be32(cmd->stat_sn); iscsit_send_conn_drop_async_message()
2553 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_send_conn_drop_async_message()
2554 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_send_conn_drop_async_message()
2601 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count); iscsit_build_datain_pdu()
2604 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count); iscsit_build_datain_pdu()
2617 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag); iscsit_build_datain_pdu()
2619 hdr->ttt = cpu_to_be32(0xFFFFFFFF); iscsit_build_datain_pdu()
2621 hdr->statsn = cpu_to_be32(cmd->stat_sn); iscsit_build_datain_pdu()
2623 hdr->statsn = cpu_to_be32(0xFFFFFFFF); iscsit_build_datain_pdu()
2625 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_build_datain_pdu()
2626 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_build_datain_pdu()
2627 hdr->datasn = cpu_to_be32(datain->data_sn); iscsit_build_datain_pdu()
2628 hdr->offset = cpu_to_be32(datain->offset); iscsit_build_datain_pdu()
2837 hdr->statsn = cpu_to_be32(cmd->stat_sn); iscsit_build_logout_rsp()
2840 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_build_logout_rsp()
2841 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_build_logout_rsp()
2895 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag); iscsit_build_nopin_rsp()
2898 hdr->statsn = cpu_to_be32(cmd->stat_sn); iscsit_build_nopin_rsp()
2903 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_build_nopin_rsp()
2904 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_build_nopin_rsp()
3048 hdr->ttt = cpu_to_be32(r2t->targ_xfer_tag); iscsit_send_r2t()
3049 hdr->statsn = cpu_to_be32(conn->stat_sn); iscsit_send_r2t()
3050 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_send_r2t()
3051 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_send_r2t()
3052 hdr->r2tsn = cpu_to_be32(r2t->r2t_sn); iscsit_send_r2t()
3053 hdr->data_offset = cpu_to_be32(r2t->offset); iscsit_send_r2t()
3054 hdr->data_length = cpu_to_be32(r2t->xfer_len); iscsit_send_r2t()
3192 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count); iscsit_build_rsp_pdu()
3195 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count); iscsit_build_rsp_pdu()
3200 hdr->statsn = cpu_to_be32(cmd->stat_sn); iscsit_build_rsp_pdu()
3203 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_build_rsp_pdu()
3204 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_build_rsp_pdu()
3319 hdr->statsn = cpu_to_be32(cmd->stat_sn); iscsit_build_task_mgt_rsp()
3322 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_build_task_mgt_rsp()
3323 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_build_task_mgt_rsp()
3568 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag); iscsit_build_text_rsp()
3570 hdr->statsn = cpu_to_be32(cmd->stat_sn); iscsit_build_text_rsp()
3579 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_build_text_rsp()
3580 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_build_text_rsp()
3654 hdr->ffffffff = cpu_to_be32(0xffffffff); iscsit_build_reject()
3656 hdr->statsn = cpu_to_be32(cmd->stat_sn); iscsit_build_reject()
3657 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); iscsit_build_reject()
3658 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); iscsit_build_reject()
4032 if (hdr->ttt == cpu_to_be32(0xFFFFFFFF)) { iscsi_target_rx_opcode()
4047 if (hdr->ttt != cpu_to_be32(0xFFFFFFFF)) { iscsi_target_rx_opcode()
/linux-4.1.27/fs/ufs/
H A Dswab.h58 return (__force __fs32)cpu_to_be32(n); cpu_to_fs32()
/linux-4.1.27/net/rds/
H A Dmessage.c182 ext_hdr.h_rdma_rkey = cpu_to_be32(r_key); rds_message_add_rdma_dest_extension()
183 ext_hdr.h_rdma_offset = cpu_to_be32(offset); rds_message_add_rdma_dest_extension()
250 rm->m_inc.i_hdr.h_len = cpu_to_be32(total_len); rds_message_map_pages()
274 rm->m_inc.i_hdr.h_len = cpu_to_be32(iov_iter_count(from)); rds_message_copy_from_user()
/linux-4.1.27/drivers/iio/dac/
H A Dad5686.c100 st->data[0].d32 = cpu_to_be32(AD5686_CMD(cmd) | ad5686_spi_write()
122 st->data[0].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_READBACK_ENABLE) | ad5686_spi_read()
124 st->data[1].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_NOOP)); ad5686_spi_read()
H A Dad5791.c113 st->data[0].d32 = cpu_to_be32(AD5791_CMD_WRITE | ad5791_spi_write()
137 st->data[0].d32 = cpu_to_be32(AD5791_CMD_READ | ad5791_spi_read()
139 st->data[1].d32 = cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP)); ad5791_spi_read()
/linux-4.1.27/drivers/net/wireless/ath/ath9k/
H A Dhtc_drv_init.c235 __be32 val, reg = cpu_to_be32(reg_offset); ath9k_regread()
262 tmpaddr[i] = cpu_to_be32(addr[i]); ath9k_multi_regread()
304 cpu_to_be32(reg_offset), ath9k_regwrite_single()
305 cpu_to_be32(val), ath9k_regwrite_single()
329 cpu_to_be32(reg_offset); ath9k_regwrite_buffer()
331 cpu_to_be32(val); ath9k_regwrite_buffer()
392 cpu_to_be32(reg_offset); ath9k_reg_rmw_buffer()
394 cpu_to_be32(set); ath9k_reg_rmw_buffer()
396 cpu_to_be32(clr); ath9k_reg_rmw_buffer()
472 buf.reg = cpu_to_be32(reg_offset); ath9k_reg_rmw_single()
473 buf.set = cpu_to_be32(set); ath9k_reg_rmw_single()
474 buf.clr = cpu_to_be32(clr); ath9k_reg_rmw_single()
/linux-4.1.27/fs/nfs/blocklayout/
H A Drpc_pipefs.c42 *p++ = cpu_to_be32(1); nfs4_encode_simple()
43 *p++ = cpu_to_be32(b->type); nfs4_encode_simple()
44 *p++ = cpu_to_be32(b->simple.nr_sigs); nfs4_encode_simple()
/linux-4.1.27/drivers/crypto/ccp/
H A Dccp-ops.c137 cpu_to_be32(SHA1_H0), cpu_to_be32(SHA1_H1),
138 cpu_to_be32(SHA1_H2), cpu_to_be32(SHA1_H3),
139 cpu_to_be32(SHA1_H4), 0, 0, 0,
143 cpu_to_be32(SHA224_H0), cpu_to_be32(SHA224_H1),
144 cpu_to_be32(SHA224_H2), cpu_to_be32(SHA224_H3),
145 cpu_to_be32(SHA224_H4), cpu_to_be32(SHA224_H5),
146 cpu_to_be32(SHA224_H6), cpu_to_be32(SHA224_H7),
150 cpu_to_be32(SHA256_H0), cpu_to_be32(SHA256_H1),
151 cpu_to_be32(SHA256_H2), cpu_to_be32(SHA256_H3),
152 cpu_to_be32(SHA256_H4), cpu_to_be32(SHA256_H5),
153 cpu_to_be32(SHA256_H6), cpu_to_be32(SHA256_H7),
/linux-4.1.27/drivers/vme/bridges/
H A Dvme_tsi148.c1598 *attr = cpu_to_be32(val); tsi148_dma_set_vme_src_attributes()
1698 *attr = cpu_to_be32(val); tsi148_dma_set_vme_dest_attributes()
1749 entry->descriptor.dsal = cpu_to_be32(pattern_attr->pattern); tsi148_dma_list_add()
1760 entry->descriptor.dsat = cpu_to_be32(val); tsi148_dma_list_add()
1767 entry->descriptor.dsau = cpu_to_be32(address_high); tsi148_dma_list_add()
1768 entry->descriptor.dsal = cpu_to_be32(address_low); tsi148_dma_list_add()
1769 entry->descriptor.dsat = cpu_to_be32(TSI148_LCSR_DSAT_TYP_PCI); tsi148_dma_list_add()
1776 entry->descriptor.dsau = cpu_to_be32(address_high); tsi148_dma_list_add()
1777 entry->descriptor.dsal = cpu_to_be32(address_low); tsi148_dma_list_add()
1778 entry->descriptor.dsat = cpu_to_be32(TSI148_LCSR_DSAT_TYP_VME); tsi148_dma_list_add()
1794 entry->descriptor.dnlau = cpu_to_be32(0); tsi148_dma_list_add()
1795 entry->descriptor.dnlal = cpu_to_be32(TSI148_LCSR_DNLAL_LLA); tsi148_dma_list_add()
1804 entry->descriptor.ddau = cpu_to_be32(address_high); tsi148_dma_list_add()
1805 entry->descriptor.ddal = cpu_to_be32(address_low); tsi148_dma_list_add()
1806 entry->descriptor.ddat = cpu_to_be32(TSI148_LCSR_DDAT_TYP_PCI); tsi148_dma_list_add()
1813 entry->descriptor.ddau = cpu_to_be32(address_high); tsi148_dma_list_add()
1814 entry->descriptor.ddal = cpu_to_be32(address_low); tsi148_dma_list_add()
1815 entry->descriptor.ddat = cpu_to_be32(TSI148_LCSR_DDAT_TYP_VME); tsi148_dma_list_add()
1831 entry->descriptor.dcnt = cpu_to_be32((u32)count); tsi148_dma_list_add()
1847 entry->descriptor.dnlau = cpu_to_be32(address_high); tsi148_dma_list_add()
1848 entry->descriptor.dnlal = cpu_to_be32(address_low); tsi148_dma_list_add()
/linux-4.1.27/drivers/infiniband/hw/ipath/
H A Dipath_mad.c112 nip->revision = cpu_to_be32((majrev << 16) | minrev); recv_subn_get_nodeinfo()
266 pip->cap_mask = cpu_to_be32(dev->port_cap_flags); recv_subn_get_portinfo()
828 #define COUNTER_MASK0_9 cpu_to_be32(COUNTER_MASK(1, 0) | \
870 p->sample_start = cpu_to_be32(dev->pma_sample_start); recv_pma_get_portsamplescontrol()
871 p->sample_interval = cpu_to_be32(dev->pma_sample_interval); recv_pma_get_portsamplescontrol()
989 cpu_to_be32( recv_pma_get_portsamplesresult()
1013 p->extended_width = cpu_to_be32(0x80000000); recv_pma_get_portsamplesresult_ext()
1100 p->port_xmit_data = cpu_to_be32(0xFFFFFFFF); recv_pma_get_portcounters()
1102 p->port_xmit_data = cpu_to_be32((u32)cntrs.port_xmit_data); recv_pma_get_portcounters()
1104 p->port_rcv_data = cpu_to_be32(0xFFFFFFFF); recv_pma_get_portcounters()
1106 p->port_rcv_data = cpu_to_be32((u32)cntrs.port_rcv_data); recv_pma_get_portcounters()
1108 p->port_xmit_packets = cpu_to_be32(0xFFFFFFFF); recv_pma_get_portcounters()
1111 cpu_to_be32((u32)cntrs.port_xmit_packets); recv_pma_get_portcounters()
1113 p->port_rcv_packets = cpu_to_be32(0xFFFFFFFF); recv_pma_get_portcounters()
1116 cpu_to_be32((u32) cntrs.port_rcv_packets); recv_pma_get_portcounters()
H A Dipath_ud.c368 ohdr->bth[0] = cpu_to_be32(bth0); ipath_make_ud_req()
374 cpu_to_be32(IPATH_MULTICAST_QPN) : ipath_make_ud_req()
375 cpu_to_be32(wqe->wr.wr.ud.remote_qpn); ipath_make_ud_req()
376 ohdr->bth[2] = cpu_to_be32(qp->s_next_psn++ & IPATH_PSN_MASK); ipath_make_ud_req()
381 ohdr->u.ud.deth[0] = cpu_to_be32((int)wqe->wr.wr.ud.remote_qkey < 0 ? ipath_make_ud_req()
383 ohdr->u.ud.deth[1] = cpu_to_be32(qp->ibqp.qp_num); ipath_make_ud_req()
577 cpu_to_be32(1 << 23)) != 0); ipath_ud_rcv()
H A Dipath_rc.c148 cpu_to_be32(e->atomic_data >> 32);
150 cpu_to_be32(e->atomic_data);
188 cpu_to_be32((qp->r_msn & IPATH_MSN_MASK) |
355 cpu_to_be32(wqe->wr.wr.rdma.rkey); ipath_make_rc_req()
356 ohdr->u.rc.reth.length = cpu_to_be32(len); ipath_make_rc_req()
406 cpu_to_be32(wqe->wr.wr.rdma.rkey); ipath_make_rc_req()
407 ohdr->u.rc.reth.length = cpu_to_be32(len); ipath_make_rc_req()
445 ohdr->u.atomic_eth.vaddr[0] = cpu_to_be32( ipath_make_rc_req()
447 ohdr->u.atomic_eth.vaddr[1] = cpu_to_be32( ipath_make_rc_req()
449 ohdr->u.atomic_eth.rkey = cpu_to_be32( ipath_make_rc_req()
572 cpu_to_be32(wqe->wr.wr.rdma.rkey); ipath_make_rc_req()
573 ohdr->u.rc.reth.length = cpu_to_be32(qp->s_len); ipath_make_rc_req()
668 ohdr->u.aeth = cpu_to_be32((qp->r_msn & IPATH_MSN_MASK) | send_rc_ack()
679 ohdr->bth[0] = cpu_to_be32(bth0); send_rc_ack()
680 ohdr->bth[1] = cpu_to_be32(qp->remote_qpn); send_rc_ack()
681 ohdr->bth[2] = cpu_to_be32(qp->r_ack_psn & IPATH_PSN_MASK); send_rc_ack()
1747 cpu_to_be32(1 << 23)) != 0);
/linux-4.1.27/fs/jbd/
H A Djournal.c354 cpu_to_be32(JFS_MAGIC_NUMBER)) { journal_write_metadata_buffer()
1040 sb->s_header.h_magic = cpu_to_be32(JFS_MAGIC_NUMBER); journal_create()
1041 sb->s_header.h_blocktype = cpu_to_be32(JFS_SUPERBLOCK_V2); journal_create()
1043 sb->s_blocksize = cpu_to_be32(journal->j_blocksize); journal_create()
1044 sb->s_maxlen = cpu_to_be32(journal->j_maxlen); journal_create()
1045 sb->s_first = cpu_to_be32(1); journal_create()
1117 sb->s_sequence = cpu_to_be32(tail_tid); journal_update_sb_log_tail()
1118 sb->s_start = cpu_to_be32(tail_block); journal_update_sb_log_tail()
1150 sb->s_sequence = cpu_to_be32(journal->j_tail_sequence); mark_journal_empty()
1151 sb->s_start = cpu_to_be32(0); mark_journal_empty()
1176 sb->s_errno = cpu_to_be32(journal->j_errno); journal_update_sb_errno()
1210 if (sb->s_header.h_magic != cpu_to_be32(JFS_MAGIC_NUMBER) || journal_get_superblock()
1211 sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) { journal_get_superblock()
1299 ~cpu_to_be32(JFS_KNOWN_ROCOMPAT_FEATURES)) || journal_load()
1301 ~cpu_to_be32(JFS_KNOWN_INCOMPAT_FEATURES))) { journal_load()
1477 sb->s_feature_compat |= cpu_to_be32(compat); journal_set_features()
1478 sb->s_feature_ro_compat |= cpu_to_be32(ro); journal_set_features()
1479 sb->s_feature_incompat |= cpu_to_be32(incompat); journal_set_features()
1528 sb->s_nr_users = cpu_to_be32(1); journal_convert_superblock_v1()
1529 sb->s_header.h_blocktype = cpu_to_be32(JFS_SUPERBLOCK_V2); journal_convert_superblock_v1()
/linux-4.1.27/fs/logfs/
H A Dsuper.c149 sh->segno = cpu_to_be32(segno); set_segment_header()
150 sh->ec = cpu_to_be32(ec); set_segment_header()
172 ds->ds_segment_size = cpu_to_be32(super->s_segsize); logfs_write_ds()
173 ds->ds_bad_seg_reserve = cpu_to_be32(super->s_bad_seg_reserve); logfs_write_ds()
181 ds->ds_journal_seg[i] = cpu_to_be32(super->s_journal_seg[i]); logfs_write_ds()
/linux-4.1.27/drivers/infiniband/hw/qib/
H A Dqib_ud.c367 ohdr->bth[0] = cpu_to_be32(bth0); qib_make_ud_req()
373 cpu_to_be32(QIB_MULTICAST_QPN) : qib_make_ud_req()
374 cpu_to_be32(wqe->wr.wr.ud.remote_qpn); qib_make_ud_req()
375 ohdr->bth[2] = cpu_to_be32(qp->s_next_psn++ & QIB_PSN_MASK); qib_make_ud_req()
380 ohdr->u.ud.deth[0] = cpu_to_be32((int)wqe->wr.wr.ud.remote_qkey < 0 ? qib_make_ud_req()
382 ohdr->u.ud.deth[1] = cpu_to_be32(qp->ibqp.qp_num); qib_make_ud_req()
585 cpu_to_be32(IB_BTH_SOLICITED)) != 0); qib_ud_rcv()
H A Dqib_mad.c158 data.details.ntc_257_258.key = cpu_to_be32(key); qib_bad_pqkey()
159 data.details.ntc_257_258.sl_qp1 = cpu_to_be32((sl << 28) | qp1); qib_bad_pqkey()
160 data.details.ntc_257_258.qp2 = cpu_to_be32(qp2); qib_bad_pqkey()
219 data.details.ntc_144.new_cap_mask = cpu_to_be32(ibp->port_cap_flags); qib_cap_mask_chg()
302 nip->revision = cpu_to_be32((majrev << 16) | minrev); subn_get_nodeinfo()
497 pip->cap_mask = cpu_to_be32(ibp->port_cap_flags); subn_get_portinfo()
1202 p->sample_start = cpu_to_be32(ibp->pma_sample_start); pma_get_portsamplescontrol()
1203 p->sample_interval = cpu_to_be32(ibp->pma_sample_interval); pma_get_portsamplescontrol()
1376 p->counter[i] = cpu_to_be32( pma_get_portsamplesresult()
1407 p->extended_width = cpu_to_be32(0x80000000); pma_get_portsamplesresult_ext()
1503 p->port_xmit_data = cpu_to_be32(0xFFFFFFFF); pma_get_portcounters()
1505 p->port_xmit_data = cpu_to_be32((u32)cntrs.port_xmit_data); pma_get_portcounters()
1507 p->port_rcv_data = cpu_to_be32(0xFFFFFFFF); pma_get_portcounters()
1509 p->port_rcv_data = cpu_to_be32((u32)cntrs.port_rcv_data); pma_get_portcounters()
1511 p->port_xmit_packets = cpu_to_be32(0xFFFFFFFF); pma_get_portcounters()
1514 cpu_to_be32((u32)cntrs.port_xmit_packets); pma_get_portcounters()
1516 p->port_rcv_packets = cpu_to_be32(0xFFFFFFFF); pma_get_portcounters()
1519 cpu_to_be32((u32) cntrs.port_rcv_packets); pma_get_portcounters()
2188 ccp->attr_mod = cpu_to_be32(cct_block_index); cc_get_congestion_control_table()
H A Dqib_rc.c158 cpu_to_be32(e->atomic_data >> 32);
160 cpu_to_be32(e->atomic_data);
203 cpu_to_be32((qp->r_msn & QIB_MSN_MASK) |
379 cpu_to_be32(wqe->wr.wr.rdma.rkey); qib_make_rc_req()
380 ohdr->u.rc.reth.length = cpu_to_be32(len); qib_make_rc_req()
430 cpu_to_be32(wqe->wr.wr.rdma.rkey); qib_make_rc_req()
431 ohdr->u.rc.reth.length = cpu_to_be32(len); qib_make_rc_req()
470 ohdr->u.atomic_eth.vaddr[0] = cpu_to_be32( qib_make_rc_req()
472 ohdr->u.atomic_eth.vaddr[1] = cpu_to_be32( qib_make_rc_req()
474 ohdr->u.atomic_eth.rkey = cpu_to_be32( qib_make_rc_req()
602 cpu_to_be32(wqe->wr.wr.rdma.rkey); qib_make_rc_req()
603 ohdr->u.rc.reth.length = cpu_to_be32(wqe->length - len); qib_make_rc_req()
689 ohdr->u.aeth = cpu_to_be32((qp->r_msn & QIB_MSN_MASK) | qib_send_rc_ack()
700 ohdr->bth[0] = cpu_to_be32(bth0); qib_send_rc_ack()
701 ohdr->bth[1] = cpu_to_be32(qp->remote_qpn); qib_send_rc_ack()
702 ohdr->bth[2] = cpu_to_be32(qp->r_ack_psn & QIB_PSN_MASK); qib_send_rc_ack()
2050 cpu_to_be32(IB_BTH_SOLICITED)) != 0); qib_rc_rcv()
/linux-4.1.27/drivers/net/ethernet/toshiba/
H A Dps3_gelic_net.c199 descr->dmac_cmd_status = cpu_to_be32(status | gelic_descr_set_status()
228 descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr); gelic_card_reset_chain()
352 descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr); gelic_card_init_chain()
402 descr->buf_size = cpu_to_be32(bufsize); gelic_descr_prepare_rx()
413 descr->buf_addr = cpu_to_be32(dma_map_single(ctodev(card), gelic_descr_prepare_rx()
717 cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM | gelic_descr_set_tx_cmdstat()
725 cpu_to_be32(GELIC_DESCR_DMA_CMD_TCP_CHKSUM | gelic_descr_set_tx_cmdstat()
730 cpu_to_be32(GELIC_DESCR_DMA_CMD_UDP_CHKSUM | gelic_descr_set_tx_cmdstat()
737 cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM | gelic_descr_set_tx_cmdstat()
804 descr->buf_addr = cpu_to_be32(buf); gelic_descr_prepare_tx()
805 descr->buf_size = cpu_to_be32(skb->len); gelic_descr_prepare_tx()
886 descr->prev->next_descr_addr = cpu_to_be32(descr->bus_addr); gelic_net_xmit()
899 descr->data_status = cpu_to_be32(GELIC_DESCR_TX_TAIL); gelic_net_xmit()
1078 descr->prev->next_descr_addr = cpu_to_be32(descr->bus_addr); gelic_card_decode_one_descr()
/linux-4.1.27/drivers/scsi/lpfc/
H A Dlpfc_ct.c558 if (CTentry & (cpu_to_be32(SLI_CT_LAST_ENTRY))) lpfc_ns_rsp()
1229 CtReq->un.gff.PortId = cpu_to_be32(context); lpfc_ns_cmd()
1237 CtReq->un.rft.PortId = cpu_to_be32(vport->fc_myDID); lpfc_ns_cmd()
1246 CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID); lpfc_ns_cmd()
1256 CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID); lpfc_ns_cmd()
1279 CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID); lpfc_ns_cmd()
1286 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID); lpfc_ns_cmd()
1487 rh->rpl.EntryCnt = cpu_to_be32(1); lpfc_fdmi_cmd()
1700 ae->un.MaxCTPayloadLen = cpu_to_be32(LPFC_MAX_CT_SIZE); lpfc_fdmi_cmd()
1727 ab->EntryCnt = cpu_to_be32(ab->EntryCnt); lpfc_fdmi_cmd()
1794 cpu_to_be32(ae->un.SupportSpeed); lpfc_fdmi_cmd()
1828 ae->un.PortSpeed = cpu_to_be32(ae->un.PortSpeed); lpfc_fdmi_cmd()
1844 cpu_to_be32(ae->un.MaxFrameSize); lpfc_fdmi_cmd()
1960 cpu_to_be32(FC_COS_CLASS2 | FC_COS_CLASS3); lpfc_fdmi_cmd()
2018 ae->un.PortState = cpu_to_be32(ae->un.PortState); lpfc_fdmi_cmd()
2030 ae->un.PortId = cpu_to_be32(vport->fc_myDID); lpfc_fdmi_cmd()
2035 pab->ab.EntryCnt = cpu_to_be32(pab->ab.EntryCnt); lpfc_fdmi_cmd()
/linux-4.1.27/drivers/scsi/osd/
H A Dosd_initiator.c236 attr->attr_page = cpu_to_be32(oa->attr_page); _osd_req_alist_elem_encode()
237 attr->attr_id = cpu_to_be32(oa->attr_id); _osd_req_alist_elem_encode()
243 attr->attr_page = cpu_to_be32(oa->attr_page); _osd_req_alist_elem_encode()
244 attr->attr_id = cpu_to_be32(oa->attr_id); _osd_req_alist_elem_encode()
926 oscd->hdr.length = cpu_to_be32(oscd_size - sizeof(*oscd)); _add_sg_continuation_descriptor()
970 cdbh->v2.cdb_continuation_length = cpu_to_be32(or->cdb_cont.total_bytes); _osd_req_finalize_cdb_cont()
1216 cdbh->attrs_list.set_attr_bytes = cpu_to_be32(or->set_attr.total_bytes); _osd_req_finalize_set_attr_list()
1279 attrid->attr_page = cpu_to_be32(oa->attr_page); osd_req_add_get_attr_list()
1280 attrid->attr_id = cpu_to_be32(oa->attr_id); osd_req_add_get_attr_list()
1324 cpu_to_be32(or->enc_get_attr.total_bytes); _osd_req_finalize_get_attr_list()
1338 cpu_to_be32(or->get_attr.total_bytes); _osd_req_finalize_get_attr_list()
1439 cdbh->attrs_page.get_attr_page = cpu_to_be32(page_id); osd_req_add_get_attr_page()
1440 cdbh->attrs_page.get_attr_alloc_length = cpu_to_be32(max_page_len); osd_req_add_get_attr_page()
1448 cdbh->attrs_page.set_attr_page = cpu_to_be32(set_one_attr->attr_page); osd_req_add_get_attr_page()
1449 cdbh->attrs_page.set_attr_id = cpu_to_be32(set_one_attr->attr_id); osd_req_add_get_attr_page()
1450 cdbh->attrs_page.set_attr_length = cpu_to_be32(set_one_attr->len); osd_req_add_get_attr_page()
2065 be32_offset = cpu_to_be32((u32)try_offset); __osd_encode_offset()
/linux-4.1.27/drivers/scsi/cxgbi/cxgb4i/
H A Dcxgb4i.c210 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ, send_act_open_req()
217 req->params = cpu_to_be32(cxgb4_select_ntuple( send_act_open_req()
221 req->opt2 = cpu_to_be32(opt2); send_act_open_req()
233 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ, send_act_open_req()
245 req->opt2 = cpu_to_be32(opt2); send_act_open_req()
294 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ6, send_act_open_req6()
309 req->opt2 = cpu_to_be32(opt2); send_act_open_req6()
311 req->params = cpu_to_be32(cxgb4_select_ntuple( send_act_open_req6()
319 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ6, send_act_open_req6()
332 req->opt2 = cpu_to_be32(opt2); send_act_open_req6()
363 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_CLOSE_CON_REQ, tid)); send_close_req()
407 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_REQ, csk->tid)); send_abort_req()
431 OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_RPL, csk->tid)); send_abort_rpl()
459 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_RX_DATA_ACK, send_rx_credits()
461 req->credit_dack = cpu_to_be32(RX_CREDITS_V(credits) send_rx_credits()
586 cpu_to_be32(FW_WR_OP_V(FW_OFLD_TX_DATA_WR) | make_tx_data_wr()
590 cpu_to_be32(FW_WR_FLOWID_V(csk->tid) | make_tx_data_wr()
/linux-4.1.27/drivers/scsi/bnx2i/
H A Dbnx2i_hwi.c1402 hdr->max_cmdsn = cpu_to_be32(resp_cqe->max_cmd_sn); bnx2i_process_scsi_cmd_resp()
1403 hdr->exp_cmdsn = cpu_to_be32(resp_cqe->exp_cmd_sn); bnx2i_process_scsi_cmd_resp()
1407 hdr->residual_count = cpu_to_be32(resp_cqe->residual_count); bnx2i_process_scsi_cmd_resp()
1480 resp_hdr->statsn = cpu_to_be32(login->stat_sn); bnx2i_process_login_resp()
1481 resp_hdr->exp_cmdsn = cpu_to_be32(login->exp_cmd_sn); bnx2i_process_login_resp()
1482 resp_hdr->max_cmdsn = cpu_to_be32(login->max_cmd_sn); bnx2i_process_login_resp()
1543 resp_hdr->ttt = cpu_to_be32(text->ttt); bnx2i_process_text_resp()
1545 resp_hdr->exp_cmdsn = cpu_to_be32(text->exp_cmd_sn); bnx2i_process_text_resp()
1546 resp_hdr->max_cmdsn = cpu_to_be32(text->max_cmd_sn); bnx2i_process_text_resp()
1598 resp_hdr->max_cmdsn = cpu_to_be32(tmf_cqe->max_cmd_sn); bnx2i_process_tmf_resp()
1599 resp_hdr->exp_cmdsn = cpu_to_be32(tmf_cqe->exp_cmd_sn); bnx2i_process_tmf_resp()
1642 resp_hdr->exp_cmdsn = cpu_to_be32(logout->exp_cmd_sn); bnx2i_process_logout_resp()
1643 resp_hdr->max_cmdsn = cpu_to_be32(logout->max_cmd_sn); bnx2i_process_logout_resp()
1645 resp_hdr->t2wait = cpu_to_be32(logout->time_to_wait); bnx2i_process_logout_resp()
1646 resp_hdr->t2retain = cpu_to_be32(logout->time_to_retain); bnx2i_process_logout_resp()
1721 hdr->max_cmdsn = cpu_to_be32(nop_in->max_cmd_sn); bnx2i_process_nopin_mesg()
1722 hdr->exp_cmdsn = cpu_to_be32(nop_in->exp_cmd_sn); bnx2i_process_nopin_mesg()
1723 hdr->ttt = cpu_to_be32(nop_in->ttt); bnx2i_process_nopin_mesg()
1738 hdr->ttt = cpu_to_be32(nop_in->ttt); bnx2i_process_nopin_mesg()
1783 resp_hdr->exp_cmdsn = cpu_to_be32(async_cqe->exp_cmd_sn); bnx2i_process_async_mesg()
1784 resp_hdr->max_cmdsn = cpu_to_be32(async_cqe->max_cmd_sn); bnx2i_process_async_mesg()
1828 hdr->max_cmdsn = cpu_to_be32(reject->max_cmd_sn); bnx2i_process_reject_mesg()
1829 hdr->exp_cmdsn = cpu_to_be32(reject->exp_cmd_sn); bnx2i_process_reject_mesg()
1830 hdr->ffffffff = cpu_to_be32(RESERVED_ITT); bnx2i_process_reject_mesg()

Completed in 5222 milliseconds

123