Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
62b74942 | 2 | * driver: reading from and writing to system console on S/390 via SCLP |
1da177e4 | 3 | * |
62b74942 MH |
4 | * Copyright IBM Corp. 1999, 2009 |
5 | * | |
6 | * Author(s): Martin Peschke <mpeschke@de.ibm.com> | |
7 | * Martin Schwidefsky <schwidefsky@de.ibm.com> | |
1da177e4 LT |
8 | */ |
9 | ||
1da177e4 LT |
10 | #include <linux/kmod.h> |
11 | #include <linux/types.h> | |
12 | #include <linux/err.h> | |
13 | #include <linux/string.h> | |
14 | #include <linux/spinlock.h> | |
15 | #include <linux/ctype.h> | |
16 | #include <asm/uaccess.h> | |
17 | ||
18 | #include "sclp.h" | |
19 | #include "sclp_rw.h" | |
20 | ||
1da177e4 LT |
21 | /* |
22 | * The room for the SCCB (only for writing) is not equal to a pages size | |
59c51591 | 23 | * (as it is specified as the maximum size in the SCLP documentation) |
1da177e4 LT |
24 | * because of the additional data structure described above. |
25 | */ | |
26 | #define MAX_SCCB_ROOM (PAGE_SIZE - sizeof(struct sclp_buffer)) | |
27 | ||
62b74942 MH |
28 | static void sclp_rw_pm_event(struct sclp_register *reg, |
29 | enum sclp_pm_event sclp_pm_event) | |
30 | { | |
31 | sclp_console_pm_event(sclp_pm_event); | |
32 | } | |
33 | ||
1da177e4 LT |
34 | /* Event type structure for write message and write priority message */ |
35 | static struct sclp_register sclp_rw_event = { | |
62b74942 MH |
36 | .send_mask = EVTYP_MSG_MASK | EVTYP_PMSGCMD_MASK, |
37 | .pm_event_fn = sclp_rw_pm_event, | |
1da177e4 LT |
38 | }; |
39 | ||
40 | /* | |
41 | * Setup a sclp write buffer. Gets a page as input (4K) and returns | |
42 | * a pointer to a struct sclp_buffer structure that is located at the | |
43 | * end of the input page. This reduces the buffer space by a few | |
44 | * bytes but simplifies things. | |
45 | */ | |
46 | struct sclp_buffer * | |
47 | sclp_make_buffer(void *page, unsigned short columns, unsigned short htab) | |
48 | { | |
49 | struct sclp_buffer *buffer; | |
50 | struct write_sccb *sccb; | |
51 | ||
52 | sccb = (struct write_sccb *) page; | |
53 | /* | |
54 | * We keep the struct sclp_buffer structure at the end | |
55 | * of the sccb page. | |
56 | */ | |
57 | buffer = ((struct sclp_buffer *) ((addr_t) sccb + PAGE_SIZE)) - 1; | |
58 | buffer->sccb = sccb; | |
59 | buffer->retry_count = 0; | |
60 | buffer->mto_number = 0; | |
61 | buffer->mto_char_sum = 0; | |
62 | buffer->current_line = NULL; | |
63 | buffer->current_length = 0; | |
64 | buffer->columns = columns; | |
65 | buffer->htab = htab; | |
66 | ||
67 | /* initialize sccb */ | |
68 | memset(sccb, 0, sizeof(struct write_sccb)); | |
69 | sccb->header.length = sizeof(struct write_sccb); | |
70 | sccb->msg_buf.header.length = sizeof(struct msg_buf); | |
6d4740c8 | 71 | sccb->msg_buf.header.type = EVTYP_MSG; |
1da177e4 LT |
72 | sccb->msg_buf.mdb.header.length = sizeof(struct mdb); |
73 | sccb->msg_buf.mdb.header.type = 1; | |
74 | sccb->msg_buf.mdb.header.tag = 0xD4C4C240; /* ebcdic "MDB " */ | |
75 | sccb->msg_buf.mdb.header.revision_code = 1; | |
76 | sccb->msg_buf.mdb.go.length = sizeof(struct go); | |
77 | sccb->msg_buf.mdb.go.type = 1; | |
78 | ||
79 | return buffer; | |
80 | } | |
81 | ||
82 | /* | |
5d67d164 | 83 | * Return a pointer to the original page that has been used to create |
1da177e4 LT |
84 | * the buffer. |
85 | */ | |
86 | void * | |
87 | sclp_unmake_buffer(struct sclp_buffer *buffer) | |
88 | { | |
89 | return buffer->sccb; | |
90 | } | |
91 | ||
92 | /* | |
93 | * Initialize a new Message Text Object (MTO) at the end of the provided buffer | |
94 | * with enough room for max_len characters. Return 0 on success. | |
95 | */ | |
96 | static int | |
97 | sclp_initialize_mto(struct sclp_buffer *buffer, int max_len) | |
98 | { | |
99 | struct write_sccb *sccb; | |
100 | struct mto *mto; | |
101 | int mto_size; | |
102 | ||
103 | /* max size of new Message Text Object including message text */ | |
104 | mto_size = sizeof(struct mto) + max_len; | |
105 | ||
106 | /* check if current buffer sccb can contain the mto */ | |
107 | sccb = buffer->sccb; | |
108 | if ((MAX_SCCB_ROOM - sccb->header.length) < mto_size) | |
109 | return -ENOMEM; | |
110 | ||
111 | /* find address of new message text object */ | |
112 | mto = (struct mto *)(((addr_t) sccb) + sccb->header.length); | |
113 | ||
114 | /* | |
115 | * fill the new Message-Text Object, | |
116 | * starting behind the former last byte of the SCCB | |
117 | */ | |
118 | memset(mto, 0, sizeof(struct mto)); | |
119 | mto->length = sizeof(struct mto); | |
120 | mto->type = 4; /* message text object */ | |
6d4740c8 | 121 | mto->line_type_flags = LNTPFLGS_ENDTEXT; /* end text */ |
1da177e4 LT |
122 | |
123 | /* set pointer to first byte after struct mto. */ | |
124 | buffer->current_line = (char *) (mto + 1); | |
125 | buffer->current_length = 0; | |
126 | ||
127 | return 0; | |
128 | } | |
129 | ||
130 | /* | |
131 | * Finalize MTO initialized by sclp_initialize_mto(), updating the sizes of | |
132 | * MTO, enclosing MDB, event buffer and SCCB. | |
133 | */ | |
134 | static void | |
135 | sclp_finalize_mto(struct sclp_buffer *buffer) | |
136 | { | |
137 | struct write_sccb *sccb; | |
138 | struct mto *mto; | |
139 | int str_len, mto_size; | |
140 | ||
141 | str_len = buffer->current_length; | |
142 | buffer->current_line = NULL; | |
143 | buffer->current_length = 0; | |
144 | ||
145 | /* real size of new Message Text Object including message text */ | |
146 | mto_size = sizeof(struct mto) + str_len; | |
147 | ||
148 | /* find address of new message text object */ | |
149 | sccb = buffer->sccb; | |
150 | mto = (struct mto *)(((addr_t) sccb) + sccb->header.length); | |
151 | ||
152 | /* set size of message text object */ | |
153 | mto->length = mto_size; | |
154 | ||
155 | /* | |
156 | * update values of sizes | |
157 | * (SCCB, Event(Message) Buffer, Message Data Block) | |
158 | */ | |
159 | sccb->header.length += mto_size; | |
160 | sccb->msg_buf.header.length += mto_size; | |
161 | sccb->msg_buf.mdb.header.length += mto_size; | |
162 | ||
163 | /* | |
164 | * count number of buffered messages (= number of Message Text | |
165 | * Objects) and number of buffered characters | |
166 | * for the SCCB currently used for buffering and at all | |
167 | */ | |
168 | buffer->mto_number++; | |
169 | buffer->mto_char_sum += str_len; | |
170 | } | |
171 | ||
172 | /* | |
173 | * processing of a message including escape characters, | |
174 | * returns number of characters written to the output sccb | |
175 | * ("processed" means that is not guaranteed that the character have already | |
176 | * been sent to the SCLP but that it will be done at least next time the SCLP | |
177 | * is not busy) | |
178 | */ | |
179 | int | |
180 | sclp_write(struct sclp_buffer *buffer, const unsigned char *msg, int count) | |
181 | { | |
182 | int spaces, i_msg; | |
183 | int rc; | |
184 | ||
185 | /* | |
186 | * parse msg for escape sequences (\t,\v ...) and put formated | |
187 | * msg into an mto (created by sclp_initialize_mto). | |
188 | * | |
189 | * We have to do this work ourselfs because there is no support for | |
190 | * these characters on the native machine and only partial support | |
191 | * under VM (Why does VM interpret \n but the native machine doesn't ?) | |
192 | * | |
193 | * Depending on i/o-control setting the message is always written | |
194 | * immediately or we wait for a final new line maybe coming with the | |
195 | * next message. Besides we avoid a buffer overrun by writing its | |
196 | * content. | |
197 | * | |
198 | * RESTRICTIONS: | |
199 | * | |
200 | * \r and \b work within one line because we are not able to modify | |
201 | * previous output that have already been accepted by the SCLP. | |
202 | * | |
203 | * \t combined with following \r is not correctly represented because | |
204 | * \t is expanded to some spaces but \r does not know about a | |
205 | * previous \t and decreases the current position by one column. | |
206 | * This is in order to a slim and quick implementation. | |
207 | */ | |
208 | for (i_msg = 0; i_msg < count; i_msg++) { | |
209 | switch (msg[i_msg]) { | |
210 | case '\n': /* new line, line feed (ASCII) */ | |
211 | /* check if new mto needs to be created */ | |
212 | if (buffer->current_line == NULL) { | |
213 | rc = sclp_initialize_mto(buffer, 0); | |
214 | if (rc) | |
215 | return i_msg; | |
216 | } | |
217 | sclp_finalize_mto(buffer); | |
218 | break; | |
219 | case '\a': /* bell, one for several times */ | |
220 | /* set SCLP sound alarm bit in General Object */ | |
221 | buffer->sccb->msg_buf.mdb.go.general_msg_flags |= | |
6d4740c8 | 222 | GNRLMSGFLGS_SNDALRM; |
1da177e4 LT |
223 | break; |
224 | case '\t': /* horizontal tabulator */ | |
225 | /* check if new mto needs to be created */ | |
226 | if (buffer->current_line == NULL) { | |
227 | rc = sclp_initialize_mto(buffer, | |
228 | buffer->columns); | |
229 | if (rc) | |
230 | return i_msg; | |
231 | } | |
232 | /* "go to (next htab-boundary + 1, same line)" */ | |
233 | do { | |
234 | if (buffer->current_length >= buffer->columns) | |
235 | break; | |
236 | /* ok, add a blank */ | |
237 | *buffer->current_line++ = 0x40; | |
238 | buffer->current_length++; | |
239 | } while (buffer->current_length % buffer->htab); | |
240 | break; | |
241 | case '\f': /* form feed */ | |
242 | case '\v': /* vertical tabulator */ | |
243 | /* "go to (actual column, actual line + 1)" */ | |
244 | /* = new line, leading spaces */ | |
245 | if (buffer->current_line != NULL) { | |
246 | spaces = buffer->current_length; | |
247 | sclp_finalize_mto(buffer); | |
248 | rc = sclp_initialize_mto(buffer, | |
249 | buffer->columns); | |
250 | if (rc) | |
251 | return i_msg; | |
252 | memset(buffer->current_line, 0x40, spaces); | |
253 | buffer->current_line += spaces; | |
254 | buffer->current_length = spaces; | |
255 | } else { | |
256 | /* one an empty line this is the same as \n */ | |
257 | rc = sclp_initialize_mto(buffer, | |
258 | buffer->columns); | |
259 | if (rc) | |
260 | return i_msg; | |
261 | sclp_finalize_mto(buffer); | |
262 | } | |
263 | break; | |
264 | case '\b': /* backspace */ | |
265 | /* "go to (actual column - 1, actual line)" */ | |
266 | /* decrement counter indicating position, */ | |
267 | /* do not remove last character */ | |
268 | if (buffer->current_line != NULL && | |
269 | buffer->current_length > 0) { | |
270 | buffer->current_length--; | |
271 | buffer->current_line--; | |
272 | } | |
273 | break; | |
274 | case 0x00: /* end of string */ | |
275 | /* transfer current line to SCCB */ | |
276 | if (buffer->current_line != NULL) | |
277 | sclp_finalize_mto(buffer); | |
278 | /* skip the rest of the message including the 0 byte */ | |
279 | i_msg = count - 1; | |
280 | break; | |
281 | default: /* no escape character */ | |
282 | /* do not output unprintable characters */ | |
283 | if (!isprint(msg[i_msg])) | |
284 | break; | |
285 | /* check if new mto needs to be created */ | |
286 | if (buffer->current_line == NULL) { | |
287 | rc = sclp_initialize_mto(buffer, | |
288 | buffer->columns); | |
289 | if (rc) | |
290 | return i_msg; | |
291 | } | |
292 | *buffer->current_line++ = sclp_ascebc(msg[i_msg]); | |
293 | buffer->current_length++; | |
294 | break; | |
295 | } | |
296 | /* check if current mto is full */ | |
297 | if (buffer->current_line != NULL && | |
298 | buffer->current_length >= buffer->columns) | |
299 | sclp_finalize_mto(buffer); | |
300 | } | |
301 | ||
302 | /* return number of processed characters */ | |
303 | return i_msg; | |
304 | } | |
305 | ||
306 | /* | |
307 | * Return the number of free bytes in the sccb | |
308 | */ | |
309 | int | |
310 | sclp_buffer_space(struct sclp_buffer *buffer) | |
311 | { | |
312 | int count; | |
313 | ||
314 | count = MAX_SCCB_ROOM - buffer->sccb->header.length; | |
315 | if (buffer->current_line != NULL) | |
316 | count -= sizeof(struct mto) + buffer->current_length; | |
317 | return count; | |
318 | } | |
319 | ||
320 | /* | |
321 | * Return number of characters in buffer | |
322 | */ | |
323 | int | |
324 | sclp_chars_in_buffer(struct sclp_buffer *buffer) | |
325 | { | |
326 | int count; | |
327 | ||
328 | count = buffer->mto_char_sum; | |
329 | if (buffer->current_line != NULL) | |
330 | count += buffer->current_length; | |
331 | return count; | |
332 | } | |
333 | ||
334 | /* | |
335 | * sets or provides some values that influence the drivers behaviour | |
336 | */ | |
337 | void | |
338 | sclp_set_columns(struct sclp_buffer *buffer, unsigned short columns) | |
339 | { | |
340 | buffer->columns = columns; | |
341 | if (buffer->current_line != NULL && | |
342 | buffer->current_length > buffer->columns) | |
343 | sclp_finalize_mto(buffer); | |
344 | } | |
345 | ||
346 | void | |
347 | sclp_set_htab(struct sclp_buffer *buffer, unsigned short htab) | |
348 | { | |
349 | buffer->htab = htab; | |
350 | } | |
351 | ||
352 | /* | |
353 | * called by sclp_console_init and/or sclp_tty_init | |
354 | */ | |
355 | int | |
356 | sclp_rw_init(void) | |
357 | { | |
358 | static int init_done = 0; | |
359 | int rc; | |
360 | ||
361 | if (init_done) | |
362 | return 0; | |
363 | ||
364 | rc = sclp_register(&sclp_rw_event); | |
365 | if (rc == 0) | |
366 | init_done = 1; | |
367 | return rc; | |
368 | } | |
369 | ||
370 | #define SCLP_BUFFER_MAX_RETRY 1 | |
371 | ||
372 | /* | |
373 | * second half of Write Event Data-function that has to be done after | |
374 | * interruption indicating completion of Service Call. | |
375 | */ | |
376 | static void | |
377 | sclp_writedata_callback(struct sclp_req *request, void *data) | |
378 | { | |
379 | int rc; | |
380 | struct sclp_buffer *buffer; | |
381 | struct write_sccb *sccb; | |
382 | ||
383 | buffer = (struct sclp_buffer *) data; | |
384 | sccb = buffer->sccb; | |
385 | ||
386 | if (request->status == SCLP_REQ_FAILED) { | |
387 | if (buffer->callback != NULL) | |
388 | buffer->callback(buffer, -EIO); | |
389 | return; | |
390 | } | |
391 | /* check SCLP response code and choose suitable action */ | |
392 | switch (sccb->header.response_code) { | |
393 | case 0x0020 : | |
394 | /* Normal completion, buffer processed, message(s) sent */ | |
395 | rc = 0; | |
396 | break; | |
397 | ||
398 | case 0x0340: /* Contained SCLP equipment check */ | |
399 | if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) { | |
400 | rc = -EIO; | |
401 | break; | |
402 | } | |
403 | /* remove processed buffers and requeue rest */ | |
404 | if (sclp_remove_processed((struct sccb_header *) sccb) > 0) { | |
405 | /* not all buffers were processed */ | |
406 | sccb->header.response_code = 0x0000; | |
407 | buffer->request.status = SCLP_REQ_FILLED; | |
408 | rc = sclp_add_request(request); | |
409 | if (rc == 0) | |
410 | return; | |
411 | } else | |
412 | rc = 0; | |
413 | break; | |
414 | ||
415 | case 0x0040: /* SCLP equipment check */ | |
416 | case 0x05f0: /* Target resource in improper state */ | |
417 | if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) { | |
418 | rc = -EIO; | |
419 | break; | |
420 | } | |
421 | /* retry request */ | |
422 | sccb->header.response_code = 0x0000; | |
423 | buffer->request.status = SCLP_REQ_FILLED; | |
424 | rc = sclp_add_request(request); | |
425 | if (rc == 0) | |
426 | return; | |
427 | break; | |
428 | default: | |
429 | if (sccb->header.response_code == 0x71f0) | |
430 | rc = -ENOMEM; | |
431 | else | |
432 | rc = -EINVAL; | |
433 | break; | |
434 | } | |
435 | if (buffer->callback != NULL) | |
436 | buffer->callback(buffer, rc); | |
437 | } | |
438 | ||
439 | /* | |
440 | * Setup the request structure in the struct sclp_buffer to do SCLP Write | |
441 | * Event Data and pass the request to the core SCLP loop. Return zero on | |
442 | * success, non-zero otherwise. | |
443 | */ | |
444 | int | |
445 | sclp_emit_buffer(struct sclp_buffer *buffer, | |
446 | void (*callback)(struct sclp_buffer *, int)) | |
447 | { | |
448 | struct write_sccb *sccb; | |
449 | ||
450 | /* add current line if there is one */ | |
451 | if (buffer->current_line != NULL) | |
452 | sclp_finalize_mto(buffer); | |
453 | ||
454 | /* Are there messages in the output buffer ? */ | |
455 | if (buffer->mto_number == 0) | |
456 | return -EIO; | |
457 | ||
458 | sccb = buffer->sccb; | |
d082d3ce | 459 | if (sclp_rw_event.sclp_receive_mask & EVTYP_MSG_MASK) |
1da177e4 | 460 | /* Use normal write message */ |
6d4740c8 | 461 | sccb->msg_buf.header.type = EVTYP_MSG; |
d082d3ce | 462 | else if (sclp_rw_event.sclp_receive_mask & EVTYP_PMSGCMD_MASK) |
1da177e4 | 463 | /* Use write priority message */ |
6d4740c8 | 464 | sccb->msg_buf.header.type = EVTYP_PMSGCMD; |
1da177e4 LT |
465 | else |
466 | return -ENOSYS; | |
ab14de6c | 467 | buffer->request.command = SCLP_CMDW_WRITE_EVENT_DATA; |
1da177e4 LT |
468 | buffer->request.status = SCLP_REQ_FILLED; |
469 | buffer->request.callback = sclp_writedata_callback; | |
470 | buffer->request.callback_data = buffer; | |
471 | buffer->request.sccb = sccb; | |
472 | buffer->callback = callback; | |
473 | return sclp_add_request(&buffer->request); | |
474 | } |