Homebrew (Wikipedie), správce balíčků pro macOS a od verze 2.0.0 také pro Linux, byl vydán ve verzi 4.5.0. Na stránce Homebrew Formulae lze procházet seznamem balíčků. K dispozici jsou také různé statistiky.
Byl vydán Mozilla Firefox 138.0. Přehled novinek v poznámkách k vydání a poznámkách k vydání pro vývojáře. Řešeny jsou rovněž bezpečnostní chyby. Nový Firefox 138 je již k dispozici také na Flathubu a Snapcraftu.
Šestnáctý ročník ne-konference jOpenSpace se koná 3. – 5. října 2025 v Hotelu Antoň v Telči. Pro účast je potřeba vyplnit registrační formulář. Ne-konference neznamená, že se organizátorům nechce připravovat program, ale naopak dává prostor všem pozvaným, aby si program sami složili z toho nejzajímavějšího, čím se v poslední době zabývají nebo co je oslovilo. Obsah, který vytvářejí všichni účastníci, se skládá z desetiminutových
… více »Richard Stallman přednáší ve středu 7. května od 16:30 na Technické univerzitě v Liberci o vlivu technologií na svobodu. Přednáška je určená jak odborné tak laické veřejnosti.
Jean-Baptiste Mardelle se v příspěvku na blogu rozepsal o novinkám v nejnovější verzi 25.04.0 editoru videa Kdenlive (Wikipedie). Ke stažení také na Flathubu.
TmuxAI (GitHub) je AI asistent pro práci v terminálu. Vyžaduje účet na OpenRouter.
Byla vydána nová verze R14.1.4 desktopového prostředí Trinity Desktop Environment (TDE, fork KDE 3.5, Wikipedie). Přehled novinek i s náhledy v poznámkách k vydání. Podrobný přehled v Changelogu.
Bylo vydáno OpenBSD 7.7. Opět bez písničky.
V Tiraně proběhl letošní Linux App Summit (LAS) (Mastodon). Zatím nesestříhané videozáznamy přednášek jsou k dispozici na YouTube.
4.3.2006 12:33
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
a proto to nezdelim zadarmo odpoved na tento problem sdelim az nekdo spravne odpovi na moji otazku jaka je ma oblibena distribuce tak zdar hodne stesti opovedi piste na kozzi11@gmail.com nebo na kozzi@tiscali.cz
4.3.2006 18:56
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
4.3.2006 19:40
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
static struct usb_device_id id_table [] = { { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) }, { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID_RSAQ2) }, { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID_RSAQ3) }, { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID_PHAROS) }, { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) }, { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) }, { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) }, { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) }, { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) }, { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) }, { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) }, { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) }, { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) }, { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) }, { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) }, { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) }, { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) }, { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) }, { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) }, { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) }, { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) }, { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) }, { USB_DEVICE( NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID ) }, { } /* Terminating entry */ };a upravte ji nasledovne:static struct usb_device_id id_table [] = { { USB_DEVICE(ANYDATA_VENDOR_ID, PL2303_PRODUCT_ID) }, { } /* Terminating entry */ };- potom se jeste musi vymazat par radku nekde na radku 790 puvodne to tam vypada takto:static void anydata_update_line_status(struct usb_serial_port *port, unsigned char *data, unsigned int actual_length) { struct anydata_private *priv = usb_get_serial_port_data(port); unsigned long flags; u8 status_idx = UART_STATE; u8 length = UART_STATE; if ((le16_to_cpu(port->serial->dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) && (le16_to_cpu(port->serial->dev-> descriptor.idProduct) == SIEMENS_PRODUCT_ID_X65 || le16_to_cpu(port->serial->dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_SX1 || le16_to_cpu(port->serial->dev->descriptor.idProduct ) == SIEMENS_PRODUCT_ID_X75)) { length = 1; status_idx = 0; } if (actual_length < length) goto exit;po uprave asi takto:static void anydata_update_line_status(struct usb_serial_port *port, unsigned char *data, unsigned int actual_length) { struct anydata_private *priv = usb_get_serial_port_data(port); unsigned long flags; u8 status_idx = UART_STATE; u8 length = UART_STATE; if (actual_length < length) goto exit;potom jsem otevrel pl2303.h a upravil ho takhle:/* * ANYDATA USB to serial adaptor driver header file * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * */ #define ANYDATA_VENDOR_ID 0x16d5 #define ANYDATA_PRODUCT_ID 0x6501pozn vyse uvedenej soubor pl2303.h je celej takze tam nic vic nebude vsechno ostatni jsem smazal a ulozi ho jako anydata.h Tak to jsou vsechny zmeny ktere jsem provedl pak jsem jen dal skompilovat jadru a hotovo kompilaci jadra a jeho nastavenim se zde zabivat nebudu. Poznamka vyzkouseno na jadrech rady 2.6.15 a 2.6.16-rc* u nizsich jader by bylo zapotrebi stahnout patch z http://dastych.sh.cvut.cz/~jtra/stuff/anydata/index.html opatchovat jadro a pak udelat vyse zminene upravy. vjadrech 2.6.15 a novejsich je sice jiz anydata.h ale ten je nefunkcni takze ho prepiste vyse uvedenymi zmenami to vlastne plati i pro nizsi rady jader po opatchovani. k zavedeni pouzivam prikaz: modprobe anydata vse jede v pohode nastaveni internetu mam pres pppconfig. v /dev ho najdete pod nazvem ttyUSB0 ja ho mam v /dev/tts/USB0 (Archlinux). jestli jsem neco zapomnel tak mi napiste objasnim.
Viz: man diff, man patch
4.3.2006 19:59
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
jednoduše vememe originál a skopírujeme upravíme a potom originál a upravený porovnáme viz: man diff no a máme rozdíly které vystavíme
4.3.2006 20:09
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
4.3.2006 22:33
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
AbcLinuxu.cz
ITBiz.cz
HDmag.cz
AbcPráce.cz
*** anydata.orig.c 2006-02-03 07:03:08.000000000 +0100
--- anydata.c 2006-03-05 18:41:28.000000000 +0100
***************
*** 1,86 ****
/*
! * AnyData CDMA Serial USB driver
*
! * Copyright (C) 2005 Greg Kroah-Hartman <gregkh@suse.de>
*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version
- * 2 as published by the Free Software Foundation.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/tty.h>
#include <linux/module.h>
#include <linux/usb.h>
#include "usb-serial.h"
static struct usb_device_id id_table [] = {
! { USB_DEVICE(0x16d5, 0x6501) }, /* AirData CDMA device */
! { },
};
- MODULE_DEVICE_TABLE(usb, id_table);
! /* if overridden by the user, then use their value for the size of the
! * read and write urbs */
! static int buffer_size;
! static int debug;
static struct usb_driver anydata_driver = {
.name = "anydata",
.probe = usb_serial_probe,
.disconnect = usb_serial_disconnect,
.id_table = id_table,
! .no_dynamic_id = 1,
};
! static int anydata_open(struct usb_serial_port *port, struct file *filp)
! {
! char *buffer;
! int result = 0;
! dbg("%s - port %d", __FUNCTION__, port->number);
- if (buffer_size) {
- /* override the default buffer sizes */
- buffer = kmalloc(buffer_size, GFP_KERNEL);
- if (!buffer) {
- dev_err(&port->dev, "%s - out of memory.\n",
- __FUNCTION__);
- return -ENOMEM;
- }
- kfree (port->read_urb->transfer_buffer);
- port->read_urb->transfer_buffer = buffer;
- port->read_urb->transfer_buffer_length = buffer_size;
-
- buffer = kmalloc(buffer_size, GFP_KERNEL);
- if (!buffer) {
- dev_err(&port->dev, "%s - out of memory.\n",
- __FUNCTION__);
- return -ENOMEM;
- }
- kfree (port->write_urb->transfer_buffer);
- port->write_urb->transfer_buffer = buffer;
- port->write_urb->transfer_buffer_length = buffer_size;
- port->bulk_out_size = buffer_size;
- }
-
- /* Start reading from the device */
- usb_fill_bulk_urb(port->read_urb, port->serial->dev,
- usb_rcvbulkpipe(port->serial->dev,
- port->bulk_in_endpointAddress),
- port->read_urb->transfer_buffer,
- port->read_urb->transfer_buffer_length,
- usb_serial_generic_write_bulk_callback, port);
- result = usb_submit_urb(port->read_urb, GFP_KERNEL);
- if (result)
- dev_err(&port->dev,
- "%s - failed submitting read urb, error %d\n",
- __FUNCTION__, result);
-
- return result;
- }
static struct usb_serial_driver anydata_device = {
.driver = {
.owner = THIS_MODULE,
--- 1,131 ----
/*
! * Prolific ANYDATA USB to serial adaptor driver
! * Based on ANYDATA USB driver
*
! * Copyright (C) 2006 Daniel Kozak (kozzi11@gmail.com)
! *
! * Original driver for 2.2.x by anonymous
! *
! * This program is free software; you can redistribute it and/or modify
! * it under the terms of the GNU General Public License as published by
! * the Free Software Foundation; either version 2 of the License.
! *
! * See Documentation/usb/usb-serial.txt for more information on using this driver
*
*/
+ #include <linux/config.h>
#include <linux/kernel.h>
+ #include <linux/errno.h>
#include <linux/init.h>
+ #include <linux/slab.h>
#include <linux/tty.h>
+ #include <linux/tty_driver.h>
+ #include <linux/tty_flip.h>
+ #include <linux/serial.h>
#include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/spinlock.h>
+ #include <asm/uaccess.h>
#include <linux/usb.h>
#include "usb-serial.h"
+ #include "anydata.h"
+
+ /*
+ * Version Information
+ */
+ #define DRIVER_DESC "Prolific ANYDATA USB to serial adaptor driver"
+
+ static int debug;
+
+ #define ANYDATA_CLOSING_WAIT (30*HZ)
+
+ #define ANYDATA_BUF_SIZE 1024
+ #define ANYDATA_TMP_BUF_SIZE 1024
+
+ struct anydata_buf {
+ unsigned int buf_size;
+ char *buf_buf;
+ char *buf_get;
+ char *buf_put;
+ };
static struct usb_device_id id_table [] = {
! { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
! /* Terminating entry */
};
! MODULE_DEVICE_TABLE (usb, id_table);
static struct usb_driver anydata_driver = {
.name = "anydata",
.probe = usb_serial_probe,
.disconnect = usb_serial_disconnect,
.id_table = id_table,
! //.no_dynamic_id = 1,
};
! #define SET_LINE_REQUEST_TYPE 0x21
! #define SET_LINE_REQUEST 0x20
! #define SET_CONTROL_REQUEST_TYPE 0x21
! #define SET_CONTROL_REQUEST 0x22
! #define CONTROL_DTR 0x01
! #define CONTROL_RTS 0x02
!
! #define BREAK_REQUEST_TYPE 0x21
! #define BREAK_REQUEST 0x23
! #define BREAK_ON 0xffff
! #define BREAK_OFF 0x0000
!
! #define GET_LINE_REQUEST_TYPE 0xa1
! #define GET_LINE_REQUEST 0x21
!
! #define VENDOR_WRITE_REQUEST_TYPE 0x40
! #define VENDOR_WRITE_REQUEST 0x01
!
! #define VENDOR_READ_REQUEST_TYPE 0xc0
! #define VENDOR_READ_REQUEST 0x01
!
! #define UART_STATE 0x08
! #define UART_STATE_TRANSIENT_MASK 0x74
! #define UART_DCD 0x01
! #define UART_DSR 0x02
! #define UART_BREAK_ERROR 0x04
! #define UART_RING 0x08
! #define UART_FRAME_ERROR 0x10
! #define UART_PARITY_ERROR 0x20
! #define UART_OVERRUN_ERROR 0x40
! #define UART_CTS 0x80
!
! /* function prototypes for a ANYDATA serial converter */
! static int anydata_open (struct usb_serial_port *port, struct file *filp);
! static void anydata_close (struct usb_serial_port *port, struct file *filp);
! static int anydata_ioctl (struct usb_serial_port *port, struct file *file,
! unsigned int cmd, unsigned long arg);
! static void anydata_read_int_callback (struct urb *urb, struct pt_regs *regs);
! static void anydata_read_bulk_callback (struct urb *urb, struct pt_regs *regs);
! static void anydata_write_bulk_callback (struct urb *urb, struct pt_regs *regs);
! static int anydata_write (struct usb_serial_port *port,
! const unsigned char *buf, int count);
! static void anydata_send (struct usb_serial_port *port);
! static int anydata_write_room(struct usb_serial_port *port);
! static int anydata_chars_in_buffer(struct usb_serial_port *port);
! static void anydata_break_ctl(struct usb_serial_port *port,int break_state);
! static int anydata_startup (struct usb_serial *serial);
! static void anydata_shutdown (struct usb_serial *serial);
! static struct anydata_buf *anydata_buf_alloc(unsigned int size);
! static void anydata_buf_free(struct anydata_buf *pb);
! static void anydata_buf_clear(struct anydata_buf *pb);
! static unsigned int anydata_buf_data_avail(struct anydata_buf *pb);
! static unsigned int anydata_buf_space_avail(struct anydata_buf *pb);
! static unsigned int anydata_buf_put(struct anydata_buf *pb, const char *buf,
! unsigned int count);
! static unsigned int anydata_buf_get(struct anydata_buf *pb, char *buf,
! unsigned int count);
+ /* All of the device info needed for the ANYDATA SIO serial converter */
static struct usb_serial_driver anydata_device = {
.driver = {
.owner = THIS_MODULE,
***************
*** 92,123 ****
.num_bulk_out = NUM_DONT_CARE,
.num_ports = 1,
.open = anydata_open,
};
! static int __init anydata_init(void)
{
int retval;
retval = usb_serial_register(&anydata_device);
if (retval)
! return retval;
retval = usb_register(&anydata_driver);
if (retval)
! usb_serial_deregister(&anydata_device);
return retval;
}
! static void __exit anydata_exit(void)
{
! usb_deregister(&anydata_driver);
! usb_serial_deregister(&anydata_device);
}
module_init(anydata_init);
module_exit(anydata_exit);
MODULE_LICENSE("GPL");
module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");
! module_param(buffer_size, int, 0);
! MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers");
--- 137,942 ----
.num_bulk_out = NUM_DONT_CARE,
.num_ports = 1,
.open = anydata_open,
+ .close = anydata_close,
+ .write = anydata_write,
+ .ioctl = anydata_ioctl,
+ .break_ctl = anydata_break_ctl,
+ .read_bulk_callback = anydata_read_bulk_callback,
+ .read_int_callback = anydata_read_int_callback,
+ .write_bulk_callback = anydata_write_bulk_callback,
+ .write_room = anydata_write_room,
+ .chars_in_buffer = anydata_chars_in_buffer,
+ .attach = anydata_startup,
+ .shutdown = anydata_shutdown,
+ };
+
+ enum anydata_type {
+ type_0, /* don't know the difference between type 0 and */
+ type_1, /* type 1, until someone from prolific tells us... */
+ HX, /* HX version of the anydata chip */
+ };
+
+ struct anydata_private {
+ spinlock_t lock;
+ struct anydata_buf *buf;
+ int write_urb_in_use;
+ wait_queue_head_t delta_msr_wait;
+ u8 line_control;
+ u8 line_status;
+ u8 termios_initialized;
+ enum anydata_type type;
};
!
! static int anydata_startup (struct usb_serial *serial)
! {
! struct anydata_private *priv;
! enum anydata_type type = type_0;
! int i;
!
! if (serial->dev->descriptor.bDeviceClass == 0x02)
! type = type_0;
! else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
! type = HX;
! else if (serial->dev->descriptor.bDeviceClass == 0x00)
! type = type_1;
! else if (serial->dev->descriptor.bDeviceClass == 0xFF)
! type = type_1;
! dbg("device type: %d", type);
!
! for (i = 0; i < serial->num_ports; ++i) {
! priv = kmalloc (sizeof (struct anydata_private), GFP_KERNEL);
! if (!priv)
! goto cleanup;
! memset (priv, 0x00, sizeof (struct anydata_private));
! spin_lock_init(&priv->lock);
! priv->buf = anydata_buf_alloc(ANYDATA_BUF_SIZE);
! if (priv->buf == NULL) {
! kfree(priv);
! goto cleanup;
! }
! init_waitqueue_head(&priv->delta_msr_wait);
! priv->type = type;
! usb_set_serial_port_data(serial->port[i], priv);
! }
! return 0;
!
! cleanup:
! for (--i; i>=0; --i) {
! priv = usb_get_serial_port_data(serial->port[i]);
! anydata_buf_free(priv->buf);
! kfree(priv);
! usb_set_serial_port_data(serial->port[i], NULL);
! }
! return -ENOMEM;
! }
!
! static int set_control_lines (struct usb_device *dev, u8 value)
{
int retval;
+
+ retval = usb_control_msg (dev, usb_sndctrlpipe (dev, 0),
+ SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
+ value, 0, NULL, 0, 100);
+ dbg("%s - value = %d, retval = %d", __FUNCTION__, value, retval);
+ return retval;
+ }
+
+ static int anydata_write (struct usb_serial_port *port, const unsigned char *buf, int count)
+ {
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ unsigned long flags;
+
+ dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
+
+ if (!count)
+ return count;
+
+ spin_lock_irqsave(&priv->lock, flags);
+ count = anydata_buf_put(priv->buf, buf, count);
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ anydata_send(port);
+
+ return count;
+ }
+
+ static void anydata_send(struct usb_serial_port *port)
+ {
+ int count, result;
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ unsigned long flags;
+
+ dbg("%s - port %d", __FUNCTION__, port->number);
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ if (priv->write_urb_in_use) {
+ spin_unlock_irqrestore(&priv->lock, flags);
+ return;
+ }
+
+ count = anydata_buf_get(priv->buf, port->write_urb->transfer_buffer,
+ port->bulk_out_size);
+
+ if (count == 0) {
+ spin_unlock_irqrestore(&priv->lock, flags);
+ return;
+ }
+
+ priv->write_urb_in_use = 1;
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, port->write_urb->transfer_buffer);
+
+ port->write_urb->transfer_buffer_length = count;
+ port->write_urb->dev = port->serial->dev;
+ result = usb_submit_urb (port->write_urb, GFP_ATOMIC);
+ if (result) {
+ dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __FUNCTION__, result);
+ priv->write_urb_in_use = 0;
+ // TODO: reschedule anydata_send
+ }
+
+ schedule_work(&port->work);
+ }
+
+ static int anydata_write_room(struct usb_serial_port *port)
+ {
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ int room = 0;
+ unsigned long flags;
+
+ dbg("%s - port %d", __FUNCTION__, port->number);
+
+ spin_lock_irqsave(&priv->lock, flags);
+ room = anydata_buf_space_avail(priv->buf);
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ dbg("%s - returns %d", __FUNCTION__, room);
+ return room;
+ }
+
+ static int anydata_chars_in_buffer(struct usb_serial_port *port)
+ {
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ int chars = 0;
+ unsigned long flags;
+
+ dbg("%s - port %d", __FUNCTION__, port->number);
+
+ spin_lock_irqsave(&priv->lock, flags);
+ chars = anydata_buf_data_avail(priv->buf);
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ dbg("%s - returns %d", __FUNCTION__, chars);
+ return chars;
+ }
+
+
+
+ static int anydata_open (struct usb_serial_port *port, struct file *filp)
+ {
+ struct usb_serial *serial = port->serial;
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ unsigned char *buf;
+ int result;
+
+ dbg("%s - port %d", __FUNCTION__, port->number);
+
+ if (priv->type != HX) {
+ usb_clear_halt(serial->dev, port->write_urb->pipe);
+ usb_clear_halt(serial->dev, port->read_urb->pipe);
+ }
+
+ buf = kmalloc(10, GFP_KERNEL);
+ if (buf==NULL)
+ return -ENOMEM;
+
+ #define FISH(a,b,c,d) \
+ result=usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev,0), \
+ b, a, c, d, buf, 1, 100); \
+ dbg("0x%x:0x%x:0x%x:0x%x %d - %x",a,b,c,d,result,buf[0]);
+
+ #define SOUP(a,b,c,d) \
+ result=usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev,0), \
+ b, a, c, d, NULL, 0, 100); \
+ dbg("0x%x:0x%x:0x%x:0x%x %d",a,b,c,d,result);
+
+ FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
+ SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 0);
+ FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
+ FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
+ FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
+ SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 1);
+ FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
+ FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
+ SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0, 1);
+ SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 1, 0);
+
+ if (priv->type == HX) {
+ /* HX chip */
+ SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x44);
+ /* reset upstream data pipes */
+ SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 8, 0);
+ SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 9, 0);
+ } else {
+ SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x24);
+ }
+
+ kfree(buf);
+
+ /* Setup termios */
+ //FIXME: need to assert RTS and DTR if CRTSCTS off
+
+ dbg("%s - submitting read urb", __FUNCTION__);
+ port->read_urb->dev = serial->dev;
+ result = usb_submit_urb (port->read_urb, GFP_KERNEL);
+ if (result) {
+ dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __FUNCTION__, result);
+ anydata_close (port, NULL);
+ return -EPROTO;
+ }
+
+ dbg("%s - submitting interrupt urb", __FUNCTION__);
+ port->interrupt_in_urb->dev = serial->dev;
+ result = usb_submit_urb (port->interrupt_in_urb, GFP_KERNEL);
+ if (result) {
+ dev_err(&port->dev, "%s - failed submitting interrupt urb, error %d\n", __FUNCTION__, result);
+ anydata_close (port, NULL);
+ return -EPROTO;
+ }
+ return 0;
+ }
+
+
+ static void anydata_close (struct usb_serial_port *port, struct file *filp)
+ {
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ unsigned long flags;
+ unsigned int c_cflag;
+ int bps;
+ long timeout;
+ wait_queue_t wait; \
+
+ dbg("%s - port %d", __FUNCTION__, port->number);
+
+ /* wait for data to drain from the buffer */
+ spin_lock_irqsave(&priv->lock, flags);
+ timeout = ANYDATA_CLOSING_WAIT;
+ init_waitqueue_entry(&wait, current);
+ add_wait_queue(&port->tty->write_wait, &wait);
+ for (;;) {
+ set_current_state(TASK_INTERRUPTIBLE);
+ if (anydata_buf_data_avail(priv->buf) == 0
+ || timeout == 0 || signal_pending(current)
+ || !usb_get_intfdata(port->serial->interface)) /* disconnect */
+ break;
+ spin_unlock_irqrestore(&priv->lock, flags);
+ timeout = schedule_timeout(timeout);
+ spin_lock_irqsave(&priv->lock, flags);
+ }
+ set_current_state(TASK_RUNNING);
+ remove_wait_queue(&port->tty->write_wait, &wait);
+ /* clear out any remaining data in the buffer */
+ anydata_buf_clear(priv->buf);
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ /* wait for characters to drain from the device */
+ /* (this is long enough for the entire 256 byte */
+ /* anydata hardware buffer to drain with no flow */
+ /* control for data rates of 1200 bps or more, */
+ /* for lower rates we should really know how much */
+ /* data is in the buffer to compute a delay */
+ /* that is not unnecessarily long) */
+ bps = tty_get_baud_rate(port->tty);
+ if (bps > 1200)
+ timeout = max((HZ*2560)/bps,HZ/10);
+ else
+ timeout = 2*HZ;
+ schedule_timeout_interruptible(timeout);
+
+ /* shutdown our urbs */
+ dbg("%s - shutting down urbs", __FUNCTION__);
+ usb_kill_urb(port->write_urb);
+ usb_kill_urb(port->read_urb);
+ usb_kill_urb(port->interrupt_in_urb);
+
+ if (port->tty) {
+ c_cflag = port->tty->termios->c_cflag;
+ if (c_cflag & HUPCL) {
+ /* drop DTR and RTS */
+ spin_lock_irqsave(&priv->lock, flags);
+ priv->line_control = 0;
+ spin_unlock_irqrestore (&priv->lock, flags);
+ set_control_lines (port->serial->dev, 0);
+ }
+ }
+ }
+
+
+
+ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
+ {
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ unsigned long flags;
+ unsigned int prevstatus;
+ unsigned int status;
+ unsigned int changed;
+
+ spin_lock_irqsave (&priv->lock, flags);
+ prevstatus = priv->line_status;
+ spin_unlock_irqrestore (&priv->lock, flags);
+
+ while (1) {
+ interruptible_sleep_on(&priv->delta_msr_wait);
+ /* see if a signal did it */
+ if (signal_pending(current))
+ return -ERESTARTSYS;
+
+ spin_lock_irqsave (&priv->lock, flags);
+ status = priv->line_status;
+ spin_unlock_irqrestore (&priv->lock, flags);
+
+ changed=prevstatus^status;
+
+ if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
+ ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
+ ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
+ ((arg & TIOCM_CTS) && (changed & UART_CTS)) ) {
+ return 0;
+ }
+ prevstatus = status;
+ }
+ /* NOTREACHED */
+ return 0;
+ }
+
+ static int anydata_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
+ {
+ dbg("%s (%d) cmd = 0x%04x", __FUNCTION__, port->number, cmd);
+
+ switch (cmd) {
+ case TIOCMIWAIT:
+ dbg("%s (%d) TIOCMIWAIT", __FUNCTION__, port->number);
+ return wait_modem_info(port, arg);
+
+ default:
+ dbg("%s not supported = 0x%04x", __FUNCTION__, cmd);
+ break;
+ }
+
+ return -ENOIOCTLCMD;
+ }
+
+ static void anydata_break_ctl (struct usb_serial_port *port, int break_state)
+ {
+ struct usb_serial *serial = port->serial;
+ u16 state;
+ int result;
+
+ dbg("%s - port %d", __FUNCTION__, port->number);
+
+ if (break_state == 0)
+ state = BREAK_OFF;
+ else
+ state = BREAK_ON;
+ dbg("%s - turning break %s", __FUNCTION__, state==BREAK_OFF ? "off" : "on");
+
+ result = usb_control_msg (serial->dev, usb_sndctrlpipe (serial->dev, 0),
+ BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
+ 0, NULL, 0, 100);
+ if (result)
+ dbg("%s - error sending break = %d", __FUNCTION__, result);
+ }
+
+
+ static void anydata_shutdown (struct usb_serial *serial)
+ {
+ int i;
+ struct anydata_private *priv;
+
+ dbg("%s", __FUNCTION__);
+
+ for (i = 0; i < serial->num_ports; ++i) {
+ priv = usb_get_serial_port_data(serial->port[i]);
+ if (priv) {
+ anydata_buf_free(priv->buf);
+ kfree(priv);
+ usb_set_serial_port_data(serial->port[i], NULL);
+ }
+ }
+ }
+
+ static void anydata_update_line_status(struct usb_serial_port *port,
+ unsigned char *data,
+ unsigned int actual_length)
+ {
+
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ unsigned long flags;
+ u8 status_idx = UART_STATE;
+ u8 length = UART_STATE + 1;
+
+
+ if (actual_length < length)
+ goto exit;
+
+ /* Save off the uart status for others to look at */
+ spin_lock_irqsave(&priv->lock, flags);
+ priv->line_status = data[status_idx];
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ exit:
+ return;
+ }
+
+ static void anydata_read_int_callback (struct urb *urb, struct pt_regs *regs)
+ {
+ struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
+ unsigned char *data = urb->transfer_buffer;
+ unsigned int actual_length = urb->actual_length;
+ int status;
+
+ dbg("%s (%d)", __FUNCTION__, port->number);
+
+ switch (urb->status) {
+ case 0:
+ /* success */
+ break;
+ case -ECONNRESET:
+ case -ENOENT:
+ case -ESHUTDOWN:
+ /* this urb is terminated, clean up */
+ dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+ return;
+ default:
+ dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+ goto exit;
+ }
+
+ usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
+ anydata_update_line_status(port, data, actual_length);
+
+ exit:
+ status = usb_submit_urb (urb, GFP_ATOMIC);
+ if (status)
+ dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with result %d\n",
+ __FUNCTION__, status);
+ }
+
+
+ static void anydata_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
+ {
+ struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ struct tty_struct *tty;
+ unsigned char *data = urb->transfer_buffer;
+ unsigned long flags;
+ int i;
+ int result;
+ u8 status;
+ char tty_flag;
+
+ dbg("%s - port %d", __FUNCTION__, port->number);
+
+ if (urb->status) {
+ dbg("%s - urb->status = %d", __FUNCTION__, urb->status);
+ if (!port->open_count) {
+ dbg("%s - port is closed, exiting.", __FUNCTION__);
+ return;
+ }
+ if (urb->status == -EPROTO) {
+ /* ANYDATA mysteriously fails with -EPROTO reschedule the read */
+ dbg("%s - caught -EPROTO, resubmitting the urb", __FUNCTION__);
+ urb->status = 0;
+ urb->dev = port->serial->dev;
+ result = usb_submit_urb(urb, GFP_ATOMIC);
+ if (result)
+ dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
+ return;
+ }
+ dbg("%s - unable to handle the error, exiting.", __FUNCTION__);
+ return;
+ }
+
+ usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
+
+ /* get tty_flag from status */
+ tty_flag = TTY_NORMAL;
+
+ spin_lock_irqsave(&priv->lock, flags);
+ status = priv->line_status;
+ priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
+ spin_unlock_irqrestore(&priv->lock, flags);
+ wake_up_interruptible (&priv->delta_msr_wait);
+
+ /* break takes precedence over parity, */
+ /* which takes precedence over framing errors */
+ if (status & UART_BREAK_ERROR )
+ tty_flag = TTY_BREAK;
+ else if (status & UART_PARITY_ERROR)
+ tty_flag = TTY_PARITY;
+ else if (status & UART_FRAME_ERROR)
+ tty_flag = TTY_FRAME;
+ dbg("%s - tty_flag = %d", __FUNCTION__, tty_flag);
+
+ tty = port->tty;
+ if (tty && urb->actual_length) {
+ /* overrun is special, not associated with a char */
+ if (status & UART_OVERRUN_ERROR)
+ tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+ for (i = 0; i < urb->actual_length; ++i)
+ tty_insert_flip_char (tty, data[i], tty_flag);
+ tty_flip_buffer_push (tty);
+ }
+
+ /* Schedule the next read _if_ we are still open */
+ if (port->open_count) {
+ urb->dev = port->serial->dev;
+ result = usb_submit_urb(urb, GFP_ATOMIC);
+ if (result)
+ dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
+ }
+
+ return;
+ }
+
+
+
+ static void anydata_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
+ {
+ struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
+ struct anydata_private *priv = usb_get_serial_port_data(port);
+ int result;
+
+ dbg("%s - port %d", __FUNCTION__, port->number);
+
+ switch (urb->status) {
+ case 0:
+ /* success */
+ break;
+ case -ECONNRESET:
+ case -ENOENT:
+ case -ESHUTDOWN:
+ /* this urb is terminated, clean up */
+ dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+ priv->write_urb_in_use = 0;
+ return;
+ default:
+ /* error in the urb, so we have to resubmit it */
+ dbg("%s - Overflow in write", __FUNCTION__);
+ dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
+ port->write_urb->transfer_buffer_length = 1;
+ port->write_urb->dev = port->serial->dev;
+ result = usb_submit_urb (port->write_urb, GFP_ATOMIC);
+ if (result)
+ dev_err(&urb->dev->dev, "%s - failed resubmitting write urb, error %d\n", __FUNCTION__, result);
+ else
+ return;
+ }
+
+ priv->write_urb_in_use = 0;
+
+ /* send any buffered data */
+ anydata_send(port);
+ }
+
+
+ /*
+ * anydata_buf_alloc
+ *
+ * Allocate a circular buffer and all associated memory.
+ */
+
+ static struct anydata_buf *anydata_buf_alloc(unsigned int size)
+ {
+
+ struct anydata_buf *pb;
+
+
+ if (size == 0)
+ return NULL;
+
+ pb = (struct anydata_buf *)kmalloc(sizeof(struct anydata_buf), GFP_KERNEL);
+ if (pb == NULL)
+ return NULL;
+
+ pb->buf_buf = kmalloc(size, GFP_KERNEL);
+ if (pb->buf_buf == NULL) {
+ kfree(pb);
+ return NULL;
+ }
+
+ pb->buf_size = size;
+ pb->buf_get = pb->buf_put = pb->buf_buf;
+
+ return pb;
+
+ }
+
+
+ /*
+ * anydata_buf_free
+ *
+ * Free the buffer and all associated memory.
+ */
+
+ static void anydata_buf_free(struct anydata_buf *pb)
+ {
+ if (pb) {
+ kfree(pb->buf_buf);
+ kfree(pb);
+ }
+ }
+
+
+ /*
+ * anydata_buf_clear
+ *
+ * Clear out all data in the circular buffer.
+ */
+
+ static void anydata_buf_clear(struct anydata_buf *pb)
+ {
+ if (pb != NULL)
+ pb->buf_get = pb->buf_put;
+ /* equivalent to a get of all data available */
+ }
+
+
+ /*
+ * anydata_buf_data_avail
+ *
+ * Return the number of bytes of data available in the circular
+ * buffer.
+ */
+
+ static unsigned int anydata_buf_data_avail(struct anydata_buf *pb)
+ {
+ if (pb != NULL)
+ return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
+ else
+ return 0;
+ }
+
+
+ /*
+ * anydata_buf_space_avail
+ *
+ * Return the number of bytes of space available in the circular
+ * buffer.
+ */
+
+ static unsigned int anydata_buf_space_avail(struct anydata_buf *pb)
+ {
+ if (pb != NULL)
+ return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
+ else
+ return 0;
+ }
+
+
+ /*
+ * anydata_buf_put
+ *
+ * Copy data data from a user buffer and put it into the circular buffer.
+ * Restrict to the amount of space available.
+ *
+ * Return the number of bytes copied.
+ */
+
+ static unsigned int anydata_buf_put(struct anydata_buf *pb, const char *buf,
+ unsigned int count)
+ {
+
+ unsigned int len;
+
+
+ if (pb == NULL)
+ return 0;
+
+ len = anydata_buf_space_avail(pb);
+ if (count > len)
+ count = len;
+
+ if (count == 0)
+ return 0;
+
+ len = pb->buf_buf + pb->buf_size - pb->buf_put;
+ if (count > len) {
+ memcpy(pb->buf_put, buf, len);
+ memcpy(pb->buf_buf, buf+len, count - len);
+ pb->buf_put = pb->buf_buf + count - len;
+ } else {
+ memcpy(pb->buf_put, buf, count);
+ if (count < len)
+ pb->buf_put += count;
+ else /* count == len */
+ pb->buf_put = pb->buf_buf;
+ }
+
+ return count;
+
+ }
+
+
+ /*
+ * anydata_buf_get
+ *
+ * Get data from the circular buffer and copy to the given buffer.
+ * Restrict to the amount of data available.
+ *
+ * Return the number of bytes copied.
+ */
+
+ static unsigned int anydata_buf_get(struct anydata_buf *pb, char *buf,
+ unsigned int count)
+ {
+
+ unsigned int len;
+
+
+ if (pb == NULL)
+ return 0;
+
+ len = anydata_buf_data_avail(pb);
+ if (count > len)
+ count = len;
+
+ if (count == 0)
+ return 0;
+
+ len = pb->buf_buf + pb->buf_size - pb->buf_get;
+ if (count > len) {
+ memcpy(buf, pb->buf_get, len);
+ memcpy(buf+len, pb->buf_buf, count - len);
+ pb->buf_get = pb->buf_buf + count - len;
+ } else {
+ memcpy(buf, pb->buf_get, count);
+ if (count < len)
+ pb->buf_get += count;
+ else /* count == len */
+ pb->buf_get = pb->buf_buf;
+ }
+
+ return count;
+
+ }
+
+ static int __init anydata_init (void)
+ {
+ int retval;
retval = usb_serial_register(&anydata_device);
if (retval)
! goto failed_usb_serial_register;
retval = usb_register(&anydata_driver);
if (retval)
! goto failed_usb_register;
! info(DRIVER_DESC);
! return 0;
! failed_usb_register:
! usb_serial_deregister(&anydata_device);
! failed_usb_serial_register:
return retval;
}
!
! static void __exit anydata_exit (void)
{
! usb_deregister (&anydata_driver);
! usb_serial_deregister (&anydata_device);
}
+
module_init(anydata_init);
module_exit(anydata_exit);
+
+ MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");
!
vyse uvedeny text oznacte (cely) a vlozte jej do textoveho editoru
ulote jej jako anydata.diff tento vznikli soubor skopirujte do adresare
/cesta/k/vasim/zdrojum/linuxu/drivers/usb/serial/
např" cp anydata.diff /usr/src/linux-2.6.15/drivers/usb/serial/"
potom prejde do slozky kam jste skopirovaly anydata.diff
napr" cd /usr/src/linux-2.6.15/drivers/usb/serial/"
a zadejte prikaz: patch -p0 < anydata.diff
jo a jeste jsem zapomnel po aplikovani patche musite ve slozce
kam jste nahravali patch vytvorit soubor anydata.h s obsahem
/*
* Prolific ANYDATA USB to serial adaptor driver header file
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
*/
#define ANYDATA_VENDOR_ID 0x16d5
#define ANYDATA_PRODUCT_ID 0x6501
Uplne nejlepsi by bylo mit nakej celkovej navod jak udelat DHCP server s timto modemem, ale nic takoveho asi neexistuje a ja jako absolutni zacatecnik to dohromady nedam . Ztravil jsem s tim uz takovyho casu, ze jsem byl kolikrat tak sprostej, ze jsem vyslovil "Zlaty Wokna !" ach jo
(tj určité verze jádra )
Taky nevím jak jste vytvářel ten soubor v MC ? Jednoduše se to skopíruje a uloží do souboru (ten patch) a nic se v MC nevytváří - kdoví co jsi dělal.
No a když máš jiné jádro na které tvůj patch nepasuje tak je tam i popsáno jak to udělat ručně co vyhledat v zdrojáku a co přepsat a co smazat atd......
Jinak pokud nepopíšeš konkrétní problém co to přesně vypsalo za chybu tak ti nikdo neporadí. Program diff vůbec nepotřebuješ .
Pro tebe je užitečný program patch viz: man patch
.Rad se necemu priucim, ale chce to presnej navod krok za krokem, kez by bylo naky video jako je od Ruika s kompilaci jadra, ktera je tak dobre vysvetlena ze i lama jako ja udela kompilaci od nuly zpameti a uspesne vzdy - RUIK je B.O.R.E.C !!!
26.4.2006 16:32
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
! Ale co, co je to 12 hodin oproti nekolika mesicum zapasenim s tim ze nakej idiot neotestuje poradne ovladac s modemem a pripojenim / odpojenim se pred tim, nez ho da do jadra ... Samozrejme verim tomu, ze vyse uvedeny postup nekomu muze fungovat ci jiz funguje a je super ze se o to autor podelil s ostatnimi ...
napada me ze se treba jeste musi upravit script ... mam dojem ze jsem pouzival navod na pripojeni na www.dastych.cz nebo nak tak ...
21.5.2006 10:41
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
12.8.2006 15:43
kozzi | skóre: 55
| blog: vse_o_vsem
| Pacman (Bratrušov)
Tiskni
Sdílej:
