unsigned long bfin_get_addr_from_rp(unsigned long *ptr, unsigned long relval, unsigned long flags, unsigned long *persistent) { unsigned short *usptr = (unsigned short *)ptr; int type = (relval >> 26) & 7; unsigned long val; switch (type) { case FLAT_BFIN_RELOC_TYPE_16_BIT: case FLAT_BFIN_RELOC_TYPE_16H_BIT: usptr = (unsigned short *)ptr; pr_debug("*usptr = %x", get_unaligned(usptr)); val = get_unaligned(usptr); val += *persistent; break; case FLAT_BFIN_RELOC_TYPE_32_BIT: pr_debug("*ptr = %lx", get_unaligned(ptr)); val = get_unaligned(ptr); break; default: pr_debug("BINFMT_FLAT: Unknown relocation type %x\n", type); return 0; } if (relval & (1 << 29)) return val + current->mm->context.end_brk; if ((flags & FLAT_FLAG_GOTPIC) == 0) val = htonl(val); return val; }
/* ======================================================================== Routine Description: For each out-going packet, check the upper layer protocol type if need to handled by our APCLI convert engine. If yes, call corresponding handler to handle it. Arguments: pAd =>Pointer to our adapter pPkt =>pointer to the 802.11 header of outgoing packet ifIdx =>Interface Index want to dispatch to. Return Value: Success => TRUE Mapped mac address if found, else return specific default mac address depends on the upper layer protocol type. Error => FALSE. Note: 1.the pPktHdr must be a 802.3 packet. 2.Maybe we need a TxD arguments? 3.We check every packet here including group mac address becasue we need to handle DHCP packet. ======================================================================== */ PUCHAR MATEngineTxHandle( IN PRTMP_ADAPTER pAd, IN PNDIS_PACKET pPkt, IN UINT ifIdx, IN UCHAR OpMode) { PUCHAR pLayerHdr = NULL, pPktHdr = NULL, pMacAddr = NULL; UINT16 protoType, protoType_ori; int i; struct _MATProtoOps *pHandle = NULL; PUCHAR retSkb = NULL; BOOLEAN bVLANPkt = FALSE; if(pAd->MatCfg.status != MAT_ENGINE_STAT_INITED) return NULL; pPktHdr = GET_OS_PKT_DATAPTR(pPkt); if (!pPktHdr) return NULL; protoType_ori = get_unaligned((PUINT16)(pPktHdr + 12)); /* Get the upper layer protocol type of this 802.3 pkt. */ protoType = OS_NTOHS(protoType_ori); /* handle 802.1q enabled packet. Skip the VLAN tag field to get the protocol type. */ if (protoType == 0x8100) { protoType_ori = get_unaligned((PUINT16)(pPktHdr + 12 + 4)); protoType = OS_NTOHS(protoType_ori); bVLANPkt = TRUE; } /* For differnet protocol, dispatch to specific handler */ for (i=0; i < MAX_MAT_SUPPORT_PROTO_NUM; i++) { if (protoType == MATProtoTb[i].protocol) { pHandle = MATProtoTb[i].pHandle; /* the pHandle must not be null! */ pLayerHdr = bVLANPkt ? (pPktHdr + MAT_VLAN_ETH_HDR_LEN) : (pPktHdr + MAT_ETHER_HDR_LEN); #ifdef CONFIG_AP_SUPPORT #ifdef APCLI_SUPPORT IF_DEV_CONFIG_OPMODE_ON_AP(pAd) pMacAddr = &pAd->ApCfg.ApCliTab[ifIdx].CurrentAddress[0]; #endif /* APCLI_SUPPORT */ #endif /* CONFIG_AP_SUPPORT */ if (pHandle->tx!=NULL) retSkb = pHandle->tx((PVOID)&pAd->MatCfg, RTPKT_TO_OSPKT(pPkt), pLayerHdr, pMacAddr); return retSkb; } } return retSkb; }
static __u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item) { if ((end - start) > 0) { __u8 b = *start++; item->type = (b >> 2) & 3; item->tag = (b >> 4) & 15; if (item->tag == HID_ITEM_TAG_LONG) { item->format = HID_ITEM_FORMAT_LONG; if ((end - start) >= 2) { item->size = *start++; item->tag = *start++; if ((end - start) >= item->size) { item->data.longdata = start; start += item->size; return start; } } } else { item->format = HID_ITEM_FORMAT_SHORT; item->size = b & 3; switch (item->size) { case 0: return start; case 1: if ((end - start) >= 1) { item->data.u8 = *start++; return start; } break; case 2: if ((end - start) >= 2) { item->data.u16 = le16_to_cpu(get_unaligned((__u16*)start)); start = (__u8 *)((__u16 *)start + 1); return start; } case 3: item->size++; if ((end - start) >= 4) { item->data.u32 = le32_to_cpu(get_unaligned((__u32*)start)); start = (__u8 *)((__u32 *)start + 1); return start; } } } }
void alx_set_macaddr(struct alx_hw *hw, const u8 *addr) { u32 val; /* for example: 00-0B-6A-F6-00-DC * STAD0=6AF600DC, STAD1=000B */ val = be32_to_cpu(get_unaligned((__be32 *)(addr + 2))); alx_write_mem32(hw, ALX_STAD0, val); val = be16_to_cpu(get_unaligned((__be16 *)addr)); alx_write_mem32(hw, ALX_STAD1, val); }
const uint8_t * romfs_get_file_by_hash(const uint8_t * romfs, uint32_t h, uint32_t * len) { const uint8_t * meta; for (meta = romfs; get_unaligned(meta) && get_unaligned(meta + 4); meta += get_unaligned(meta + 4) + 12) { if (get_unaligned(meta) == h) { if (len) { *len = get_unaligned(meta + 4); } return meta + 12; } } return NULL; }
static void downmix_to_mono(struct sco_stream_out *out, const uint8_t *buffer, size_t frame_num) { const int16_t *input = (const void *) buffer; int16_t *output = (void *) out->downmix_buf; size_t i; for (i = 0; i < frame_num; i++) { int16_t l = le16_to_cpu(get_unaligned(&input[i * 2])); int16_t r = le16_to_cpu(get_unaligned(&input[i * 2 + 1])); put_unaligned(cpu_to_le16((l + r) >> 1), &output[i]); } }
static inline unsigned int hash_superfast(const char *key, unsigned int len) { /* Paul Hsieh (http://www.azillionmonkeys.com/qed/hash.html) * used by WebCore (http://webkit.org/blog/8/hashtables-part-2/) * EFL's eina and possible others. */ unsigned int tmp, hash = len, rem = len & 3; len /= 4; /* Main loop */ for (; len > 0; len--) { hash += get_unaligned((uint16_t *) key); tmp = (get_unaligned((uint16_t *)(key + 2)) << 11) ^ hash; hash = (hash << 16) ^ tmp; key += 4; hash += hash >> 11; } /* Handle end cases */ switch (rem) { case 3: hash += get_unaligned((uint16_t *) key); hash ^= hash << 16; hash ^= key[2] << 18; hash += hash >> 11; break; case 2: hash += get_unaligned((uint16_t *) key); hash ^= hash << 11; hash += hash >> 17; break; case 1: hash += *key; hash ^= hash << 10; hash += hash >> 1; } /* Force "avalanching" of final 127 bits */ hash ^= hash << 3; hash += hash >> 5; hash ^= hash << 4; hash += hash >> 17; hash ^= hash << 25; hash += hash >> 6; return hash; }
/* * si470x_get_rds_registers - read rds registers */ static int si470x_get_rds_registers(struct si470x_device *radio) { unsigned char buf[RDS_REPORT_SIZE]; int retval; int size; unsigned char regnr; buf[0] = RDS_REPORT; retval = usb_interrupt_msg(radio->usbdev, usb_rcvintpipe(radio->usbdev, 1), (void *) &buf, sizeof(buf), &size, usb_timeout); if (size != sizeof(buf)) printk(KERN_WARNING DRIVER_NAME ": si470x_get_rds_registers: " "return size differs: %d != %zu\n", size, sizeof(buf)); if (retval < 0) printk(KERN_WARNING DRIVER_NAME ": si470x_get_rds_registers: " "usb_interrupt_msg returned %d\n", retval); if (retval >= 0) for (regnr = 0; regnr < RDS_REGISTER_NUM; regnr++) radio->registers[STATUSRSSI + regnr] = be16_to_cpu(get_unaligned((unsigned short *) &buf[regnr * RADIO_REGISTER_SIZE + 1])); return (retval < 0) ? -EINVAL : 0; }
static off_t romfs_seek(void * opaque, off_t offset, int whence) { struct romfs_fds_t * f = (struct romfs_fds_t *) opaque; const uint8_t * size_p = f->file - 4; uint32_t size = get_unaligned(size_p); uint32_t origin; switch (whence) { case SEEK_SET: origin = 0; break; case SEEK_CUR: origin = f->cursor; break; case SEEK_END: origin = size; break; default: return -1; } offset = origin + offset; if (offset < 0) return -1; if (offset > size) offset = size; f->cursor = offset; return offset; }
/** * This function writes a packet into the Tx FIFO associated with the * EP. For non-periodic EPs the non-periodic Tx FIFO is written. For * periodic EPs the periodic Tx FIFO associated with the EP is written * with all packets for the next micro-frame. * * @param _core_if Programming view of DWC_otg controller. * @param _ep The EP to write packet for. * @param _dma Indicates if DMA is being used. */ void dwc_otg_ep_write_packet( dwc_ep_t *_ep) { /** * The buffer is padded to DWORD on a per packet basis in * slave/dma mode if the MPS is not DWORD aligned. The last * packet, if short, is also padded to a multiple of DWORD. * * ep->xfer_buff always starts DWORD aligned in memory and is a * multiple of DWORD in length * * ep->xfer_len can be any number of bytes * * ep->xfer_count is a multiple of ep->maxpacket until the last * packet * * FIFO access is DWORD */ uint32_t i; uint32_t byte_count; uint32_t dword_count; uint32_t fifo; uint8_t *data_buff = _ep->xfer_buff; uint32_t temp_data ; //DBG("dwc_otg_ep_write_packet() : %d\n",_ep->xfer_len); if (_ep->xfer_count >= _ep->xfer_len) { //DWC_WARN("%s() No data for EP%d!!!\n", "dwc_otg_ep_write_packet", _ep->num); return; } /* Find the byte length of the packet either short packet or MPS */ if ((_ep->xfer_len - _ep->xfer_count) < _ep->maxpacket) { byte_count = _ep->xfer_len - _ep->xfer_count; } else { byte_count = _ep->maxpacket; } /* Find the DWORD length, padded by extra bytes as neccessary if MPS * is not a multiple of DWORD */ dword_count = (byte_count + 3) / 4; //fifo = _core_if->data_fifo[_ep->num]; fifo = DWC_REG_DATA_FIFO(_ep->num); for (i=0; i<dword_count; i++) { temp_data =get_unaligned(data_buff); dwc_write_reg32( fifo, temp_data ); data_buff += 4; } _ep->xfer_count += byte_count; _ep->xfer_buff += byte_count; flush_cpu_cache(); }
static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) { l2cap_hdr *lh = (l2cap_hdr *) skb->data; __u16 cid, psm, len; skb_pull(skb, L2CAP_HDR_SIZE); cid = __le16_to_cpu(lh->cid); len = __le16_to_cpu(lh->len); BT_DBG("len %d, cid 0x%4.4x", len, cid); switch (cid) { case 0x0001: l2cap_sig_channel(conn, skb); break; case 0x0002: psm = get_unaligned((__u16 *) skb->data); skb_pull(skb, 2); l2cap_conless_channel(conn, psm, skb); break; default: l2cap_data_channel(conn, cid, skb); break; } }
static int uniphier_sd_pio_write_one_block(struct udevice *dev, const u32 **pbuf, uint blocksize) { struct uniphier_sd_priv *priv = dev_get_priv(dev); int i, ret; /* wait until the buffer becomes empty */ ret = uniphier_sd_wait_for_irq(dev, UNIPHIER_SD_INFO2, UNIPHIER_SD_INFO2_BWE); if (ret) return ret; writel(0, priv->regbase + UNIPHIER_SD_INFO2); if (likely(IS_ALIGNED((unsigned long)*pbuf, 4))) { for (i = 0; i < blocksize / 4; i++) writel(*(*pbuf)++, priv->regbase + UNIPHIER_SD_BUF); } else { for (i = 0; i < blocksize / 4; i++) writel(get_unaligned((*pbuf)++), priv->regbase + UNIPHIER_SD_BUF); } return 0; }
static void nft_byteorder_eval(const struct nft_expr *expr, struct nft_regs *regs, const struct nft_pktinfo *pkt) { const struct nft_byteorder *priv = nft_expr_priv(expr); u32 *src = ®s->data[priv->sreg]; u32 *dst = ®s->data[priv->dreg]; union { u32 u32; u16 u16; } *s, *d; unsigned int i; s = (void *)src; d = (void *)dst; switch (priv->size) { case 8: { u64 src64; switch (priv->op) { case NFT_BYTEORDER_NTOH: for (i = 0; i < priv->len / 8; i++) { src64 = get_unaligned((u64 *)&src[i]); put_unaligned_be64(src64, &dst[i]); } break; case NFT_BYTEORDER_HTON: for (i = 0; i < priv->len / 8; i++) { src64 = get_unaligned_be64(&src[i]); put_unaligned(src64, (u64 *)&dst[i]); } break; } break; } case 4: switch (priv->op) { case NFT_BYTEORDER_NTOH: for (i = 0; i < priv->len / 4; i++) d[i].u32 = ntohl((__force __be32)s[i].u32); break; case NFT_BYTEORDER_HTON: for (i = 0; i < priv->len / 4; i++) d[i].u32 = (__force __u32)htonl(s[i].u32); break; } break; case 2: switch (priv->op) { case NFT_BYTEORDER_NTOH: for (i = 0; i < priv->len / 2; i++) d[i].u16 = ntohs((__force __be16)s[i].u16); break; case NFT_BYTEORDER_HTON: for (i = 0; i < priv->len / 2; i++) d[i].u16 = (__force __u16)htons(s[i].u16); break; } break; } }
static void downmix_to_mono(struct a2dp_stream_out *out, const uint8_t *buffer, size_t bytes) { const int16_t *input = (const void *) buffer; int16_t *output = (void *) out->downmix_buf; size_t i, frames; /* PCM 16bit stereo */ frames = bytes / (2 * sizeof(int16_t)); for (i = 0; i < frames; i++) { int16_t l = le16_to_cpu(get_unaligned(&input[i * 2])); int16_t r = le16_to_cpu(get_unaligned(&input[i * 2 + 1])); put_unaligned(cpu_to_le16((l + r) / 2), &output[i]); } }
/* * Get <addr,port> from the string "xxx.xxx.xxx.xxx,ppp,ppp", started * with the "pattern" and terminated with the "term" character. * <addr,port> is in network order. */ static int ip_vs_ftp_get_addrport(char *data, char *data_limit, const char *pattern, size_t plen, char term, __be32 *addr, __be16 *port, char **start, char **end) { unsigned char p[6]; int i = 0; if (data_limit - data < plen) { /* check if there is partial match */ if (strnicmp(data, pattern, data_limit - data) == 0) return -1; else return 0; } if (strnicmp(data, pattern, plen) != 0) { return 0; } *start = data + plen; for (data = *start; *data != term; data++) { if (data == data_limit) return -1; } *end = data; memset(p, 0, sizeof(p)); for (data = *start; data != *end; data++) { if (*data >= '0' && *data <= '9') { p[i] = p[i]*10 + *data - '0'; } else if (*data == ',' && i < 5) { i++; } else { /* unexpected character */ return -1; } } if (i != 5) return -1; *addr = get_unaligned((__be32 *)p); *port = get_unaligned((__be16 *)(p + 4)); return 1; }
static int usbduxsigma_ai_insn_read(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { struct usbduxsigma_private *devpriv = dev->private; unsigned int chan = CR_CHAN(insn->chanspec); uint8_t muxsg0 = 0; uint8_t muxsg1 = 0; uint8_t sysred = 0; int ret; int i; down(&devpriv->sem); if (devpriv->ai_cmd_running) { up(&devpriv->sem); return -EBUSY; } create_adc_command(chan, &muxsg0, &muxsg1); /* Mode 0 is used to get a single conversion on demand */ devpriv->dux_commands[1] = 0x16; /* CONFIG0: chopper on */ devpriv->dux_commands[2] = 0x80; /* CONFIG1: 2kHz sampling rate */ devpriv->dux_commands[3] = 0x00; /* CONFIG3: diff. channels off */ devpriv->dux_commands[4] = muxsg0; devpriv->dux_commands[5] = muxsg1; devpriv->dux_commands[6] = sysred; /* adc commands */ ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD); if (ret < 0) { up(&devpriv->sem); return ret; } for (i = 0; i < insn->n; i++) { uint32_t val; ret = usbduxsigma_receive_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD); if (ret < 0) { up(&devpriv->sem); return ret; } /* 32 bits big endian from the A/D converter */ val = be32_to_cpu(get_unaligned((__be32 *)(devpriv->insn_buf + 1))); val &= 0x00ffffff; /* strip status byte */ val ^= 0x00800000; /* convert to unsigned */ data[i] = val; } up(&devpriv->sem); return insn->n; }
static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer, unsigned int length) { int i; struct zd_mac *mac = zd_usb_to_mac(usb); const struct rx_length_info *length_info; if (length < sizeof(struct rx_length_info)) { /* It's not a complete packet anyhow. */ struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac); ieee->stats.rx_errors++; ieee->stats.rx_length_errors++; return; } length_info = (struct rx_length_info *) (buffer + length - sizeof(struct rx_length_info)); /* It might be that three frames are merged into a single URB * transaction. We have to check for the length info tag. * * While testing we discovered that length_info might be unaligned, * because if USB transactions are merged, the last packet will not * be padded. Unaligned access might also happen if the length_info * structure is not present. */ if (get_unaligned(&length_info->tag) == cpu_to_le16(RX_LENGTH_INFO_TAG)) { unsigned int l, k, n; for (i = 0, l = 0;; i++) { k = le16_to_cpu(get_unaligned(&length_info->length[i])); if (k == 0) return; n = l+k; if (n > length) return; zd_mac_rx_irq(mac, buffer+l, k); if (i >= 2) return; l = (n+3) & ~3; } } else { zd_mac_rx_irq(mac, buffer, length); } }
/* Command Complete OGF LINK_POLICY */ static void hci_cc_link_policy(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb) { struct hci_conn *conn; struct hci_rp_role_discovery *rd; struct hci_rp_write_link_policy *lp; void *sent; BT_DBG("%s ocf 0x%x", hdev->name, ocf); switch (ocf) { case OCF_ROLE_DISCOVERY: rd = (void *) skb->data; if (rd->status) break; hci_dev_lock(hdev); conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rd->handle)); if (conn) { if (rd->role) conn->link_mode &= ~HCI_LM_MASTER; else conn->link_mode |= HCI_LM_MASTER; } hci_dev_unlock(hdev); break; case OCF_WRITE_LINK_POLICY: sent = hci_sent_cmd_data(hdev, OGF_LINK_POLICY, OCF_WRITE_LINK_POLICY); if (!sent) break; lp = (struct hci_rp_write_link_policy *) skb->data; if (lp->status) break; hci_dev_lock(hdev); conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(lp->handle)); if (conn) { __le16 policy = get_unaligned((__le16 *) (sent + 2)); conn->link_policy = __le16_to_cpu(policy); } hci_dev_unlock(hdev); break; default: BT_DBG("%s: Command complete: ogf LINK_POLICY ocf %x", hdev->name, ocf); break; } }
const uint8_t * romfs_get_file_by_hash(const uint8_t * romfs, uint32_t h, uint32_t * len) { const uint8_t * meta; uint32_t hash; uint32_t flen; meta = romfs; do { hash = get_unaligned(meta); flen = get_unaligned(meta + 4); if (hash == h) { if (len) *len = get_unaligned(meta + 4); return meta + 8; } meta += flen + 8; } while ((hash != 0) || (flen != 0)); return NULL; }
static int bnep_rx_frame(struct bnep_session *s, struct sk_buff *skb) { struct net_device *dev = s->dev; struct sk_buff *nskb; u8 type, ctrl_type; dev->stats.rx_bytes += skb->len; type = *(u8 *) skb->data; skb_pull(skb, 1); ctrl_type = *(u8 *)skb->data; if ((type & BNEP_TYPE_MASK) >= sizeof(__bnep_rx_hlen)) goto badframe; if ((type & BNEP_TYPE_MASK) == BNEP_CONTROL) { if (bnep_rx_control(s, skb->data, skb->len) < 0) { dev->stats.tx_errors++; kfree_skb(skb); return 0; } if (!(type & BNEP_EXT_HEADER)) { kfree_skb(skb); return 0; } /* Verify and pull ctrl message since it's already processed */ switch (ctrl_type) { case BNEP_SETUP_CONN_REQ: /* Pull: ctrl type (1 b), len (1 b), data (len bytes) */ if (!skb_pull(skb, 2 + *(u8 *)(skb->data + 1) * 2)) goto badframe; break; case BNEP_FILTER_MULTI_ADDR_SET: case BNEP_FILTER_NET_TYPE_SET: /* Pull: ctrl type (1 b), len (2 b), data (len bytes) */ if (!skb_pull(skb, 3 + *(u16 *)(skb->data + 1) * 2)) goto badframe; break; default: kfree_skb(skb); return 0; } } else { skb_reset_mac_header(skb); /* Verify and pull out header */ if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK])) goto badframe; s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2)); } if (type & BNEP_EXT_HEADER) {
/* return offset of the body of @idx-th entry in @coord */ static unsigned int offset_of(const coord_t * coord /* coord of item */ , int idx /* index of unit */ ) { if (idx < units(coord)) return le16_to_cpu(get_unaligned(&header_at(coord, idx)->offset)); else if (idx == units(coord)) return item_length_by_coord(coord); else impossible("nikita-1308", "Wrong idx"); return 0; }
/* Number of completed packets */ static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb) { struct hci_ev_num_comp_pkts *ev = (struct hci_ev_num_comp_pkts *) skb->data; __le16 *ptr; int i; skb_pull(skb, sizeof(*ev)); BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl); if (skb->len < ev->num_hndl * 4) { BT_DBG("%s bad parameters", hdev->name); return; } tasklet_disable(&hdev->tx_task); for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) { struct hci_conn *conn; __u16 handle, count; handle = __le16_to_cpu(get_unaligned(ptr++)); count = __le16_to_cpu(get_unaligned(ptr++)); conn = hci_conn_hash_lookup_handle(hdev, handle); if (conn) { conn->sent -= count; if (conn->type == SCO_LINK) { if ((hdev->sco_cnt += count) > hdev->sco_pkts) hdev->sco_cnt = hdev->sco_pkts; } else { if ((hdev->acl_cnt += count) > hdev->acl_pkts) hdev->acl_cnt = hdev->acl_pkts; } } } hci_sched_tx(hdev); tasklet_enable(&hdev->tx_task); }
static void ataid_complete(struct aoedev *d, unsigned char *id) { u64 ssize; u16 n; /* word 83: command set supported */ n = le16_to_cpu(get_unaligned((__le16 *) &id[83<<1])); /* word 86: command set/feature enabled */ n |= le16_to_cpu(get_unaligned((__le16 *) &id[86<<1])); if (n & (1<<10)) { /* bit 10: LBA 48 */ d->flags |= DEVFL_EXT; /* word 100: number lba48 sectors */ ssize = le64_to_cpu(get_unaligned((__le64 *) &id[100<<1])); /* set as in ide-disk.c:init_idedisk_capacity */ d->geo.cylinders = ssize; d->geo.cylinders /= (255 * 63); d->geo.heads = 255; d->geo.sectors = 63; } else { d->flags &= ~DEVFL_EXT; /* number lba28 sectors */ ssize = le32_to_cpu(get_unaligned((__le32 *) &id[60<<1])); /* NOTE: obsolete in ATA 6 */ d->geo.cylinders = le16_to_cpu(get_unaligned((__le16 *) &id[54<<1])); d->geo.heads = le16_to_cpu(get_unaligned((__le16 *) &id[55<<1])); d->geo.sectors = le16_to_cpu(get_unaligned((__le16 *) &id[56<<1])); } if (d->ssize != ssize) printk(KERN_INFO "aoe: %012llx e%lu.%lu v%04x has %llu sectors\n", (unsigned long long)mac_addr(d->addr), d->aoemajor, d->aoeminor, d->fw_ver, (long long)ssize); d->ssize = ssize; d->geo.start = 0; if (d->gd != NULL) { d->gd->capacity = ssize; d->flags |= DEVFL_NEWSIZE; } else { if (d->flags & DEVFL_GDALLOC) { printk(KERN_ERR "aoe: can't schedule work for e%lu.%lu, %s\n", d->aoemajor, d->aoeminor, "it's already on! This shouldn't happen.\n"); return; } d->flags |= DEVFL_GDALLOC; } schedule_work(&d->work); }
static __u8 * find_end_of_eof_list(__u8 * ptr, __u8 * limit) { while (ptr + 3 < limit) { if (get_unaligned((__u32*)ptr)) { ptr += sizeof(__u32); } else { return ptr; } } return NULL; }
/* Determine ether protocol. Based on eth_type_trans. */ static inline u16 bnep_net_eth_proto(struct sk_buff *skb) { struct ethhdr *eh = (void *) skb->data; if (ntohs(eh->h_proto) >= 1536) return eh->h_proto; if (get_unaligned((u16 *) skb->data) == 0xFFFF) return htons(ETH_P_802_3); return htons(ETH_P_802_2); }
/* Refer to school510587's implementation*/ void romfs_mount(void * mountpoint, struct fs_info *file_info) { uint8_t * p = (uint8_t *)mountpoint; if (!mountpoint) return NULL; p += 4; file_info->name = (const char *)p; fio_write(1, "\nhashing", 8); return get_unaligned(p) ? p : NULL; }
static void adj_offset(const coord_t * coord /* coord of item */ , int idx /* index of unit */ , int delta /* offset change */ ) { d16 *doffset; __u16 offset; doffset = &header_at(coord, idx)->offset; offset = le16_to_cpu(get_unaligned(doffset)); offset += delta; put_unaligned(cpu_to_le16((__u16) offset), doffset); }
unsigned long bfin_get_addr_from_rp(unsigned long *ptr, unsigned long relval, unsigned long flags, unsigned long *persistent) { unsigned short *usptr = (unsigned short *)ptr; int type = (relval >> 26) & 7; unsigned long val; switch (type) { case FLAT_BFIN_RELOC_TYPE_16_BIT: case FLAT_BFIN_RELOC_TYPE_16H_BIT: usptr = (unsigned short *)ptr; pr_debug("*usptr = %x", get_unaligned(usptr)); val = get_unaligned(usptr); val += *persistent; break; case FLAT_BFIN_RELOC_TYPE_32_BIT: pr_debug("*ptr = %lx", get_unaligned(ptr)); val = get_unaligned(ptr); break; default: pr_debug("BINFMT_FLAT: Unknown relocation type %x\n", type); return 0; } /* * Stack-relative relocs contain the offset into the stack, we * have to add the stack's start address here and return 1 from * flat_addr_absolute to prevent the normal address calculations */ if (relval & (1 << 29)) return val + current->mm->context.end_brk; if ((flags & FLAT_FLAG_GOTPIC) == 0) val = htonl(val); return val; }
static ssize_t romfs_read(void * opaque, void * buf, size_t count) { struct romfs_fds_t * f = (struct romfs_fds_t *) opaque; const uint8_t * size_p = f->file - 4; uint32_t size = get_unaligned(size_p); if ((f->cursor + count) > size) count = size - f->cursor; memcpy(buf, f->file + f->cursor, count); f->cursor += count; return count; }
/* Determine ether protocol. Based on eth_type_trans. */ static inline u16 bnep_net_eth_proto(struct sk_buff *skb) { struct ethhdr *eh = (void *) skb->data; u16 proto = ntohs(eh->h_proto); if (proto >= 1536) return proto; if (get_unaligned((__be16 *) skb->data) == htons(0xFFFF)) return ETH_P_802_3; return ETH_P_802_2; }