ep0.c

Linux2.4.20针对三星公司的s3c2440内核基础上的一些设备驱动代码

					interface_descriptor =
					    alternate_instance->interface_descriptor;
					for (bNumEndpoint = 0;
					     bNumEndpoint < alternate_instance->endpoints;
					     bNumEndpoint++) {
						struct usb_endpoint_descriptor *endpoint_descriptor;
						//dbg_ep0(3, "[%d:%d:%d] endpoint: %d", bNumInterface, bAlternateSetting, 
						//        bNumEndpoint, interface_descriptor->bNumEndpoints);
						if (!(endpoint_descriptor =
						      usbd_device_endpoint_descriptor_index (device,
											     port,
											     index,
											     bNumInterface,
											     bAlternateSetting,
											     bNumEndpoint)))
						{
							dbg_ep0 (3, "[%d] endpoint NULL",
								 bNumEndpoint);
							return -EINVAL;
						}
						// copy descriptor for this endpoint
						copy_config (urb, endpoint_descriptor,
							     sizeof (struct
								     usb_endpoint_descriptor), max);
					}
				}
			}
			//dbg_ep0(3, "lengths: %d %d", le16_to_cpu(configuration_descriptor->wTotalLength), urb->actual_length);
		}
		break;

	case USB_DESCRIPTOR_TYPE_STRING:
		{
			struct usb_string_descriptor *string_descriptor;
			if (!(string_descriptor = usbd_get_string (index))) {
				return -EINVAL;
			}
			//dbg_ep0(3, "string_descriptor: %p", string_descriptor);
			copy_config (urb, string_descriptor, string_descriptor->bLength, max);
		}
		break;
	case USB_DESCRIPTOR_TYPE_INTERFACE:
		return -EINVAL;
	case USB_DESCRIPTOR_TYPE_ENDPOINT:
		return -EINVAL;
	case USB_DESCRIPTOR_TYPE_HID:
        {
		int bNumInterface = le16_to_cpu(urb->device_request.wIndex);
		int bAlternateSetting = 0;
		int class = 0;
		struct usb_class_descriptor *class_descriptor;
		if (!(class_descriptor = 
		      usbd_device_class_descriptor_index(
			      device, port, 0, bNumInterface,
			      bAlternateSetting, class)) ||
		    class_descriptor->descriptor.hid.bDescriptorType !=
		    USB_DT_HID) 
		{
			dbg_ep0(3, "[%d] interface is not HID", bNumInterface);
			return -EINVAL;
		}
		// copy descriptor for this class
		copy_config(urb, class_descriptor,
			    class_descriptor->descriptor.hid.bLength, max);
        }
        break;
	case USB_DESCRIPTOR_TYPE_REPORT:
	{
		int bNumInterface = le16_to_cpu(urb->device_request.wIndex);
		int bAlternateSetting = 0;
		int class = 0;
		struct usb_class_report_descriptor *report_descriptor;
		if (!(report_descriptor = 
		      usbd_device_class_report_descriptor_index(
			      device, port, 0, bNumInterface,
			      bAlternateSetting, class)) ||
		    report_descriptor->bDescriptorType != USB_DT_REPORT) 
		{
			dbg_ep0(3, "[%d] descriptor is not REPORT",
				bNumInterface);
			return -EINVAL;
		}
		// copy report descriptor for this class
		//copy_config(urb, &report_descriptor->bData[0], report_descriptor->wLength, max);
		if (max - urb->actual_length > 0) {
			int length = min_t(int, report_descriptor->wLength,
					   max - urb->actual_length);
			memcpy(urb->buffer + urb->actual_length,
			       &report_descriptor->bData[0], length);
			urb->actual_length += length;
		}
        }
        break;
	default:
		return -EINVAL;
	}


	//dbg_ep0(1, "urb: buffer: %p buffer_length: %2d actual_length: %2d packet size: %2d", 
	//        urb->buffer, urb->buffer_length, urb->actual_length, device->bus->endpoint_array[0].tx_packetSize);
/*
    if ((urb->actual_length < max) && !(urb->actual_length % device->bus->endpoint_array[0].tx_packetSize)) {
        dbg_ep0(0, "adding null byte");
        urb->buffer[urb->actual_length++] = 0;
        dbg_ep0(0, "urb: buffer_length: %2d actual_length: %2d packet size: %2d", 
                urb->buffer_length, urb->actual_length device->bus->endpoint_array[0].tx_packetSize);
    }
*/
	return 0;

}

/**
 * ep0_recv_setup - called to indicate URB has been received
 * @urb: pointer to struct urb
 *
 * Check if this is a setup packet, process the device request, put results
 * back into the urb and return zero or non-zero to indicate success (DATA)
 * or failure (STALL).
 *
 */
static int ep0_recv_setup (struct urb *urb)
{
	//struct usb_device_request *request = urb->buffer;
	//struct usb_device_instance *device = urb->device;

	struct usb_device_request *request;
	struct usb_device_instance *device;
	int address;

	if (!urb || !urb->device) {
		dbg_ep0 (3, "invalid URB %p", urb);
		return -EINVAL;
	}

	request = &urb->device_request;
	device = urb->device;

	//dbg_ep0(3, "urb: %p device: %p", urb, urb->device);


	//dbg_ep0(2, "-       -       -       -       -       -       -       -       -       -");

	dbg_ep0(2, "bmRequestType:%02x bRequest:%02x wValue:%04x wIndex:%04x wLength:%04x %s",
	        request->bmRequestType, 
                request->bRequest, 
	        le16_to_cpu(request->wValue), 
	        le16_to_cpu(request->wIndex), 
	        le16_to_cpu(request->wLength),
                USBD_DEVICE_REQUESTS(request->bRequest));

	// handle USB Standard Request (c.f. USB Spec table 9-2)
	if ((request->bmRequestType & USB_REQ_TYPE_MASK) != 0) {
		dbg_ep0 (1, "non standard request: %x", request->bmRequestType & USB_REQ_TYPE_MASK);
		return 0;	// XXX
	}
#if 0
	// check that this is for endpoint zero and is a SETUP packet
	if (urb->endpoint->endpoint_address != 0) {
		dbg_ep0 (1, "endpoint non zero: %d or not setup packet: %x",
			 urb->endpoint->endpoint_address, urb->pid);
		return -EINVAL;
	}
#endif

	switch (device->device_state) {
	case STATE_CREATED:
	case STATE_ATTACHED:
	case STATE_POWERED:
		dbg_ep0 (1, "request %s not allowed in this state: %s", 
                                USBD_DEVICE_REQUESTS(request->bRequest), 
                                usbd_device_states[device->device_state]);
		return -EINVAL;

	case STATE_INIT:
	case STATE_DEFAULT:
		switch (request->bRequest) {
		case USB_REQ_GET_STATUS:
		case USB_REQ_GET_INTERFACE:
		case USB_REQ_SYNCH_FRAME:	// XXX should never see this (?)
		case USB_REQ_CLEAR_FEATURE:
		case USB_REQ_SET_FEATURE:
		case USB_REQ_SET_DESCRIPTOR:
		// case USB_REQ_SET_CONFIGURATION:
		case USB_REQ_SET_INTERFACE:
			dbg_ep0 (1, "request %s not allowed in DEFAULT state: %s",
				 USBD_DEVICE_REQUESTS(request->bRequest), usbd_device_states[device->device_state]);
			return -EINVAL;

		case USB_REQ_SET_CONFIGURATION:
		case USB_REQ_SET_ADDRESS:
		case USB_REQ_GET_DESCRIPTOR:
		case USB_REQ_GET_CONFIGURATION:
			break;
		}
	case STATE_ADDRESSED:
	case STATE_CONFIGURED:
		break;
	case STATE_UNKNOWN:
		dbg_ep0 (1, "request %s not allowed in UNKNOWN state: %s", 
                                USBD_DEVICE_REQUESTS(request->bRequest), usbd_device_states[device->device_state]);
		return -EINVAL;
	}

	// handle all requests that return data (direction bit set on bm RequestType)
	if ((request->bmRequestType & USB_REQ_DIRECTION_MASK)) {

		//dbg_ep0(3, "Device-to-Host");

		switch (request->bRequest) {

		case USB_REQ_GET_STATUS:
			return ep0_get_status (device, urb, request->wIndex, request->bmRequestType & USB_REQ_RECIPIENT_MASK);

		case USB_REQ_GET_DESCRIPTOR:
			return ep0_get_descriptor (device, urb,
                                        le16_to_cpu (request->wLength),
                                        le16_to_cpu (request->wValue) >> 8,
                                        le16_to_cpu (request->wValue) & 0xff);

		case USB_REQ_GET_CONFIGURATION:
			return ep0_get_one (device, urb, device->configuration);

		case USB_REQ_GET_INTERFACE:
			return ep0_get_one (device, urb, device->alternate);

		case USB_REQ_SYNCH_FRAME:	// XXX should never see this (?)
			return -EINVAL;

		case USB_REQ_CLEAR_FEATURE:
		case USB_REQ_SET_FEATURE:
		case USB_REQ_SET_ADDRESS:
		case USB_REQ_SET_DESCRIPTOR:
		case USB_REQ_SET_CONFIGURATION:
		case USB_REQ_SET_INTERFACE:
			return -EINVAL;
		}
	}
	// handle the requests that do not return data
	else {


		//dbg_ep0(3, "Host-to-Device");
		switch (request->bRequest) {

		case USB_REQ_CLEAR_FEATURE:
		case USB_REQ_SET_FEATURE:
                        dbg_ep0(0, "Host-to-Device");
			switch (request->bmRequestType & USB_REQ_RECIPIENT_MASK) {
			case USB_REQ_RECIPIENT_DEVICE:
                                // XXX DEVICE_REMOTE_WAKEUP or TEST_MODE would be added here
                                // XXX fall through for now as we do not support either
			case USB_REQ_RECIPIENT_INTERFACE:
			case USB_REQ_RECIPIENT_OTHER:
                                dbg_ep0 (0, "request %s not", USBD_DEVICE_REQUESTS(request->bRequest));
                        default:
				return -EINVAL;

                        case USB_REQ_RECIPIENT_ENDPOINT:
                                dbg_ep0(0, "ENDPOINT: %x", le16_to_cpu(request->wValue));
                                if (le16_to_cpu(request->wValue) == USB_ENDPOINT_HALT) {
                                        return usbd_device_feature (device, le16_to_cpu (request->wIndex),
                                                        request->bRequest == USB_REQ_SET_FEATURE);
                                }
                                else {
                                        dbg_ep0 (1, "request %s bad wValue: %04x", 
                                                        USBD_DEVICE_REQUESTS(request->bRequest), le16_to_cpu(request->wValue));
                                        return -EINVAL ;
                                }
                        }

                case USB_REQ_SET_ADDRESS:
                        // check if this is a re-address, reset first if it is (this shouldn't be possible)
                        if (device->device_state != STATE_DEFAULT) {
                                dbg_ep0 (1, "set_address: %02x state: %s",
					 le16_to_cpu (request->wValue), usbd_device_states[device->device_state]);
				return -EINVAL;
			}
			address = le16_to_cpu (request->wValue);
			if ((address & 0x7f) != address) {
				dbg_ep0 (1, "invalid address %04x %04x", address, address & 0x7f);
				return -EINVAL;
			}
			device->address = address;

			//dbg_ep0(2, "address: %d %d %d", 
			//        request->wValue, le16_to_cpu(request->wValue), device->address);

			usbd_device_event (device, DEVICE_ADDRESS_ASSIGNED, 0);
			return 0;

		case USB_REQ_SET_DESCRIPTOR:	// XXX should we support this?
			dbg_ep0 (0, "set descriptor: NOT SUPPORTED");
			return -EINVAL;

		case USB_REQ_SET_CONFIGURATION:
			// c.f. 9.4.7 - the top half of wValue is reserved
			//
			if ((device->configuration = le16_to_cpu (request->wValue) & 0x7f) != 0) {
				// c.f. 9.4.7 - zero is the default or addressed state, in our case this
				// is the same is configuration zero
				device->configuration = 0;  // TBR - ??????
			}
			// reset interface and alternate settings
			device->interface = device->alternate = 0;

			//dbg_ep0(2, "set configuration: %d", device->configuration);
			usbd_device_event (device, DEVICE_CONFIGURED, 0);
			return 0;

		case USB_REQ_SET_INTERFACE:
			device->interface = le16_to_cpu (request->wIndex);
			device->alternate = le16_to_cpu (request->wValue);
			//dbg_ep0(2, "set interface: %d alternate: %d", device->interface, device->alternate);
			usbd_device_event (device, DEVICE_SET_INTERFACE, 0);
			return 0;

		case USB_REQ_GET_STATUS:
		case USB_REQ_GET_DESCRIPTOR:
		case USB_REQ_GET_CONFIGURATION:
		case USB_REQ_GET_INTERFACE:
		case USB_REQ_SYNCH_FRAME:	// XXX should never see this (?)
			return -EINVAL;
		}
	}
	return -EINVAL;
}

/**
 * ep0_urb_sent - called to indicate URB transmit finished
 * @urb: pointer to struct urb
 * @rc: result
 */
static int ep0_urb_sent (struct urb *urb, int rc)
{
	//dbg_ep0(2, "%s rc: %d", urb->device->name, rc);
	//usbd_dealloc_urb(urb);
	return 0;
}

static struct usb_function_operations ep0_ops = {
	event:		ep0_event,
	recv_setup:	ep0_recv_setup,
	urb_sent:	ep0_urb_sent,
};

struct usb_function_driver ep0_driver = {
	name:		"EP0",
	ops:		&ep0_ops,
};