Context Navigation

source: rtems/c/src/libchip/ide/ata.c @ c0cc985

4.104.114.95

Last change on this file since c0cc985 was f031251c, checked in by Chris Johns <chrisj@…>, on 08/02/08 at 06:26:29

2008-08-02 Chris Johns <chrisj@…>

libchip/i2c/spi-sd-card.c, libchip/ide/ata.c: Remove rtems_blkdev_request count and start references. Use RTEMS_BLKDEV_START_BLOCK.

Property mode set to 100644

File size: 49.8 KB

Line
1	/*
2	* ata.c
3	*
4	* ATA RTEMS driver. ATA driver is hardware independant implementation of
5	* ATA-2 standart, working draft X3T10/0948D, revision 4c. ATA driver bases
6	* on RTEMS IDE controller driver.
7	*
8	* Copyright (C) 2001 OKTET Ltd., St.-Petersburg, Russia
9	* Authors: Eugeny S. Mints <Eugeny.Mints@oktet.ru>
10	*
11	* The license and distribution terms for this file may be
12	* found in the file LICENSE in this distribution or at
13	* http://www.rtems.com/license/LICENSE.
14	*
15	* $Id$
16	*
17	*/
18	#include <errno.h>
19	#include <rtems/chain.h>
20	#include <assert.h>
21	#include <string.h> /* for "memset" declaration */
22
23	#include <rtems/diskdevs.h>
24	#include <rtems/blkdev.h>
25	#include <libchip/ide_ctrl_io.h>
26	#include <libchip/ide_ctrl_cfg.h>
27	#include "ata_internal.h"
28	#include <libchip/ata.h>
29	/* #define DEBUG */
30
31	#ifdef DEBUG
32	#include <stdio.h>
33	#endif
34
35	/*
36	* FIXME: make this better...
37	* find out, which exception model is used
38	* assume, that all i386 BSPs use new exception handling
39	* assume, that some PPC BSPs use new exception handling
40	* assume, that all other BSPs use old exception handling
41	*/
42	#if defined(_OLD_EXCEPTIONS) \|\| (!defined(__i386__) && !defined(__PPC__))
43
44	#define ATA_USE_OLD_EXCEPTIONS
45	#endif
46
47	#if !defined(ATA_USE_OLD_EXCEPTIONS)
48	#include <bsp/irq.h>
49	#define ATA_IRQ_CHAIN_MAX_CNT 4 /* support up to 4 ATA devices */
50	typedef struct {
51	rtems_irq_number name;
52	rtems_chain_control irq_chain;
53	} ata_irq_chain_t;
54
55	ata_irq_chain_t ata_irq_chain[ATA_IRQ_CHAIN_MAX_CNT];
56	int ata_irq_chain_cnt = 0;
57	#endif
58
59	#define SAFE
60	#define SAFE_MUTEX
61
62	#ifdef SAFE
63	#ifdef SAFE_MUTEX
64	static rtems_id ata_lock;
65	static void
66	rtems_ata_lock ()
67	{
68	rtems_status_code sc = rtems_semaphore_obtain (ata_lock,
69	RTEMS_WAIT,
70	RTEMS_NO_TIMEOUT);
71	if (sc != RTEMS_SUCCESSFUL)
72	rtems_fatal_error_occurred (RTEMS_INTERNAL_ERROR);
73	}
74
75	static void
76	rtems_ata_unlock ()
77	{
78	rtems_status_code sc = rtems_semaphore_release (ata_lock);
79	if (sc != RTEMS_SUCCESSFUL)
80	rtems_fatal_error_occurred (RTEMS_INTERNAL_ERROR);
81	}
82
83	#define RTEMS_ATA_LOCK_ATTRIBS \
84	(RTEMS_PRIORITY \| RTEMS_BINARY_SEMAPHORE \| \
85	RTEMS_INHERIT_PRIORITY \| RTEMS_NO_PRIORITY_CEILING \| RTEMS_LOCAL)
86
87	#define PREEMPTION_KEY(key)
88	#define DISABLE_PREEMPTION(key) rtems_ata_lock ()
89	#define ENABLE_PREEMPTION(key) rtems_ata_unlock ()
90
91	#else /* !SAFE_MUTEX */
92	typedef rtems_mode preemption_key;
93
94	#define PREEMPTION_KEY(key) preemption_key key
95
96	#define DISABLE_PREEMPTION(key) \
97	do { \
98	rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &(key)); \
99	} while (0)
100
101	#define ENABLE_PREEMPTION(key) \
102	do { \
103	rtems_mode temp; \
104	rtems_task_mode((key), RTEMS_PREEMPT_MASK, &temp); \
105	} while (0)
106	#endif
107	#else /* !SAFE */
108	typedef boolean preemption_key;
109
110	#define PREEMPTION_KEY(key) preemption_key key
111
112	#define DISABLE_PREEMPTION(key) \
113	do { \
114	(key) = _Thread_Executing->is_preemptible; \
115	_Thread_Executing->is_preemptible = 0; \
116	} while (0)
117
118	#define ENABLE_PREEMPTION(key) \
119	do { \
120	_Thread_Executing->is_preemptible = (key); \
121	if (_Thread_Evaluate_mode()) \
122	_Thread_Dispatch(); \
123	} while (0)
124
125	#endif
126
127	/* FIXME: case if ATA device is FLASH device need more attention */
128	#undef ATA_DEV_IS_FLASH_DISK
129
130	/* Block device request with a single buffer provided */
131	typedef struct blkdev_request1 {
132	rtems_blkdev_request req;
133	rtems_blkdev_sg_buffer sg[1];
134	} blkdev_request1;
135
136
137	/* Array indexed by controllers minor number */
138	static ata_ide_ctrl_t ata_ide_ctrls[IDE_CTRL_MAX_MINOR_NUMBER];
139
140	/*
141	* Mapping from ATA-minor numbers to
142	* controller-minor and device on this controller.
143	*/
144	static ata_ide_dev_t ata_devs[2 * IDE_CTRL_MAX_MINOR_NUMBER];
145	static int ata_devs_number;
146
147	/* Flag meaning that ATA driver has already been initialized */
148	static rtems_boolean ata_initialized = FALSE;
149
150
151	/* task and queue used for asynchronous I/O operations */
152	static rtems_id ata_task_id;
153	static rtems_id ata_queue_id;
154
155	#if defined (ATA_USE_OLD_EXCEPTIONS)
156	/* Mapping of interrupt vectors to devices */
157	static rtems_chain_control ata_int_vec[ATA_MAX_RTEMS_INT_VEC_NUMBER + 1];
158	#endif
159
160	static void
161	ata_process_request(rtems_device_minor_number ctrl_minor);
162
163	static void
164	ata_process_request_on_init_phase(rtems_device_minor_number ctrl_minor,
165	ata_req_t *areq);
166
167	static void
168	ata_add_to_controller_queue(rtems_device_minor_number ctrl_minor,
169	ata_req_t *areq);
170
171	/*
172	* read/write, open/close and ioctl are provided by general block device
173	* driver. Only initialization and ata-specific ioctl are here.
174	*/
175
176	/* ata_io_data_request --
177	* Form read/write request for an ATA device and enqueue it to
178	* IDE controller.
179	*
180	* PARAMETERS:
181	* device - device identifier
182	* req - read/write request from block device driver
183	*
184	* RETURNS:
185	* RTEMS_SUCCESSFUL on success, or error code if
186	* error occured
187	*/
188	static rtems_status_code
189	ata_io_data_request(dev_t device, rtems_blkdev_request *req)
190	{
191	ata_req_t areq; / ATA request */
192	rtems_device_minor_number rel_minor; /* relative minor which indexes
193	* ata_devs array
194	*/
195	rtems_device_minor_number ctrl_minor;
196	uint8_t dev;
197
198	rel_minor = (rtems_filesystem_dev_minor_t(device)) /
199	ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
200
201	/* get controller which serves the ATA device */
202	ctrl_minor = ata_devs[rel_minor].ctrl_minor;
203
204	/* get ATA device identifier (0 or 1) */
205	dev = ata_devs[rel_minor].device;
206
207	areq = malloc(sizeof(ata_req_t));
208	if (areq == NULL)
209	{
210	return RTEMS_NO_MEMORY;
211	}
212
213	areq->breq = req;
214	areq->cnt = req->bufnum;
215	areq->cbuf = 0;
216	areq->pos = 0;
217
218	/* set up registers masks */
219	areq->regs.to_write = ATA_REGISTERS_POSITION;
220	areq->regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_STATUS);
221
222	/* choose device on the controller for which the command will be issued */
223	areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] =
224	(dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);
225
226	/* Find ATA command and its type */
227	if (ATA_DEV_INFO(ctrl_minor, dev).mode_active & ATA_MODES_DMA)
228	{
229	/* XXX: never has been tested */
230	areq->type = ATA_COMMAND_TYPE_DMA;
231	if (req->req == RTEMS_BLKDEV_REQ_READ)
232	areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_READ_DMA;
233	else
234	areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_WRITE_DMA;
235	}
236	else
237	{
238	if (req->req == RTEMS_BLKDEV_REQ_READ)
239	{
240	#ifdef DEBUG
241	printf("ata_io_data_request: type: READ: %d, %d\n",
242	req->bufs[0].block, req->bufnum);
243	#endif
244	areq->type = ATA_COMMAND_TYPE_PIO_IN;
245
246	/*
247	* choose command to issue: if the number of blocks to be
248	* exchanged is greater then 1 and for ATA command READ MULTIPLE
249	* data block consists of more then 1 sector choose READ MULTIPLE
250	* otherwise READ SECTORS
251	*/
252	areq->regs.regs[IDE_REGISTER_COMMAND] =
253	((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
254	(req->bufnum > 1) &&
255	(ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ?
256	ATA_COMMAND_READ_MULTIPLE :
257	ATA_COMMAND_READ_SECTORS;
258	}
259	else
260	{
261	#ifdef DEBUG
262	printf("ata_io_data_request: type: WRITE: %d, %d\n",
263	req->bufs[0].block, req->bufnum);
264	#endif
265	areq->type = ATA_COMMAND_TYPE_PIO_OUT;
266
267	/*
268	* choose command to issue: if the number of blocks to be
269	* exchanged is greater then 1 and for ATA command WRITE MULTIPLE
270	* data block consists of more then 1 sector choose WRITE MULTIPLE
271	* otherwise WRITE SECTORS
272	*/
273	areq->regs.regs[IDE_REGISTER_COMMAND] =
274	((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
275	(req->bufnum > 1) &&
276	(ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ?
277	ATA_COMMAND_WRITE_MULTIPLE :
278	ATA_COMMAND_WRITE_SECTORS;
279	}
280	}
281
282	/*
283	* Fill position registers
284	*/
285	if (ATA_DEV_INFO(ctrl_minor, dev).lba_avaible)
286	{
287	uint32_t start = req->bufs[0].block;
288	areq->regs.regs[IDE_REGISTER_LBA0] = (uint8_t)start;
289	areq->regs.regs[IDE_REGISTER_LBA1] = (uint8_t)(start >> 8);
290	areq->regs.regs[IDE_REGISTER_LBA2] = (uint8_t)(start >> 16);
291	areq->regs.regs[IDE_REGISTER_LBA3] \|= (uint8_t) (start >> 24);
292	areq->regs.regs[IDE_REGISTER_LBA3] \|= IDE_REGISTER_LBA3_L;
293	}
294	else
295	{
296	uint32_t count = req->bufs[0].block;
297
298	areq->regs.regs[IDE_REGISTER_SECTOR_NUMBER] =
299	(count % ATA_DEV_INFO(ctrl_minor, dev).sectors) + 1;
300
301	/* now count = number of tracks: */
302	count /= ATA_DEV_INFO(ctrl_minor, dev).sectors;
303	areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] \|=
304	(count / ATA_DEV_INFO(ctrl_minor, dev).cylinders);
305
306	/* now count = number of cylinders */
307	count %= ATA_DEV_INFO(ctrl_minor, dev).cylinders;
308	areq->regs.regs[IDE_REGISTER_CYLINDER_LOW] = (uint8_t)count;
309	areq->regs.regs[IDE_REGISTER_CYLINDER_HIGH] = (uint8_t)(count >> 8);
310	areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &=
311	~IDE_REGISTER_DEVICE_HEAD_L;
312	}
313
314	/* fill sector count register */
315	areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] = areq->breq->bufnum;
316
317	/* add request to the queue of awaiting requests to the controller */
318	ata_add_to_controller_queue(ctrl_minor, areq);
319
320	return RTEMS_SUCCESSFUL;
321	}
322
323	/* ata_non_data_request --
324	* Form and serve request of NON DATA type for an ATA device.
325	* Processing of NON DATA request is SYNChronous operation.
326	*
327	* PARAMETERS:
328	* device - device identifier
329	* cmd - command
330	* argp - arguments for command
331	*
332	* RETURNS:
333	* RTEMS_SUCCESSFUL on success, or error code if
334	* error occured
335	*/
336	static rtems_status_code
337	ata_non_data_request(dev_t device, int cmd, void *argp)
338	{
339	rtems_status_code rc;
340	ata_req_t areq; / ATA request */
341	rtems_device_minor_number rel_minor; /* relative minor which indexes
342	* ata_devs array
343	*/
344	rtems_device_minor_number ctrl_minor;
345	uint8_t dev;
346	ata_queue_msg_t msg;
347
348	rel_minor = (rtems_filesystem_dev_minor_t(device)) /
349	ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
350
351	/* get controller which serves the ATA device */
352	ctrl_minor = ata_devs[rel_minor].ctrl_minor;
353
354	/* get ATA device identifier (0 or 1) */
355	dev = ata_devs[rel_minor].device;
356
357	/* form the request */
358	areq = malloc(sizeof(ata_req_t));
359	if (areq == NULL)
360	{
361	return RTEMS_NO_MEMORY;
362	}
363	memset(areq, 0, sizeof(ata_req_t));
364
365	areq->type = ATA_COMMAND_TYPE_NON_DATA;
366	areq->regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
367	areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] \|=
368	(dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);
369	areq->breq = NULL;
370	areq->regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_ERROR);
371
372	/*
373	* depending on command fill command register and additional registers
374	* which are needed for command execution
375	*/
376	switch(cmd)
377	{
378	case ATAIO_SET_MULTIPLE_MODE:
379	areq->regs.regs[IDE_REGISTER_COMMAND] =
380	ATA_COMMAND_SET_MULTIPLE_MODE;
381	areq->regs.to_write \|=
382	ATA_REGISTERS_VALUE(IDE_REGISTER_SECTOR_COUNT);
383	areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] = (uint8_t)argp;
384	break;
385
386	default:
387	free(areq);
388	return RTEMS_INVALID_NUMBER;
389	break;
390	}
391
392	rc = rtems_semaphore_create(rtems_build_name('I', 'D', 'E', 'S'),
393	0,
394	RTEMS_FIFO \| RTEMS_COUNTING_SEMAPHORE \|
395	RTEMS_NO_INHERIT_PRIORITY \|
396	RTEMS_NO_PRIORITY_CEILING \| RTEMS_LOCAL,
397	0,
398	&(areq->sema));
399	if (rc != RTEMS_SUCCESSFUL)
400	{
401	free(areq);
402	return rc;
403	}
404
405	ata_add_to_controller_queue(ctrl_minor, areq);
406
407	/* wait for request processing... */
408	rc = rtems_semaphore_obtain(areq->sema, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
409	if (rc != RTEMS_SUCCESSFUL)
410	{
411	free(areq);
412	return rc;
413	}
414
415	rtems_semaphore_delete(areq->sema);
416
417	/*
418	* if no error occurred and if necessary, update internal ata driver data
419	* structures to reflect changes (in device configuration, for example)
420	*/
421	if (areq->status == RTEMS_SUCCESSFUL)
422	{
423	switch(cmd)
424	{
425	case ATAIO_SET_MULTIPLE_MODE:
426	ATA_DEV_INFO(ctrl_minor, dev).current_multiple =
427	(uint8_t)argp;
428	break;
429
430	default:
431	rc = RTEMS_INVALID_NUMBER;
432	break;
433	}
434	}
435	else
436	{
437	/* XXX: should be correct error processing: for ex, may be
438	* ABRT and then we should return RTEMS_NOT_IMPLEMENTED
439	*/
440	rc = RTEMS_IO_ERROR;
441	}
442
443	/* tell ata driver that controller ready to serve next request */
444	ATA_SEND_EVT(msg, ATA_MSG_SUCCESS_EVT, ctrl_minor, 0);
445
446	return rc;
447	}
448
449	/* ata_process_request --
450	* Get first request from controller's queue and process it.
451	*
452	* PARAMETERS:
453	* ctrl_minor - controller identifier
454	*
455	* RETURNS:
456	* NONE
457	*/
458	static void
459	ata_process_request(rtems_device_minor_number ctrl_minor)
460	{
461	ata_req_t *areq;
462	uint16_t byte; /* emphasize that only 8 low bits is meaningful */
463	ata_queue_msg_t msg;
464	uint8_t i, dev;
465	uint16_t val;
466	uint16_t data_bs; /* the number of 512-bytes sectors in one
467	* data block
468	*/
469	ISR_Level level;
470
471	/* if no requests to controller then do nothing */
472	if (rtems_chain_is_empty(&ata_ide_ctrls[ctrl_minor].reqs))
473	return;
474
475	/* get first request in the controller's queue */
476	_ISR_Disable(level);
477	areq = (ata_req_t *)(ata_ide_ctrls[ctrl_minor].reqs.first);
478	_ISR_Enable(level);
479
480	/* get ATA device identifier (0 or 1) */
481	dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
482	IDE_REGISTER_DEVICE_HEAD_DEV;
483
484	/* get data block size */
485	data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
486	ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
487
488	/* execute device select protocol */
489	ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD,
490	areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]);
491
492	do {
493	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &byte);
494	} while ((byte & IDE_REGISTER_STATUS_BSY) \|\|
495	(!(byte & IDE_REGISTER_STATUS_DRDY)));
496
497	/* fill in all necessary registers on the controller */
498	for (i=0; i< ATA_MAX_CMD_REG_OFFSET; i++)
499	{
500	uint32_t reg = (1 << i);
501	if (areq->regs.to_write & reg)
502	ide_controller_write_register(ctrl_minor, i, areq->regs.regs[i]);
503	}
504
505	#ifdef DEBUG
506	printf("ata_process_request: type: %d\n", areq->type);
507	#endif
508
509	/* continue to execute ATA protocols depending on type of request */
510	if (areq->type == ATA_COMMAND_TYPE_PIO_OUT)
511	{
512	do {
513	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
514	&byte);
515	} while (byte & IDE_REGISTER_STATUS_BSY);
516
517	if (byte & IDE_REGISTER_STATUS_DRQ)
518	{
519	ide_controller_write_data_block(
520	ctrl_minor,
521	MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE,
522	areq->breq->bufs, &areq->cbuf,
523	&areq->pos);
524	areq->cnt -= MIN(data_bs, areq->cnt);
525	}
526	else
527	{
528	if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
529	{
530	ide_controller_read_register(
531	ctrl_minor,
532	IDE_REGISTER_ALTERNATE_STATUS_OFFSET,
533	&val);
534	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
535	&val);
536
537	ATA_SEND_EVT(msg, ATA_MSG_ERROR_EVT, ctrl_minor,
538	RTEMS_IO_ERROR);
539	}
540	}
541	}
542
543	if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
544	{
545	do {
546	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
547	&byte);
548	} while (byte & IDE_REGISTER_STATUS_BSY);
549
550	ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, ctrl_minor, 0);
551	}
552	}
553
554	/* ata_request_done --
555	* Extract request from controller queue, execute callback if necessary
556	* and process next request for the controller.
557	*
558	* PARAMETERS:
559	* areq - ATA request
560	* ctrl_minor - controller identifier
561	* status - status with which request has been done
562	* error - error, if status != RTEMS_SUCCESSFUL
563	*
564	* RETURNS:
565	* NONE
566	*/
567	static inline void
568	ata_request_done(ata_req_t *areq, rtems_device_minor_number ctrl_minor,
569	rtems_status_code status, int error)
570	{
571	assert(areq);
572
573	#ifdef DEBUG
574	printf("ata_request_done: entry\n");
575	#endif
576
577	ATA_EXEC_CALLBACK(areq, status, error);
578	rtems_chain_extract(&areq->link);
579
580	if (!rtems_chain_is_empty(&ata_ide_ctrls[ctrl_minor].reqs))
581	{
582	free(areq);
583	ata_process_request(ctrl_minor);
584	return;
585	}
586
587	free(areq);
588
589	#ifdef DEBUG
590	printf("ata_request_done: exit\n");
591	#endif
592	}
593
594	/* ata_non_data_request_done --
595	* Set up request status and release request's semaphore.
596	*
597	* PARAMETERS:
598	* areq - ATA request
599	* ctrl_minor - controller identifier
600	* status - status with which request has been done
601	* error - error, if status != RTEMS_SUCCESSFUL
602	*
603	* RETURNS:
604	* NONE
605	*/
606	static inline void
607	ata_non_data_request_done(ata_req_t *areq,
608	rtems_device_minor_number ctrl_minor,
609	rtems_status_code status, int error)
610	{
611	areq->status = status;
612	areq->error = error;
613	rtems_semaphore_release(areq->sema);
614	}
615
616
617	/* ata_add_to_controller_queue --
618	* Add request to the controller's queue.
619	*
620	* PARAMETERS:
621	* ctrl_minor - controller identifier
622	* areq - ATA request
623	*
624	* RETURNS:
625	* NONE
626	*/
627	static void
628	ata_add_to_controller_queue(rtems_device_minor_number ctrl_minor,
629	ata_req_t *areq)
630	{
631	PREEMPTION_KEY(key);
632
633	DISABLE_PREEMPTION(key);
634
635	rtems_chain_append(&ata_ide_ctrls[ctrl_minor].reqs, &areq->link);
636	if (rtems_chain_has_only_one_node(&ata_ide_ctrls[ctrl_minor].reqs))
637	{
638
639	ata_queue_msg_t msg;
640
641	#ifdef DEBUG
642	uint16_t val;
643	/*
644	* read IDE_REGISTER_ALTERNATE_STATUS instead IDE_REGISTER_STATUS
645	* to prevent clearing of pending interrupt
646	*/
647	ide_controller_read_register(ctrl_minor,
648	IDE_REGISTER_ALTERNATE_STATUS,
649	&val);
650	if (val & IDE_REGISTER_STATUS_BSY)
651	return;
652	#endif
653	ATA_SEND_EVT(msg, ATA_MSG_PROCESS_NEXT_EVT, ctrl_minor, 0);
654	}
655
656	ENABLE_PREEMPTION(key);
657	}
658
659
660	/* ata_interrupt_handler --
661	* ATA driver interrrupt handler. If interrrupt happend it mapped it to
662	* controller (controllerS, if a number of controllers share one int line)
663	* and generates ATA event(s).
664	*
665	* PARAMETERS:
666	* vec - interrupt vector
667	*
668	* RETURNS:
669	* NONE
670	*/
671	#if defined(ATA_USE_OLD_EXCEPTIONS)
672	rtems_isr
673	ata_interrupt_handler(rtems_vector_number vec)
674	{
675	rtems_chain_node the_node = ((rtems_chain_control )(&ata_int_vec[vec]))->first;
676	ata_queue_msg_t msg;
677	uint16_t byte; /* emphasize that only 8 low bits is meaningful */
678
679	for ( ; !rtems_chain_is_tail(&ata_int_vec[vec], the_node) ; )
680	{
681	/* if (1) - is temporary hack - currently I don't know how to identify
682	* controller which asserted interrupt if few controllers share one
683	* interrupt line
684	*/
685	if (1)
686	{
687	msg.ctrl_minor = ((ata_int_st_t *)the_node)->ctrl_minor;
688	ide_controller_read_register(msg.ctrl_minor, IDE_REGISTER_STATUS,
689	&byte);
690	ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, msg.ctrl_minor, 0);
691	}
692	the_node = the_node->next;
693	}
694	}
695	#else
696	void ata_interrupt_handler(rtems_irq_hdl_param handle)
697	{
698	int ata_irq_chain_index = (int) handle;
699	rtems_chain_node *the_node =
700	ata_irq_chain[ata_irq_chain_index].irq_chain.last;
701	ata_queue_msg_t msg;
702	uint16_t byte; /* emphasize that only 8 low bits is meaningful */
703
704
705	for ( ; !rtems_chain_is_tail(&ata_irq_chain[ata_irq_chain_index].irq_chain,
706	the_node) ; )
707	{
708	/* if (1) - is temporary hack - currently I don't know how to identify
709	* controller which asserted interrupt if few controllers share one
710	* interrupt line
711	*/
712	if (1)
713	{
714	msg.ctrl_minor = ((ata_int_st_t *)the_node)->ctrl_minor;
715	ide_controller_read_register(msg.ctrl_minor, IDE_REGISTER_STATUS,
716	&byte);
717	ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, msg.ctrl_minor, 0);
718	}
719	the_node = the_node->next;
720	}
721	}
722
723	void ata_interrupt_on(const rtems_irq_connect_data *ptr)
724	{
725
726	/* enable ATA device interrupt */
727	ide_controller_write_register(0,
728	IDE_REGISTER_DEVICE_CONTROL_OFFSET,
729	0x00
730	);
731	}
732
733
734	void ata_interrupt_off(const rtems_irq_connect_data *ptr)
735	{
736
737	/* disable ATA device interrupt */
738	ide_controller_write_register(0,
739	IDE_REGISTER_DEVICE_CONTROL_OFFSET,
740	IDE_REGISTER_DEVICE_CONTROL_nIEN
741	);
742	}
743
744
745	int ata_interrupt_isOn(const rtems_irq_connect_data *ptr)
746	{
747	uint16_t byte; /* emphasize that only 8 low bits is meaningful */
748
749	/* return int. status od ATA device */
750	ide_controller_read_register(0,
751	IDE_REGISTER_DEVICE_CONTROL_OFFSET,
752	&byte
753	);
754
755	return !(byte & IDE_REGISTER_DEVICE_CONTROL_nIEN);
756	}
757
758
759	static rtems_irq_connect_data ata_irq_data =
760	{
761
762	0, /* filled out before use... */
763	ata_interrupt_handler,/* filled out before use... */
764	NULL,
765	ata_interrupt_on,
766	ata_interrupt_off,
767	ata_interrupt_isOn
768	};
769	#endif
770
771	/* ata_pio_in_protocol --
772	* ATA PIO_IN protocol implementation, see specification
773	*
774	* PARAMETERS:
775	* ctrl_minor - controller identifier
776	* areq - ATA request
777	*
778	* RETURNS:
779	* NONE
780	*/
781	static inline void
782	ata_pio_in_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
783	{
784	uint16_t bs, val;
785	uint8_t dev;
786	uint32_t min_val;
787	ata_queue_msg_t msg;
788
789	dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
790	IDE_REGISTER_DEVICE_HEAD_DEV;
791
792	bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
793	ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
794	min_val = MIN(bs, areq->cnt);
795
796	ide_controller_read_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE,
797	areq->breq->bufs, &areq->cbuf, &areq->pos);
798
799	areq->cnt -= min_val;
800	if (areq->cnt == 0)
801	{
802	ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL);
803	}
804	else if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
805	{
806	do {
807	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &val);
808	} while (val & IDE_REGISTER_STATUS_BSY);
809
810	ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, ctrl_minor, 0);
811	}
812	}
813
814	/* ata_pio_out_protocol --
815	* ATA PIO_OUT protocol implementation, see specification
816	*
817	* PARAMETERS:
818	* ctrl_minor - controller identifier
819	* areq - ATA request
820	*
821	* RETURNS:
822	* NONE
823	*/
824	static inline void
825	ata_pio_out_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
826	{
827	uint16_t bs, val;
828	uint8_t dev;
829	uint32_t min_val;
830	ata_queue_msg_t msg;
831
832	#ifdef DEBUG
833	printf("ata_pio_out_protocol:\n");
834	#endif
835
836	dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
837	IDE_REGISTER_DEVICE_HEAD_DEV;
838
839	bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
840	ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
841
842	min_val = MIN(bs, areq->cnt);
843
844	if (areq->cnt == 0)
845	{
846	ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL);
847	}
848	else
849	{
850	ide_controller_write_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE,
851	areq->breq->bufs, &areq->cbuf,
852	&areq->pos);
853	areq->cnt -= min_val;
854	if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
855	{
856	do {
857	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
858	&val);
859	} while (val & IDE_REGISTER_STATUS_BSY);
860
861	ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, ctrl_minor, 0);
862	}
863	}
864	}
865
866	/* ata_queue_task --
867	* Task which manages ATA driver events queue.
868	*
869	* PARAMETERS:
870	* arg - ignored
871	*
872	* RETURNS:
873	* NONE
874	*
875	* NOTES:
876	* should be non-preemptive
877	*/
878	static rtems_task
879	ata_queue_task(rtems_task_argument arg)
880	{
881	ata_queue_msg_t msg;
882	size_t size;
883	ata_req_t *areq;
884	rtems_device_minor_number ctrl_minor;
885	uint16_t val;
886	uint16_t val1;
887	rtems_status_code rc;
888	ISR_Level level;
889
890	PREEMPTION_KEY(key);
891
892	DISABLE_PREEMPTION(key);
893
894	while (1)
895	{
896	ENABLE_PREEMPTION(key);
897
898	/* get event which has happend */
899	rc = rtems_message_queue_receive(ata_queue_id, &msg, &size, RTEMS_WAIT,
900	RTEMS_NO_TIMEOUT);
901	if (rc != RTEMS_SUCCESSFUL)
902	rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
903
904	/* get controller on which event has happend */
905	ctrl_minor = msg.ctrl_minor;
906
907	DISABLE_PREEMPTION(key);
908
909	/* get current request to the controller */
910	_ISR_Disable(level);
911	areq = (ata_req_t *)(ata_ide_ctrls[ctrl_minor].reqs.first);
912	_ISR_Enable(level);
913
914	switch(msg.type)
915	{
916	case ATA_MSG_PROCESS_NEXT_EVT:
917	/* process next request in the controller queue */
918	ata_process_request(ctrl_minor);
919	break;
920
921	case ATA_MSG_SUCCESS_EVT:
922	/*
923	* finish processing of current request with successful
924	* status and start processing of the next request in the
925	* controller queue
926	*/
927	ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL,
928	msg.error);
929	break;
930
931	case ATA_MSG_ERROR_EVT:
932	/*
933	* finish processing of current request with error
934	* status and start processing of the next request in the
935	* controller queue
936	*/
937	ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED,
938	msg.error);
939	break;
940
941	case ATA_MSG_GEN_EVT:
942	/*
943	* continue processing of the current request to the
944	* controller according to current request state and
945	* ATA protocol
946	*/
947	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
948	&val);
949	/* process error case */
950	if (val & IDE_REGISTER_STATUS_ERR)
951	{
952	ide_controller_read_register(ctrl_minor,
953	IDE_REGISTER_ERROR,
954	&val);
955	if (areq->type == ATA_COMMAND_TYPE_NON_DATA)
956	ata_non_data_request_done(areq, ctrl_minor,
957	RTEMS_UNSATISFIED,
958	RTEMS_IO_ERROR);
959	else
960	ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED,
961	RTEMS_IO_ERROR);
962	break;
963	}
964
965	switch(areq->type)
966	{
967	case ATA_COMMAND_TYPE_PIO_IN:
968	ata_pio_in_protocol(ctrl_minor, areq);
969	break;
970
971	case ATA_COMMAND_TYPE_PIO_OUT:
972	ata_pio_out_protocol(ctrl_minor, areq);
973	break;
974
975	case ATA_COMMAND_TYPE_NON_DATA:
976	ide_controller_read_register(ctrl_minor,
977	IDE_REGISTER_ERROR,
978	&val1);
979	ata_non_data_request_done(areq, ctrl_minor,
980	RTEMS_SUCCESSFUL,
981	val1);
982	break;
983
984	default:
985	#ifdef DEBUG
986	printf("ata_queue_task: non-supported command type\n");
987	#endif
988	ata_request_done(areq, ctrl_minor,
989	RTEMS_UNSATISFIED,
990	RTEMS_NOT_IMPLEMENTED);
991	break;
992	}
993	break;
994
995	default:
996	#ifdef DEBUG
997	printf("ata_queue_task: internal error\n");
998	rtems_task_delete (RTEMS_SELF);
999	#endif
1000	rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
1001	break;
1002	}
1003	}
1004	}
1005
1006	/* ata_ioctl --
1007	* ATA driver ioctl interface.
1008	*
1009	* PARAMETERS:
1010	* device - device identifier
1011	* cmd - command
1012	* argp - arguments
1013	*
1014	* RETURNS:
1015	* depend on 'cmd'
1016	*/
1017	int
1018	ata_ioctl(dev_t device, int cmd, void *argp)
1019	{
1020	rtems_status_code status;
1021	rtems_device_minor_number rel_minor;
1022
1023	rel_minor = (rtems_filesystem_dev_minor_t(device)) /
1024	ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
1025
1026	/*
1027	* in most cases this means that device 'device' is not an registred ATA
1028	* device
1029	*/
1030	if (ata_devs[rel_minor].device == ATA_UNDEFINED_VALUE)
1031	{
1032	errno = ENODEV;
1033	return -1;
1034	}
1035
1036	switch (cmd)
1037	{
1038	case RTEMS_BLKIO_REQUEST:
1039	status = ata_io_data_request(device, (rtems_blkdev_request *)argp);
1040	break;
1041
1042	case ATAIO_SET_MULTIPLE_MODE:
1043	status = ata_non_data_request(device, cmd, argp);
1044	break;
1045
1046	case RTEMS_BLKDEV_CAPABILITIES:
1047	((uint32_t) argp) = RTEMS_BLKDEV_CAP_MULTISECTOR_CONT;
1048	status = RTEMS_SUCCESSFUL;
1049	break;
1050
1051	default:
1052	errno = EBADRQC;
1053	return -1;
1054	break;
1055	}
1056
1057	if (status != RTEMS_SUCCESSFUL)
1058	{
1059	errno = EIO;
1060	return -1;
1061	}
1062	return 0;
1063	}
1064
1065	/*
1066	* ata_initialize --
1067	* Initializes all ATA devices found on initialized IDE controllers.
1068	*
1069	* PARAMETERS:
1070	* major - device major number
1071	* minor - device minor number
1072	* args - arguments
1073	*
1074	* RETURNS:
1075	* RTEMS_SUCCESSFUL on success, or error code if
1076	* error occured
1077	*/
1078	rtems_device_driver
1079	rtems_ata_initialize(rtems_device_major_number major,
1080	rtems_device_minor_number minor_arg,
1081	void *args)
1082	{
1083	uint32_t ctrl_minor;
1084	rtems_status_code status;
1085	ata_req_t areq;
1086	blkdev_request1 breq;
1087	uint8_t i, dev = 0;
1088	uint16_t *buffer;
1089	uint16_t ec;
1090	char name[ATA_MAX_NAME_LENGTH];
1091	dev_t device;
1092	ata_int_st_t *int_st;
1093
1094	#if defined(ATA_USE_OLD_EXCEPTIONS)
1095	rtems_isr_entry old_isr;
1096	#else
1097	int ata_irq_chain_use;
1098	#endif
1099
1100	if (ata_initialized)
1101	return RTEMS_SUCCESSFUL;
1102
1103	/* initialization of disk devices library */
1104	status = rtems_disk_io_initialize();
1105	if (status != RTEMS_SUCCESSFUL)
1106	return status;
1107
1108	#ifdef SAFE
1109	#ifdef SAFE_MUTEX
1110	status = rtems_semaphore_create (rtems_build_name ('A', 'T', 'A', 'L'),
1111	1, RTEMS_ATA_LOCK_ATTRIBS, 0,
1112	&ata_lock);
1113	if (status != RTEMS_SUCCESSFUL)
1114	return status;
1115	#endif
1116	#endif
1117
1118	/* create queue for asynchronous requests handling */
1119	status = rtems_message_queue_create(
1120	rtems_build_name('A', 'T', 'A', 'Q'),
1121	ATA_DRIVER_MESSAGE_QUEUE_SIZE,
1122	sizeof(ata_queue_msg_t),
1123	RTEMS_FIFO \| RTEMS_LOCAL,
1124	&ata_queue_id);
1125	if (status != RTEMS_SUCCESSFUL)
1126	{
1127	rtems_disk_io_done();
1128	return status;
1129	}
1130
1131	/*
1132	* create ATA driver task, see comments for task implementation for
1133	* details
1134	*/
1135	status = rtems_task_create(
1136	rtems_build_name ('A', 'T', 'A', 'T'),
1137	((rtems_ata_driver_task_priority > 0)
1138	? rtems_ata_driver_task_priority
1139	: ATA_DRIVER_TASK_DEFAULT_PRIORITY),
1140	ATA_DRIVER_TASK_STACK_SIZE,
1141	RTEMS_PREEMPT \| RTEMS_NO_TIMESLICE \| RTEMS_NO_ASR \|
1142	RTEMS_INTERRUPT_LEVEL(0),
1143	RTEMS_NO_FLOATING_POINT \| RTEMS_LOCAL,
1144	&ata_task_id);
1145	if (status != RTEMS_SUCCESSFUL)
1146	{
1147	rtems_message_queue_delete(ata_queue_id);
1148	rtems_disk_io_done();
1149	return status;
1150	}
1151
1152	/*
1153	* start ATA driver task. Actually the task will not start immediately -
1154	* it will start only after multitasking support will be started
1155	*/
1156	status = rtems_task_start(ata_task_id, ata_queue_task, 0);
1157	if (status != RTEMS_SUCCESSFUL)
1158	{
1159	rtems_task_delete(ata_task_id);
1160	rtems_message_queue_delete(ata_queue_id);
1161	rtems_disk_io_done();
1162	return status;
1163	}
1164
1165	buffer = (uint16_t*)malloc(ATA_SECTOR_SIZE);
1166	if (buffer == NULL)
1167	{
1168	rtems_task_delete(ata_task_id);
1169	rtems_message_queue_delete(ata_queue_id);
1170	rtems_disk_io_done();
1171	return RTEMS_NO_MEMORY;
1172	}
1173
1174	ata_devs_number = 0;
1175
1176	for (i = 0; i < (2 * IDE_CTRL_MAX_MINOR_NUMBER); i++)
1177	ata_devs[i].device = ATA_UNDEFINED_VALUE;
1178
1179	#if defined(ATA_USE_OLD_EXCEPTIONS)
1180	/* prepare ATA driver for handling interrupt driven devices */
1181	for (i = 0; i < ATA_MAX_RTEMS_INT_VEC_NUMBER; i++)
1182	rtems_chain_initialize_empty(&ata_int_vec[i]);
1183	#else
1184	for (i = 0; i < ATA_IRQ_CHAIN_MAX_CNT; i++) {
1185	rtems_chain_initialize_empty(&(ata_irq_chain[i].irq_chain));
1186	}
1187	#endif
1188
1189	/*
1190	* during ATA driver initialization EXECUTE DEVICE DIAGNOSTIC and
1191	* IDENTIFY DEVICE ATA command should be issued; for these purposes ATA
1192	* requests should be formed; ATA requests contain block device request,
1193	* so form block device request first
1194	*/
1195	memset(&breq, 0, sizeof(blkdev_request1));
1196	breq.req.req_done = NULL;
1197	breq.req.done_arg = &breq;
1198	breq.req.bufnum = 1;
1199	breq.req.bufs[0].length = ATA_SECTOR_SIZE;
1200	breq.req.bufs[0].buffer = buffer;
1201
1202	/*
1203	* for each presented IDE controller execute EXECUTE DEVICE DIAGNOSTIC
1204	* ATA command; for each found device execute IDENTIFY DEVICE ATA
1205	* command
1206	*/
1207	for (ctrl_minor = 0; ctrl_minor < IDE_Controller_Count; ctrl_minor++)
1208	if (IDE_Controller_Table[ctrl_minor].status == IDE_CTRL_INITIALIZED)
1209	{
1210	rtems_chain_initialize_empty(&ata_ide_ctrls[ctrl_minor].reqs);
1211
1212	if (IDE_Controller_Table[ctrl_minor].int_driven == TRUE)
1213	{
1214	int_st = malloc(sizeof(ata_int_st_t));
1215	if (int_st == NULL)
1216	{
1217	free(buffer);
1218	rtems_task_delete(ata_task_id);
1219	rtems_message_queue_delete(ata_queue_id);
1220	rtems_disk_io_done();
1221	return RTEMS_NO_MEMORY;
1222	}
1223
1224	int_st->ctrl_minor = ctrl_minor;
1225	#if defined(ATA_USE_OLD_EXCEPTIONS)
1226	status = rtems_interrupt_catch(
1227	ata_interrupt_handler,
1228	IDE_Controller_Table[ctrl_minor].int_vec,
1229	&old_isr);
1230	#else
1231	/*
1232	* FIXME: check existing entries. if they use the same
1233	* IRQ name, then append int_st to respective chain
1234	* otherwise, use new ata_irq_chain entry
1235	*/
1236	ata_irq_chain_use = -1;
1237	for (i = 0;
1238	((i < ata_irq_chain_cnt) &&
1239	(ata_irq_chain_use < 0));i++) {
1240	if (ata_irq_chain[i].name ==
1241	IDE_Controller_Table[ctrl_minor].int_vec) {
1242	ata_irq_chain_use = i;
1243	}
1244	}
1245	if (ata_irq_chain_use < 0) {
1246	/*
1247	* no match found, try to use new channel entry
1248	*/
1249	if (ata_irq_chain_cnt < ATA_IRQ_CHAIN_MAX_CNT) {
1250	ata_irq_chain_use = ata_irq_chain_cnt++;
1251
1252	ata_irq_chain[ata_irq_chain_use].name =
1253	IDE_Controller_Table[ctrl_minor].int_vec;
1254	ata_irq_data.name =
1255	IDE_Controller_Table[ctrl_minor].int_vec;
1256	ata_irq_data.hdl = ata_interrupt_handler;
1257	ata_irq_data.handle = (rtems_irq_hdl_param) ctrl_minor;
1258
1259	status = ((0 == BSP_install_rtems_irq_handler(&ata_irq_data))
1260	? RTEMS_INVALID_NUMBER
1261	: RTEMS_SUCCESSFUL);
1262	}
1263	else {
1264	status = RTEMS_TOO_MANY;
1265	}
1266	}
1267	#endif
1268	if (status != RTEMS_SUCCESSFUL)
1269	{
1270	free(int_st);
1271	free(buffer);
1272	rtems_task_delete(ata_task_id);
1273	rtems_message_queue_delete(ata_queue_id);
1274	rtems_disk_io_done();
1275	return status;
1276	}
1277	#if defined(ATA_USE_OLD_EXCEPTIONS)
1278	rtems_chain_append(
1279	&ata_int_vec[IDE_Controller_Table[ctrl_minor].int_vec],
1280	&int_st->link);
1281	#else
1282	rtems_chain_append(
1283	&(ata_irq_chain[ata_irq_chain_use].irq_chain),
1284	&int_st->link);
1285	#endif
1286
1287	/* disable interrupts */
1288	ide_controller_write_register(ctrl_minor,
1289	IDE_REGISTER_DEVICE_CONTROL_OFFSET,
1290	IDE_REGISTER_DEVICE_CONTROL_nIEN);
1291	}
1292
1293	/*
1294	* Issue EXECUTE DEVICE DIAGNOSTIC ATA command for explore is
1295	* there any ATA device on the controller.
1296	*/
1297	memset(&areq, 0, sizeof(ata_req_t));
1298	areq.type = ATA_COMMAND_TYPE_NON_DATA;
1299	areq.regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
1300	areq.regs.regs[IDE_REGISTER_COMMAND] =
1301	ATA_COMMAND_EXECUTE_DEVICE_DIAGNOSTIC;
1302	areq.regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_ERROR);
1303
1304	areq.breq = (rtems_blkdev_request *)&breq;
1305
1306	/*
1307	* Process the request. Special processing of requests on
1308	* initialization phase is needed because at this moment there
1309	* is no multitasking enviroment
1310	*/
1311	ata_process_request_on_init_phase(ctrl_minor, &areq);
1312
1313	/*
1314	* check status of I/O operation
1315	*/
1316	if (breq.req.status != RTEMS_SUCCESSFUL)
1317	continue;
1318
1319	/* disassemble returned diagnostic codes */
1320	if (breq.req.error == ATA_DEV0_PASSED_DEV1_PASSED_OR_NOT_PRSNT)
1321	{
1322	ATA_DEV_INFO(ctrl_minor, 0).present = 1;
1323	ATA_DEV_INFO(ctrl_minor,1).present = 1;
1324	}
1325	else if (breq.req.error == ATA_DEV0_PASSED_DEV1_FAILED)
1326	{
1327	ATA_DEV_INFO(ctrl_minor,0).present = 1;
1328	ATA_DEV_INFO(ctrl_minor,1).present = 0;
1329	}
1330	else if (breq.req.error < ATA_DEV1_PASSED_DEV0_FAILED)
1331	{
1332	ATA_DEV_INFO(ctrl_minor,0).present = 0;
1333	ATA_DEV_INFO(ctrl_minor,1).present = 1;
1334	}
1335	else
1336	{
1337	ATA_DEV_INFO(ctrl_minor, 0).present = 0;
1338	ATA_DEV_INFO(ctrl_minor, 1).present = 0;
1339	}
1340
1341	/* refine the returned codes */
1342	if (ATA_DEV_INFO(ctrl_minor, 1).present != 0)
1343	{
1344	ide_controller_read_register(ctrl_minor, IDE_REGISTER_ERROR, &ec);
1345	if (ec & ATA_DEV1_PASSED_DEV0_FAILED)
1346	ATA_DEV_INFO(ctrl_minor, 1).present = 1;
1347	else
1348	ATA_DEV_INFO(ctrl_minor, 1).present = 0;
1349	}
1350
1351	/* for each found ATA device obtain it configuration */
1352	for (dev = 0; dev < 2; dev++)
1353	if (ATA_DEV_INFO(ctrl_minor, dev).present)
1354	{
1355	/*
1356	* Issue DEVICE IDENTIFY ATA command and get device
1357	* configuration
1358	*/
1359	memset(&areq, 0, sizeof(ata_req_t));
1360	areq.type = ATA_COMMAND_TYPE_PIO_IN;
1361	areq.regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
1362	areq.regs.regs[IDE_REGISTER_COMMAND] =
1363	ATA_COMMAND_IDENTIFY_DEVICE;
1364	areq.regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_STATUS);
1365	areq.breq = (rtems_blkdev_request *)&breq;
1366
1367	areq.cnt = breq.req.bufnum;
1368
1369	areq.regs.regs[IDE_REGISTER_DEVICE_HEAD] \|=
1370	(dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);
1371
1372	/*
1373	* Process the request. Special processing of requests on
1374	* initialization phase is needed because at this moment there
1375	* is no multitasking enviroment
1376	*/
1377	ata_process_request_on_init_phase(ctrl_minor, &areq);
1378
1379	/* check status of I/O operation */
1380	if (breq.req.status != RTEMS_SUCCESSFUL)
1381	continue;
1382
1383	/*
1384	* Parse returned device configuration and fill in ATA internal
1385	* device info structure
1386	*/
1387	ATA_DEV_INFO(ctrl_minor, dev).cylinders =
1388	CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_CLNDS]);
1389	ATA_DEV_INFO(ctrl_minor, dev).heads =
1390	CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_HEADS]);
1391	ATA_DEV_INFO(ctrl_minor, dev).sectors =
1392	CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_SECS]);
1393	ATA_DEV_INFO(ctrl_minor, dev).lba_sectors =
1394	(CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS0]) << 16) +
1395	CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS1]);
1396	ATA_DEV_INFO(ctrl_minor, dev).lba_avaible =
1397	(CF_LE_W(buffer[ATA_IDENT_WORD_CAPABILITIES]) >> 9) & 0x1;
1398	ATA_DEV_INFO(ctrl_minor, dev).max_multiple =
1399	(uint8_t) (CF_LE_W(buffer[ATA_IDENT_WORD_RW_MULT]));
1400	ATA_DEV_INFO(ctrl_minor, dev).current_multiple =
1401	(CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS]) & 0x100) ?
1402	(uint8_t)(CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS])) :
1403	0;
1404
1405	if ((CF_LE_W(buffer[ATA_IDENT_WORD_FIELD_VALIDITY]) &
1406	ATA_IDENT_BIT_VALID) == 0) {
1407	/* no "supported modes" info -> use default */
1408	ATA_DEV_INFO(ctrl_minor, dev).mode_active = ATA_MODES_PIO3;
1409	}
1410	else {
1411	ATA_DEV_INFO(ctrl_minor, dev).modes_available =
1412	((CF_LE_W(buffer[64]) & 0x1) ? ATA_MODES_PIO3 : 0) \|
1413	((CF_LE_W(buffer[64]) & 0x2) ? ATA_MODES_PIO4 : 0) \|
1414	((CF_LE_W(buffer[63]) & 0x1) ? ATA_MODES_DMA0 : 0) \|
1415	((CF_LE_W(buffer[63]) & 0x2) ?
1416	ATA_MODES_DMA0 \| ATA_MODES_DMA1 : 0) \|
1417	((CF_LE_W(buffer[63]) & 0x4) ?
1418	ATA_MODES_DMA0 \| ATA_MODES_DMA1 \| ATA_MODES_DMA2 : 0);
1419	if (ATA_DEV_INFO(ctrl_minor, dev).modes_available == 0)
1420	continue;
1421	/*
1422	* choose most appropriate ATA device data I/O speed supported
1423	* by the controller
1424	*/
1425	status = ide_controller_config_io_speed(
1426	ctrl_minor,
1427	ATA_DEV_INFO(ctrl_minor, dev).modes_available);
1428	if (status != RTEMS_SUCCESSFUL)
1429	continue;
1430	}
1431	/*
1432	* Ok, let register new ATA device in the system
1433	*/
1434	ata_devs[ata_devs_number].ctrl_minor = ctrl_minor;
1435	ata_devs[ata_devs_number].device = dev;
1436
1437	/* The space leaves a hole for the character. */
1438	strcpy(name, "/dev/hd ");
1439	name[7] = 'a' + 2 * ctrl_minor + dev;
1440
1441	device = rtems_filesystem_make_dev_t(
1442	major,
1443	(ata_devs_number *
1444	ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE));
1445
1446	status = rtems_disk_create_phys(device, ATA_SECTOR_SIZE,
1447	ATA_DEV_INFO(ctrl_minor, dev).lba_avaible ?
1448	ATA_DEV_INFO(ctrl_minor, dev).lba_sectors :
1449	(ATA_DEV_INFO(ctrl_minor, dev).heads *
1450	ATA_DEV_INFO(ctrl_minor, dev).cylinders *
1451	ATA_DEV_INFO(ctrl_minor, dev).sectors),
1452	(rtems_block_device_ioctl) ata_ioctl, name);
1453	if (status != RTEMS_SUCCESSFUL)
1454	{
1455	ata_devs[ata_devs_number].device = ATA_UNDEFINED_VALUE;
1456	continue;
1457	}
1458	ata_devs_number++;
1459	}
1460	if (IDE_Controller_Table[ctrl_minor].int_driven == TRUE)
1461	{
1462	ide_controller_write_register(ctrl_minor,
1463	IDE_REGISTER_DEVICE_CONTROL_OFFSET,
1464	0x00);
1465	}
1466	}
1467
1468	free(buffer);
1469	ata_initialized = TRUE;
1470	return RTEMS_SUCCESSFUL;
1471	}
1472
1473	/* ata_process_request_on_init_phase --
1474	* Process the ATA request during system initialization. Request
1475	* processing is syncronous and doesn't use multiprocessing enviroment.
1476	*
1477	* PARAMETERS:
1478	* ctrl_minor - controller identifier
1479	* areq - ATA request
1480	*
1481	* RETURNS:
1482	* NONE
1483	*/
1484	static void
1485	ata_process_request_on_init_phase(rtems_device_minor_number ctrl_minor,
1486	ata_req_t *areq)
1487	{
1488	uint16_t byte;/* emphasize that only 8 low bits is meaningful */
1489	uint8_t i, dev;
1490	uint16_t val, val1;
1491	uint16_t data_bs; /* the number of 512 bytes sectors into one
1492	* data block
1493	*/
1494	unsigned retries;
1495	assert(areq);
1496
1497	dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
1498	IDE_REGISTER_DEVICE_HEAD_DEV;
1499
1500	data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
1501	ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
1502
1503	ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD,
1504	areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]);
1505
1506	retries = 0;
1507	do {
1508	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &byte);
1509	/* If device (on INIT, i.e. it should be idle) is neither
1510	* busy nor ready something's fishy, i.e., there is probably
1511	* no device present.
1512	* I'd like to do a proper timeout but don't know of a portable
1513	* timeout routine (w/o using multitasking / rtems_task_wake_after())
1514	*/
1515	if ( ! (byte & (IDE_REGISTER_STATUS_BSY \| IDE_REGISTER_STATUS_DRDY)))
1516	retries++;
1517	else
1518	retries=0;
1519	if ( 10000 == retries ) {
1520	/* probably no drive connected */
1521	areq->breq->status = RTEMS_UNSATISFIED;
1522	areq->breq->error = RTEMS_IO_ERROR;
1523	return;
1524	}
1525	} while ((byte & IDE_REGISTER_STATUS_BSY) \|\|
1526	(!(byte & IDE_REGISTER_STATUS_DRDY)));
1527
1528	for (i=0; i< ATA_MAX_CMD_REG_OFFSET; i++)
1529	{
1530	uint32_t reg = (1 << i);
1531	if (areq->regs.to_write & reg)
1532	ide_controller_write_register(ctrl_minor, i,
1533	areq->regs.regs[i]);
1534	}
1535
1536	do {
1537	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &byte);
1538	} while (byte & IDE_REGISTER_STATUS_BSY);
1539
1540	ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &val);
1541	ide_controller_read_register(ctrl_minor, IDE_REGISTER_ERROR, &val1);
1542
1543	if (val & IDE_REGISTER_STATUS_ERR)
1544	{
1545	areq->breq->status = RTEMS_UNSATISFIED;
1546	areq->breq->error = RTEMS_IO_ERROR;
1547	return;
1548	}
1549
1550	switch(areq->type)
1551	{
1552	case ATA_COMMAND_TYPE_PIO_IN:
1553	ide_controller_read_data_block(
1554	ctrl_minor,
1555	MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE,
1556	areq->breq->bufs, &areq->cbuf,
1557	&areq->pos);
1558
1559	areq->cnt -= MIN(data_bs, areq->cnt);
1560	if (areq->cnt == 0)
1561	{
1562	areq->breq->status = RTEMS_SUCCESSFUL;
1563	}
1564	else
1565	{
1566	/*
1567	* this shouldn't happend on the initialization
1568	* phase!
1569	*/
1570	rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
1571	}
1572	break;
1573
1574	case ATA_COMMAND_TYPE_NON_DATA:
1575	areq->breq->status = RTEMS_SUCCESSFUL;
1576	areq->breq->error = val1;
1577	break;
1578
1579	default:
1580	#ifdef DEBUG
1581	printf("ata_queue_task: non-supported command type\n");
1582	#endif
1583	areq->breq->status = RTEMS_UNSATISFIED;
1584	areq->breq->error = RTEMS_NOT_IMPLEMENTED;
1585	break;
1586	}
1587	}

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

Download in other formats: