Aros/开发人员/USBDriversDev
< Aros
要编写驱动程序，您首先需要了解 Exec 信号、消息、IO 请求和列表。
对于驱动程序（通常是设备），只有几个“函数”DoIO、SendIO 等。细节在 IO 请求字段中。查看 VUSBHCI 驱动程序。没有硬件内容，只有针对 Poseidon 驱动程序和 libusb 的高级代码。
VUSBHCI 也更易读，因为所有内容都以结构形式清晰可见。您将识别出其中的 usb 规范内容以及内容是如何传递的。
Poseidon 是主要的 USB 代码，它本身不知道硬件的任何信息。驱动程序代码附加到它。Poseidon 负责所有首选项、类和驱动程序。驱动程序只尝试满足来自 Poseidon 或更具体地说是其类的更高级请求。
每个驱动程序都必须有一个 roothub，根据 usb 规范。Roothub 代表您的硬件。Roothub 有端口，这些是主机控制器拥有的物理端口（不必如此……您也可以实现虚拟端口并让虚拟设备连接）
hub.class 调用您的 roothub，您的驱动程序必须响应 roothub 请求。所有这些都在 usb 规范中。Poseidon 尚未了解 usb 3.x 请求的任何信息。驱动程序还响应对物理设备的请求并在主机和设备之间传递消息。
EHCI 主机控制器必须在其相应的 PCI 插槽上具有伴侣控制器，否则它不知道哪个端口是其伴侣端口并且无法释放其端口（它需要事先知道该端口是否有伴侣端口……）。在 poseidon 上，只有一个 PCIUSB 驱动程序，所有这些主机都在单个驱动程序上，并且使用了一些技巧来进行端口转发，但它们不必在同一个驱动程序上。芯片组能够检测到何时释放端口，伴侣主机控制器将自动接管该端口。
当前的 AROS XHCI 驱动程序代码可以从主机控制器中找到 USB3 和 USB2 端口，并为它们以及相应的 roothub 创建端口列表。在某些主板上，XHCI 可能在其控制器上只有 USB3 端口，还有一个真正的 EHCI 芯片，并且 usb 数据线通过数字 MUX 指向。
来自 pcixhci_controller.c 的函数 BOOL PCIXHCI_FindPorts(struct PCIXHCIUnit *unit) 应该能够从 XHCI 控制器中检测到 usb3.0 和 usb2.0 端口。
- 建议使用他的 sata 驱动程序的 slab 内存分配器。XHCI 中的内存分配很糟糕。这是一个问题。
- 对 init 例程进行了编码，使其使用 PCI INT（仅事件处理程序 0）。对于 PCI-X，也可以使用其他事件环。
- 删除巨大的 switch 语句并添加所有 usb3 命令（并非所有命令在一开始都需要），并对 hubss.class 进行编码以使用它们。
- 硬件环形缓冲区需要正确实现。
如果 XHCI 同时具有 usb3 和 usb2 端口，则驱动程序需要为每个控制器提供两个单元。这是因为我们需要为 Poseidon 提供正确的 roothub（hub 或 hubss），并且一个驱动程序单元每个单元只能提供一个 roothub。VUSBHCI 中已经存在一些代码来实现这一点，但没有针对 usb3 部分的代码。即使在拥有原生 XHCI 驱动程序之前，也可以使用上述托管驱动程序通过 VUSBHCI 驱动程序对更高级别的 usb3 代码进行编码。
一个好处是，我们应该获得 ISOC 传输，因为 XHCI 负责将它们排列起来，无需为不同的数据包创建调度器。
CPU ---------------- Device Side Controller ---------------- Peripherals
Controller Bus Bridge Peripheral Bus
PCI, etc USB, etc
以下是在托管 usb “工作”时所需的步骤
- 构建 AROS 的托管版本（现在需要使用 --enable_usb30_code 构建）
- cd 到构建目录
- 发出 make kernel-usb（如果它没有构建所有内容，那么只构建其余部分）
- 发出 make kernel-usb-vusbhci
- 发出 make kernel-fs-fat（如果打算使用 fat usb 驱动器）
- 发出 make kernel-partition（否则 AROS 会崩溃，因为它会尝试使用 partition.library，错误？它应该知道它没有打开它）
- 发出 make kernel-usb-classes-hubss
某些 Linux 发行版不允许用户访问 usb 设备，因此可能需要在 /etc/udev/rules.d 中添加规则
# Allow user to access all usb devices SUBSYSTEMS=="usb", \ MODE:="0666"
并将其保存为“49-all-usb-devices.rules”
- 启动托管 AROS 并转到首选项，打开 Trident。
- 转到“控制器”并按下“新建”，选择“vusbhci.device”作为单元号 0。按下“联机”并按下“保存”。
- 再次转到“控制器”并按下“新建”，选择“vusbhci.device”作为单元号 1。按下“联机”并按下“保存”。
单元 0 现在是 USB2 roothub，单元 1 是 USB3 roothub。（硬编码，顺序不重要）
每次启动托管版本的 AROS 时都需要打开 Trident。托管版本没有 usbrombootstrap，因此 Trident 用于设置 USB 堆栈。
VUSBHCI.device 依赖于 libusb，因此它需要 Linux 端的包含文件（libusb-dev 或类似的东西……）
VUSBHCI 目前可能会输出大量调试消息。如果从控制台启动，这些消息当然会输出到控制台。
VUSBHCI 只是指 (V)irtual (USB) (H)ost (C)ontroller (I)nterface（虚拟 USB 主机控制器接口）
每个虚拟主机控制器（usb2/usb3（usb3 尚未实现））只有一个虚拟端口。AROS 将在 Trident 启动后以及设备插入后看到 usb 设备。AROS 不能接管已插入的设备，因为驱动程序使用 libusb 的插入事件。Linux 已经枚举并重置了设备，因此在 AROS 端需要一些 hackery。VUSHCI 驱动程序不会重置设备，也不会为其发出新的地址。否则它会使 Linux 混乱。AROS 然后将拥有该设备并按其意愿使用它。
要开始为 USB3 编码（现在，如果没有它，vusbhci.device 就无法构建），那么 AROS 构建需要使用“--enable-usb30-code”开关进行配置。这将改变 Poseidon USB 堆栈，使其对 USB3 有所了解。要确保其稳定性，还有很多工作要做。
类源代码保存在 rom/usb/classes 中的各自抽屉（文件夹）中
rom/usb/classes/rndis/rndis.h rom/usb/classes/mmakefile.src rom/usb/classes/rndis/LEGAL rom/usb/classes/rndis/common.h rom/usb/classes/rndis/debug.c rom/usb/classes/rndis/debug.h rom/usb/classes/rndis/dev.c rom/usb/classes/rndis/dev.h rom/usb/classes/rndis/if_urndis.c rom/usb/classes/rndis/if_urndisreg.h rom/usb/classes/rndis/mmakefile.src rom/usb/classes/rndis/rndis.class.c rom/usb/classes/rndis/rndis.class.h rom/usb/classes/rndis/rndis.conf
/*
* $Id$
*/
#ifndef RNDIS_H
#define RNDIS_H
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <libraries/mui.h>
#include <libraries/gadtools.h>
#include <devices/sana2.h>
#include <devices/sana2specialstats.h>
#include <exec/devices.h>
#include <stdint.h>
#if defined(__GNUC__)
# pragma pack(2)
#endif
#define DDF_CONFIGURED (1<<2) /* station address is configured */
#define DDF_ONLINE (1<<3) /* device is online */
#define DDF_OFFLINE (1<<4) /* device was put offline */
#define DROPPED (1<<0) /* Did the packet get dropped? */
#define PACKETFILTER (1<<1) /* Use the packet filter? */
/* Ethernet address bytesize
*/
#define ETHER_ADDR_SIZE 6
#define ETHER_MIN_LEN 60 /* smallest amount that nic will accept */
#define ETHER_MAX_LEN 1536 /* largest legal amount for Ethernet */
/* Ethernet packet data sizes (maximum)
*/
#define ETHERPKT_SIZE 1500
#define RAWPKT_SIZE 1514
#define ID_ABOUT 0x55555555
#define ID_STORE_CONFIG 0xaaaaaaaa
#define ID_DEF_CONFIG 0xaaaaaaab
struct ClsDevCfg
{
ULONG cdc_ChunkID;
ULONG cdc_Length;
ULONG cdc_DefaultUnit;
UBYTE cdc_MACAddress[ETHER_ADDR_SIZE];
};
#if defined(__GNUC__)
# pragma pack()
#endif
/* Structure of an ethernet packet - internal
*/
struct EtherPacketHeader
{
UBYTE eph_Dest[ETHER_ADDR_SIZE]; /* 0 destination address */
UBYTE eph_Src[ETHER_ADDR_SIZE]; /* 6 originator address */
UWORD eph_Type; /* 12 packet type */
};
/* Buffer management node - private
*/
struct BufMan
{
struct Node bm_Node;
APTR bm_DMACopyFromBuf32;
APTR bm_CopyFromBuf;
APTR bm_DMACopyToBuf32;
APTR bm_CopyToBuf;
APTR bm_PacketFilter;
struct List bm_RXQueue; /* read requests */
};
/* Multicast address range record - private
*/
struct MulticastAddressRange
{
struct Node mar_Node; /* 0 list node */
ULONG mar_UseCount; /* 8 number of times used */
UBYTE mar_LowerAddr[ETHER_ADDR_SIZE]; /* 12 multicast address lower bound */
UBYTE mar_UpperAddr[ETHER_ADDR_SIZE]; /* 18 multicast address upper bound */
};
struct PacketTypeStats
{
struct Node pts_Node;
ULONG pts_PacketType;
struct Sana2PacketTypeStats pts_Stats;
};
struct NepEthDevBase
{
struct Library np_Library; /* standard */
UWORD np_Flags; /* various flags */
BPTR np_SegList; /* device seglist */
struct NepEthBase *np_ClsBase; /* pointer to class base */
struct Library *np_UtilityBase; /* cached utilitybase */
};
struct NepClassEth
{
struct Unit ncp_Unit; /* Unit structure */
ULONG ncp_UnitNo; /* Unit number */
ULONG ncp_OpenFlags; /* Flags used to open the device */
struct NepEthBase *ncp_ClsBase; /* Up linkage */
struct NepEthDevBase *ncp_DevBase; /* Device base */
struct Library *ncp_Base; /* Poseidon base */
struct PsdDevice *ncp_Device; /* Up linkage */
struct PsdConfig *ncp_Config; /* Up linkage */
struct PsdInterface *ncp_Interface; /* Up linkage */
struct Task *ncp_ReadySigTask; /* Task to send ready signal to */
LONG ncp_ReadySignal; /* Signal to send when ready */
struct Task *ncp_Task; /* Subtask */
struct MsgPort *ncp_TaskMsgPort; /* Message Port of Subtask */
struct PsdPipe *ncp_EP0Pipe; /* Endpoint 0 pipe */
struct PsdEndpoint *ncp_EPOut; /* Endpoint 1 */
struct PsdPipe *ncp_EPOutPipe[2]; /* Endpoint 1 pipes */
struct PsdEndpoint *ncp_EPIn; /* Endpoint 2 */
struct PsdPipe *ncp_EPInPipe; /* Endpoint 2 pipe */
struct MsgPort *ncp_DevMsgPort; /* Message Port for IOParReq */
UWORD ncp_UnitProdID; /* ProductID of unit */
UWORD ncp_UnitVendorID; /* VendorID of unit */
//BOOL ncp_DenyRequests; /* Do not accept further IO requests */
struct List ncp_BufManList; /* Buffer Managers */
struct List ncp_EventList; /* List for DoEvent */
struct List ncp_TrackList; /* List of trackables */
struct List ncp_Multicasts; /* List of multicast addresses */
UBYTE ncp_MacAddress[ETHER_ADDR_SIZE]; /* Current Mac Address */
UBYTE ncp_ROMAddress[ETHER_ADDR_SIZE]; /* ROM Mac Address */
UBYTE ncp_MulticastArray[8]; /* array for the multicast hashes */
ULONG ncp_StateFlags; /* State of the unit */
ULONG ncp_Retries; /* tx collision count */
ULONG ncp_BadMulticasts; /* bad multicast count */
UBYTE *ncp_ReadBuffer[2]; /* Packet Double Buffered Read Buffer */
UBYTE *ncp_WriteBuffer[2]; /* Packet Write Buffer */
UWORD ncp_ReadBufNum; /* Next Read Buffer to use */
UWORD ncp_WriteBufNum; /* Next Write Buffer to use */
struct Sana2DeviceStats ncp_DeviceStats; /* SANA Stats */
struct Sana2PacketTypeStats *ncp_TypeStats2048; /* IP protocol stats ptr, or NULL */
struct Sana2PacketTypeStats *ncp_TypeStats2054; /* ARP protocol stats ptr, or NULL */
UBYTE *ncp_ReadPending; /* read IORequest pending */
struct IOSana2Req *ncp_WritePending[2]; /* write IORequest pending */
struct List ncp_OrphanQueue; /* List of orphan read requests */
struct List ncp_WriteQueue; /* List of write requests */
UBYTE ncp_DevIDString[128]; /* Device ID String */
BOOL ncp_UsingDefaultCfg;
struct ClsDevCfg *ncp_CDC;
uint32_t sc_filter; /* rndis stuff */
uint32_t sc_lim_pktsz;
struct Library *ncp_MUIBase; /* MUI master base */
struct Library *ncp_PsdBase; /* Poseidon base */
struct Library *ncp_IntBase; /* Intuition base */
};
struct NepEthBase
{
struct Library nh_Library; /* standard */
UWORD nh_Flags; /* various flags */
struct Library *nh_UtilityBase; /* utility base */
struct NepEthDevBase *nh_DevBase; /* base of device created */
struct List nh_Units; /* List of units available */
struct NepClassEth nh_DummyNCP; /* Dummy ncp for default config */
};
#endif /* RNDIS_H */
#include LC_LIBDEFS_FILE #include <aros/libcall.h> #include <aros/asmcall.h> #include <aros/symbolsets.h> #include <exec/types.h> #include <exec/lists.h> #include <exec/alerts.h> #include <exec/memory.h> #include <exec/libraries.h> #include <exec/interrupts.h> #include <exec/semaphores.h> #include <exec/execbase.h> #include <exec/devices.h> #include <exec/io.h> #include <exec/ports.h> #include <exec/errors.h> #include <exec/resident.h> #include <exec/initializers.h> #include <devices/timer.h> #include <devices/input.h> #include <utility/utility.h> #include <dos/dos.h> #include <intuition/intuition.h> #include <devices/usb.h> #include <devices/usbhardware.h> #include <libraries/usbclass.h> #include <string.h> #include <stddef.h> #include <stdio.h> #include <proto/dos.h> #include <proto/commodities.h> #include <proto/intuition.h> #include <proto/poseidon.h> #include <proto/utility.h> #include <proto/keymap.h> #include <proto/layers.h> #include <proto/input.h> #include <proto/expansion.h> #include <proto/exec.h> #include <proto/muimaster.h> #define NewList NEWLIST #include <stdarg.h> #define min(x,y) (((x) < (y)) ? (x) : (y)) #define max(x,y) (((x) > (y)) ? (x) : (y))
/*
* $Id$
*/
#include "debug.h"
#include "rndis.class.h"
/* /// "Lib Stuff" */
static const STRPTR libname = MOD_NAME_STRING;
static
const APTR DevFuncTable[] =
{
&AROS_SLIB_ENTRY(devOpen, dev),
&AROS_SLIB_ENTRY(devClose, dev),
&AROS_SLIB_ENTRY(devExpunge, dev),
&AROS_SLIB_ENTRY(devReserved, dev),
&AROS_SLIB_ENTRY(devBeginIO, dev),
&AROS_SLIB_ENTRY(devAbortIO, dev),
(APTR) -1,
};
static int libInit(LIBBASETYPEPTR nh)
{
struct NepClassEth *ncp;
struct NepEthBase *ret = NULL;
KPRINTF(10, ("libInit nh: 0x%08lx SysBase: 0x%08lx\n", nh, SysBase));
nh->nh_UtilityBase = OpenLibrary("utility.library", 39);
#define UtilityBase nh->nh_UtilityBase
if(UtilityBase)
{
NewList(&nh->nh_Units);
if((nh->nh_DevBase = (struct NepEthDevBase *) MakeLibrary((APTR) DevFuncTable, NULL, (APTR) devInit,
sizeof(struct NepEthDevBase), NULL)))
{
ncp = &nh->nh_DummyNCP;
ncp->ncp_ClsBase = nh;
ncp->ncp_Interface = NULL;
ncp->ncp_CDC = AllocVec(sizeof(struct ClsDevCfg), MEMF_PUBLIC|MEMF_CLEAR);
if(ncp->ncp_CDC)
{
nh->nh_DevBase->np_ClsBase = nh;
Forbid();
AddDevice((struct Device *) nh->nh_DevBase);
nh->nh_DevBase->np_Library.lib_OpenCnt++;
Permit();
ret = nh;
}
} else {
KPRINTF(20, ("failed to create usbrndis.device\n"));
}
if(!ret)
{
CloseLibrary(UtilityBase);
}
} else {
KPRINTF(20, ("libInit: OpenLibrary(\"utility.library\", 39) failed!\n"));
}
KPRINTF(10, ("libInit: Ok\n"));
return(ret ? TRUE : FALSE);
}
static int libExpunge(LIBBASETYPEPTR nh)
{
struct NepClassEth *ncp;
KPRINTF(10, ("libExpunge nh: 0x%08lx\n", nh));
if(nh->nh_DevBase->np_Library.lib_OpenCnt == 1)
{
KPRINTF(1, ("libExpunge: closelibrary utilitybase 0x%08lx\n",
UtilityBase));
CloseLibrary((struct Library *) UtilityBase);
ncp = (struct NepClassEth *) nh->nh_Units.lh_Head;
while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
{
Remove((struct Node *) ncp);
FreeVec(ncp->ncp_CDC);
FreeVec(ncp);
ncp = (struct NepClassEth *) nh->nh_Units.lh_Head;
}
nh->nh_DevBase->np_Library.lib_OpenCnt--;
RemDevice((struct Device *) nh->nh_DevBase);
KPRINTF(5, ("libExpunge: Unloading done! rndis.class expunged!\n\n"));
} else {
KPRINTF(5, ("libExpunge: Could not expunge, LIBF_DELEXP set!\n"));
return(FALSE);
}
return(TRUE);
}
ADD2INITLIB(libInit, 0)
ADD2EXPUNGELIB(libExpunge, 0)
/* \\\ */
/*
* ***********************************************************************
* * Library functions *
* ***********************************************************************
*/
struct AutoBindData
{
UWORD abd_VendID;
UWORD abd_ProdID;
};
struct AutoBindData ClassBinds[] =
{
//{ 0x12d1, 0x1039 }, // Huawei u8800
{ 0, 0 }
};
/* /// "usbAttemptDeviceBinding()" */
struct NepClassEth * usbAttemptDeviceBinding(struct NepEthBase *nh, struct PsdDevice *pd)
{
struct Library *ps;
struct AutoBindData *abd = ClassBinds;
struct PsdInterface *pif;
IPTR prodid;
IPTR vendid;
IPTR ifclass;
IPTR subclass;
IPTR proto;
KPRINTF(1, ("nepEthAttemptDeviceBinding(%08lx)\n", pd));
if((ps = OpenLibrary("poseidon.library", 4)))
{
psdGetAttrs(PGA_DEVICE, pd,
DA_VendorID, &vendid,
DA_ProductID, &prodid,
TAG_END);
if( (pif = psdFindInterface(pd, NULL,TAG_END)) ){
psdGetAttrs(PGA_INTERFACE, pif,
IFA_Class, &ifclass,
IFA_SubClass, &subclass,
IFA_Protocol, &proto,
TAG_DONE);
if (ifclass == 224 && // WIRELESS
subclass == 1 && // RF
proto == 3) // RNDIS
{
CloseLibrary(ps);
return(usbForceDeviceBinding(nh, pd));
}
}
while(abd->abd_VendID)
{
if((vendid == abd->abd_VendID) && (prodid == abd->abd_ProdID))
{
CloseLibrary(ps);
return(usbForceDeviceBinding(nh, pd));
}
abd++;
}
}
return(NULL);
}
/* \\\ */
/* /// "usbForceDeviceBinding()" */
struct NepClassEth * usbForceDeviceBinding(struct NepEthBase *nh, struct PsdDevice *pd)
{
struct Library *ps;
struct NepClassEth *ncp;
struct NepClassEth *tmpncp;
struct ClsDevCfg *cdc;
STRPTR devname;
STRPTR devidstr;
IPTR prodid;
IPTR vendid;
ULONG unitno;
BOOL unitfound;
UBYTE buf[64];
KPRINTF(1, ("nepEthForceDeviceBinding(%08lx)\n", pd));
if((ps = OpenLibrary("poseidon.library", 4)))
{
psdGetAttrs(PGA_DEVICE, pd,
DA_ProductID, &prodid,
DA_VendorID, &vendid,
DA_ProductName, &devname,
DA_IDString, &devidstr,
TAG_END);
Forbid();
unitfound = FALSE;
unitno = (ULONG) -1;
ncp = (struct NepClassEth *) nh->nh_Units.lh_Head;
while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
{
if(!strcmp(ncp->ncp_DevIDString, devidstr))
{
unitno = ncp->ncp_UnitNo;
unitfound = TRUE;
break;
}
ncp = (struct NepClassEth *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
}
if(!unitfound)
{
/* as units are freed in the expunge-vector, the memory is
outside the scope of the poseidon library */
if(!(ncp = AllocVec(sizeof(struct NepClassEth), MEMF_PUBLIC|MEMF_CLEAR)))
{
Permit();
CloseLibrary(ps);
return(NULL);
}
ncp->ncp_CDC = cdc = AllocVec(sizeof(struct ClsDevCfg), MEMF_PUBLIC|MEMF_CLEAR);
if(!cdc)
{
Permit();
FreeVec(ncp);
CloseLibrary(ps);
return(NULL);
}
/* IORequests may be queued even if the task is gone. */
ncp->ncp_UnitNo = (ULONG) -1;
NewList(&ncp->ncp_Unit.unit_MsgPort.mp_MsgList);
NewList(&ncp->ncp_OrphanQueue);
NewList(&ncp->ncp_WriteQueue);
NewList(&ncp->ncp_BufManList);
NewList(&ncp->ncp_EventList);
NewList(&ncp->ncp_TrackList);
NewList(&ncp->ncp_Multicasts);
strncpy(ncp->ncp_DevIDString, devidstr, 127);
AddTail(&nh->nh_Units, &ncp->ncp_Unit.unit_MsgPort.mp_Node);
}
ncp->ncp_ClsBase = nh;
ncp->ncp_Device = pd;
ncp->ncp_UnitProdID = prodid;
ncp->ncp_UnitVendorID = vendid;
//nLoadBindingConfig(ncp);
/* Find next free unit number */
if(unitno == (ULONG) -1)
{
unitno = ncp->ncp_CDC->cdc_DefaultUnit;
tmpncp = (struct NepClassEth *) nh->nh_Units.lh_Head;
while(tmpncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
{
if(tmpncp->ncp_UnitNo == unitno)
{
unitno++;
tmpncp = (struct NepClassEth *) nh->nh_Units.lh_Head;
} else {
tmpncp = (struct NepClassEth *) tmpncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
}
}
}
ncp->ncp_UnitNo = unitno;
Permit();
psdSafeRawDoFmt(buf, 64, "rndis.class<%08lx>", ncp);
ncp->ncp_ReadySignal = SIGB_SINGLE;
ncp->ncp_ReadySigTask = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
if(psdSpawnSubTask(buf, nEthTask, ncp))
{
Wait(1L<<ncp->ncp_ReadySignal);
if(ncp->ncp_Task)
{
ncp->ncp_ReadySigTask = NULL;
//FreeSignal(ncp->ncp_ReadySignal);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"Mr. Data linked '%s' to %s unit %ld!",
devname, nh->nh_DevBase->np_Library.lib_Node.ln_Name,
ncp->ncp_UnitNo);
CloseLibrary(ps);
return(ncp);
}
}
ncp->ncp_ReadySigTask = NULL;
//FreeSignal(ncp->ncp_ReadySignal);
/* Get rid of unit structure */
/*Forbid();
Remove((struct Node *) ncp);
FreeVec(ncp->ncp_CDC);
FreeVec(ncp);
Permit();*/
CloseLibrary(ps);
}
return(NULL);
}
/* \\\ */
/* /// "usbReleaseDeviceBinding()" */
void usbReleaseDeviceBinding(struct NepEthBase *nh, struct NepClassEth *ncp)
{
struct Library *ps;
STRPTR devname;
KPRINTF(1, ("nepEthReleaseDeviceBinding(%08lx)\n", ncp));
if((ps = OpenLibrary("poseidon.library", 4)))
{
Forbid();
ncp->ncp_ReadySignal = SIGB_SINGLE;
ncp->ncp_ReadySigTask = FindTask(NULL);
if(ncp->ncp_Task)
{
Signal(ncp->ncp_Task, SIGBREAKF_CTRL_C);
}
Permit();
while(ncp->ncp_Task)
{
Wait(1L<<ncp->ncp_ReadySignal);
}
//FreeSignal(ncp->ncp_ReadySignal);
psdGetAttrs(PGA_DEVICE, ncp->ncp_Device, DA_ProductName, &devname, TAG_END);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"Shrinkwrapped and wasted '%s'.",
devname);
/*psdFreeVec(ncp);*/
CloseLibrary(ps);
}
}
/* \\\ */
/* /// "usbGetAttrsA()" */
AROS_LH3(LONG, usbGetAttrsA,
AROS_LHA(ULONG, type, D0),
AROS_LHA(APTR, usbstruct, A0),
AROS_LHA(struct TagItem *, tags, A1),
LIBBASETYPEPTR, nh, 5, nep)
{
AROS_LIBFUNC_INIT
struct TagItem *ti;
LONG count = 0;
KPRINTF(1, ("nepEthGetAttrsA(%ld, %08lx, %08lx)\n", type, usbstruct, tags));
switch(type)
{
case UGA_CLASS:
if((ti = FindTagItem(UCCA_Priority, tags)))
{
*((SIPTR *) ti->ti_Data) = -100;
count++;
}
if((ti = FindTagItem(UCCA_Description, tags)))
{
*((STRPTR *) ti->ti_Data) = "Ethernet SANA wrapper for RNDIS devices via usbrndis.device";
count++;
}
if((ti = FindTagItem(UCCA_HasClassCfgGUI, tags)))
{
*((IPTR *) ti->ti_Data) = TRUE;
count++;
}
if((ti = FindTagItem(UCCA_HasBindingCfgGUI, tags)))
{
*((IPTR *) ti->ti_Data) = TRUE;
count++;
}
if((ti = FindTagItem(UCCA_AfterDOSRestart, tags)))
{
*((IPTR *) ti->ti_Data) = FALSE;
count++;
}
if((ti = FindTagItem(UCCA_UsingDefaultCfg, tags)))
{
*((IPTR *) ti->ti_Data) = nh->nh_DummyNCP.ncp_UsingDefaultCfg;
count++;
}
break;
case UGA_BINDING:
if((ti = FindTagItem(UCBA_UsingDefaultCfg, tags)))
{
*((IPTR *) ti->ti_Data) = ((struct NepClassEth *) usbstruct)->ncp_UsingDefaultCfg;
count++;
}
break;
}
return(count);
AROS_LIBFUNC_EXIT
}
/* \\\ */
/* /// "usbSetAttrsA()" */
AROS_LH3(LONG, usbSetAttrsA,
AROS_LHA(ULONG, type, D0),
AROS_LHA(APTR, usbstruct, A0),
AROS_LHA(struct TagItem *, tags, A1),
LIBBASETYPEPTR, nh, 6, nep)
{
AROS_LIBFUNC_INIT
return(0);
AROS_LIBFUNC_EXIT
}
/* \\\ */
/* /// "usbDoMethodA()" */
AROS_LH2(IPTR, usbDoMethodA,
AROS_LHA(ULONG, methodid, D0),
AROS_LHA(IPTR *, methoddata, A1),
LIBBASETYPEPTR, nh, 7, nep)
{
AROS_LIBFUNC_INIT
KPRINTF(10, ("Do Method %ld\n", methodid));
switch(methodid)
{
case UCM_AttemptDeviceBinding:
return((IPTR) usbAttemptDeviceBinding(nh, (struct PsdDevice *) methoddata[0]));
case UCM_ForceDeviceBinding:
return((IPTR) usbForceDeviceBinding(nh, (struct PsdDevice *) methoddata[0]));
case UCM_ReleaseDeviceBinding:
usbReleaseDeviceBinding(nh, (struct NepClassEth *) methoddata[0]);
return(TRUE);
default:
break;
}
return(0);
AROS_LIBFUNC_EXIT
}
/* \\\ */
/**************************************************************************/
#undef ps
#define ps ncp->ncp_Base
/* /// "nEthTask()" */
AROS_UFH0(void, nEthTask)
{
AROS_USERFUNC_INIT
struct NepClassEth *ncp;
struct PsdPipe *pp;
ULONG sigmask;
ULONG sigs;
LONG ioerr;
UBYTE *pktptr;
ULONG pktlen;
UWORD cnt;
LONG lastioerr = 0;
ULONG errcount = 0;
struct IOSana2Req *ioreq;
if((ncp = nAllocEth()))
{
urndis_attach(ncp);
Forbid();
if(ncp->ncp_ReadySigTask)
{
Signal(ncp->ncp_ReadySigTask, 1L<<ncp->ncp_ReadySignal);
}
Permit();
{
/* Record start time_of_day */
//GetSysTime(&ncp->ncp_DeviceStats.LastStart);
/* Now online */
ncp->ncp_StateFlags |= DDF_ONLINE;
ncp->ncp_StateFlags &= ~DDF_OFFLINE;
/* Trigger any ONLINE events */
nDoEvent(ncp, S2EVENT_ONLINE);
}
/* Main task */
sigmask = (1L<<ncp->ncp_Unit.unit_MsgPort.mp_SigBit)|(1L<<ncp->ncp_TaskMsgPort->mp_SigBit)|SIGBREAKF_CTRL_C;
do
{
// start transmitting read request if online...
if((ncp->ncp_StateFlags & DDF_ONLINE) && (ncp->ncp_ReadPending == NULL))
{
ncp->ncp_ReadPending = ncp->ncp_ReadBuffer[ncp->ncp_ReadBufNum];
psdSendPipe(ncp->ncp_EPInPipe, ncp->ncp_ReadPending, RNDIS_BUFSZ );
ncp->ncp_ReadBufNum ^= 1;
}
while((pp = (struct PsdPipe *) GetMsg(ncp->ncp_TaskMsgPort)))
{
KPRINTF(1, ("Pipe back %08lx\n", pp));
for(cnt = 0; cnt < 2; cnt++)
{
if(pp == ncp->ncp_EPOutPipe[cnt])
{
if((ioreq = ncp->ncp_WritePending[cnt]))
{
ioerr = psdGetPipeError(pp);
if(ioerr)
{
psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
"Eth transmit failed: %s (%ld)",
psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
/* Trigger any tx or generic error events */
nDoEvent(ncp, S2EVENT_ERROR|S2EVENT_TX);
/* Set error code and terminate the iorequest.
NOTE: Can't use RC_* or deverror() this is not
called from devBeginIO()!
*/
ioreq->ios2_DataLength = 0;
ioreq->ios2_Req.io_Error = S2ERR_TX_FAILURE;
ioreq->ios2_WireError = S2WERR_GENERIC_ERROR;
psdDelayMS(50);
}
ReplyMsg((struct Message *) ioreq);
ncp->ncp_WritePending[cnt] = NULL;
}
break;
}
}
if(pp == ncp->ncp_EPInPipe)
{
if((pktptr = ncp->ncp_ReadPending))
{
ioerr = psdGetPipeError(pp);
pktlen = psdGetPipeActual(pp);
KPRINTF(1, ("ReadBack with %ld bytes.\n", pktlen));
// interleave next packet reading ASAP.
if(ncp->ncp_StateFlags & DDF_ONLINE)
{
ncp->ncp_ReadPending = ncp->ncp_ReadBuffer[ncp->ncp_ReadBufNum];
psdSendPipe(ncp->ncp_EPInPipe, ncp->ncp_ReadPending, RNDIS_BUFSZ );
ncp->ncp_ReadBufNum ^= 1;
} else {
ncp->ncp_ReadPending = NULL;
}
if(ioerr)
{
if(lastioerr != ioerr)
{
psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
"Eth receive failed: %s (%ld)",
psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
errcount = 0;
} else {
errcount++;
if(errcount > 20)
{
psdAddErrorMsg(RETURN_FAIL, (STRPTR) libname,
"That's it, that device pissed me off long enough!");
Signal(ncp->ncp_Task, SIGBREAKF_CTRL_C);
}
}
lastioerr = ioerr;
psdDelayMS(50);
break;
} else {
KPRINTF(1, ("Pkt %ld received\n", pktlen));
nReadPacket(ncp, pktptr, pktlen);
}
}
}
}
Forbid();
while((!ncp->ncp_WritePending[ncp->ncp_WriteBufNum]) && ncp->ncp_WriteQueue.lh_Head->ln_Succ)
{
ioreq = (struct IOSana2Req *) RemHead(&ncp->ncp_WriteQueue);
Permit();
nWritePacket(ncp, ioreq);
Forbid();
}
Permit();
sigs = Wait(sigmask);
} while(!(sigs & SIGBREAKF_CTRL_C));
Forbid();
/* Now remove all requests still pending *anywhere* */
//ncp->ncp_DenyRequests = TRUE;
/* Current transfers */
for(cnt = 0; cnt < 2; cnt++)
{
if((ioreq = ncp->ncp_WritePending[cnt]))
{
KPRINTF(1, ("Aborting pending write...\n"));
psdAbortPipe(ncp->ncp_EPOutPipe[cnt]);
psdWaitPipe(ncp->ncp_EPOutPipe[cnt]);
ioreq->ios2_Req.io_Error = IOERR_ABORTED;
ReplyMsg((struct Message *) ioreq);
ncp->ncp_WritePending[cnt] = NULL;
}
}
if(ncp->ncp_ReadPending)
{
KPRINTF(1, ("Aborting pending read...\n"));
psdAbortPipe(ncp->ncp_EPInPipe);
psdWaitPipe(ncp->ncp_EPInPipe);
ncp->ncp_ReadPending = NULL;
}
Permit();
nDoEvent(ncp, S2EVENT_OFFLINE);
KPRINTF(20, ("Going down the river!\n"));
nFreeEth(ncp);
}
AROS_USERFUNC_EXIT
}
/* \\\ */
/* /// "nAllocEth()" */
struct NepClassEth * nAllocEth(void)
{
struct Task *thistask;
struct NepClassEth *ncp;
thistask = FindTask(NULL);
do
{
ncp = thistask->tc_UserData;
if(!(ncp->ncp_Base = OpenLibrary("poseidon.library", 4)))
{
Alert(AG_OpenLib);
break;
}
ncp->ncp_Interface = NULL;
do
{
ncp->ncp_Interface = psdFindInterface(ncp->ncp_Device, ncp->ncp_Interface,
TAG_END);
if(!ncp->ncp_Interface)
{
break;
}
ncp->ncp_EPIn = psdFindEndpoint(ncp->ncp_Interface, NULL,
EA_IsIn, TRUE,
EA_TransferType, USEAF_BULK,
TAG_END);
ncp->ncp_EPOut = psdFindEndpoint(ncp->ncp_Interface, NULL,
EA_IsIn, FALSE,
EA_TransferType, USEAF_BULK,
TAG_END);
} while(!(ncp->ncp_EPOut && ncp->ncp_EPIn));
if(!ncp->ncp_Interface)
{
psdAddErrorMsg(RETURN_FAIL, (STRPTR) libname, "No interface?");
break;
}
if(!(ncp->ncp_EPIn && ncp->ncp_EPOut))
{
psdAddErrorMsg(RETURN_FAIL, (STRPTR) libname, "IN or OUT endpoint missing!");
break;
}
ncp->ncp_ReadPending = NULL;
ncp->ncp_WritePending[0] = NULL;
ncp->ncp_WritePending[1] = NULL;
if(!(ncp->ncp_ReadBuffer[0] = AllocVec(ETHER_MAX_LEN * 4, MEMF_PUBLIC|MEMF_CLEAR)))
{
KPRINTF(1, ("Out of memory for read buffer\n"));
break;
}
ncp->ncp_ReadBuffer[1] = ncp->ncp_ReadBuffer[0] + ETHER_MAX_LEN;
ncp->ncp_WriteBuffer[0] = ncp->ncp_ReadBuffer[1] + ETHER_MAX_LEN;
ncp->ncp_WriteBuffer[1] = ncp->ncp_WriteBuffer[0] + ETHER_MAX_LEN;
ncp->ncp_Unit.unit_MsgPort.mp_SigBit = AllocSignal(-1);
ncp->ncp_Unit.unit_MsgPort.mp_SigTask = thistask;
ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Type = NT_MSGPORT;
ncp->ncp_Unit.unit_MsgPort.mp_Flags = PA_SIGNAL;
if((ncp->ncp_TaskMsgPort = CreateMsgPort()))
{
if((ncp->ncp_EP0Pipe = psdAllocPipe(ncp->ncp_Device, ncp->ncp_TaskMsgPort, NULL)))
{
if((ncp->ncp_EPOutPipe[0] = psdAllocPipe(ncp->ncp_Device, ncp->ncp_TaskMsgPort, ncp->ncp_EPOut)))
{
/* Turn off short packets */
psdSetAttrs(PGA_PIPE, ncp->ncp_EPOutPipe[0],
PPA_NoShortPackets, FALSE,
PPA_NakTimeout, TRUE,
PPA_NakTimeoutTime, 5000,
TAG_END);
if((ncp->ncp_EPOutPipe[1] = psdAllocPipe(ncp->ncp_Device, ncp->ncp_TaskMsgPort, ncp->ncp_EPOut)))
{
/* Turn off short packets */
psdSetAttrs(PGA_PIPE, ncp->ncp_EPOutPipe[1],
PPA_NoShortPackets, FALSE,
PPA_NakTimeout, TRUE,
PPA_NakTimeoutTime, 5000,
TAG_END);
if((ncp->ncp_EPInPipe = psdAllocPipe(ncp->ncp_Device, ncp->ncp_TaskMsgPort, ncp->ncp_EPIn)))
{
/* Turn off short packets */
psdSetAttrs(PGA_PIPE, ncp->ncp_EPInPipe,
PPA_NakTimeout, FALSE,
PPA_NakTimeoutTime, 5000,
PPA_AllowRuntPackets, TRUE,
TAG_END);
ncp->ncp_Task = thistask;
return(ncp);
}
psdFreePipe(ncp->ncp_EPOutPipe[1]);
}
psdFreePipe(ncp->ncp_EPOutPipe[0]);
}
psdFreePipe(ncp->ncp_EP0Pipe);
}
DeleteMsgPort(ncp->ncp_TaskMsgPort);
}
FreeSignal((LONG) ncp->ncp_Unit.unit_MsgPort.mp_SigBit);
} while(FALSE);
if(ncp->ncp_ReadBuffer[0])
{
FreeVec(ncp->ncp_ReadBuffer[0]);
ncp->ncp_ReadBuffer[0] = NULL;
}
CloseLibrary(ncp->ncp_Base);
Forbid();
ncp->ncp_Task = NULL;
if(ncp->ncp_ReadySigTask)
{
Signal(ncp->ncp_ReadySigTask, 1L<<ncp->ncp_ReadySignal);
}
return(NULL);
}
/* \\\ */
/* /// "nFreeEth()" */
void nFreeEth(struct NepClassEth *ncp)
{
struct IOSana2Req *ioreq;
Forbid();
/* Disable the message port, messages may still be queued */
ncp->ncp_Unit.unit_MsgPort.mp_SigTask = NULL;
ncp->ncp_Unit.unit_MsgPort.mp_Flags = PA_IGNORE;
FreeSignal((LONG) ncp->ncp_Unit.unit_MsgPort.mp_SigBit);
// get rid of all messages that still have appeared here
while((ioreq = (struct IOSana2Req *) GetMsg(&ncp->ncp_Unit.unit_MsgPort)))
{
ioreq->ios2_Req.io_Error = IOERR_ABORTED;
ReplyMsg((struct Message *) ioreq);
}
Permit();
psdFreePipe(ncp->ncp_EPInPipe);
psdFreePipe(ncp->ncp_EPOutPipe[0]);
psdFreePipe(ncp->ncp_EPOutPipe[1]);
psdFreePipe(ncp->ncp_EP0Pipe);
if(ncp->ncp_ReadBuffer[0])
{
FreeVec(ncp->ncp_ReadBuffer[0]);
ncp->ncp_ReadBuffer[0] = NULL;
}
DeleteMsgPort(ncp->ncp_TaskMsgPort);
CloseLibrary(ncp->ncp_Base);
Forbid();
ncp->ncp_Task = NULL;
if(ncp->ncp_ReadySigTask)
{
Signal(ncp->ncp_ReadySigTask, 1L<<ncp->ncp_ReadySignal);
}
}
/* \\\ */
/* /// "nDoEvent()" */
void nDoEvent(struct NepClassEth *ncp, ULONG events)
{
struct IOSana2Req *worknode, *nextnode;
KPRINTF(1, ("DoEvent events: 0x%08lx\n", events));
Forbid();
/* Process pending S2_ONEVENT requests */
worknode = (struct IOSana2Req *) ncp->ncp_EventList.lh_Head;
while((nextnode = (struct IOSana2Req *) (((struct Node *) worknode)->ln_Succ)))
{
if(worknode->ios2_WireError & events)
{
Remove(&worknode->ios2_Req.io_Message.mn_Node);
worknode->ios2_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
KPRINTF(1, ("DoEvent: returned eventreq 0x%08lx\n", worknode));
ReplyMsg(&worknode->ios2_Req.io_Message);
}
worknode = nextnode;
}
Permit();
}
/* \\\ */
/* /// "support routines" */
static
inline void *callcopy(void *routine,
void *from,
void *to,
ULONG len)
{
void * (*call) (APTR, APTR, ULONG) = routine;
return (*call) (from, to, len);
}
#define callfilter CallHookPkt
/* \\\ */
/* /// "nWritePacket()" */
BOOL nWritePacket(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
{
ULONG packettype;
struct EtherPacketHeader *eph;
// UBYTE *packetdata;
UBYTE *copydest;
UWORD writelen;
struct BufMan *bufman;
struct Sana2PacketTypeStats *stats;
UBYTE *buf = ncp->ncp_WriteBuffer[ncp->ncp_WriteBufNum];
LONG encaplen;
packettype = ioreq->ios2_PacketType;
copydest = buf;
writelen = ioreq->ios2_DataLength;
bufman = ioreq->ios2_BufferManagement;
// remove RNDIS header
encaplen = urndis_encap(ncp, buf ,writelen +
(!(ioreq->ios2_Req.io_Flags & SANA2IOF_RAW) ? sizeof(struct EtherPacketHeader) : 0)
);
copydest += encaplen;
writelen += encaplen;
eph = (struct EtherPacketHeader *)copydest;
/* Not a raw packet? */
if(!(ioreq->ios2_Req.io_Flags & SANA2IOF_RAW))
{
UWORD cnt;
KPRINTF(10, ("RAW WRITE!\n"));
/* The ethernet header isn't included in the data */
/* Build ethernet packet header */
for(cnt = 0; cnt < ETHER_ADDR_SIZE; cnt++)
{
eph->eph_Dest[cnt] = ioreq->ios2_DstAddr[cnt];
eph->eph_Src[cnt] = ncp->ncp_MacAddress[cnt];
}
eph->eph_Type = AROS_BE2WORD(packettype);
/* Packet data is at txbuffer */
copydest += sizeof(struct EtherPacketHeader);
writelen += sizeof(struct EtherPacketHeader);
}
/* Dma not available, fallback to regular copy */
if(callcopy(bufman->bm_CopyFromBuf, copydest, ioreq->ios2_Data, ioreq->ios2_DataLength) == NULL)
{
KPRINTF(10, ("writepacket: copyfrom returned failure!\n"));
/* Trigger any tx, buff or generic error events */
nDoEvent(ncp, S2EVENT_ERROR|S2EVENT_TX|S2EVENT_BUFF);
/* Set error code and terminate the iorequest.
NOTE: Can't use RC_* or deverror() this is not
called from devBeginIO()! */
ioreq->ios2_DataLength = 0;
ioreq->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
ioreq->ios2_WireError = S2WERR_BUFF_ERROR;
return FALSE;
}
//bug("out %d\n",writelen);
KPRINTF(20, ("PktOut[%ld] %ld\n", ncp->ncp_WriteBufNum, writelen));
//dumpmem(buf, writelen);
ncp->ncp_WritePending[ncp->ncp_WriteBufNum] = ioreq;
psdSendPipe(ncp->ncp_EPOutPipe[ncp->ncp_WriteBufNum], buf, (ULONG) writelen);
ncp->ncp_WriteBufNum ^= 1;
DB(
if(AROS_BE2WORD(eph->eph_Type) < 1500)
{
KPRINTF(5, ("writepacket: %04lx%08lx > %04lx%08lx (IEEE802.3) len %lu, %lu bytes\n",
*((UWORD *) eph->eph_Src), *((ULONG *) (eph->eph_Src + 2)),
*((UWORD *) eph->eph_Dest), *((ULONG *) (eph->eph_Dest + 2)),
AROS_BE2WORD(eph->eph_Type), writelen));
} else {
KPRINTF(5, ("writepacket: %04lx%08lx > %04lx%08lx type %lu, %lu bytes\n",
*((UWORD *) eph->eph_Src), *((ULONG *) (eph->eph_Src + 2)),
*((UWORD *) eph->eph_Dest), *((ULONG *) (eph->eph_Dest + 2)),
AROS_BE2WORD(eph->eph_Type), writelen));
}
//dumpmem(buf, (ULONG) writelen);
)
/* Update statistics */
stats = FindPacketTypeStats(ncp, packettype);
if(stats)
{
stats->PacketsSent++;
stats->BytesSent += writelen;
}
ncp->ncp_DeviceStats.PacketsSent++;
return TRUE;
}
/* \\\ */
/* /// "nReadIOReq()" */
UWORD nReadIOReq(struct NepClassEth *ncp, struct EtherPacketHeader *eph, UWORD datasize, struct IOSana2Req *ioreq, UWORD flags)
{
LIBBASETYPEPTR nh = ncp->ncp_ClsBase;
UBYTE *copyfrom;
UWORD cnt;
/* Handle RAW read */
if(ioreq->ios2_Req.io_Flags & SANA2IOF_RAW)
{
/* ShapeShifter won't work with `sizeof(struct etherpacket_hdr)'
here. This is most likely because it want the RAW ethernet
packet checksum size (4) added to the packet size. */
copyfrom = (UBYTE *) eph;
datasize += sizeof(struct EtherPacketHeader) + 4;
} else {
copyfrom = (UBYTE *) (eph + 1);
}
/* Build up the ios2 structure enough so we can call the packet filter. */
ioreq->ios2_PacketType = AROS_BE2WORD(eph->eph_Type);
for(cnt = 0; cnt < ETHER_ADDR_SIZE; cnt++)
{
ioreq->ios2_SrcAddr[cnt] = eph->eph_Src[cnt];
ioreq->ios2_DstAddr[cnt] = eph->eph_Dest[cnt];
}
ioreq->ios2_DataLength = datasize;
/* Call the packet filter, if available. */
if((flags & PACKETFILTER) &&
(((struct BufMan *) ioreq->ios2_BufferManagement)->bm_PacketFilter) &&
(!callfilter(((struct BufMan *) ioreq->ios2_BufferManagement)->bm_PacketFilter,
ioreq, copyfrom)))
{
/* This packet got dropped! */
KPRINTF(7, ("readioreq: packet type %lu for ioreq 0x%08lx dropped\n",
AROS_BE2WORD(eph->eph_Type), ioreq));
return flags;
}
/* Ok, the packet didn't get dropped, set the BCAST and MCAST
flags according to dstaddr. */
/* Address == Multicast? */
if(ioreq->ios2_DstAddr[0] & 1)
{
/* Address == Broadcast? */
if((*((ULONG *) ioreq->ios2_DstAddr) == 0xffffffff) &&
(*((UWORD *) (ioreq->ios2_DstAddr + 4)) == 0xffff))
{
ioreq->ios2_Req.io_Flags |= SANA2IOF_BCAST;
} else {
ioreq->ios2_Req.io_Flags |= SANA2IOF_MCAST;
}
}
/* Finally copy the packet data! */
if(callcopy(((struct BufMan *) ioreq->ios2_BufferManagement)->bm_CopyToBuf,
ioreq->ios2_Data, copyfrom, ioreq->ios2_DataLength))
{
DB(
KPRINTF(5, ("readioreq: copytobuffed packet ior 0x%08lx, %04lx%08lx < %04lx%08lx, type %lu, %lu bytes, %s%s%s\n",
ioreq,
*((UWORD *) ioreq->ios2_DstAddr), *((ULONG *) (ioreq->ios2_DstAddr + 2)),
*((UWORD *) ioreq->ios2_SrcAddr), *((ULONG *) (ioreq->ios2_SrcAddr + 2)),
ioreq->ios2_PacketType, ioreq->ios2_DataLength,
(ioreq->ios2_Req.io_Flags & SANA2IOF_RAW) ? "RAW " : "",
(ioreq->ios2_Req.io_Flags & SANA2IOF_BCAST) ? "BCAST " : "",
(ioreq->ios2_Req.io_Flags & SANA2IOF_MCAST) ? "MCAST " : ""));
//dumpmem(copyfrom, ioreq->ios2_DataLength);
)
/* Clear the dropped flag */
flags &= ~DROPPED;
} else {
KPRINTF(10, ("readioreq: copyto returned failure!\n"));
/* Trigger any rx, buff or generic error events */
nDoEvent(ncp, S2EVENT_ERROR|S2EVENT_RX|S2EVENT_BUFF);
/* Set error code.
NOTE: Can't use RC_* or deverror() this is not called from devBeginIO()!
*/
ioreq->ios2_DataLength = 0;
ioreq->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
ioreq->ios2_WireError = S2WERR_BUFF_ERROR;
}
/* Pull the ioreq off the list & terminate it */
Forbid();
Remove((struct Node *) ioreq);
Permit();
ReplyMsg((struct Message *) ioreq);
return flags;
}
/* \\\ */
/* /// "nReadPacket()" */
BOOL nReadPacket(struct NepClassEth *ncp, UBYTE *pktptr, ULONG pktlen)
{
struct EtherPacketHeader *eph;
UBYTE *packetdata;
struct BufMan *bufman;
struct IOSana2Req *worknode, *nextnode;
struct Sana2PacketTypeStats *stats;
UWORD flags;
UWORD datasize;
KPRINTF(20, ("PktIn [%ld] %ld\n", ncp->ncp_ReadBufNum, pktlen));
//bug("in %d\n",pktlen);
// add RNDIS header
urndis_decap(ncp, (BYTE **)&pktptr, (LONG *)&pktlen);
//dumpmem(pktptr, pktlen);
if(pktlen < 14)
{
ncp->ncp_DeviceStats.BadData++;
return FALSE;
}
ncp->ncp_DeviceStats.PacketsReceived++;
eph = (struct EtherPacketHeader *) pktptr;
packetdata = (UBYTE *) (eph + 1);
stats = FindPacketTypeStats(ncp, (ULONG) AROS_BE2WORD(eph->eph_Type));
flags = DROPPED|PACKETFILTER;
/* Calculate size of the actual data */
datasize = pktlen - sizeof(struct EtherPacketHeader);
/* Is the packet datasize valid? */
if(pktlen <= ETHER_MAX_LEN)
{
/* Update the packet statistics */
if(stats)
{
stats->PacketsReceived++;
stats->BytesReceived += datasize; /* NOTE: don't include headers */
}
/* For each device user (bufman)
NOTE: We absolutely *MUST* try to offer the packet to *all*
different device users (SANA-II V2 spec requirement). */
Forbid();
bufman = (struct BufMan *) ncp->ncp_BufManList.lh_Head;
while(((struct Node *) bufman)->ln_Succ)
{
/* For each queued read request (ioreq) */
worknode = (struct IOSana2Req *) bufman->bm_RXQueue.lh_Head;
while((nextnode = (struct IOSana2Req *) (((struct Node *) worknode)->ln_Succ)))
{
/* Check the packet type. Also handles 802.3 packets. */
if((worknode->ios2_PacketType == AROS_BE2WORD(eph->eph_Type)) ||
((AROS_BE2WORD(eph->eph_Type) < 1500) && (worknode->ios2_PacketType < 1500)))
{
flags = nReadIOReq(ncp, eph, datasize, worknode, flags);
/* Break out - let other callers get the packet too */
break;
}
worknode = nextnode;
}
bufman = (struct BufMan *) (((struct Node *) bufman)->ln_Succ);
}
Permit();
/* Now we've tried to give the packet to every CMD_READ caller.
If DROPPED is set at this point no-one wanted this packet. */
if(flags & DROPPED)
{
/* So there were no outstanding CMD_READs or the packet wasn't
accepted by any of them. Okay, check if we have any pending
S2_READORPHAN ioreq in list and if we have return this packet
with it. Note that packet filter must not be used for this
time!
NOTE: orphanlist is global, ie. only one caller will get the
packet if multiple users have pending S2_READORPHANs.
*/
/* Process pending orphanread iorequs */
Forbid();
worknode = (struct IOSana2Req *) ncp->ncp_OrphanQueue.lh_Head;
while((nextnode = (struct IOSana2Req *) (((struct Node *) worknode)->ln_Succ)))
{
nReadIOReq(ncp, eph, datasize, worknode, 0);
worknode = nextnode;
}
Permit();
} else {
/* Packet not dropped - return ok */
return TRUE;
}
} else {
KPRINTF(20, ("Pktlen %ld invalid!\n", pktlen));
ncp->ncp_DeviceStats.BadData++;
}
/* Update global dropped packet counter. */
ncp->ncp_DeviceStats.UnknownTypesReceived++;
/* Update dropped packet statistics. */
if(stats)
{
stats->PacketsDropped++;
}
KPRINTF(9, ("readpacket: packet type %lu dropped\n", AROS_BE2WORD(eph->eph_Type)));
/* Trigger any rx or generic error events */
nDoEvent(ncp, S2EVENT_ERROR|S2EVENT_RX);
return FALSE;
}
/* \\\ */
/**************************************************************************/
/* * $Id$ */ #ifndef RNDIS_CLASS_H #define RNDIS_CLASS_H /* *---------------------------------------------------------------------------- * Includes for rndis class *---------------------------------------------------------------------------- */ #include "common.h" #include <devices/sana2.h> #include <devices/sana2specialstats.h> #include <libraries/gadtools.h> #include <devices/newstyle.h> #include <string.h> #include <stddef.h> #include <stdio.h> #include "if_urndisreg.h" #include "rndis.h" #include "dev.h" /* Protos */ struct NepClassEth * usbAttemptDeviceBinding(struct NepEthBase *nh, struct PsdDevice *pd); struct NepClassEth * usbForceDeviceBinding(struct NepEthBase *nh, struct PsdDevice *pd); void usbReleaseDeviceBinding(struct NepEthBase *nh, struct NepClassEth *ncp); struct NepClassEth * nAllocEth(void); void nFreeEth(struct NepClassEth *ncp); void nSetOnline(struct NepClassEth *ncp); void nDoEvent(struct NepClassEth *ncp, ULONG events); BOOL nWritePacket(struct NepClassEth *ncp, struct IOSana2Req *ioreq); BOOL nReadPacket(struct NepClassEth *ncp, UBYTE *pktptr, ULONG len); BOOL nLoadClassConfig(struct NepEthBase *nh); BOOL nLoadBindingConfig(struct NepClassEth *ncp); LONG nOpenBindingCfgWindow(struct NepEthBase *nh, struct NepClassEth *ncp); void nGUITaskCleanup(struct NepClassEth *nh); uint32_t urndis_ctrl_init(struct NepClassEth *ncp); uint32_t urndis_ctrl_handle(struct NepClassEth *ncp, struct urndis_comp_hdr *hdr,void **buf, size_t *bufsz); void urndis_attach(struct NepClassEth *ncp); long urndis_encap(struct NepClassEth *ncp, BYTE *m,LONG len ); void urndis_decap(struct NepClassEth *ncp, BYTE **buf, LONG *len); AROS_UFP0(void, nEthTask); AROS_UFP0(void, nGUITask); #endif /* RNDIS_CLASS_H */
唯一剩下的事情是在 Aros 上定义 uvc api 并编写驱动程序（不像在 Aros 上看到 v4l(2)）。
uvc.class 应该公开设备还是库？我希望它公开一个库，可以查询连接的设备并控制摄像头。如果设备上存在一些按钮，它还需要某种事件处理程序。当然，一个像 Webcam:cam1 这样的带有 fifo 的设备会很好。将所有解码留给 ffmpeg 或 mplayer 或其他任何东西……库更适合 Amiga，而我们可以使用库 + lib264 始终使用 mui 编写新的网络摄像头工具应用程序。
从网络摄像头捕获视频的建议
- 仅支持网络摄像头和测试图案。仅输入 -> webcam.library，可以在其中注册不同的驱动程序
- webcam.library 自行提供测试图案
另一方面，如果网络摄像头的输出不能随意抛出，那么它就没有用处。它将需要各种接口，帧格式还需要转换。MJPEG 到 RGB 等等。需要某种通用的视频堆栈。
void bayer2rgb24(unsigned char *dst, unsigned char *src, long int WIDTH, long int HEIGHT)
{
long int i;
unsigned char *rawpt, *scanpt;
long int size;
rawpt = src;
scanpt = dst;
size = WIDTH*HEIGHT;
for ( i = 0; i < size; i++ ) {
if ( (i/WIDTH) % 2 == 0 ) {
if ( (i % 2) == 0 ) {
/* B */
if ( (i > WIDTH) && ((i % WIDTH) > 0) ) {
*scanpt++ = (*(rawpt-WIDTH-1)+*(rawpt-WIDTH+1)+
*(rawpt+WIDTH-1)+*(rawpt+WIDTH+1))/4; /* R */
*scanpt++ = (*(rawpt-1)+*(rawpt+1)+
*(rawpt+WIDTH)+*(rawpt-WIDTH))/4; /* G */
*scanpt++ = *rawpt; /* B */
} else {
/* first line or left column */
*scanpt++ = *(rawpt+WIDTH+1); /* R */
*scanpt++ = (*(rawpt+1)+*(rawpt+WIDTH))/2; /* G */
*scanpt++ = *rawpt; /* B */
}
} else {
/* (B)G */
if ( (i > WIDTH) && ((i % WIDTH) < (WIDTH-1)) ) {
*scanpt++ = (*(rawpt+WIDTH)+*(rawpt-WIDTH))/2; /* R */
*scanpt++ = *rawpt; /* G */
*scanpt++ = (*(rawpt-1)+*(rawpt+1))/2; /* B */
} else {
/* first line or right column */
*scanpt++ = *(rawpt+WIDTH); /* R */
*scanpt++ = *rawpt; /* G */
*scanpt++ = *(rawpt-1); /* B */
}
}
} else {
if ( (i % 2) == 0 ) {
/* G(R) */
if ( (i < (WIDTH*(HEIGHT-1))) && ((i % WIDTH) > 0) ) {
*scanpt++ = (*(rawpt-1)+*(rawpt+1))/2; /* R */
*scanpt++ = *rawpt; /* G */
*scanpt++ = (*(rawpt+WIDTH)+*(rawpt-WIDTH))/2; /* B */
} else {
/* bottom line or left column */
*scanpt++ = *(rawpt+1); /* R */
*scanpt++ = *rawpt; /* G */
*scanpt++ = *(rawpt-WIDTH); /* B */
}
} else {
/* R */
if ( i < (WIDTH*(HEIGHT-1)) && ((i % WIDTH) < (WIDTH-1)) ) {
*scanpt++ = *rawpt; /* R */
*scanpt++ = (*(rawpt-1)+*(rawpt+1)+
*(rawpt-WIDTH)+*(rawpt+WIDTH))/4; /* G */
*scanpt++ = (*(rawpt-WIDTH-1)+*(rawpt-WIDTH+1)+
*(rawpt+WIDTH-1)+*(rawpt+WIDTH+1))/4; /* B */
} else {
/* bottom line or right column */
*scanpt++ = *rawpt; /* R */
*scanpt++ = (*(rawpt-1)+*(rawpt-WIDTH))/2; /* G */
*scanpt++ = *(rawpt-WIDTH-1); /* B */
}
}
}
rawpt++;
}
}
PS3-eye 摄像头，它使用 BULK 传输。使用该摄像头将是 Aros 上捕获视频的最快途径。PS3 摄像头还具有极高的帧速率，可以用于各种事情，如 3D 扫描等。成功打开 BULK 端点。摄像头输出 YUV，我只是将其写入窗口上的 ARGB。两者之间需要一些转换。一些伪像来自帧头（每隔 12 字节出现一次）。摄像头需要一些时间才能显示任何内容，这仅仅是因为我在捕获之前等待最后一帧到达，有时它无法捕获到。删除了 uvc 头字节，它开始看起来像可以识别的东西。有效负载大小有一个最佳值，一旦你达到这个值，就不需要同步帧以将原始像素写入 rastport。
一些或所有公共 Poseidon 包含文件都使用这些指令打包
#if defined(__GNUC__) # pragma pack(1) #endif
对于 ABIv1，是否反对删除它？在 Aros 中，我们尽可能使用原生打包。
这意味着代码将不再可以在 AROS/OS3/MorphOS/OS4 之间互换，并且还会影响与 PPC 上的 m68k 的二进制兼容性。在我看来，这不是一个好主意。也许添加某种 #define 或宏来仅在启用 M68K_COMPATIBILITY 时添加打包将允许在不可能使用 m68k 透明模拟器的平台上实现更好的性能。对 USB 来说，没有必要进行二进制兼容性。其他系统结构都没有打包。
这些是原始 USB 数据包。不要这样做，否则 Poseidon 将停止工作。MorphOS 使用 pack(2)。抱歉，关于 pack(1) 实例你说得对。但是，还有其他使用 pack(2) 打包的系统结构，应该解包。