1 2 /* 3 * IBM ASM Service Processor Device Driver 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 18 * 19 * Copyright (C) IBM Corporation, 2004 20 * 21 * Author: Max Asb�ck <amax@us.ibm.com> 22 * 23 */ 24 25 #include "ibmasm.h" 26 #include "lowlevel.h" 27 28 /* 29 * ASM service processor event handling routines. 30 * 31 * Events are signalled to the device drivers through interrupts. 32 * They have the format of dot commands, with the type field set to 33 * sp_event. 34 * The driver does not interpret the events, it simply stores them in a 35 * circular buffer. 36 */ 37 38 static void wake_up_event_readers(struct service_processor *sp) 39 { 40 struct event_reader *reader; 41 42 list_for_each_entry(reader, &sp->event_buffer->readers, node) 43 wake_up_interruptible(&reader->wait); 44 } 45 46 /** 47 * receive_event 48 * Called by the interrupt handler when a dot command of type sp_event is 49 * received. 50 * Store the event in the circular event buffer, wake up any sleeping 51 * event readers. 52 * There is no reader marker in the buffer, therefore readers are 53 * responsible for keeping up with the writer, or they will loose events. 54 */ 55 void ibmasm_receive_event(struct service_processor *sp, void *data, unsigned int data_size) 56 { 57 struct event_buffer *buffer = sp->event_buffer; 58 struct ibmasm_event *event; 59 unsigned long flags; 60 61 data_size = min(data_size, IBMASM_EVENT_MAX_SIZE); 62 63 spin_lock_irqsave(&sp->lock, flags); 64 /* copy the event into the next slot in the circular buffer */ 65 event = &buffer->events[buffer->next_index]; 66 memcpy_fromio(event->data, data, data_size); 67 event->data_size = data_size; 68 event->serial_number = buffer->next_serial_number; 69 70 /* advance indices in the buffer */ 71 buffer->next_index = (buffer->next_index + 1) % IBMASM_NUM_EVENTS; 72 buffer->next_serial_number++; 73 spin_unlock_irqrestore(&sp->lock, flags); 74 75 wake_up_event_readers(sp); 76 } 77 78 static inline int event_available(struct event_buffer *b, struct event_reader *r) 79 { 80 return (r->next_serial_number < b->next_serial_number); 81 } 82 83 /** 84 * get_next_event 85 * Called by event readers (initiated from user space through the file 86 * system). 87 * Sleeps until a new event is available. 88 */ 89 int ibmasm_get_next_event(struct service_processor *sp, struct event_reader *reader) 90 { 91 struct event_buffer *buffer = sp->event_buffer; 92 struct ibmasm_event *event; 93 unsigned int index; 94 unsigned long flags; 95 96 reader->cancelled = 0; 97 98 if (wait_event_interruptible(reader->wait, 99 event_available(buffer, reader) || reader->cancelled)) 100 return -ERESTARTSYS; 101 102 if (!event_available(buffer, reader)) 103 return 0; 104 105 spin_lock_irqsave(&sp->lock, flags); 106 107 index = buffer->next_index; 108 event = &buffer->events[index]; 109 while (event->serial_number < reader->next_serial_number) { 110 index = (index + 1) % IBMASM_NUM_EVENTS; 111 event = &buffer->events[index]; 112 } 113 memcpy(reader->data, event->data, event->data_size); 114 reader->data_size = event->data_size; 115 reader->next_serial_number = event->serial_number + 1; 116 117 spin_unlock_irqrestore(&sp->lock, flags); 118 119 return event->data_size; 120 } 121 122 void ibmasm_cancel_next_event(struct event_reader *reader) 123 { 124 reader->cancelled = 1; 125 wake_up_interruptible(&reader->wait); 126 } 127 128 void ibmasm_event_reader_register(struct service_processor *sp, struct event_reader *reader) 129 { 130 unsigned long flags; 131 132 reader->next_serial_number = sp->event_buffer->next_serial_number; 133 init_waitqueue_head(&reader->wait); 134 spin_lock_irqsave(&sp->lock, flags); 135 list_add(&reader->node, &sp->event_buffer->readers); 136 spin_unlock_irqrestore(&sp->lock, flags); 137 } 138 139 void ibmasm_event_reader_unregister(struct service_processor *sp, struct event_reader *reader) 140 { 141 unsigned long flags; 142 143 spin_lock_irqsave(&sp->lock, flags); 144 list_del(&reader->node); 145 spin_unlock_irqrestore(&sp->lock, flags); 146 } 147 148 int ibmasm_event_buffer_init(struct service_processor *sp) 149 { 150 struct event_buffer *buffer; 151 struct ibmasm_event *event; 152 int i; 153 154 buffer = kmalloc(sizeof(struct event_buffer), GFP_KERNEL); 155 if (!buffer) 156 return 1; 157 158 buffer->next_index = 0; 159 buffer->next_serial_number = 1; 160 161 event = buffer->events; 162 for (i=0; i<IBMASM_NUM_EVENTS; i++, event++) 163 event->serial_number = 0; 164 165 INIT_LIST_HEAD(&buffer->readers); 166 167 sp->event_buffer = buffer; 168 169 return 0; 170 } 171 172 void ibmasm_event_buffer_exit(struct service_processor *sp) 173 { 174 kfree(sp->event_buffer); 175 } 176