Context Navigation

source: mainline/uspace/drv/ohci/root_hub.c@ ccbcd895

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since ccbcd895 was ccbcd895, checked in by Jan Vesely <jano.vesely@…>, 14 years ago
Fix: do not EVER touch batch.buffer
Property mode set to `100644`
File size: 23.9 KB

Rev	Line
[41b96b4]	1	/*
	2	* Copyright (c) 2011 Jan Vesely
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	*
	9	* - Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* - Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* - The name of the author may not be used to endorse or promote products
	15	* derived from this software without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	27	*/
	28	/** @addtogroup drvusbohci
	29	* @{
	30	*/
	31	/** @file
[81dce9f]	32	* @brief OHCI driver
[41b96b4]	33	*/
	34	#include <assert.h>
	35	#include <errno.h>
	36	#include <str_error.h>
	37
	38	#include <usb/debug.h>
	39
[bab71635]	40	#include "root_hub.h"
[d8421c4]	41	#include "usb/classes/classes.h"
[66a54cc]	42	#include "usb/devdrv.h"
[4d0c40b]	43	#include <usb/request.h>
	44	#include <usb/classes/hub.h>
	45
[0368669c]	46	/**
	47	* standart device descriptor for ohci root hub
	48	*/
[b3f655f]	49	static const usb_standard_device_descriptor_t ohci_rh_device_descriptor =
	50	{
	51	.configuration_count = 1,
	52	.descriptor_type = USB_DESCTYPE_DEVICE,
	53	.device_class = USB_CLASS_HUB,
	54	.device_protocol = 0,
	55	.device_subclass = 0,
	56	.device_version = 0,
	57	.length = sizeof(usb_standard_device_descriptor_t),
	58	/// \TODO this value is guessed
	59	.max_packet_size = 8,
	60	.vendor_id = 0x16db,
	61	.product_id = 0x0001,
	62	/// \TODO these values migt be different
	63	.str_serial_number = 0,
[66a54cc]	64	.usb_spec_version = 0x110,
[b3f655f]	65	};
	66
[0368669c]	67	/**
	68	* standart configuration descriptor with filled common values
	69	* for ohci root hubs
	70	*/
[b3f655f]	71	static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor =
	72	{
	73	/// \TODO some values are default or guessed
	74	.attributes = 1<<7,
	75	.configuration_number = 1,
	76	.descriptor_type = USB_DESCTYPE_CONFIGURATION,
	77	.interface_count = 1,
	78	.length = sizeof(usb_standard_configuration_descriptor_t),
	79	.max_power = 100,
	80	.str_configuration = 0,
	81	};
	82
[0368669c]	83	/**
	84	* standart ohci root hub interface descriptor
	85	*/
[b3f655f]	86	static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor =
	87	{
	88	.alternate_setting = 0,
	89	.descriptor_type = USB_DESCTYPE_INTERFACE,
	90	.endpoint_count = 1,
	91	.interface_class = USB_CLASS_HUB,
	92	/// \TODO is this correct?
	93	.interface_number = 1,
	94	.interface_protocol = 0,
	95	.interface_subclass = 0,
	96	.length = sizeof(usb_standard_interface_descriptor_t),
	97	.str_interface = 0,
	98	};
	99
[0368669c]	100	/**
	101	* standart ohci root hub endpoint descriptor
	102	*/
[b3f655f]	103	static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor =
	104	{
	105	.attributes = USB_TRANSFER_INTERRUPT,
	106	.descriptor_type = USB_DESCTYPE_ENDPOINT,
	107	.endpoint_address = 1 + (1<<7),
	108	.length = sizeof(usb_standard_endpoint_descriptor_t),
	109	.max_packet_size = 8,
	110	.poll_interval = 255,
	111	};
[41b96b4]	112
[8123695a]	113	static const uint32_t hub_clear_feature_valid_mask =
	114	(1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) +
	115	(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
	116
	117	static const uint32_t hub_clear_feature_by_writing_one_mask =
	118	1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
	119
	120	static const uint32_t hub_set_feature_valid_mask =
	121	(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
	122
	123
	124	static const uint32_t hub_set_feature_direct_mask =
	125	(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
	126
	127	static const uint32_t port_set_feature_valid_mask =
	128	(1 << USB_HUB_FEATURE_PORT_ENABLE) +
	129	(1 << USB_HUB_FEATURE_PORT_SUSPEND) +
	130	(1 << USB_HUB_FEATURE_PORT_RESET) +
	131	(1 << USB_HUB_FEATURE_PORT_POWER);
	132
	133	static const uint32_t port_clear_feature_valid_mask =
	134	(1 << USB_HUB_FEATURE_PORT_CONNECTION) +
	135	(1 << USB_HUB_FEATURE_PORT_SUSPEND) +
	136	(1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) +
	137	(1 << USB_HUB_FEATURE_PORT_POWER) +
	138	(1 << USB_HUB_FEATURE_C_PORT_CONNECTION) +
	139	(1 << USB_HUB_FEATURE_C_PORT_ENABLE) +
	140	(1 << USB_HUB_FEATURE_C_PORT_SUSPEND) +
	141	(1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) +
	142	(1 << USB_HUB_FEATURE_C_PORT_RESET);
	143	//note that USB_HUB_FEATURE_PORT_POWER bit is translated into USB_HUB_FEATURE_PORT_LOW_SPEED
	144
	145
	146
	147
[66a54cc]	148	/**
	149	* Create hub descriptor used in hub-driver <-> hub communication
	150	*
	151	* This means creating byt array from data in root hub registers. For more
	152	* info see usb hub specification.
	153	*
	154	* @param instance root hub instance
	155	* @param@out out_result pointer to resultant serialized descriptor
	156	* @param@out out_size size of serialized descriptor
	157	*/
	158	static void usb_create_serialized_hub_descriptor(rh_t *instance,
	159	uint8_t ** out_result,
	160	size_t * out_size) {
	161	//base size
	162	size_t size = 7;
	163	//variable size according to port count
	164	size_t var_size = instance->port_count / 8 +
	165	((instance->port_count % 8 > 0) ? 1 : 0);
	166	size += 2 * var_size;
	167	uint8_t * result = (uint8_t*) malloc(size);
	168	bzero(result,size);
	169	//size
	170	result[0] = size;
	171	//descriptor type
	172	result[1] = USB_DESCTYPE_HUB;
	173	result[2] = instance->port_count;
	174	uint32_t hub_desc_reg = instance->registers->rh_desc_a;
	175	result[3] =
	176	((hub_desc_reg >> 8) %2) +
	177	(((hub_desc_reg >> 9) %2) << 1) +
	178	(((hub_desc_reg >> 10) %2) << 2) +
	179	(((hub_desc_reg >> 11) %2) << 3) +
	180	(((hub_desc_reg >> 12) %2) << 4);
	181	result[4] = 0;
	182	result[5] = /descriptor->pwr_on_2_good_time/ 50;
	183	result[6] = 50;
	184
	185	int port;
	186	for (port = 1; port <= instance->port_count; ++port) {
	187	result[7 + port/8] +=
	188	((instance->registers->rh_desc_b >> port)%2) << (port%8);
	189	}
	190	size_t i;
	191	for (i = 0; i < var_size; ++i) {
	192	result[7 + var_size + i] = 255;
	193	}
	194	(*out_result) = result;
	195	(*out_size) = size;
	196	}
	197
	198
	199	/** initialize hub descriptors
	200	*
	201	* Initialized are device and full configuration descriptor. These need to
	202	* be initialized only once per hub.
	203	* @instance root hub instance
	204	*/
	205	static void rh_init_descriptors(rh_t *instance){
	206	memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
	207	sizeof(ohci_rh_device_descriptor)
	208	);
	209	usb_standard_configuration_descriptor_t descriptor;
	210	memcpy(&descriptor,&ohci_rh_conf_descriptor,
	211	sizeof(ohci_rh_conf_descriptor));
	212	uint8_t * hub_descriptor;
	213	size_t hub_desc_size;
	214	usb_create_serialized_hub_descriptor(instance, &hub_descriptor,
	215	&hub_desc_size);
	216
	217	descriptor.total_length =
	218	sizeof(usb_standard_configuration_descriptor_t)+
	219	sizeof(usb_standard_endpoint_descriptor_t)+
	220	sizeof(usb_standard_interface_descriptor_t)+
	221	hub_desc_size;
	222
	223	uint8_t * full_config_descriptor =
	224	(uint8_t*) malloc(descriptor.total_length);
	225	memcpy(full_config_descriptor, &descriptor, sizeof(descriptor));
	226	memcpy(full_config_descriptor + sizeof(descriptor),
	227	&ohci_rh_iface_descriptor, sizeof(ohci_rh_iface_descriptor));
	228	memcpy(full_config_descriptor + sizeof(descriptor) +
	229	sizeof(ohci_rh_iface_descriptor),
	230	&ohci_rh_ep_descriptor, sizeof(ohci_rh_ep_descriptor));
	231	memcpy(full_config_descriptor + sizeof(descriptor) +
	232	sizeof(ohci_rh_iface_descriptor) +
	233	sizeof(ohci_rh_ep_descriptor),
	234	hub_descriptor, hub_desc_size);
	235
	236	instance->descriptors.configuration = full_config_descriptor;
	237	instance->descriptors.configuration_size = descriptor.total_length;
	238	}
	239
[41b96b4]	240	/** Root hub initialization
	241	* @return Error code.
	242	*/
[a6d1bc1]	243	int rh_init(rh_t instance, ddf_dev_t dev, ohci_regs_t *regs)
[41b96b4]	244	{
	245	assert(instance);
[5156580]	246	instance->address = -1;
[42dbb26]	247	instance->registers = regs;
[a6d1bc1]	248	instance->device = dev;
[8123695a]	249	instance->port_count = instance->registers->rh_desc_a & 0xff;
[66a54cc]	250	rh_init_descriptors(instance);
[8123695a]	251	/// \TODO set port power mode
[42dbb26]	252
[4d0c40b]	253
[2c617b0]	254	usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
[42dbb26]	255
[4d0c40b]	256	//start generic usb hub driver
	257
[41b96b4]	258	/* TODO: implement */
	259	return EOK;
	260	}
	261	/----------------------------------------------------------------------------/
[4d0c40b]	262
[f3da9b2]	263	/**
	264	* create answer to port status_request
	265	*
	266	* Copy content of corresponding port status register to answer buffer.
	267	*
	268	* @param instance root hub instance
	269	* @param port port number, counted from 1
	270	* @param request structure containing both request and response information
	271	* @return error code
	272	*/
[4d0c40b]	273	static int process_get_port_status_request(rh_t *instance, uint16_t port,
[d8421c4]	274	usb_transfer_batch_t * request){
[4d0c40b]	275	if(port<1 \|\| port>instance->port_count)
	276	return EINVAL;
[ccbcd895]	277	uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
[d8421c4]	278	request->transfered_size = 4;
[4d0c40b]	279	uint32_buffer[0] = instance->registers->rh_port_status[port -1];
	280	return EOK;
	281	}
	282
[f3da9b2]	283	/**
	284	* create answer to port status_request
	285	*
	286	* Copy content of hub status register to answer buffer.
	287	*
	288	* @param instance root hub instance
	289	* @param request structure containing both request and response information
	290	* @return error code
	291	*/
[d8421c4]	292	static int process_get_hub_status_request(rh_t *instance,
	293	usb_transfer_batch_t * request){
[ccbcd895]	294	uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
[4d0c40b]	295	//bits, 0,1,16,17
[d8421c4]	296	request->transfered_size = 4;
[4d0c40b]	297	uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
	298	uint32_buffer[0] = mask & instance->registers->rh_status;
	299	return EOK;
	300
	301	}
	302
[d8421c4]	303
	304
[f3da9b2]	305	/**
	306	* create answer to status request
	307	*
	308	* This might be either hub status or port status request. If neither,
	309	* ENOTSUP is returned.
	310	* @param instance root hub instance
	311	* @param request structure containing both request and response information
	312	* @return error code
	313	*/
[d8421c4]	314	static int process_get_status_request(rh_t *instance,
	315	usb_transfer_batch_t * request)
	316	{
	317	size_t buffer_size = request->buffer_size;
	318	usb_device_request_setup_packet_t * request_packet =
	319	(usb_device_request_setup_packet_t*)
	320	request->setup_buffer;
	321
	322	usb_hub_bm_request_type_t request_type = request_packet->request_type;
	323	if(buffer_size<4/request_packet->length/){///\TODO
	324	usb_log_warning("requested more data than buffer size\n");
	325	return EINVAL;
	326	}
[4d0c40b]	327
	328	if(request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
[d8421c4]	329	return process_get_hub_status_request(instance, request);
[4d0c40b]	330	if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
[d8421c4]	331	return process_get_port_status_request(instance, request_packet->index,
	332	request);
[4d0c40b]	333	return ENOTSUP;
	334	}
	335
[f3da9b2]	336	/**
	337	* create answer to status interrupt consisting of change bitmap
	338	*
	339	* Result contains bitmap where bit 0 indicates change on hub and
	340	* bit i indicates change on i`th port (i>0). For more info see
	341	* Hub and Port status bitmap specification in USB specification.
	342	* @param instance root hub instance
	343	* @param@out buffer pointer to created interrupt mas
	344	* @param@out buffer_size size of created interrupt mask
	345	*/
[d8421c4]	346	static void create_interrupt_mask(rh_t instance, void * buffer,
	347	size_t * buffer_size){
	348	int bit_count = instance->port_count + 1;
	349	(*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1;
	350	(buffer) = malloc(buffer_size);
	351	uint8_t * bitmap = (uint8_t)(buffer);
	352	uint32_t mask = (1<<16) + (1<<17);
	353	bzero(bitmap,(*buffer_size));
	354	if(instance->registers->rh_status & mask){
	355	bitmap[0] = 1;
	356	}
	357	int port;
	358	mask = 0;
	359	int i;
	360	for(i=16;i<=20;++i)
	361	mask += 1<<i;
	362	for(port = 1; port<=instance->port_count;++port){
	363	if(mask & instance->registers->rh_port_status[port-1]){
	364	bitmap[(port+1)/8] += 1<<(port%8);
	365	}
	366	}
	367	}
[66a54cc]	368
[f3da9b2]	369	/**
	370	* create answer to a descriptor request
	371	*
	372	* This might be a request for standard (configuration, device, endpoint or
	373	* interface) or device specific (hub) descriptor.
	374	* @param instance root hub instance
	375	* @param request structure containing both request and response information
	376	* @return error code
	377	*/
[4d0c40b]	378	static int process_get_descriptor_request(rh_t *instance,
	379	usb_transfer_batch_t *request){
	380	usb_device_request_setup_packet_t * setup_request =
	381	(usb_device_request_setup_packet_t*)request->setup_buffer;
[d8421c4]	382	size_t size;
[aee6c73]	383	const void * result_descriptor = NULL;
[b3f655f]	384	const uint16_t setup_request_value = setup_request->value_high;
[d8421c4]	385	//(setup_request->value_low << 8);
[b3f655f]	386	bool del = false;
	387	switch (setup_request_value)
	388	{
[0368669c]	389	case USB_DESCTYPE_HUB: {
	390	uint8_t * descriptor;
	391	usb_create_serialized_hub_descriptor(
	392	instance, &descriptor, &size);
	393	result_descriptor = descriptor;
	394	if(result_descriptor) del = true;
	395	break;
	396	}
	397	case USB_DESCTYPE_DEVICE: {
	398	usb_log_debug("USB_DESCTYPE_DEVICE\n");
	399	result_descriptor = &ohci_rh_device_descriptor;
	400	size = sizeof(ohci_rh_device_descriptor);
	401	break;
	402	}
	403	case USB_DESCTYPE_CONFIGURATION: {
	404	usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
[66a54cc]	405	result_descriptor = instance->descriptors.configuration;
	406	size = instance->descriptors.configuration_size;
[0368669c]	407	break;
	408	}
	409	case USB_DESCTYPE_INTERFACE: {
	410	usb_log_debug("USB_DESCTYPE_INTERFACE\n");
	411	result_descriptor = &ohci_rh_iface_descriptor;
	412	size = sizeof(ohci_rh_iface_descriptor);
	413	break;
	414	}
	415	case USB_DESCTYPE_ENDPOINT: {
	416	usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
	417	result_descriptor = &ohci_rh_ep_descriptor;
	418	size = sizeof(ohci_rh_ep_descriptor);
	419	break;
	420	}
	421	default: {
	422	usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
	423	usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
	424	setup_request->request_type,
	425	setup_request->request,
	426	setup_request_value,
	427	setup_request->index,
	428	setup_request->length
	429	);
	430	return EINVAL;
	431	}
[4d0c40b]	432	}
[d8421c4]	433	if(request->buffer_size < size){
	434	size = request->buffer_size;
	435	}
	436	request->transfered_size = size;
[66a54cc]	437	memcpy(request->transport_buffer,result_descriptor,size);
	438	usb_log_debug("sent desctiptor: %s\n",
	439	usb_debug_str_buffer((uint8_t*)request->transport_buffer,size,size));
[0368669c]	440	if (del)
[b3f655f]	441	free(result_descriptor);
[4d0c40b]	442	return EOK;
	443	}
	444
[f3da9b2]	445	/**
	446	* answer to get configuration request
	447	*
	448	* Root hub works independently on the configuration.
	449	* @param instance root hub instance
	450	* @param request structure containing both request and response information
	451	* @return error code
	452	*/
[d8421c4]	453	static int process_get_configuration_request(rh_t *instance,
	454	usb_transfer_batch_t *request){
[4d0c40b]	455	//set and get configuration requests do not have any meaning, only dummy
	456	//values are returned
[d8421c4]	457	if(request->buffer_size != 1)
[4d0c40b]	458	return EINVAL;
[ccbcd895]	459	request->transport_buffer[0] = 1;
[d8421c4]	460	request->transfered_size = 1;
[4d0c40b]	461	return EOK;
	462	}
	463
[f3da9b2]	464	/**
[8123695a]	465	* process feature-enabling request on hub
[f3da9b2]	466	*
	467	* @param instance root hub instance
	468	* @param feature feature selector
	469	* @return error code
	470	*/
[4d0c40b]	471	static int process_hub_feature_set_request(rh_t *instance,
[8123695a]	472	uint16_t feature){
	473	if(! ((1<<feature) & hub_set_feature_valid_mask))
[4d0c40b]	474	return EINVAL;
	475	instance->registers->rh_status =
	476	(instance->registers->rh_status \| (1<<feature))
[8123695a]	477	& (~ hub_clear_feature_by_writing_one_mask);
[4d0c40b]	478	return EOK;
	479	}
	480
[f3da9b2]	481	/**
[8123695a]	482	* process feature-disabling request on hub
	483	*
	484	* @param instance root hub instance
	485	* @param feature feature selector
	486	* @return error code
	487	*/
	488	static int process_hub_feature_clear_request(rh_t *instance,
	489	uint16_t feature){
	490	if(! ((1<<feature) & hub_clear_feature_valid_mask))
	491	return EINVAL;
	492	//is the feature cleared directly?
	493	if ((1<<feature) & hub_set_feature_direct_mask){
	494	instance->registers->rh_status =
	495	(instance->registers->rh_status & (~(1<<feature)))
	496	& (~ hub_clear_feature_by_writing_one_mask);
	497	}else{//the feature is cleared by writing '1'
	498	instance->registers->rh_status =
	499	(instance->registers->rh_status
	500	& (~ hub_clear_feature_by_writing_one_mask))
	501	\| (1<<feature);
	502	}
	503	return EOK;
	504	}
	505
	506
	507
	508	/**
	509	* process feature-enabling request on hub
[f3da9b2]	510	*
	511	* @param instance root hub instance
	512	* @param feature feature selector
	513	* @param port port number, counted from 1
	514	* @param enable enable or disable the specified feature
	515	* @return error code
	516	*/
[4d0c40b]	517	static int process_port_feature_set_request(rh_t *instance,
[8123695a]	518	uint16_t feature, uint16_t port){
	519	if(!((1<<feature) & port_set_feature_valid_mask))
[4d0c40b]	520	return EINVAL;
	521	if(port<1 \|\| port>instance->port_count)
	522	return EINVAL;
	523	instance->registers->rh_port_status[port - 1] =
	524	(instance->registers->rh_port_status[port - 1] \| (1<<feature))
[8123695a]	525	& (~port_clear_feature_valid_mask);
	526	/// \TODO any error?
	527	return EOK;
	528	}
	529
	530	/**
	531	* process feature-disabling request on hub
	532	*
	533	* @param instance root hub instance
	534	* @param feature feature selector
	535	* @param port port number, counted from 1
	536	* @param enable enable or disable the specified feature
	537	* @return error code
	538	*/
	539	static int process_port_feature_clear_request(rh_t *instance,
	540	uint16_t feature, uint16_t port){
	541	if(!((1<<feature) & port_clear_feature_valid_mask))
	542	return EINVAL;
	543	if(port<1 \|\| port>instance->port_count)
	544	return EINVAL;
	545	if(feature == USB_HUB_FEATURE_PORT_POWER)
	546	feature = USB_HUB_FEATURE_PORT_LOW_SPEED;
	547	if(feature == USB_HUB_FEATURE_PORT_SUSPEND)
	548	feature = USB_HUB_FEATURE_PORT_OVER_CURRENT;
	549	instance->registers->rh_port_status[port - 1] =
	550	(instance->registers->rh_port_status[port - 1]
	551	& (~port_clear_feature_valid_mask))
	552	\| (1<<feature);
[4d0c40b]	553	/// \TODO any error?
	554	return EOK;
[d8421c4]	555	}
[4d0c40b]	556
[8123695a]	557
[f3da9b2]	558	/**
	559	* register address to this device
	560	*
	561	* @param instance root hub instance
	562	* @param address new address
	563	* @return error code
	564	*/
[d8421c4]	565	static int process_address_set_request(rh_t *instance,
	566	uint16_t address){
	567	instance->address = address;
	568	return EOK;
[4d0c40b]	569	}
	570
[f3da9b2]	571	/**
	572	* process one of requests that requere output data
	573	*
	574	* Request can be one of USB_DEVREQ_GET_STATUS, USB_DEVREQ_GET_DESCRIPTOR or
	575	* USB_DEVREQ_GET_CONFIGURATION.
	576	* @param instance root hub instance
	577	* @param request structure containing both request and response information
	578	* @return error code
	579	*/
[4d0c40b]	580	static int process_request_with_output(rh_t *instance,
	581	usb_transfer_batch_t *request){
	582	usb_device_request_setup_packet_t * setup_request =
	583	(usb_device_request_setup_packet_t*)request->setup_buffer;
	584	if(setup_request->request == USB_DEVREQ_GET_STATUS){
[d8421c4]	585	usb_log_debug("USB_DEVREQ_GET_STATUS\n");
	586	return process_get_status_request(instance, request);
[4d0c40b]	587	}
	588	if(setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){
[d8421c4]	589	usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
[4d0c40b]	590	return process_get_descriptor_request(instance, request);
	591	}
	592	if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
[d8421c4]	593	usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
	594	return process_get_configuration_request(instance, request);
[4d0c40b]	595	}
	596	return ENOTSUP;
	597	}
	598
[f3da9b2]	599	/**
	600	* process one of requests that carry input data
	601	*
	602	* Request can be one of USB_DEVREQ_SET_DESCRIPTOR or
	603	* USB_DEVREQ_SET_CONFIGURATION.
	604	* @param instance root hub instance
	605	* @param request structure containing both request and response information
	606	* @return error code
	607	*/
[4d0c40b]	608	static int process_request_with_input(rh_t *instance,
	609	usb_transfer_batch_t *request){
	610	usb_device_request_setup_packet_t * setup_request =
	611	(usb_device_request_setup_packet_t*)request->setup_buffer;
[d8421c4]	612	request->transfered_size = 0;
[4d0c40b]	613	if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
	614	return ENOTSUP;
	615	}
	616	if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
	617	//set and get configuration requests do not have any meaning,
	618	//only dummy values are returned
	619	return EOK;
	620	}
	621	return ENOTSUP;
	622	}
	623
[f3da9b2]	624	/**
	625	* process one of requests that do not request nor carry additional data
	626	*
	627	* Request can be one of USB_DEVREQ_CLEAR_FEATURE, USB_DEVREQ_SET_FEATURE or
	628	* USB_DEVREQ_SET_ADDRESS.
	629	* @param instance root hub instance
	630	* @param request structure containing both request and response information
	631	* @return error code
	632	*/
[4d0c40b]	633	static int process_request_without_data(rh_t *instance,
	634	usb_transfer_batch_t *request){
	635	usb_device_request_setup_packet_t * setup_request =
	636	(usb_device_request_setup_packet_t*)request->setup_buffer;
[d8421c4]	637	request->transfered_size = 0;
[8123695a]	638	if(setup_request->request == USB_DEVREQ_CLEAR_FEATURE){
[d8421c4]	639	if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
	640	usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
[8123695a]	641	return process_hub_feature_clear_request(instance,
	642	setup_request->value);
[d8421c4]	643	}
	644	if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
	645	usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
[8123695a]	646	return process_port_feature_clear_request(instance,
	647	setup_request->value,
	648	setup_request->index);
	649	}
	650	usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
	651	setup_request->request_type);
	652	return EINVAL;
	653	}
	654	if(setup_request->request == USB_DEVREQ_SET_FEATURE){
	655	if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
	656	usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
	657	return process_hub_feature_set_request(instance,
	658	setup_request->value);
	659	}
	660	if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
	661	usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
	662	return process_port_feature_set_request(instance,
	663	setup_request->value,
	664	setup_request->index);
[d8421c4]	665	}
	666	usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type);
	667	return EINVAL;
[4d0c40b]	668	}
[d8421c4]	669	if(setup_request->request == USB_DEVREQ_SET_ADDRESS){
	670	usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
	671	return process_address_set_request(instance, setup_request->value);
[4d0c40b]	672	}
[d8421c4]	673	usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type);
[4d0c40b]	674	return ENOTSUP;
	675	}
	676
[f3da9b2]	677	/**
	678	* process hub control request
	679	*
	680	* If needed, writes answer into the request structure.
	681	* Request can be one of
	682	* USB_DEVREQ_GET_STATUS,
	683	* USB_DEVREQ_GET_DESCRIPTOR,
	684	* USB_DEVREQ_GET_CONFIGURATION,
	685	* USB_DEVREQ_CLEAR_FEATURE,
	686	* USB_DEVREQ_SET_FEATURE,
	687	* USB_DEVREQ_SET_ADDRESS,
	688	* USB_DEVREQ_SET_DESCRIPTOR or
	689	* USB_DEVREQ_SET_CONFIGURATION.
	690	*
	691	* @param instance root hub instance
	692	* @param request structure containing both request and response information
	693	* @return error code
	694	*/
	695	static int process_ctrl_request(rh_t instance, usb_transfer_batch_t request){
	696	int opResult;
	697	if (request->setup_buffer) {
	698	if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){
	699	usb_log_error("setup packet too small\n");
	700	return EINVAL;
	701	}
	702	usb_log_info("CTRL packet: %s.\n",
	703	usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
	704	usb_device_request_setup_packet_t * setup_request =
	705	(usb_device_request_setup_packet_t*)request->setup_buffer;
	706	if(
	707	setup_request->request == USB_DEVREQ_GET_STATUS
	708	\|\| setup_request->request == USB_DEVREQ_GET_DESCRIPTOR
	709	\|\| setup_request->request == USB_DEVREQ_GET_CONFIGURATION
	710	){
	711	usb_log_debug("processing request with output\n");
	712	opResult = process_request_with_output(instance,request);
	713	}else if(
	714	setup_request->request == USB_DEVREQ_CLEAR_FEATURE
	715	\|\| setup_request->request == USB_DEVREQ_SET_FEATURE
	716	\|\| setup_request->request == USB_DEVREQ_SET_ADDRESS
	717	){
	718	usb_log_debug("processing request without additional data\n");
	719	opResult = process_request_without_data(instance,request);
	720	}else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR
	721	\|\| setup_request->request == USB_DEVREQ_SET_CONFIGURATION
	722	){
	723	usb_log_debug("processing request with input\n");
	724	opResult = process_request_with_input(instance,request);
	725	}else{
	726	usb_log_warning("received unsuported request: %d\n",
	727	setup_request->request
	728	);
	729	opResult = ENOTSUP;
	730	}
	731	}else{
	732	usb_log_error("root hub received empty transaction?");
	733	opResult = EINVAL;
	734	}
	735	return opResult;
	736	}
[4d0c40b]	737
	738	/**
[f3da9b2]	739	* process root hub request
[4d0c40b]	740	*
[f3da9b2]	741	* @param instance root hub instance
	742	* @param request structure containing both request and response information
	743	* @return error code
[4d0c40b]	744	*/
[1387692]	745	int rh_request(rh_t instance, usb_transfer_batch_t request)
[41b96b4]	746	{
[d328172]	747	assert(instance);
	748	assert(request);
[4d0c40b]	749	int opResult;
[d8421c4]	750	if(request->transfer_type == USB_TRANSFER_CONTROL){
[f3da9b2]	751	usb_log_info("Root hub got CONTROL packet\n");
	752	opResult = process_ctrl_request(instance,request);
[d8421c4]	753	}else if(request->transfer_type == USB_TRANSFER_INTERRUPT){
	754	usb_log_info("Root hub got INTERRUPT packet\n");
	755	void * buffer;
	756	create_interrupt_mask(instance, &buffer,
	757	&(request->transfered_size));
	758	memcpy(request->transport_buffer,buffer, request->transfered_size);
	759	opResult = EOK;
[4d0c40b]	760	}else{
	761	opResult = EINVAL;
[d328172]	762	}
[4d0c40b]	763	usb_transfer_batch_finish(request, opResult);
[d328172]	764	return EOK;
[41b96b4]	765	}
	766	/----------------------------------------------------------------------------/
[d8421c4]	767
	768
[a6d1bc1]	769	void rh_interrupt(rh_t *instance)
[41b96b4]	770	{
[0368669c]	771	usb_log_info("Whoa whoa wait, I`m not supposed to receive any interrupts, am I?\n");
[f3da9b2]	772	/* TODO: implement? */
[41b96b4]	773	}
	774	/**
	775	* @}
	776	*/

Note: See TracBrowser for help on using the repository browser.

Download in other formats: