ehv_bytechan.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* ePAPR hypervisor byte channel device driver
  3. *
  4. * Copyright 2009-2011 Freescale Semiconductor, Inc.
  5. *
  6. * Author: Timur Tabi <timur@freescale.com>
  7. *
  8. * This driver support three distinct interfaces, all of which are related to
  9. * ePAPR hypervisor byte channels.
  10. *
  11. * 1) An early-console (udbg) driver. This provides early console output
  12. * through a byte channel. The byte channel handle must be specified in a
  13. * Kconfig option.
  14. *
  15. * 2) A normal console driver. Output is sent to the byte channel designated
  16. * for stdout in the device tree. The console driver is for handling kernel
  17. * printk calls.
  18. *
  19. * 3) A tty driver, which is used to handle user-space input and output. The
  20. * byte channel used for the console is designated as the default tty.
  21. */
  22. #include <linux/init.h>
  23. #include <linux/slab.h>
  24. #include <linux/err.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/fs.h>
  27. #include <linux/poll.h>
  28. #include <asm/epapr_hcalls.h>
  29. #include <linux/of.h>
  30. #include <linux/of_irq.h>
  31. #include <linux/platform_device.h>
  32. #include <linux/cdev.h>
  33. #include <linux/console.h>
  34. #include <linux/tty.h>
  35. #include <linux/tty_flip.h>
  36. #include <linux/circ_buf.h>
  37. #include <asm/udbg.h>
  38. /* The size of the transmit circular buffer. This must be a power of two. */
  39. #define BUF_SIZE 2048
  40. /* Per-byte channel private data */
  41. struct ehv_bc_data {
  42. struct device *dev;
  43. struct tty_port port;
  44. uint32_t handle;
  45. unsigned int rx_irq;
  46. unsigned int tx_irq;
  47. spinlock_t lock; /* lock for transmit buffer */
  48. unsigned char buf[BUF_SIZE]; /* transmit circular buffer */
  49. unsigned int head; /* circular buffer head */
  50. unsigned int tail; /* circular buffer tail */
  51. int tx_irq_enabled; /* true == TX interrupt is enabled */
  52. };
  53. /* Array of byte channel objects */
  54. static struct ehv_bc_data *bcs;
  55. /* Byte channel handle for stdout (and stdin), taken from device tree */
  56. static unsigned int stdout_bc;
  57. /* Virtual IRQ for the byte channel handle for stdin, taken from device tree */
  58. static unsigned int stdout_irq;
  59. /**************************** SUPPORT FUNCTIONS ****************************/
  60. /*
  61. * Enable the transmit interrupt
  62. *
  63. * Unlike a serial device, byte channels have no mechanism for disabling their
  64. * own receive or transmit interrupts. To emulate that feature, we toggle
  65. * the IRQ in the kernel.
  66. *
  67. * We cannot just blindly call enable_irq() or disable_irq(), because these
  68. * calls are reference counted. This means that we cannot call enable_irq()
  69. * if interrupts are already enabled. This can happen in two situations:
  70. *
  71. * 1. The tty layer makes two back-to-back calls to ehv_bc_tty_write()
  72. * 2. A transmit interrupt occurs while executing ehv_bc_tx_dequeue()
  73. *
  74. * To work around this, we keep a flag to tell us if the IRQ is enabled or not.
  75. */
  76. static void enable_tx_interrupt(struct ehv_bc_data *bc)
  77. {
  78. if (!bc->tx_irq_enabled) {
  79. enable_irq(bc->tx_irq);
  80. bc->tx_irq_enabled = 1;
  81. }
  82. }
  83. static void disable_tx_interrupt(struct ehv_bc_data *bc)
  84. {
  85. if (bc->tx_irq_enabled) {
  86. disable_irq_nosync(bc->tx_irq);
  87. bc->tx_irq_enabled = 0;
  88. }
  89. }
  90. /*
  91. * find the byte channel handle to use for the console
  92. *
  93. * The byte channel to be used for the console is specified via a "stdout"
  94. * property in the /chosen node.
  95. */
  96. static int find_console_handle(void)
  97. {
  98. struct device_node *np = of_stdout;
  99. const uint32_t *iprop;
  100. /* We don't care what the aliased node is actually called. We only
  101. * care if it's compatible with "epapr,hv-byte-channel", because that
  102. * indicates that it's a byte channel node.
  103. */
  104. if (!np || !of_device_is_compatible(np, "epapr,hv-byte-channel"))
  105. return 0;
  106. stdout_irq = irq_of_parse_and_map(np, 0);
  107. if (stdout_irq == NO_IRQ) {
  108. pr_err("ehv-bc: no 'interrupts' property in %pOF node\n", np);
  109. return 0;
  110. }
  111. /*
  112. * The 'hv-handle' property contains the handle for this byte channel.
  113. */
  114. iprop = of_get_property(np, "hv-handle", NULL);
  115. if (!iprop) {
  116. pr_err("ehv-bc: no 'hv-handle' property in %pOFn node\n",
  117. np);
  118. return 0;
  119. }
  120. stdout_bc = be32_to_cpu(*iprop);
  121. return 1;
  122. }
  123. static unsigned int local_ev_byte_channel_send(unsigned int handle,
  124. unsigned int *count,
  125. const char *p)
  126. {
  127. char buffer[EV_BYTE_CHANNEL_MAX_BYTES];
  128. unsigned int c = *count;
  129. if (c < sizeof(buffer)) {
  130. memcpy(buffer, p, c);
  131. memset(&buffer[c], 0, sizeof(buffer) - c);
  132. p = buffer;
  133. }
  134. return ev_byte_channel_send(handle, count, p);
  135. }
  136. /*************************** EARLY CONSOLE DRIVER ***************************/
  137. #ifdef CONFIG_PPC_EARLY_DEBUG_EHV_BC
  138. /*
  139. * send a byte to a byte channel, wait if necessary
  140. *
  141. * This function sends a byte to a byte channel, and it waits and
  142. * retries if the byte channel is full. It returns if the character
  143. * has been sent, or if some error has occurred.
  144. *
  145. */
  146. static void byte_channel_spin_send(const char data)
  147. {
  148. int ret, count;
  149. do {
  150. count = 1;
  151. ret = local_ev_byte_channel_send(CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE,
  152. &count, &data);
  153. } while (ret == EV_EAGAIN);
  154. }
  155. /*
  156. * The udbg subsystem calls this function to display a single character.
  157. * We convert CR to a CR/LF.
  158. */
  159. static void ehv_bc_udbg_putc(char c)
  160. {
  161. if (c == '\n')
  162. byte_channel_spin_send('\r');
  163. byte_channel_spin_send(c);
  164. }
  165. /*
  166. * early console initialization
  167. *
  168. * PowerPC kernels support an early printk console, also known as udbg.
  169. * This function must be called via the ppc_md.init_early function pointer.
  170. * At this point, the device tree has been unflattened, so we can obtain the
  171. * byte channel handle for stdout.
  172. *
  173. * We only support displaying of characters (putc). We do not support
  174. * keyboard input.
  175. */
  176. void __init udbg_init_ehv_bc(void)
  177. {
  178. unsigned int rx_count, tx_count;
  179. unsigned int ret;
  180. /* Verify the byte channel handle */
  181. ret = ev_byte_channel_poll(CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE,
  182. &rx_count, &tx_count);
  183. if (ret)
  184. return;
  185. udbg_putc = ehv_bc_udbg_putc;
  186. register_early_udbg_console();
  187. udbg_printf("ehv-bc: early console using byte channel handle %u\n",
  188. CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE);
  189. }
  190. #endif
  191. /****************************** CONSOLE DRIVER ******************************/
  192. static struct tty_driver *ehv_bc_driver;
  193. /*
  194. * Byte channel console sending worker function.
  195. *
  196. * For consoles, if the output buffer is full, we should just spin until it
  197. * clears.
  198. */
  199. static int ehv_bc_console_byte_channel_send(unsigned int handle, const char *s,
  200. unsigned int count)
  201. {
  202. unsigned int len;
  203. int ret = 0;
  204. while (count) {
  205. len = min_t(unsigned int, count, EV_BYTE_CHANNEL_MAX_BYTES);
  206. do {
  207. ret = local_ev_byte_channel_send(handle, &len, s);
  208. } while (ret == EV_EAGAIN);
  209. count -= len;
  210. s += len;
  211. }
  212. return ret;
  213. }
  214. /*
  215. * write a string to the console
  216. *
  217. * This function gets called to write a string from the kernel, typically from
  218. * a printk(). This function spins until all data is written.
  219. *
  220. * We copy the data to a temporary buffer because we need to insert a \r in
  221. * front of every \n. It's more efficient to copy the data to the buffer than
  222. * it is to make multiple hcalls for each character or each newline.
  223. */
  224. static void ehv_bc_console_write(struct console *co, const char *s,
  225. unsigned int count)
  226. {
  227. char s2[EV_BYTE_CHANNEL_MAX_BYTES];
  228. unsigned int i, j = 0;
  229. char c;
  230. for (i = 0; i < count; i++) {
  231. c = *s++;
  232. if (c == '\n')
  233. s2[j++] = '\r';
  234. s2[j++] = c;
  235. if (j >= (EV_BYTE_CHANNEL_MAX_BYTES - 1)) {
  236. if (ehv_bc_console_byte_channel_send(stdout_bc, s2, j))
  237. return;
  238. j = 0;
  239. }
  240. }
  241. if (j)
  242. ehv_bc_console_byte_channel_send(stdout_bc, s2, j);
  243. }
  244. /*
  245. * When /dev/console is opened, the kernel iterates the console list looking
  246. * for one with ->device and then calls that method. On success, it expects
  247. * the passed-in int* to contain the minor number to use.
  248. */
  249. static struct tty_driver *ehv_bc_console_device(struct console *co, int *index)
  250. {
  251. *index = co->index;
  252. return ehv_bc_driver;
  253. }
  254. static struct console ehv_bc_console = {
  255. .name = "ttyEHV",
  256. .write = ehv_bc_console_write,
  257. .device = ehv_bc_console_device,
  258. .flags = CON_PRINTBUFFER | CON_ENABLED,
  259. };
  260. /*
  261. * Console initialization
  262. *
  263. * This is the first function that is called after the device tree is
  264. * available, so here is where we determine the byte channel handle and IRQ for
  265. * stdout/stdin, even though that information is used by the tty and character
  266. * drivers.
  267. */
  268. static int __init ehv_bc_console_init(void)
  269. {
  270. if (!find_console_handle()) {
  271. pr_debug("ehv-bc: stdout is not a byte channel\n");
  272. return -ENODEV;
  273. }
  274. #ifdef CONFIG_PPC_EARLY_DEBUG_EHV_BC
  275. /* Print a friendly warning if the user chose the wrong byte channel
  276. * handle for udbg.
  277. */
  278. if (stdout_bc != CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE)
  279. pr_warn("ehv-bc: udbg handle %u is not the stdout handle\n",
  280. CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE);
  281. #endif
  282. /* add_preferred_console() must be called before register_console(),
  283. otherwise it won't work. However, we don't want to enumerate all the
  284. byte channels here, either, since we only care about one. */
  285. add_preferred_console(ehv_bc_console.name, ehv_bc_console.index, NULL);
  286. register_console(&ehv_bc_console);
  287. pr_info("ehv-bc: registered console driver for byte channel %u\n",
  288. stdout_bc);
  289. return 0;
  290. }
  291. console_initcall(ehv_bc_console_init);
  292. /******************************** TTY DRIVER ********************************/
  293. /*
  294. * byte channel receive interrupt handler
  295. *
  296. * This ISR is called whenever data is available on a byte channel.
  297. */
  298. static irqreturn_t ehv_bc_tty_rx_isr(int irq, void *data)
  299. {
  300. struct ehv_bc_data *bc = data;
  301. unsigned int rx_count, tx_count, len;
  302. int count;
  303. char buffer[EV_BYTE_CHANNEL_MAX_BYTES];
  304. int ret;
  305. /* Find out how much data needs to be read, and then ask the TTY layer
  306. * if it can handle that much. We want to ensure that every byte we
  307. * read from the byte channel will be accepted by the TTY layer.
  308. */
  309. ev_byte_channel_poll(bc->handle, &rx_count, &tx_count);
  310. count = tty_buffer_request_room(&bc->port, rx_count);
  311. /* 'count' is the maximum amount of data the TTY layer can accept at
  312. * this time. However, during testing, I was never able to get 'count'
  313. * to be less than 'rx_count'. I'm not sure whether I'm calling it
  314. * correctly.
  315. */
  316. while (count > 0) {
  317. len = min_t(unsigned int, count, sizeof(buffer));
  318. /* Read some data from the byte channel. This function will
  319. * never return more than EV_BYTE_CHANNEL_MAX_BYTES bytes.
  320. */
  321. ev_byte_channel_receive(bc->handle, &len, buffer);
  322. /* 'len' is now the amount of data that's been received. 'len'
  323. * can't be zero, and most likely it's equal to one.
  324. */
  325. /* Pass the received data to the tty layer. */
  326. ret = tty_insert_flip_string(&bc->port, buffer, len);
  327. /* 'ret' is the number of bytes that the TTY layer accepted.
  328. * If it's not equal to 'len', then it means the buffer is
  329. * full, which should never happen. If it does happen, we can
  330. * exit gracefully, but we drop the last 'len - ret' characters
  331. * that we read from the byte channel.
  332. */
  333. if (ret != len)
  334. break;
  335. count -= len;
  336. }
  337. /* Tell the tty layer that we're done. */
  338. tty_flip_buffer_push(&bc->port);
  339. return IRQ_HANDLED;
  340. }
  341. /*
  342. * dequeue the transmit buffer to the hypervisor
  343. *
  344. * This function, which can be called in interrupt context, dequeues as much
  345. * data as possible from the transmit buffer to the byte channel.
  346. */
  347. static void ehv_bc_tx_dequeue(struct ehv_bc_data *bc)
  348. {
  349. unsigned int count;
  350. unsigned int len, ret;
  351. unsigned long flags;
  352. do {
  353. spin_lock_irqsave(&bc->lock, flags);
  354. len = min_t(unsigned int,
  355. CIRC_CNT_TO_END(bc->head, bc->tail, BUF_SIZE),
  356. EV_BYTE_CHANNEL_MAX_BYTES);
  357. ret = local_ev_byte_channel_send(bc->handle, &len, bc->buf + bc->tail);
  358. /* 'len' is valid only if the return code is 0 or EV_EAGAIN */
  359. if (!ret || (ret == EV_EAGAIN))
  360. bc->tail = (bc->tail + len) & (BUF_SIZE - 1);
  361. count = CIRC_CNT(bc->head, bc->tail, BUF_SIZE);
  362. spin_unlock_irqrestore(&bc->lock, flags);
  363. } while (count && !ret);
  364. spin_lock_irqsave(&bc->lock, flags);
  365. if (CIRC_CNT(bc->head, bc->tail, BUF_SIZE))
  366. /*
  367. * If we haven't emptied the buffer, then enable the TX IRQ.
  368. * We'll get an interrupt when there's more room in the
  369. * hypervisor's output buffer.
  370. */
  371. enable_tx_interrupt(bc);
  372. else
  373. disable_tx_interrupt(bc);
  374. spin_unlock_irqrestore(&bc->lock, flags);
  375. }
  376. /*
  377. * byte channel transmit interrupt handler
  378. *
  379. * This ISR is called whenever space becomes available for transmitting
  380. * characters on a byte channel.
  381. */
  382. static irqreturn_t ehv_bc_tty_tx_isr(int irq, void *data)
  383. {
  384. struct ehv_bc_data *bc = data;
  385. ehv_bc_tx_dequeue(bc);
  386. tty_port_tty_wakeup(&bc->port);
  387. return IRQ_HANDLED;
  388. }
  389. /*
  390. * This function is called when the tty layer has data for us send. We store
  391. * the data first in a circular buffer, and then dequeue as much of that data
  392. * as possible.
  393. *
  394. * We don't need to worry about whether there is enough room in the buffer for
  395. * all the data. The purpose of ehv_bc_tty_write_room() is to tell the tty
  396. * layer how much data it can safely send to us. We guarantee that
  397. * ehv_bc_tty_write_room() will never lie, so the tty layer will never send us
  398. * too much data.
  399. */
  400. static int ehv_bc_tty_write(struct tty_struct *ttys, const unsigned char *s,
  401. int count)
  402. {
  403. struct ehv_bc_data *bc = ttys->driver_data;
  404. unsigned long flags;
  405. unsigned int len;
  406. unsigned int written = 0;
  407. while (1) {
  408. spin_lock_irqsave(&bc->lock, flags);
  409. len = CIRC_SPACE_TO_END(bc->head, bc->tail, BUF_SIZE);
  410. if (count < len)
  411. len = count;
  412. if (len) {
  413. memcpy(bc->buf + bc->head, s, len);
  414. bc->head = (bc->head + len) & (BUF_SIZE - 1);
  415. }
  416. spin_unlock_irqrestore(&bc->lock, flags);
  417. if (!len)
  418. break;
  419. s += len;
  420. count -= len;
  421. written += len;
  422. }
  423. ehv_bc_tx_dequeue(bc);
  424. return written;
  425. }
  426. /*
  427. * This function can be called multiple times for a given tty_struct, which is
  428. * why we initialize bc->ttys in ehv_bc_tty_port_activate() instead.
  429. *
  430. * The tty layer will still call this function even if the device was not
  431. * registered (i.e. tty_register_device() was not called). This happens
  432. * because tty_register_device() is optional and some legacy drivers don't
  433. * use it. So we need to check for that.
  434. */
  435. static int ehv_bc_tty_open(struct tty_struct *ttys, struct file *filp)
  436. {
  437. struct ehv_bc_data *bc = &bcs[ttys->index];
  438. if (!bc->dev)
  439. return -ENODEV;
  440. return tty_port_open(&bc->port, ttys, filp);
  441. }
  442. /*
  443. * Amazingly, if ehv_bc_tty_open() returns an error code, the tty layer will
  444. * still call this function to close the tty device. So we can't assume that
  445. * the tty port has been initialized.
  446. */
  447. static void ehv_bc_tty_close(struct tty_struct *ttys, struct file *filp)
  448. {
  449. struct ehv_bc_data *bc = &bcs[ttys->index];
  450. if (bc->dev)
  451. tty_port_close(&bc->port, ttys, filp);
  452. }
  453. /*
  454. * Return the amount of space in the output buffer
  455. *
  456. * This is actually a contract between the driver and the tty layer outlining
  457. * how much write room the driver can guarantee will be sent OR BUFFERED. This
  458. * driver MUST honor the return value.
  459. */
  460. static int ehv_bc_tty_write_room(struct tty_struct *ttys)
  461. {
  462. struct ehv_bc_data *bc = ttys->driver_data;
  463. unsigned long flags;
  464. int count;
  465. spin_lock_irqsave(&bc->lock, flags);
  466. count = CIRC_SPACE(bc->head, bc->tail, BUF_SIZE);
  467. spin_unlock_irqrestore(&bc->lock, flags);
  468. return count;
  469. }
  470. /*
  471. * Stop sending data to the tty layer
  472. *
  473. * This function is called when the tty layer's input buffers are getting full,
  474. * so the driver should stop sending it data. The easiest way to do this is to
  475. * disable the RX IRQ, which will prevent ehv_bc_tty_rx_isr() from being
  476. * called.
  477. *
  478. * The hypervisor will continue to queue up any incoming data. If there is any
  479. * data in the queue when the RX interrupt is enabled, we'll immediately get an
  480. * RX interrupt.
  481. */
  482. static void ehv_bc_tty_throttle(struct tty_struct *ttys)
  483. {
  484. struct ehv_bc_data *bc = ttys->driver_data;
  485. disable_irq(bc->rx_irq);
  486. }
  487. /*
  488. * Resume sending data to the tty layer
  489. *
  490. * This function is called after previously calling ehv_bc_tty_throttle(). The
  491. * tty layer's input buffers now have more room, so the driver can resume
  492. * sending it data.
  493. */
  494. static void ehv_bc_tty_unthrottle(struct tty_struct *ttys)
  495. {
  496. struct ehv_bc_data *bc = ttys->driver_data;
  497. /* If there is any data in the queue when the RX interrupt is enabled,
  498. * we'll immediately get an RX interrupt.
  499. */
  500. enable_irq(bc->rx_irq);
  501. }
  502. static void ehv_bc_tty_hangup(struct tty_struct *ttys)
  503. {
  504. struct ehv_bc_data *bc = ttys->driver_data;
  505. ehv_bc_tx_dequeue(bc);
  506. tty_port_hangup(&bc->port);
  507. }
  508. /*
  509. * TTY driver operations
  510. *
  511. * If we could ask the hypervisor how much data is still in the TX buffer, or
  512. * at least how big the TX buffers are, then we could implement the
  513. * .wait_until_sent and .chars_in_buffer functions.
  514. */
  515. static const struct tty_operations ehv_bc_ops = {
  516. .open = ehv_bc_tty_open,
  517. .close = ehv_bc_tty_close,
  518. .write = ehv_bc_tty_write,
  519. .write_room = ehv_bc_tty_write_room,
  520. .throttle = ehv_bc_tty_throttle,
  521. .unthrottle = ehv_bc_tty_unthrottle,
  522. .hangup = ehv_bc_tty_hangup,
  523. };
  524. /*
  525. * initialize the TTY port
  526. *
  527. * This function will only be called once, no matter how many times
  528. * ehv_bc_tty_open() is called. That's why we register the ISR here, and also
  529. * why we initialize tty_struct-related variables here.
  530. */
  531. static int ehv_bc_tty_port_activate(struct tty_port *port,
  532. struct tty_struct *ttys)
  533. {
  534. struct ehv_bc_data *bc = container_of(port, struct ehv_bc_data, port);
  535. int ret;
  536. ttys->driver_data = bc;
  537. ret = request_irq(bc->rx_irq, ehv_bc_tty_rx_isr, 0, "ehv-bc", bc);
  538. if (ret < 0) {
  539. dev_err(bc->dev, "could not request rx irq %u (ret=%i)\n",
  540. bc->rx_irq, ret);
  541. return ret;
  542. }
  543. /* request_irq also enables the IRQ */
  544. bc->tx_irq_enabled = 1;
  545. ret = request_irq(bc->tx_irq, ehv_bc_tty_tx_isr, 0, "ehv-bc", bc);
  546. if (ret < 0) {
  547. dev_err(bc->dev, "could not request tx irq %u (ret=%i)\n",
  548. bc->tx_irq, ret);
  549. free_irq(bc->rx_irq, bc);
  550. return ret;
  551. }
  552. /* The TX IRQ is enabled only when we can't write all the data to the
  553. * byte channel at once, so by default it's disabled.
  554. */
  555. disable_tx_interrupt(bc);
  556. return 0;
  557. }
  558. static void ehv_bc_tty_port_shutdown(struct tty_port *port)
  559. {
  560. struct ehv_bc_data *bc = container_of(port, struct ehv_bc_data, port);
  561. free_irq(bc->tx_irq, bc);
  562. free_irq(bc->rx_irq, bc);
  563. }
  564. static const struct tty_port_operations ehv_bc_tty_port_ops = {
  565. .activate = ehv_bc_tty_port_activate,
  566. .shutdown = ehv_bc_tty_port_shutdown,
  567. };
  568. static int ehv_bc_tty_probe(struct platform_device *pdev)
  569. {
  570. struct device_node *np = pdev->dev.of_node;
  571. struct ehv_bc_data *bc;
  572. const uint32_t *iprop;
  573. unsigned int handle;
  574. int ret;
  575. static unsigned int index = 1;
  576. unsigned int i;
  577. iprop = of_get_property(np, "hv-handle", NULL);
  578. if (!iprop) {
  579. dev_err(&pdev->dev, "no 'hv-handle' property in %pOFn node\n",
  580. np);
  581. return -ENODEV;
  582. }
  583. /* We already told the console layer that the index for the console
  584. * device is zero, so we need to make sure that we use that index when
  585. * we probe the console byte channel node.
  586. */
  587. handle = be32_to_cpu(*iprop);
  588. i = (handle == stdout_bc) ? 0 : index++;
  589. bc = &bcs[i];
  590. bc->handle = handle;
  591. bc->head = 0;
  592. bc->tail = 0;
  593. spin_lock_init(&bc->lock);
  594. bc->rx_irq = irq_of_parse_and_map(np, 0);
  595. bc->tx_irq = irq_of_parse_and_map(np, 1);
  596. if ((bc->rx_irq == NO_IRQ) || (bc->tx_irq == NO_IRQ)) {
  597. dev_err(&pdev->dev, "no 'interrupts' property in %pOFn node\n",
  598. np);
  599. ret = -ENODEV;
  600. goto error;
  601. }
  602. tty_port_init(&bc->port);
  603. bc->port.ops = &ehv_bc_tty_port_ops;
  604. bc->dev = tty_port_register_device(&bc->port, ehv_bc_driver, i,
  605. &pdev->dev);
  606. if (IS_ERR(bc->dev)) {
  607. ret = PTR_ERR(bc->dev);
  608. dev_err(&pdev->dev, "could not register tty (ret=%i)\n", ret);
  609. goto error;
  610. }
  611. dev_set_drvdata(&pdev->dev, bc);
  612. dev_info(&pdev->dev, "registered /dev/%s%u for byte channel %u\n",
  613. ehv_bc_driver->name, i, bc->handle);
  614. return 0;
  615. error:
  616. tty_port_destroy(&bc->port);
  617. irq_dispose_mapping(bc->tx_irq);
  618. irq_dispose_mapping(bc->rx_irq);
  619. memset(bc, 0, sizeof(struct ehv_bc_data));
  620. return ret;
  621. }
  622. static const struct of_device_id ehv_bc_tty_of_ids[] = {
  623. { .compatible = "epapr,hv-byte-channel" },
  624. {}
  625. };
  626. static struct platform_driver ehv_bc_tty_driver = {
  627. .driver = {
  628. .name = "ehv-bc",
  629. .of_match_table = ehv_bc_tty_of_ids,
  630. .suppress_bind_attrs = true,
  631. },
  632. .probe = ehv_bc_tty_probe,
  633. };
  634. /**
  635. * ehv_bc_init - ePAPR hypervisor byte channel driver initialization
  636. *
  637. * This function is called when this driver is loaded.
  638. */
  639. static int __init ehv_bc_init(void)
  640. {
  641. struct device_node *np;
  642. unsigned int count = 0; /* Number of elements in bcs[] */
  643. int ret;
  644. pr_info("ePAPR hypervisor byte channel driver\n");
  645. /* Count the number of byte channels */
  646. for_each_compatible_node(np, NULL, "epapr,hv-byte-channel")
  647. count++;
  648. if (!count)
  649. return -ENODEV;
  650. /* The array index of an element in bcs[] is the same as the tty index
  651. * for that element. If you know the address of an element in the
  652. * array, then you can use pointer math (e.g. "bc - bcs") to get its
  653. * tty index.
  654. */
  655. bcs = kcalloc(count, sizeof(struct ehv_bc_data), GFP_KERNEL);
  656. if (!bcs)
  657. return -ENOMEM;
  658. ehv_bc_driver = alloc_tty_driver(count);
  659. if (!ehv_bc_driver) {
  660. ret = -ENOMEM;
  661. goto err_free_bcs;
  662. }
  663. ehv_bc_driver->driver_name = "ehv-bc";
  664. ehv_bc_driver->name = ehv_bc_console.name;
  665. ehv_bc_driver->type = TTY_DRIVER_TYPE_CONSOLE;
  666. ehv_bc_driver->subtype = SYSTEM_TYPE_CONSOLE;
  667. ehv_bc_driver->init_termios = tty_std_termios;
  668. ehv_bc_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
  669. tty_set_operations(ehv_bc_driver, &ehv_bc_ops);
  670. ret = tty_register_driver(ehv_bc_driver);
  671. if (ret) {
  672. pr_err("ehv-bc: could not register tty driver (ret=%i)\n", ret);
  673. goto err_put_tty_driver;
  674. }
  675. ret = platform_driver_register(&ehv_bc_tty_driver);
  676. if (ret) {
  677. pr_err("ehv-bc: could not register platform driver (ret=%i)\n",
  678. ret);
  679. goto err_deregister_tty_driver;
  680. }
  681. return 0;
  682. err_deregister_tty_driver:
  683. tty_unregister_driver(ehv_bc_driver);
  684. err_put_tty_driver:
  685. put_tty_driver(ehv_bc_driver);
  686. err_free_bcs:
  687. kfree(bcs);
  688. return ret;
  689. }
  690. device_initcall(ehv_bc_init);