atomic_cmpxchg(&net_device->refcnt, 0, 2);
net_device->dev = device;
- device->Extension = net_device;
+ device->ext = net_device;
return net_device;
}
static void free_net_device(struct netvsc_device *device)
{
WARN_ON(atomic_read(&device->refcnt) == 0);
- device->dev->Extension = NULL;
+ device->dev->ext = NULL;
kfree(device);
}
{
struct netvsc_device *net_device;
- net_device = device->Extension;
+ net_device = device->ext;
if (net_device && atomic_read(&net_device->refcnt) > 1)
atomic_inc(&net_device->refcnt);
else
{
struct netvsc_device *net_device;
- net_device = device->Extension;
+ net_device = device->ext;
if (net_device && atomic_read(&net_device->refcnt))
atomic_inc(&net_device->refcnt);
else
{
struct netvsc_device *net_device;
- net_device = device->Extension;
+ net_device = device->ext;
/* ASSERT(netDevice); */
atomic_dec(&net_device->refcnt);
{
struct netvsc_device *net_device;
- net_device = device->Extension;
+ net_device = device->ext;
if (net_device == NULL)
return NULL;
{
struct netvsc_device *net_device;
- net_device = device->Extension;
+ net_device = device->ext;
if (net_device == NULL)
return NULL;
while (atomic_cmpxchg(&net_device->refcnt, 1, 0) != 1)
udelay(100);
- device->Extension = NULL;
+ device->ext = NULL;
return net_device;
}
/* ASSERT(driver->RingBufferSize >= (PAGE_SIZE << 1)); */
drv->name = driver_name;
- memcpy(&drv->deviceType, &netvsc_device_type, sizeof(struct hv_guid));
+ memcpy(&drv->dev_type, &netvsc_device_type, sizeof(struct hv_guid));
/* Make sure it is set by the caller */
/* FIXME: These probably should still be tested in some way */
/* ASSERT(driver->OnLinkStatusChanged); */
/* Setup the dispatch table */
- driver->base.OnDeviceAdd = netvsc_device_add;
- driver->base.OnDeviceRemove = netvsc_device_remove;
- driver->base.OnCleanup = netvsc_cleanup;
+ driver->base.dev_add = netvsc_device_add;
+ driver->base.dev_rm = netvsc_device_remove;
+ driver->base.cleanup = netvsc_cleanup;
driver->send = netvsc_send;
ret = vmbus_sendpacket(device->channel, init_packet,
sizeof(struct nvsp_message),
(unsigned long)init_packet,
- VmbusPacketTypeDataInBand,
+ VM_PKT_DATA_INBAND,
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
if (ret != 0) {
DPRINT_ERR(NETVSC,
ret = vmbus_sendpacket(device->channel, init_packet,
sizeof(struct nvsp_message),
(unsigned long)init_packet,
- VmbusPacketTypeDataInBand,
+ VM_PKT_DATA_INBAND,
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
if (ret != 0) {
DPRINT_ERR(NETVSC,
revoke_packet,
sizeof(struct nvsp_message),
(unsigned long)revoke_packet,
- VmbusPacketTypeDataInBand, 0);
+ VM_PKT_DATA_INBAND, 0);
/*
* If we failed here, we might as well return and
* have a leak rather than continue and a bugchk
revoke_packet,
sizeof(struct nvsp_message),
(unsigned long)revoke_packet,
- VmbusPacketTypeDataInBand, 0);
+ VM_PKT_DATA_INBAND, 0);
/*
* If we failed here, we might as well return and have a leak
* rather than continue and a bugchk
ret = vmbus_sendpacket(device->channel, init_packet,
sizeof(struct nvsp_message),
(unsigned long)init_packet,
- VmbusPacketTypeDataInBand,
+ VM_PKT_DATA_INBAND,
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
if (ret != 0) {
ret = vmbus_sendpacket(device->channel, init_packet,
sizeof(struct nvsp_message),
(unsigned long)init_packet,
- VmbusPacketTypeDataInBand, 0);
+ VM_PKT_DATA_INBAND, 0);
if (ret != 0) {
DPRINT_ERR(NETVSC,
"unable to send NvspMessage1TypeSendNdisVersion");
struct netvsc_device *net_device;
struct hv_netvsc_packet *packet, *pos;
struct netvsc_driver *net_driver =
- (struct netvsc_driver *)device->Driver;
+ (struct netvsc_driver *)device->drv;
net_device = alloc_net_device(device);
if (!net_device) {
struct hv_netvsc_packet *netvsc_packet, *pos;
DPRINT_INFO(NETVSC, "Disabling outbound traffic on net device (%p)...",
- device->Extension);
+ device->ext);
/* Stop outbound traffic ie sends and receives completions */
net_device = release_outbound_net_device(device);
NetVscDisconnectFromVsp(net_device);
DPRINT_INFO(NETVSC, "Disabling inbound traffic on net device (%p)...",
- device->Extension);
+ device->ext);
/* Stop inbound traffic ie receives and sends completions */
net_device = release_inbound_net_device(device);
}
nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
- (packet->DataOffset8 << 3));
+ (packet->offset8 << 3));
DPRINT_DBG(NETVSC, "send completion packet - type %d",
nvsp_packet->hdr.msg_type);
NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) {
/* Get the send context */
nvsc_packet = (struct hv_netvsc_packet *)(unsigned long)
- packet->TransactionId;
+ packet->trans_id;
/* ASSERT(nvscPacket); */
/* Notify the layer above us */
ret = vmbus_sendpacket(device->channel, &sendMessage,
sizeof(struct nvsp_message),
(unsigned long)packet,
- VmbusPacketTypeDataInBand,
+ VM_PKT_DATA_INBAND,
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
}
* All inbound packets other than send completion should be xfer page
* packet
*/
- if (packet->Type != VmbusPacketTypeDataUsingTransferPages) {
+ if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) {
DPRINT_ERR(NETVSC, "Unknown packet type received - %d",
- packet->Type);
+ packet->type);
put_net_device(device);
return;
}
nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
- (packet->DataOffset8 << 3));
+ (packet->offset8 << 3));
/* Make sure this is a valid nvsp packet */
if (nvsp_packet->hdr.msg_type !=
vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet;
- if (vmxferpage_packet->TransferPageSetId != NETVSC_RECEIVE_BUFFER_ID) {
+ if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) {
DPRINT_ERR(NETVSC, "Invalid xfer page set id - "
"expecting %x got %x", NETVSC_RECEIVE_BUFFER_ID,
- vmxferpage_packet->TransferPageSetId);
+ vmxferpage_packet->xfer_pageset_id);
put_net_device(device);
return;
}
DPRINT_DBG(NETVSC, "xfer page - range count %d",
- vmxferpage_packet->RangeCount);
+ vmxferpage_packet->range_cnt);
/*
* Grab free packets (range count + 1) to represent this xfer
spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
while (!list_empty(&net_device->recv_pkt_list)) {
list_move_tail(net_device->recv_pkt_list.next, &listHead);
- if (++count == vmxferpage_packet->RangeCount + 1)
+ if (++count == vmxferpage_packet->range_cnt + 1)
break;
}
spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
if (count < 2) {
DPRINT_ERR(NETVSC, "Got only %d netvsc pkt...needed %d pkts. "
"Dropping this xfer page packet completely!",
- count, vmxferpage_packet->RangeCount + 1);
+ count, vmxferpage_packet->range_cnt + 1);
/* Return it to the freelist */
spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
flags);
netvsc_send_recv_completion(device,
- vmxferpage_packet->d.TransactionId);
+ vmxferpage_packet->d.trans_id);
put_net_device(device);
return;
/* ASSERT(xferpagePacket->Count > 0 && xferpagePacket->Count <= */
/* vmxferpagePacket->RangeCount); */
- if (xferpage_packet->count != vmxferpage_packet->RangeCount) {
+ if (xferpage_packet->count != vmxferpage_packet->range_cnt) {
DPRINT_INFO(NETVSC, "Needed %d netvsc pkts to satisy this xfer "
- "page...got %d", vmxferpage_packet->RangeCount,
+ "page...got %d", vmxferpage_packet->range_cnt,
xferpage_packet->count);
}
netvsc_packet->device = device;
/* Save this so that we can send it back */
netvsc_packet->completion.recv.recv_completion_tid =
- vmxferpage_packet->d.TransactionId;
+ vmxferpage_packet->d.trans_id;
netvsc_packet->total_data_buflen =
- vmxferpage_packet->Ranges[i].ByteCount;
+ vmxferpage_packet->ranges[i].byte_count;
netvsc_packet->page_buf_cnt = 1;
/* ASSERT(vmxferpagePacket->Ranges[i].ByteOffset + */
/* vmxferpagePacket->Ranges[i].ByteCount < */
/* netDevice->ReceiveBufferSize); */
- netvsc_packet->page_buf[0].Length =
- vmxferpage_packet->Ranges[i].ByteCount;
+ netvsc_packet->page_buf[0].len =
+ vmxferpage_packet->ranges[i].byte_count;
start = virt_to_phys((void *)((unsigned long)net_device->
- recv_buf + vmxferpage_packet->Ranges[i].ByteOffset));
+ recv_buf + vmxferpage_packet->ranges[i].byte_offset));
- netvsc_packet->page_buf[0].Pfn = start >> PAGE_SHIFT;
+ netvsc_packet->page_buf[0].pfn = start >> PAGE_SHIFT;
end_virtual = (unsigned long)net_device->recv_buf
- + vmxferpage_packet->Ranges[i].ByteOffset
- + vmxferpage_packet->Ranges[i].ByteCount - 1;
+ + vmxferpage_packet->ranges[i].byte_offset
+ + vmxferpage_packet->ranges[i].byte_count - 1;
end = virt_to_phys((void *)end_virtual);
/* Calculate the page relative offset */
- netvsc_packet->page_buf[0].Offset =
- vmxferpage_packet->Ranges[i].ByteOffset &
+ netvsc_packet->page_buf[0].offset =
+ vmxferpage_packet->ranges[i].byte_offset &
(PAGE_SIZE - 1);
if ((end >> PAGE_SHIFT) != (start >> PAGE_SHIFT)) {
/* Handle frame across multiple pages: */
- netvsc_packet->page_buf[0].Length =
- (netvsc_packet->page_buf[0].Pfn <<
+ netvsc_packet->page_buf[0].len =
+ (netvsc_packet->page_buf[0].pfn <<
PAGE_SHIFT)
+ PAGE_SIZE - start;
bytes_remain = netvsc_packet->total_data_buflen -
- netvsc_packet->page_buf[0].Length;
+ netvsc_packet->page_buf[0].len;
for (j = 1; j < NETVSC_PACKET_MAXPAGE; j++) {
- netvsc_packet->page_buf[j].Offset = 0;
+ netvsc_packet->page_buf[j].offset = 0;
if (bytes_remain <= PAGE_SIZE) {
- netvsc_packet->page_buf[j].Length =
+ netvsc_packet->page_buf[j].len =
bytes_remain;
bytes_remain = 0;
} else {
- netvsc_packet->page_buf[j].Length =
+ netvsc_packet->page_buf[j].len =
PAGE_SIZE;
bytes_remain -= PAGE_SIZE;
}
- netvsc_packet->page_buf[j].Pfn =
+ netvsc_packet->page_buf[j].pfn =
virt_to_phys((void *)(end_virtual -
bytes_remain)) >> PAGE_SHIFT;
netvsc_packet->page_buf_cnt++;
}
DPRINT_DBG(NETVSC, "[%d] - (abs offset %u len %u) => "
"(pfn %llx, offset %u, len %u)", i,
- vmxferpage_packet->Ranges[i].ByteOffset,
- vmxferpage_packet->Ranges[i].ByteCount,
- netvsc_packet->page_buf[0].Pfn,
- netvsc_packet->page_buf[0].Offset,
- netvsc_packet->page_buf[0].Length);
+ vmxferpage_packet->ranges[i].byte_offset,
+ vmxferpage_packet->ranges[i].byte_count,
+ netvsc_packet->page_buf[0].pfn,
+ netvsc_packet->page_buf[0].offset,
+ netvsc_packet->page_buf[0].len);
/* Pass it to the upper layer */
- ((struct netvsc_driver *)device->Driver)->
+ ((struct netvsc_driver *)device->drv)->
recv_cb(device, netvsc_packet);
netvsc_receive_completion(netvsc_packet->
/* Send the completion */
ret = vmbus_sendpacket(device->channel, &recvcompMessage,
sizeof(struct nvsp_message), transaction_id,
- VmbusPacketTypeCompletion, 0);
+ VM_PKT_COMP, 0);
if (ret == 0) {
/* success */
/* no-op */
bytes_recvd, request_id);
desc = (struct vmpacket_descriptor *)buffer;
- switch (desc->Type) {
- case VmbusPacketTypeCompletion:
+ switch (desc->type) {
+ case VM_PKT_COMP:
netvsc_send_completion(device, desc);
break;
- case VmbusPacketTypeDataUsingTransferPages:
+ case VM_PKT_DATA_USING_XFER_PAGES:
netvsc_receive(device, desc);
break;
DPRINT_ERR(NETVSC,
"unhandled packet type %d, "
"tid %llx len %d\n",
- desc->Type, request_id,
+ desc->type, request_id,
bytes_recvd);
break;
}
projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blobdiff